package com.qianwen.smartman.modules.smis.service.impl; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.temporal.ChronoUnit; import java.time.temporal.TemporalAccessor; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.UUID; import java.util.function.Function; import java.util.regex.Pattern; import java.util.stream.Collectors; import javax.servlet.http.HttpServletResponse; import org.apache.commons.collections.MapUtils; import org.apache.commons.lang3.StringUtils; import org.jetbrains.annotations.NotNull; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.multipart.MultipartFile; import com.alibaba.excel.write.merge.AbstractMergeStrategy; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.google.common.collect.Lists; import com.qianwen.core.cache.utils.CacheUtil; import com.qianwen.core.excel.util.ExcelUtil; import com.qianwen.core.log.exception.ServiceException; import com.qianwen.core.mp.base.BaseServiceImpl; import com.qianwen.core.mp.support.Condition; import com.qianwen.core.mp.support.Query; import com.qianwen.core.oss.model.BladeFile; import com.qianwen.core.secure.utils.AuthUtil; import com.qianwen.core.tool.utils.DateUtil; import com.qianwen.core.tool.utils.Func; import com.qianwen.core.tool.utils.StringUtil; import com.qianwen.license.common.LicenseExtraModel; import com.qianwen.license.common.LicenseVerify; import com.qianwen.smartman.common.cache.DictCache; import com.qianwen.smartman.common.cache.cps.WorkstationCache; import com.qianwen.smartman.common.constant.CalendarConstant; import com.qianwen.smartman.common.constant.CommonConstant; import com.qianwen.smartman.common.constant.CommonGroupConstant; import com.qianwen.smartman.common.constant.ExcelConstant; import com.qianwen.smartman.common.constant.ExtCacheConstant; import com.qianwen.smartman.common.constant.MachineConstant; import com.qianwen.smartman.common.constant.MdcConstant; import com.qianwen.smartman.common.enums.CommonGroupTypeEnum; import com.qianwen.smartman.common.enums.DictEnum; import com.qianwen.smartman.common.enums.StatusType; import com.qianwen.smartman.common.enums.WcsDataTypeEnums; import com.qianwen.smartman.common.license.LicenseWrapper; import com.qianwen.smartman.common.mqtt.MqttMessageSender; import com.qianwen.smartman.common.utils.Lambda; import com.qianwen.smartman.common.utils.MessageUtils; import com.qianwen.smartman.common.utils.ValidatorUtils; import com.qianwen.smartman.common.websocket.entity.FmsWorkBench; import com.qianwen.smartman.modules.smis.convert.CommonGroupConvert; import com.qianwen.smartman.modules.smis.convert.WorkstationConvert; import com.qianwen.smartman.modules.smis.convert.WorkstationWorkbenchConvert; import com.qianwen.smartman.modules.smis.dto.CodeMapDTO; import com.qianwen.smartman.modules.smis.dto.WorkstationRealTimeStatusDTO; import com.qianwen.smartman.modules.smis.dto.WorkstationWcsDmpDTO; import com.qianwen.smartman.modules.smis.entity.CommonGroup; import com.qianwen.smartman.modules.smis.entity.CommonGroupOfItem; import com.qianwen.smartman.modules.smis.entity.Machine; import com.qianwen.smartman.modules.smis.entity.ProductionCalendar; import com.qianwen.smartman.modules.smis.entity.ProductionCalendarDay; import com.qianwen.smartman.modules.smis.entity.Workstation; import com.qianwen.smartman.modules.smis.entity.WorkstationOfMachine; import com.qianwen.smartman.modules.smis.entity.WorkstationWorkbench; import com.qianwen.smartman.modules.smis.enums.WorkTypeEnum; import com.qianwen.smartman.modules.smis.excel.WorkstationExcel; import com.qianwen.smartman.modules.smis.excel.WorkstationImport; import com.qianwen.smartman.modules.smis.mapper.WorkstationMapper; import com.qianwen.smartman.modules.smis.message.dto.TelemetryDataResponseDTO; import com.qianwen.smartman.modules.smis.message.producer.InsertWorkstationProducer; import com.qianwen.smartman.modules.smis.service.ICalendarService; import com.qianwen.smartman.modules.smis.service.ICommonGroupOfItemService; import com.qianwen.smartman.modules.smis.service.ICommonGroupService; import com.qianwen.smartman.modules.smis.service.IMachineService; import com.qianwen.smartman.modules.smis.service.IWorkstationOfMachineService; import com.qianwen.smartman.modules.smis.service.IWorkstationService; import com.qianwen.smartman.modules.smis.service.IWorkstationWcsService; import com.qianwen.smartman.modules.smis.service.IWorkstationWorkbenchService; import com.qianwen.smartman.modules.smis.service.WorkstationDatapointsService; import com.qianwen.smartman.modules.smis.vo.DmpVariablesVO; import com.qianwen.smartman.modules.smis.vo.FmsWorkstationGroupVO; import com.qianwen.smartman.modules.smis.vo.FmsWorkstationQueryVO; import com.qianwen.smartman.modules.smis.vo.MachineDetailVO; import com.qianwen.smartman.modules.smis.vo.MachineVO; import com.qianwen.smartman.modules.smis.vo.RealTimeStatusVO; import com.qianwen.smartman.modules.smis.vo.WorkMachineEasyVO; import com.qianwen.smartman.modules.smis.vo.WorkstationChangeCalendarVO; import com.qianwen.smartman.modules.smis.vo.WorkstationDatapointsVO; import com.qianwen.smartman.modules.smis.vo.WorkstationOfWorkbenchVO; import com.qianwen.smartman.modules.smis.vo.WorkstationPageQueryVO; import com.qianwen.smartman.modules.smis.vo.WorkstationRealTimeStatusVO; import com.qianwen.smartman.modules.smis.vo.WorkstationSubmitVO; import com.qianwen.smartman.modules.smis.vo.WorkstationVO; import com.qianwen.smartman.modules.smis.vo.WorkstationWorkbenchVO; import com.qianwen.smartman.modules.mdc.dto.GroupWorkDTO; import com.qianwen.smartman.modules.mdc.dto.WorkstationDmpDTO; import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder; import com.qianwen.smartman.modules.tdengine.service.IWorkstationDynamicCollectService; import cn.hutool.core.util.ObjectUtil; @Service public class WorkstationServiceImpl extends BaseServiceImpl implements IWorkstationService { private static final Pattern CHINESE = Pattern.compile("^[A-Za-z0-9]+$"); @Autowired private IMachineService machineService; @Autowired private IWorkstationOfMachineService workstationOfMachineService; @Autowired private IWorkstationWcsService workstationWcsService; @Autowired private ICommonGroupOfItemService commonGroupOfItemService; @Autowired private ICommonGroupService commonGroupService; @Autowired private ICalendarService calendarService; @Autowired private WorkstationMapper workstationMapper; @Autowired private OssBuilder ossBuilder; @Autowired private IWorkstationWorkbenchService workbenchService; @Autowired private InsertWorkstationProducer workstationProducer; @Autowired private IWorkstationDynamicCollectService dynamicCollectService; @Autowired private MqttMessageSender mqttMsgSender; @Autowired private WorkstationDatapointsService wsDpService; @Autowired private LicenseWrapper licenseWrapper; @Autowired private WorkstationDatapointsService dataPointService; private final String NAME = "默认工作台"; private final Integer SORT = 1; private final Integer DEFAULT = 1; private final Integer NOT_DEFAULT = 0; private final String ALL_WORKSTATION_GROUP = CommonGroupConstant.ALL_NAME; private final Integer FTP_CORRELATION_DIRECTORY = 1; private final Integer FTP_SAME_DIRECTORY = 2; public static Long getTimeDifference(LocalDateTime startTime, LocalDateTime endTime) { if (Func.isEmpty(startTime)) { return 0L; } LocalDateTime tempDateTime = LocalDateTime.from((TemporalAccessor) startTime); long seconds = tempDateTime.until(endTime, ChronoUnit.SECONDS); return Long.valueOf(seconds); } @Override public List queryWcsList(String workstationId) { return this.baseMapper.queryWcsList(workstationId).stream().filter(c -> { return (WcsDataTypeEnums.WcsDataType.ALARM.getCode().equals(c.getWcsDataType()) || WcsDataTypeEnums.WcsDataType.ALARM_NUM.getCode().equals(c.getWcsDataType()) || WcsDataTypeEnums.WcsDataType.ALARM_INFO.getCode().equals(c.getWcsDataType())) ? false : true; }).collect(Collectors.toList()); } @Override public WorkstationWcsDmpDTO queryDateTypeState(Integer code, String workstationId) { return this.baseMapper.queryDateTypeState(code, workstationId); } @Override public List queryDmpList(String workstationId) { return ((WorkstationMapper) this.baseMapper).queryDmpList(workstationId); } @Override @Transactional(rollbackFor = {Exception.class}) public WorkstationVO submit(WorkstationSubmitVO workstationSubmitVO) { checkLicenseCount(); checkWorkstation(workstationSubmitVO); if (Func.isEmpty(workstationSubmitVO.getId())) { checkUnableWorkstation(workstationSubmitVO); } Workstation workstation = WorkstationConvert.INSTANCE.convert(workstationSubmitVO); workstation.setTransmissionMethod(workstationSubmitVO.getTransmissionMethod()); if (Func.isEmpty(workstation.getCalendarCode())) { workstation.setCalendarCode(CalendarConstant.DEFAULT_CALENDAR); } if (workstation.getCalendarCode().equals(workstation.getCalendarCodeWaiting())) { workstation.setCalendarCodeWaiting(null); } saveOrUpdate(workstation); if (Func.isNotEmpty(workstationSubmitVO.getGroupId())) { List itemList = this.commonGroupOfItemService.list(Wrappers.lambdaQuery().eq(CommonGroupOfItem::getItemId, workstation.getId())); if (Func.isEmpty(itemList)) { CommonGroupOfItem commonGroupOfItem = new CommonGroupOfItem(workstationSubmitVO.getGroupId(), workstation.getId(), CommonGroupTypeEnum.WORKSTATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY); this.commonGroupOfItemService.save(commonGroupOfItem); } else { changeWorkstationGroup(workstationSubmitVO.getGroupId(), Lists.newArrayList(new Long[]{workstation.getId()})); } } submitWorkstationMachine(workstationSubmitVO, workstation); //submitWorkstationFtpDirectory(workstationSubmitVO, workstation); submitWorkstationWorkbench(workstationSubmitVO, workstation); WorkstationCache.clearWorkstationCache(); WorkstationCache.clearWorkstationRealTime(workstation.getId()); CacheUtil.clear(ExtCacheConstant.COLLECT_WORKSTATION, Boolean.FALSE); CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE); CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE); String redisKey = ExtCacheConstant.CPS_CACHE.concat(":").concat(":").concat(WorkstationCache.CRC); CacheUtil.clear(redisKey, Boolean.FALSE); WorkstationVO workstationVO = WorkstationConvert.INSTANCE.convertSaveVO(workstationSubmitVO); workstationVO.setId(workstation.getId()); if (Func.isNull(workstationSubmitVO.getId())) {//新增工位，发送消息，post应用打固定点 //WorkstationCreateMessageDTO dto = WorkstationCreateMessageDTO.builder().workstationId(workstation.getId().toString()).operationTime(DateUtil.now()).build(); //this.workstationProducer.sendInsertWorkstationMessage(dto); workstationProducer.sendInsertWorkstationMessage(workstation.getId()); } return workstationVO; } /** * 验证许可中配置的设备数量 */ void checkLicenseCount() { Wrapper wrapper = Wrappers.lambdaQuery(Workstation.class).eq(Workstation::getIsDeleted, 0); Long count = workstationMapper.selectCount(wrapper); Long machineAmount = licenseWrapper.getWorkstationAmount(); if(count >= machineAmount) { throw new ServiceException("工位数超过许可上限数:"+ machineAmount); } } /* private void submitWorkstationFtpDirectory(WorkstationSubmitVO workstationSubmitVO, Workstation workstation) { if (Func.isEmpty(workstationSubmitVO.getId()) && Func.isNotEmpty(workstationSubmitVO.getFtpDirectoryType())) { WorkstationTdVO workstationTdVO = new WorkstationTdVO(); workstationTdVO.setWorkstationId(String.valueOf(workstation.getId())); workstationTdVO.setWorkstationName(workstation.getName()); workstationTdVO.setWorkstationGroupId(String.valueOf(workstationSubmitVO.getGroupId())); if (this.FTP_CORRELATION_DIRECTORY.equals(workstationSubmitVO.getFtpDirectoryType())) { workstationTdVO.setType(this.FTP_CORRELATION_DIRECTORY); if (Func.isNotEmpty(workstationSubmitVO.getDirectoryId())) { workstationTdVO.setDirectorTransferId(workstationSubmitVO.getDirectoryId()); } } else { workstationTdVO.setType(this.FTP_SAME_DIRECTORY); } if (Objects.equals(workstationSubmitVO.getFtpDirectoryType(), CommonConstant.ASSOCIATED_DIRECTORY)) { this.transferDirectoryService.judgeAndSaveWorkStationFtp(String.valueOf(workstationSubmitVO.getMachineId()), workstation.getId(), workstationSubmitVO.getDirectoryId()); } this.wsRelationTdService.relationFtpDirectory(workstationTdVO); } }*/ private void submitWorkstationMachine(WorkstationSubmitVO workstationSubmitVO, Workstation workstation) { if (Func.isEmpty(workstationSubmitVO.getId()) && Func.isNotEmpty(workstationSubmitVO.getType()) && 0 == workstationSubmitVO.getType().intValue()) { if (1 == workstationSubmitVO.getLinkWay().intValue()) { MachineVO machineVO = MachineVO.builder().machineCode(workstationSubmitVO.getMachineCode()).machineName(workstationSubmitVO.getMachineName()).groupId(CommonGroupConstant.DEFAULT_MACHINE_ID).brand(workstationSubmitVO.getMachineBrand()).collectSwitch(workstationSubmitVO.getCollectSwitch()).extendId(UUID.randomUUID().toString()).machinePinCode(workstationSubmitVO.getMachinePinCode()).machineShortCode(workstationSubmitVO.getMachineShortCode()).externalKey(workstationSubmitVO.getMachineCode()).build(); MachineVO insert = this.machineService.insert(machineVO); WorkstationOfMachine workstationOfMachine = new WorkstationOfMachine(workstation.getId(), insert.getId()); this.workstationOfMachineService.save(workstationOfMachine); workstationSubmitVO.setMachineId(insert.getId()); workstationSubmitVO.setExtendId(insert.getExtendId()); return; } if (Func.isEmpty(workstationSubmitVO.getMachineId())) { Machine machine1 = this.machineService.getOne(Wrappers.lambdaQuery().eq(Machine::getMachineCode, workstationSubmitVO.getMachineCode())); workstationSubmitVO.setMachineId(machine1.getId()); /* workstationSubmitVO.setMachineId(((Machine) this.machineService.getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> { return v0.getMachineCode(); }, workstationSubmitVO.getMachineCode()))).getId());*/ } WorkstationOfMachine workstationOfMachine2 = new WorkstationOfMachine(workstation.getId(), workstationSubmitVO.getMachineId()); this.workstationOfMachineService.save(workstationOfMachine2); Integer collectSwitch = workstationSubmitVO.getCollectSwitch(); String machineBrand = workstationSubmitVO.getMachineBrand(); Machine machine = (Machine) this.machineService.getById(workstationSubmitVO.getMachineId()); if (Func.isNotEmpty(collectSwitch) || Func.isNotEmpty(machineBrand)) { machine.setCollectSwitch(collectSwitch); machine.setBrand(machineBrand); this.machineService.updateById(machine); } workstationSubmitVO.setExtendId(machine.getExtendId()); } } private void submitWorkstationWorkbench(WorkstationSubmitVO workstationSubmitVO, Workstation workstation) { if (Func.isEmpty(workstationSubmitVO.getId())) { if (Func.isEmpty(workstationSubmitVO.getWorkbenchVOList())) { WorkstationWorkbench workbench = new WorkstationWorkbench(); workbench.setWorkstationId(workstation.getId()); workbench.setSort(this.SORT); workbench.setName("默认工作台"); workbench.setWorkbenchDefault(this.DEFAULT); this.workbenchService.save(workbench); return; } List workbenchVOList = workstationSubmitVO.getWorkbenchVOList(); List workstationWorkbenchList = new ArrayList<>(); Map> map = workbenchVOList.stream().collect(Collectors.groupingBy(c -> { return c.getName(); })); map.values().forEach(workbenchList -> { if (workbenchList.size() > 1) { throw new ServiceException(MessageUtils.message("work.station.work.bench.name.already.exist", new Object[0])); } WorkstationWorkbench workbench2 = new WorkstationWorkbench(); workbench2.setWorkstationId(workstation.getId()); workbench2.setSort(((WorkstationWorkbenchVO) workbenchList.get(0)).getSort()); workbench2.setName(((WorkstationWorkbenchVO) workbenchList.get(0)).getName()); workbench2.setWorkbenchDefault(this.NOT_DEFAULT); workstationWorkbenchList.add(workbench2); }); this.workbenchService.saveBatch(workstationWorkbenchList); } else if (Func.isNotEmpty(workstationSubmitVO.getWorkbenchVOList())) { List workbenchList2 = workstationSubmitVO.getWorkbenchVOList(); List deleteWorkbenchIdList = new ArrayList<>(); List submitWorkbenchList = new ArrayList<>(); workbenchList2.forEach(x -> { if (1 == x.getIsDeleted().intValue()) { deleteWorkbenchIdList.add(x.getId()); return; } WorkstationWorkbench workstationWorkbench = WorkstationWorkbenchConvert.INSTANCE.convert(x); workstationWorkbench.setWorkstationId(workstation.getId()); submitWorkbenchList.add(workstationWorkbench); }); if (Func.isNotEmpty(deleteWorkbenchIdList)) { this.workbenchService.removeByIds(deleteWorkbenchIdList); } if (Func.isEmpty(submitWorkbenchList)) { throw new ServiceException(MessageUtils.message("work.station.work.bench.is.only.so.not.delete", new Object[0])); } this.workbenchService.saveOrUpdateBatch(submitWorkbenchList); } } @Override public Boolean changeCollectSwitch(Long workstationId, Integer collectSwitch) { return this.machineService.changeCollectSwitch(workstationId, collectSwitch); } @Override @Transactional(rollbackFor = {Exception.class}) public Boolean delete(List workstationIds, Integer type) { String redisKey = ExtCacheConstant.CPS_CACHE.concat(":").concat(":").concat(WorkstationCache.CRC); if (StatusType.REMOVE.getType().equals(type)) { /* workstationIds.forEach(id -> { this.transferDirectoryService.deleteWorkstationDirectory(id); WorkstationCache.clearWorkstationRealTime(id); }); */ removeByIds(workstationIds); this.dynamicCollectService.removeTableByDelWorkstations(workstationIds); this.workstationWcsService.deleteByWorkstationIdList(workstationIds); this.workstationOfMachineService.remove(Wrappers.lambdaQuery().in(WorkstationOfMachine::getWorkstationId, workstationIds)); this.commonGroupOfItemService.remove(Wrappers.lambdaQuery().in(CommonGroupOfItem::getItemId, workstationIds)); //20250324新增，删除工位对应的数据点位配置。 dataPointService.removeByWorkstation(workstationIds); /* this.workstationOfMachineService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> { return v0.getWorkstationId(); }, workstationIds)); this.commonGroupOfItemService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> { return v0.getItemId(); }, workstationIds));*/ WorkstationCache.clearWorkstationCache(); CacheUtil.clear(ExtCacheConstant.COLLECT_WORKSTATION, Boolean.FALSE); CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE); CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE); CacheUtil.clear(redisKey, Boolean.FALSE); } changeStatus(workstationIds, CommonConstant.DEACTIVATE); WorkstationCache.clearWorkstationCache(); CacheUtil.clear(ExtCacheConstant.COLLECT_WORKSTATION, Boolean.FALSE); CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE); CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE); CacheUtil.clear(redisKey, Boolean.FALSE); return true; } @Override public IPage listPage(IPage workstationVOIPage, String keyWord, Long groupId, Integer status, Integer type) { List workStationGroupIdList = new ArrayList<>(); if (!Objects.equals(groupId, CommonGroupConstant.ALL_WORKSTATION_ID) && Func.isNotEmpty(groupId)) { workStationGroupIdList.add(String.valueOf(groupId)); workStationGroupIdList.addAll(getCommonGroupIds(workStationGroupIdList, new ArrayList<>()).stream().map(item -> { return String.valueOf(item.getId()); }).collect(Collectors.toList())); } List workstationVOS = this.workstationMapper.listPage(workStationGroupIdList, workstationVOIPage, keyWord, groupId, CommonGroupConstant.ALL_WORKSTATION_ID, status == null ? CommonConstant.ENABLE : status, type, LocalDate.now().getYear()); workstationVOS.forEach(workstationVO -> { String calendarName = workstationVO.getCalendarName(); if (Func.isBlank(calendarName)) { workstationVO.setCalendarName("系统日历"); } }); return workstationVOIPage.setRecords(workstationVOS); } @Override public List getWorkstationByGroupIds(final List groupIds) { List workstationVOS = this.workstationMapper.listWorkstation(groupIds); workstationVOS.forEach(workstationVO -> { WorkstationOfMachine workstationOfMachine = this.workstationOfMachineService.getWorkstationOfMachineByWorkstationId(workstationVO.getId()); if (Func.isNotEmpty(workstationOfMachine)) { Machine machine = (Machine) this.machineService.getById(workstationOfMachine.getMachineId()); if (Func.isNotEmpty(machine)) { workstationVO.setMachineCode(machine.getMachineCode()); workstationVO.setMachineName(machine.getMachineName()); workstationVO.setCollectSwitch(machine.getCollectSwitch()); workstationVO.setMachinePinCode(machine.getPinCode()); workstationVO.setMachineShortCode(machine.getShortCode()); } } }); return workstationVOS; } @NotNull private List wrapperBench(WorkstationOfWorkbenchVO station) { return station.getWorkstationWorkbenchVOList().stream().map(bench -> { FmsWorkBench workBench = new FmsWorkBench(); workBench.setId(Func.toStr(bench.getId())); workBench.setName(bench.getName()); workBench.setSort(bench.getSort()); return workBench; }).collect(Collectors.toList()); } /* @Override public List getFmsWorkstation(final List workstationIds) { List commonGroupIds = this.commonGroupService.list(Lambda.eq(CommonGroup::getGroupTag, FmsOrderEnum.FMS_BELTLINE.getCode())).stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); List fmsWorkstations = commonGroupIds.stream().flatMap(id -> { return this.commonGroupService.getAllSubGroup(id, CommonGroupTypeEnum.WORKSTATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY).stream(); }).map((v0) -> { return v0.getId(); }).flatMap(groupId -> { return this.workbenchService.listByGroupId(groupId, null, null).stream(); }).filter(station -> { return Func.isEmpty(workstationIds) || workstationIds.contains(station.getWorkstationId()); }).map(station2 -> { FmsWorkstation fmsWorkstation = new FmsWorkstation(); fmsWorkstation.setCode(station2.getWorkstationCode()); fmsWorkstation.setName(station2.getWorkstationName()); fmsWorkstation.setId(Func.toStr(station2.getWorkstationId())); fmsWorkstation.setWorkBenchList(wrapperBench(station2)); return fmsWorkstation; }).collect(Collectors.collectingAndThen(Collectors.toCollection(() -> { return new TreeSet<>(Comparator.comparing((v0) -> { return v0.getId(); })); }), (v1) -> { return new ArrayList<>(v1); })); return fmsWorkstations; } */ @Override public Boolean changeCalendarCode(WorkstationChangeCalendarVO workstationChangeCalendarVO) { Workstation workstation = getById(workstationChangeCalendarVO.getWorkstationId()); workstation.setCalendarCodeWaiting(workstationChangeCalendarVO.getCalendarCodeWaiting()); return Boolean.valueOf(updateById(workstation)); } @Override public void updateWorkstationCalendar() { List list = list(new QueryWrapper().lambda().isNotNull(Workstation::getCalendarCodeWaiting)); List workstationList = new ArrayList<>(); if (Func.isNotEmpty(list)) { list.stream().filter(workstation -> { return Func.isNotEmpty(workstation.getCalendarCodeWaiting()); }).forEach(workstation2 -> { workstation2.setCalendarCode(workstation2.getCalendarCodeWaiting()); workstation2.setCalendarCodeWaiting(""); workstationList.add(workstation2); }); } updateBatchById(workstationList); WorkstationCache.clearWorkstationCache(); } @Override @Transactional(rollbackFor = {Exception.class}) public Boolean changeWorkstationGroup(Long groupId, List workstationIdList) { CommonGroup commonGroup = (CommonGroup) this.commonGroupService.getById(groupId); List list = this.commonGroupOfItemService.list( Wrappers.lambdaQuery().in(CommonGroupOfItem::getItemId, workstationIdList)); list.forEach(commonGroupOfItem -> { commonGroupOfItem.setGroupId(groupId); commonGroupOfItem.setGroupType(commonGroup.getGroupType()); commonGroupOfItem.setGroupCategory(commonGroup.getGroupCategory()); this.commonGroupOfItemService.updateById(commonGroupOfItem); /* WorkstationDirectoryDto workstationDirectoryDto = new WorkstationDirectoryDto(); workstationDirectoryDto.setWorkstationId(commonGroupOfItem.getItemId()).setWorkstationParentId(groupId); this.transferDirectoryService.updateWorkstationDirectory(workstationDirectoryDto); */ }); return true; } @Override @Transactional(rollbackFor = {Exception.class}) public Boolean deleteGroup(Long groupId) { if (this.commonGroupOfItemService.count(Lambda.eq(CommonGroupOfItem::getGroupId, groupId)) > 0) { throw new ServiceException(MessageUtils.message("cps.common.group.production.line.delete.fail", new Object[0])); } //this.transferDirectoryGroupService.deleteWorkstationGroup(groupId); this.commonGroupService.deleteGroup(groupId); return true; } @Override @Transactional(rollbackFor = {Exception.class}) public BladeFile importWorkstation(List data) { if (Func.isEmpty(data)) { throw new ServiceException(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0])); } if (data.size() > 200) { throw new ServiceException(MessageUtils.message("excel.import.size.failed", new Object[0])); } HashMap commonGroupNameMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.WORKSTATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY); List machineList = this.machineService.list(Wrappers.lambdaQuery().eq(Machine::getStatus, CommonConstant.ENABLE)); List calendarCodeList = this.calendarService.getCalendarList(AuthUtil.getTenantId()).stream().map((v0) -> { return v0.getCode(); }).collect(Collectors.toList()); Boolean flag = Boolean.TRUE; HashMap pinCodeMap = new HashMap<>(); HashMap shortCodeMap = new HashMap<>(); Map importPinCodeMap = new HashMap<>(); Map importShortCodeMap = new HashMap<>(); List workstationCodeList = new ArrayList<>(); List machineCodeList = new ArrayList<>(); List machineVOList = this.machineService.listHaveBand(); Set machineCodeSet = machineVOList.stream().map((v0) -> { return v0.getMachineCode(); }).collect(Collectors.toSet()); CodeMapDTO codeMapDTO = new CodeMapDTO(pinCodeMap, shortCodeMap, workstationCodeList, machineCodeList, importPinCodeMap, importShortCodeMap); for (WorkstationImport workstationImport : data) { checkWorkstationImport(workstationImport, machineList, calendarCodeList, commonGroupNameMap, codeMapDTO, machineCodeSet); if (Func.isNotEmpty(workstationImport.getFailReason())) { flag = Boolean.FALSE; } } if (!flag.booleanValue()) { MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "workstationFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "工位信息表", data.stream().filter(x -> { return Func.isNotEmpty(x.getFailReason()); }).collect(Collectors.toList()), (Object) null, (AbstractMergeStrategy) null); BladeFile bladeFile = this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile); return bladeFile; } data.forEach(workstationImport2 -> { WorkstationSubmitVO workstationSubmitVO = WorkstationConvert.INSTANCE.convert(workstationImport2); submit(workstationSubmitVO); }); return null; } @Override public BladeFile exportWorkstation(String keyWord, Long groupId, HttpServletResponse response) { Query query = new Query(); query.setSize(-1); IPage workstationVOIPage = listPage(Condition.getPage(query), keyWord, groupId, null, null); List records = workstationVOIPage.getRecords(); List workstationExcels = WorkstationConvert.INSTANCE.convertList(records); workstationExcels.forEach(workstationExcel -> { workstationExcel.setTypeName(DictCache.getValue(DictEnum.WORKSTATION_TYPE, workstationExcel.getType())); }); String fileName = String.format("%s-%s.xlsx", "工位数据", DateUtil.time()); MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "工位数据表", workstationExcels, WorkstationExcel.class); BladeFile bladeFile = this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile); return bladeFile; } @Override public IPage getRealTimeStatus(WorkstationRealTimeStatusDTO dto, Query query) { List workStationGroupIdList = dto.getWorkStationGroupIdList(); if (workStationGroupIdList.size() == 1) { List workStationGroupIdByParentList = getCommonGroupIds(workStationGroupIdList, new ArrayList<>()).stream().map(item -> { return String.valueOf(item.getId()); }).collect(Collectors.toList()); dto.getWorkStationGroupIdList().addAll(workStationGroupIdByParentList); } List result = this.baseMapper.getWorkstationListByWorkStationGroupIdList(new Page().setSize(-1L), dto); return manualBuildIPage(query, buildProperties(result, dto.getDeviceStatus())); } /** * 获取实时数据展示的数据点列表 * @param workstationIdList 工位id集合 * @return map(工位id -> 数据点集合) */ public Map> getRealTimeProperties(List workstationIdList) { Map> properties = new HashMap<>(); //yangys修改，改为数据点位的方式 for(Long workstationId: workstationIdList) { Map map = WorkstationCache.getWorkstationRealTime(String.valueOf(workstationId));//应该有数据，因为缓存没有，内部直接查的queryLastParameter JSONObject cfgRow; ArrayList arrayList = new ArrayList<>(); WorkstationDatapointsVO dpVO = wsDpService.getDatapoints(workstationId); if(dpVO!=null && ObjectUtil.isNotEmpty(dpVO.getDpHead())) { String prop; JSONArray dpCfgJson = JSONArray.parseArray(dpVO.getDpConfig()); for(int i=0;i listWorkStationOnShiftIndex(List ids, LocalDate localDate, Query query, Integer shift, Integer type) { return ((WorkstationMapper) this.baseMapper).listWorkStationOnShiftIndex(Condition.getPage(query), Integer.valueOf(localDate.getYear()), DateUtil.formatDate(localDate), shift, type, ids); } @Override public List listWorkStationOnShift(List ids, LocalDate localDate, List shifts, Integer type) { return ((WorkstationMapper) this.baseMapper).listWorkStationOnShift(Integer.valueOf(localDate.getYear()), DateUtil.formatDate(localDate), shifts, type, ids); } @Override public Integer countWorkStationOnShiftIndex(List ids, LocalDate localDate, Integer shift, Integer type) { return ((WorkstationMapper) this.baseMapper).countWorkStationOnShiftIndex(Integer.valueOf(localDate.getYear()), DateUtil.formatDate(localDate), shift, type, ids); } @Override public List listWorkStationByGroupId(List ids) { return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids); } @Override public List listWorkStationByGroup(List ids) { return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids.stream().map((v0) -> { return String.valueOf(v0); }).collect(Collectors.toList())); } @Override public Set findByIndexAndDateAndTypeAndYear(Integer year, String queryDate, Integer shiftIndex, Integer code) { return ((WorkstationMapper) this.baseMapper).findByIndexAndDateAndTypeAndYear(year, queryDate, shiftIndex, code); } @Override public List findByMachineShortCode(String code) { return ((WorkstationMapper) this.baseMapper).findByMachineShortCode(code); } @Override public List workStationList(List ids) { return list(new QueryWrapper().lambda().in(Workstation::getId, ids).orderByAsc(Workstation::getName)); } @Override public Map queryGroupWorkStation(List ids) { List groupWorkDTOS = this.baseMapper.queryGroupWorkStation(ids); return groupWorkDTOS.stream().collect(Collectors.toMap((v0) -> { return v0.getItemId(); }, v -> { return v; })); } @Override public ProductionCalendarDay getDayShift(Long workstationId, String calendarDate) { return ((WorkstationMapper) this.baseMapper).getDayShift(workstationId, calendarDate); } @Override public List productionLineList(Long groupId) { List ids = Lists.newArrayList(); CommonGroup commonGroup = (CommonGroup) this.commonGroupService.getById(groupId); if (commonGroup != null) { String code = commonGroup.getCode(); List commonGroupList = this.commonGroupService.list(Wrappers.lambdaQuery() .eq(CommonGroup::getGroupCategory, CommonGroupConstant.DEFAULT_CATEGORY) .eq(CommonGroup::getGroupType, CommonGroupTypeEnum.WORKSTATION.getName()) .likeRight(CommonGroup::getCode, code)); if (Func.isNotEmpty(commonGroupList)) { List collect = commonGroupList.stream().map((v0) -> { return v0.getId(); }).distinct().collect(Collectors.toList()); ids.addAll(collect); } } return ids; } @Override public List getDmpVar(String workstationId) { return ((WorkstationMapper) this.baseMapper).getDmpVar(workstationId); } private void checkWorkstationImport(WorkstationImport workstationImport, List machineList, List calendarCodeList, HashMap commonGroupNameMap, CodeMapDTO codeMapDTO, Set machineCodeSet) { List codeList = codeMapDTO.getWorkstationCodeList(); List machineCodeList = codeMapDTO.getMachineCodeList(); codeMapDTO.getPinCodeMap(); Map shortCodeMap = codeMapDTO.getShortCodeMap(); Map importPinCodeMap = codeMapDTO.getImportPinCodeMap(); Map importShortCodeMap = codeMapDTO.getImportShortCodeMap(); Map machineDeaMap = null; List deactivateList = this.machineService.list( Wrappers.lambdaQuery().eq(Machine::getStatus, CommonConstant.DEACTIVATE)); if (Func.isNotEmpty(deactivateList)) { machineDeaMap = deactivateList.stream().collect(Collectors.toMap((v0) -> { return v0.getMachineCode(); }, Function.identity())); } List machineShortCodeList = machineList.stream().map((v0) -> { return v0.getShortCode(); }).distinct().collect(Collectors.toList()); Map machineCodeToValue = machineList.stream().collect(Collectors.toMap((v0) -> { return v0.getMachineCode(); }, v -> { return v; })); if (Func.isEmpty(workstationImport.getName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.name.can.not.be.null", new Object[0])); } else if (ValidatorUtils.stringFilter(workstationImport.getName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.name.exist.special.symbols.error", new Object[0])); } else if (Func.isEmpty(workstationImport.getCode())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.code.can.not.be.null", new Object[0])); } else if (checkUnableImportWorkstation(workstationImport.getCode())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.code.already.exists.stop.status", new Object[0])); } else if (ValidatorUtils.stringFilter(workstationImport.getCode())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.code.exist.special.symbols.error", new Object[0])); } else if (count(Wrappers.lambdaQuery().eq(Workstation::getCode, workstationImport.getCode())) > 0) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.code.already.exists", new Object[0])); } else if (!codeList.contains(workstationImport.getCode())) { codeList.add(workstationImport.getCode()); if (Func.isEmpty(workstationImport.getTypeName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.typeName.can.not.be.null", new Object[0])); } else if (!MachineConstant.TYPE_MACHINE.equals(workstationImport.getTypeName()) && !MachineConstant.TYPE_HUMAN.equals(workstationImport.getTypeName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.typeName.can.only.be.machine.or.human", new Object[0])); } else { if (MachineConstant.TYPE_MACHINE.equals(workstationImport.getTypeName())) { if (Func.isNotEmpty(workstationImport.getMachineCode()) && Func.isEmpty(workstationImport.getMachineName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machineName.can.not.be.null", new Object[0])); return; } String importMachinePinCode = workstationImport.getMachinePinCode(); String importMachineShortCode = workstationImport.getMachineShortCode(); if (Func.isNotEmpty(workstationImport.getMachineCode())) { if (machineDeaMap != null) { Machine machine = machineDeaMap.get(workstationImport.getMachineCode()); if (machine != null) { workstationImport.setFailReason(MessageUtils.message("machine.machine.workstation.already.exist.stop.status", new Object[0])); return; } } if (machineCodeToValue.containsKey(workstationImport.getMachineCode())) { if (!machineCodeToValue.get(workstationImport.getMachineCode()).getMachineName().equals(workstationImport.getMachineName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machineName.not.correct", new Object[0])); return; } String pinCode = machineCodeToValue.get(workstationImport.getMachineCode()).getPinCode(); if (Func.isNotEmpty(pinCode) && Func.isNotEmpty(importMachinePinCode)) { if (!pinCode.equals(importMachinePinCode)) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machinePinCode.not.correct", new Object[0])); return; } } else if (!Func.isEmpty(pinCode) || !Func.isEmpty(importMachinePinCode)) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machinePinCode.not.correct", new Object[0])); return; } String shortCode = machineCodeToValue.get(workstationImport.getMachineCode()).getShortCode(); if (Func.isNotEmpty(shortCode) && Func.isNotEmpty(importMachinePinCode)) { if (!shortCode.equals(importMachineShortCode)) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machineShortCode.not.correct", new Object[0])); return; } } else if (!Func.isEmpty(shortCode) || !Func.isEmpty(importMachinePinCode)) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machineShortCode.not.correct", new Object[0])); return; } workstationImport.setMachineId(machineCodeToValue.get(workstationImport.getMachineCode()).getId()); workstationImport.setLinkWay(0); if (machineCodeSet.contains(workstationImport.getMachineCode())) { workstationImport.setFailReason(MessageUtils.message("workstation.machine.code.already.band", new Object[0])); } else { machineCodeSet.add(workstationImport.getMachineCode()); } } else if (machineCodeList.contains(workstationImport.getMachineCode())) { workstationImport.setLinkWay(0); if (machineCodeSet.contains(workstationImport.getMachineCode())) { workstationImport.setFailReason(MessageUtils.message("workstation.machine.code.already.band", new Object[0])); } else { machineCodeSet.add(workstationImport.getMachineCode()); } } else { workstationImport.setLinkWay(1); machineCodeList.add(workstationImport.getMachineCode()); machineCodeSet.add(workstationImport.getMachineCode()); } } else if (machineCodeToValue.containsKey(workstationImport.getCode())) { workstationImport.setFailReason(MessageUtils.message("workstation.machine.code.already.exists", new Object[0])); return; } else { workstationImport.setLinkWay(1); workstationImport.setMachineName(workstationImport.getName()); workstationImport.setMachineCode(workstationImport.getCode()); machineCodeList.add(workstationImport.getMachineCode()); machineCodeSet.add(workstationImport.getMachineCode()); } if (Func.isNotEmpty(workstationImport.getMachinePinCode())) { if (importPinCodeMap.containsKey(workstationImport.getMachineCode())) { if (!workstationImport.getMachinePinCode().equals(importPinCodeMap.get(workstationImport.getMachineCode()))) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machinePinCode.not.correct", new Object[0])); return; } } else { importPinCodeMap.put(workstationImport.getMachineCode(), workstationImport.getMachinePinCode()); } } if (Func.isNotEmpty(workstationImport.getMachineShortCode())) { if (importShortCodeMap.containsKey(workstationImport.getMachineCode())) { if (!workstationImport.getMachineShortCode().equals(importShortCodeMap.get(workstationImport.getMachineCode()))) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machineShortCode.not.correct", new Object[0])); return; } } else { importShortCodeMap.put(workstationImport.getMachineCode(), workstationImport.getMachineShortCode()); } } if (Func.isNotEmpty(importMachineShortCode) && !machineShortCodeList.contains(importMachineShortCode)) { if (shortCodeMap.containsValue(importMachineShortCode)) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.machineShortCode.already.exists", new Object[0])); return; } shortCodeMap.put(workstationImport.getMachineCode(), importMachineShortCode); } workstationImport.setType(0); if (Func.isNotEmpty(importMachinePinCode)) { boolean valid = checkPinCode(importMachinePinCode, workstationImport.getMachineCode(), workstationImport); if (valid) { return; } } if (Func.isNotEmpty(importMachineShortCode)) { boolean valid2 = validShortCode(importMachineShortCode, workstationImport.getMachineCode(), workstationImport); if (valid2) { return; } } } else { workstationImport.setType(1); } if (Func.isNotEmpty(workstationImport.getCalendarCode()) && !calendarCodeList.contains(workstationImport.getCalendarCode())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.calendarCode.not.exists", new Object[0])); } else if (Func.isEmpty(workstationImport.getGroupName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.groupName.can.not.be.null", new Object[0])); } else if (!commonGroupNameMap.containsKey(workstationImport.getGroupName())) { workstationImport.setFailReason(MessageUtils.message("cps.workstation.groupName.not.exists", new Object[0])); } else { if (CommonGroupConstant.ALL_NAME.equals(workstationImport.getGroupName())) { workstationImport.setGroupName(CommonGroupConstant.DEFAULT_GROUP); } workstationImport.setGroupId(commonGroupNameMap.get(workstationImport.getGroupName())); } } } else { workstationImport.setFailReason(MessageUtils.message("cps.workstation.code.already.exists", new Object[0])); } } private boolean validShortCode(String shortCode, String code, WorkstationImport workstationImport) { int len = shortCode.length(); if (len < 4 || len > 8) { workstationImport.setFailReason(StringUtil.format(MessageUtils.message("cps.tpm.machine.short.code.length", new Object[0]), new Object[]{4, 8})); return true; } Long count = Long.valueOf(this.machineService.count(Wrappers.lambdaQuery().eq(Machine::getShortCode, shortCode) .ne(Func.isNotEmpty(code), Machine::getMachineCode, code))); if (count.longValue() > 0) { workstationImport.setFailReason(MessageUtils.message("cps.tpm.machine.short.code.exists", new Object[0])); return true; } boolean matches = CHINESE.matcher(shortCode).matches(); if (!matches) { workstationImport.setFailReason(MessageUtils.message("machine.short.code.chinese.characters.exist", new Object[0])); return true; } return false; } private boolean checkPinCode(String pinCode, String code, WorkstationImport workstationImport) { int len = pinCode.length(); if (len < 4 || len > 6) { workstationImport.setFailReason(StringUtil.format(MessageUtils.message("cps.tpm.machine.pin.code.length", new Object[0]), new Object[]{4, 6})); return true; } boolean matches = CHINESE.matcher(pinCode).matches(); if (!matches) { workstationImport.setFailReason(MessageUtils.message("machine.ping.code.chinese.characters.exist", new Object[0])); return true; } return false; } @Override public WorkstationVO getDetail(Long workstationId) { //SpaceRootNodeVO ftpDirectory; Workstation workstation = (Workstation) getById(workstationId); if (workstation != null) { WorkstationVO workstationVO = WorkstationConvert.INSTANCE.convert(workstation); ProductionCalendar calendar = this.calendarService.getOne(Wrappers.lambdaQuery() .eq(ProductionCalendar::getCode, workstation.getCalendarCode()) .eq(ProductionCalendar::getYear, Integer.valueOf(LocalDate.now().getYear()))); /* ProductionCalendar calendar = (ProductionCalendar) this.calendarService.getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> { return v0.getCode(); }, workstation.getCalendarCode())).eq((v0) -> { return v0.getYear(); }, Integer.valueOf(LocalDate.now().getYear())));*/ if (Func.notNull(calendar)) { workstationVO.setCalendarName(calendar.getName()); } else { workstationVO.setCalendarName("系统日历"); } CommonGroupOfItem commonGroupOfItem = this.commonGroupOfItemService.getOne(Wrappers.lambdaQuery().eq(CommonGroupOfItem::getItemId, workstationId)); if (commonGroupOfItem != null) { CommonGroup commonGroup = (CommonGroup) this.commonGroupService.getById(commonGroupOfItem.getGroupId()); if (Func.isNotEmpty(commonGroup)) { workstationVO.setGroupName(commonGroup.getName()); } workstationVO.setGroupId(commonGroupOfItem.getGroupId()); } WorkstationOfMachine workstationOfMachine = this.workstationOfMachineService.getWorkstationOfMachineByWorkstationId(workstationId); if (Func.isNotEmpty(workstationOfMachine)) { Long machineId = workstationOfMachine.getMachineId(); MachineDetailVO machine = this.machineService.detailMachine(machineId); if (Func.isNotEmpty(machine)) { workstationVO.setMachineCode(machine.getMachineCode()); workstationVO.setMachineName(machine.getMachineName()); workstationVO.setMachineBrand(machine.getBrand()); workstationVO.setMachineTypeId(machine.getMachineTypeId()); workstationVO.setMachineTypeCode(machine.getMachineTypeCode()); workstationVO.setMachineTypeName(machine.getMachineTypeName()); workstationVO.setMachineModel(machine.getMachineModel()); } workstationVO.setMachineId(machineId); } /* try { ftpDirectory = this.dncFixedSpaceService.getRootNodeId(String.valueOf(workstationId)); } catch (Exception e) { ftpDirectory = new SpaceRootNodeVO(); } workstationVO.setFtpDirectoryId(ftpDirectory.getRootNodeId()); workstationVO.setFtpDirectoryName(ftpDirectory.getName()); */ return workstationVO; } return null; } /* @Override public List getDmpVariables(String workstationId, String machineId) { if (Func.isBlank(machineId)) { throw new ServiceException(MessageUtils.message("workstation.not.turn.on.acquisition.function", new Object[0])); } List dmpVariablesVOS = this.dmpVariablesService.getDmpVariablesByWorkstationId(Long.valueOf(workstationId)); return dmpVariablesVOS.stream().filter((v0) -> { return v0.getRealTimeData(); }).collect(Collectors.toList()); } */ private void checkWorkstation(WorkstationSubmitVO workstationSubmitVO) { if (Func.isNotEmpty(workstationSubmitVO.getCode()) && workstationSubmitVO.getCode().length() > 24) { throw new ServiceException(MessageUtils.message("cps.workstation.code.length.too.long", new Object[0])); } Long count = Long.valueOf(count(Wrappers.lambdaQuery() .ne(Func.isNotEmpty(workstationSubmitVO.getId()), Workstation::getId, workstationSubmitVO.getId()) .eq(Workstation::getCode, workstationSubmitVO.getCode()) .eq(Workstation::getStatus, CommonConstant.ENABLE))); /* Long count = Long.valueOf(count((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(workstationSubmitVO.getId()), (v0) -> { return v0.getId(); }, workstationSubmitVO.getId()).eq((v0) -> { return v0.getCode(); }, workstationSubmitVO.getCode())).eq((v0) -> { return v0.getStatus(); }, CommonConstant.ENABLE)));*/ if (count.longValue() > 0) { throw new ServiceException(MessageUtils.message("cps.workstation.code.already.exists", new Object[0])); } } private boolean checkUnableImportWorkstation(String code) { Workstation workstation = getOne(Wrappers.lambdaQuery() .eq(Workstation::getCode, code) .eq(Workstation::getStatus, CommonConstant.DEACTIVATE)); /* Workstation workstation = (Workstation) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> { return v0.getCode(); }, code)).eq((v0) -> { return v0.getStatus(); }, CommonConstant.DEACTIVATE));*/ if (workstation != null) { return Boolean.TRUE.booleanValue(); } return Boolean.FALSE.booleanValue(); } private void checkUnableWorkstation(WorkstationSubmitVO workstationSubmitVO) { Workstation workstation = getOne(Wrappers.lambdaQuery().ne(Func.isNotEmpty(workstationSubmitVO.getId()), Workstation::getId, workstationSubmitVO.getId()) .eq(Workstation::getCode, workstationSubmitVO.getCode()) .eq(Workstation::getStatus, CommonConstant.DEACTIVATE)); /* Workstation workstation = (Workstation) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(workstationSubmitVO.getId()), (v0) -> { return v0.getId(); }, workstationSubmitVO.getId()).eq((v0) -> { return v0.getCode(); }, workstationSubmitVO.getCode())).eq((v0) -> { return v0.getStatus(); }, CommonConstant.DEACTIVATE));*/ if (workstation != null) { throw new ServiceException(MessageUtils.message("cps.workstation.code.already.exists.stop.status", new Object[0])); } } public List getCommonGroupIds(List idList, List list) { /* List commonGroupList = this.commonGroupService.list(Lambda.in((v0) -> { return v0.getParentId(); }, idList));*/ List commonGroupList = this.commonGroupService.list(Lambda.in(CommonGroup::getParentId, idList)); if (Func.isEmpty(commonGroupList)) { return list; } List ids = commonGroupList.stream().map(item -> { return String.valueOf(item.getId()); }).collect(Collectors.toList()); list.addAll(commonGroupList); return getCommonGroupIds(ids, list); } @Override public WorkMachineEasyVO getWorkMachine(String workstationId) { return ((WorkstationMapper) this.baseMapper).getWorkMachine(workstationId); } @Override public List fmsTreeWorkstation(FmsWorkstationQueryVO queryVO) { WorkTypeEnum workTypeEnum; List allSubGroup = this.commonGroupService.getAllSubGroup(CommonGroupConstant.WARE_ROOT, CommonGroupTypeEnum.WORKSTATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY); if (Func.isEmpty(allSubGroup)) { return new ArrayList<>(); } List groupIds = allSubGroup.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); List fmsWorkstationGroupVOS = CommonGroupConvert.INSTANCE.convertFmsList(allSubGroup); List list = this.commonGroupOfItemService.list(Wrappers.lambdaQuery().in(CommonGroupOfItem::getGroupId, groupIds)); Map groupOfItemMap = list.stream().collect(Collectors.toMap((v0) -> { return v0.getItemId(); }, item -> { return item; })); List workstationIds = list.stream().map((v0) -> { return v0.getItemId(); }).collect(Collectors.toList()); List roots = fmsWorkstationGroupVOS.stream().filter(item2 -> { return Func.equals(item2.getParentId(), Long.valueOf(CommonGroupConstant.ROOT.longValue())); }).collect(Collectors.toList()); if (Func.isEmpty(workstationIds)) { return roots; } List workstations = list(Wrappers.lambdaQuery().in(Workstation::getId, workstationIds).eq(Workstation::getStatus, CommonConstant.ENABLE) .in(Func.isNotEmpty(queryVO.getTypeList()),Workstation::getType, queryVO.getTypeList()) .in(Func.isNotEmpty(queryVO.getDeviceTypeList()), Workstation::getDeviceType, queryVO.getDeviceTypeList())); List vos = WorkstationConvert.INSTANCE.convertListFms(workstations); for (FmsWorkstationGroupVO fmsWorkstationVO : vos) { CommonGroupOfItem commonGroupOfItem = groupOfItemMap.get(fmsWorkstationVO.getId()); fmsWorkstationVO.setParentId(commonGroupOfItem.getGroupId()); Integer deviceType = fmsWorkstationVO.getDeviceType(); if (Func.isNotEmpty(deviceType) && (workTypeEnum = WorkTypeEnum.findByCode(deviceType)) != null) { fmsWorkstationVO.setDeviceTypeName(workTypeEnum.getDesc()); } } fmsWorkstationGroupVOS.addAll(vos); assembleFmsTree(roots, fmsWorkstationGroupVOS); return roots; } @Override public List listMachine(Integer status, String keyword) { return ((WorkstationMapper) this.baseMapper).listMachine(status, keyword); } @Override public List getWorkstationListInMaintainOrRepairById(Long orderProcessId, Set workstationIdList) { return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairById(orderProcessId, workstationIdList); } @Override public List getWorkstationListInMaintainOrRepairByIdList(List orderProcessIdList, Set workstationIdList) { return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairByIdList(orderProcessIdList, workstationIdList); } @Override public IPage pageH5(Query query, WorkstationPageQueryVO workstationPageQueryVO) { IPage workstationVOIPage = listPage(new Page().setSize(-1L), workstationPageQueryVO.getKeyWord(), null, workstationPageQueryVO.getStatus(), workstationPageQueryVO.getType()); IPage convert = WorkstationConvert.INSTANCE.convertPage(workstationVOIPage); List result = buildProperties(convert.getRecords(), workstationPageQueryVO.getDeviceStatus()); return manualBuildIPage(query, result); } private IPage manualBuildIPage(Query query, List result) { Page page = new Page<>(query.getCurrent(), query.getSize(), result.size()); if (result.size() == 0) { return page; } if (query.getSize() == -1) { page.setRecords(result); } else if (result.size() < ((query.getCurrent() - 1) * query.getSize()) + query.getSize()) { page.setRecords(result.subList((query.getCurrent() - 1) * query.getSize(), result.size())); } else { page.setRecords(result.subList((query.getCurrent() - 1) * query.getSize(), ((query.getCurrent() - 1) * query.getSize()) + query.getSize())); } return page; } private List buildProperties(List list, List deviceStatus) { List dataList = new ArrayList<>(); if (Func.isEmpty(list)) { return dataList; } //TODO，格式太差 Map> realTimePropertiesMap = getRealTimeProperties( list.stream().map(WorkstationRealTimeStatusVO::getId).collect(Collectors.toList())); return list.stream().filter(i -> { boolean filter = true; if (Func.isEmpty(i.getMachineId())) { filter = false; } List properties = realTimePropertiesMap.get(i.getId()); if (Func.isNotEmpty(deviceStatus)) { if (Func.isEmpty(properties)) { filter = false; } else { Iterator it = properties.iterator(); while (true) { if (!it.hasNext()) { break; } RealTimeStatusVO r = it.next(); if (MdcConstant.DEVICE_STATUS.equals(r.getKey()) && Func.isNotEmpty(r.getValue()) && deviceStatus.contains(Integer.valueOf(r.getValue()))) { filter = true; break; } filter = false; } } } i.setProperties(properties); return filter; }).collect(Collectors.toList()); } private void assembleFmsTree(List roots, List fmsWorkstationGroupVOS) { if (Func.isEmpty(roots)) { return; } List itemGroups = new ArrayList<>(); for (FmsWorkstationGroupVO vo : roots) { List vos = fmsWorkstationGroupVOS.stream().filter(item -> { return Func.equals(item.getParentId(), vo.getId()); }).collect(Collectors.toList()); vo.setChildren(vos); itemGroups.addAll(vos); } assembleFmsTree(itemGroups, fmsWorkstationGroupVOS); } /* public void dealWorkstation(List fmsWorkstationList, List informationVOList, Integer key, List realTimeTrayList, List positionList) { informationVOList.forEach(workstation -> { FmsWorkstation fmsWorkstation = new FmsWorkstation(); String workstationId = String.valueOf(workstation.getWorkstationId()); WorkstationWcsDmpDTO workstationWcsDmpDTO = queryDateTypeState(WcsDataTypeEnums.WcsDataType.STATE.getCode(), workstationId); if (workstationWcsDmpDTO != null) { String name = workstationWcsDmpDTO.getName(); TelemetryDataResponseDTO value = getValue(name, workstationId); if (value != null) { String state = value.getV(); Long time = value.getT(); if (Func.isNotEmpty(state)) { fmsWorkstation.setState(state); } if (time != null) { LocalDateTime localDateTime = LocalDateTimeUtils.DateToLocalDateTime(new Date(time.longValue())); Long timeDifference = getTimeDifference(localDateTime, LocalDateTime.now()); fmsWorkstation.setTs(String.valueOf(timeDifference)); } } } WorkstationWcsDmpDTO workstationProgram = queryDateTypeState(WcsDataTypeEnums.WcsDataType.PROGRAM.getCode(), workstationId); if (workstationProgram != null) { String name2 = workstationProgram.getName(); TelemetryDataResponseDTO value2 = getValue(name2, workstationId); if (value2 != null) { String program = value2.getV(); if (Func.isNotEmpty(program)) { fmsWorkstation.setProgrammName(program); } } } fmsWorkstation.setCode(workstation.getWorkstationCode()); fmsWorkstation.setName(workstation.getWorkstationName()); fmsWorkstation.setId(workstationId); List workbenchList = workstation.getWorkstationList(); if (Func.isNotEmpty(workbenchList)) { if (!WorkTypeEnum.HANDLE.getCode().equals(key)) { fmsWorkstation.setWorkBenchList(workbenchList.stream().map(s -> { List collect = realTimeTrayList.stream().filter(r -> { return workstation.getWorkstationCode().equals(r.getCurrentPosition()) && String.valueOf(s.getSort()).equals(r.getCurrentStation()); }).collect(Collectors.toList()); FmsWorkBench fmsWorkBench = new FmsWorkBench(); fmsWorkBench.setId(String.valueOf(s.getId())); fmsWorkBench.setName(s.getName()); fmsWorkBench.setSort(s.getSort()); if (Func.isNotEmpty(collect)) { FmsRealTimeTray currentRealTimeTray = collect.get(0); if (Func.isNotEmpty(currentRealTimeTray.getPartType())) { fmsWorkBench.setState(String.valueOf(currentRealTimeTray.getPartType())); } fmsWorkBench.setPalletCode(currentRealTimeTray.getTrayCode()); } return fmsWorkBench; }).collect(Collectors.toList())); } else { fmsWorkstation.setWorkBenchList(workbenchList.stream().map(s2 -> { List collect = realTimeTrayList.stream().filter(r -> { return workstation.getWorkstationCode().equals(r.getCurrentPosition()); }).collect(Collectors.toList()); FmsWorkBench fmsWorkBench = new FmsWorkBench(); fmsWorkBench.setId(String.valueOf(s2.getId())); fmsWorkBench.setName(s2.getName()); fmsWorkBench.setSort(s2.getSort()); if (Func.isNotEmpty(collect)) { FmsRealTimeTray currentRealTimeTray = collect.get(0); if (Func.isNotEmpty(currentRealTimeTray.getPartType())) { fmsWorkBench.setState(String.valueOf(currentRealTimeTray.getPartType())); } fmsWorkBench.setPalletCode(currentRealTimeTray.getTrayCode()); } return fmsWorkBench; }).collect(Collectors.toList())); } } if ((WorkTypeEnum.LOAD_AND_UNLOAD.getCode().equals(key) || WorkTypeEnum.PROCESS.getCode().equals(key)) && positionList.contains(workstation.getWorkstationCode())) { List collect = realTimeTrayList.stream().filter(r -> { return workstation.getWorkstationCode().equals(r.getCurrentPosition()); }).collect(Collectors.toList()); FmsRealTimeTray trayRealTimeData = collect.get(0); if (trayRealTimeData != null && Func.isNotEmpty(trayRealTimeData.getPartType()) && OrderStatusEnum.MACH_ING.getValue() == trayRealTimeData.getPartType().intValue() && Func.isNotEmpty(trayRealTimeData.getPartTypeTime())) { LocalDateTime localDateTime2 = LocalDateTimeUtils.DateToLocalDateTime(trayRealTimeData.getPartTypeTime()); Long timeDifference2 = getTimeDifference(localDateTime2, LocalDateTime.now()); fmsWorkstation.setTime(String.valueOf(timeDifference2)); } } fmsWorkstationList.add(fmsWorkstation); }); }*/ private TelemetryDataResponseDTO getValue(String name, String workstationId) { Map workstationAllCollect = WorkstationCache.getWorkstationAllCollect(workstationId); if (!workstationAllCollect.isEmpty()) { return (TelemetryDataResponseDTO) workstationAllCollect.get(name); } return null; } }