package com.qianwen.smartman.modules.cps.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.Comparator; import java.util.Date; 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.TreeSet; 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.jetbrains.annotations.NotNull; 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.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.CollectionUtil; import com.qianwen.core.tool.utils.DateUtil; import com.qianwen.core.tool.utils.Func; import com.qianwen.core.tool.utils.StringUtil; 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.utils.Lambda; import com.qianwen.smartman.common.utils.LocalDateTimeUtils; 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.common.websocket.entity.FmsWorkstation; import com.qianwen.smartman.modules.cps.convert.CommonGroupConvert; import com.qianwen.smartman.modules.cps.convert.WorkstationConvert; import com.qianwen.smartman.modules.cps.convert.WorkstationWorkbenchConvert; import com.qianwen.smartman.modules.cps.dto.CodeMapDTO; import com.qianwen.smartman.modules.cps.dto.WorkstationCreateMessageDTO; import com.qianwen.smartman.modules.cps.dto.WorkstationRealTimeStatusDTO; import com.qianwen.smartman.modules.cps.dto.WorkstationWcsDmpDTO; import com.qianwen.smartman.modules.cps.entity.CommonGroup; import com.qianwen.smartman.modules.cps.entity.CommonGroupOfItem; import com.qianwen.smartman.modules.cps.entity.Machine; import com.qianwen.smartman.modules.cps.entity.ProductionCalendar; import com.qianwen.smartman.modules.cps.entity.ProductionCalendarDay; import com.qianwen.smartman.modules.cps.entity.Workstation; import com.qianwen.smartman.modules.cps.entity.WorkstationOfMachine; import com.qianwen.smartman.modules.cps.entity.WorkstationWorkbench; import com.qianwen.smartman.modules.cps.enums.WorkTypeEnum; import com.qianwen.smartman.modules.cps.excel.WorkstationExcel; import com.qianwen.smartman.modules.cps.excel.WorkstationImport; import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper; import com.qianwen.smartman.modules.cps.message.dto.TelemetryDataResponseDTO; import com.qianwen.smartman.modules.cps.message.producer.InsertWorkstationProducer; import com.qianwen.smartman.modules.cps.service.ICalendarService; import com.qianwen.smartman.modules.cps.service.ICommonGroupOfItemService; import com.qianwen.smartman.modules.cps.service.ICommonGroupService; import com.qianwen.smartman.modules.cps.service.IDmpVariablesService; import com.qianwen.smartman.modules.cps.service.IMachineService; import com.qianwen.smartman.modules.cps.service.IWorkstationOfMachineService; import com.qianwen.smartman.modules.cps.service.IWorkstationService; import com.qianwen.smartman.modules.cps.service.IWorkstationWcsService; import com.qianwen.smartman.modules.cps.service.IWorkstationWorkbenchService; import com.qianwen.smartman.modules.cps.vo.DmpVariablesVO; import com.qianwen.smartman.modules.cps.vo.FmsWorkstationGroupVO; import com.qianwen.smartman.modules.cps.vo.FmsWorkstationQueryVO; import com.qianwen.smartman.modules.cps.vo.MachineDetailVO; import com.qianwen.smartman.modules.cps.vo.MachineInformationVO; import com.qianwen.smartman.modules.cps.vo.MachineVO; import com.qianwen.smartman.modules.cps.vo.RealTimeStatusVO; import com.qianwen.smartman.modules.cps.vo.WorkMachineEasyVO; import com.qianwen.smartman.modules.cps.vo.WorkstationChangeCalendarVO; import com.qianwen.smartman.modules.cps.vo.WorkstationOfWorkbenchVO; import com.qianwen.smartman.modules.cps.vo.WorkstationPageQueryVO; import com.qianwen.smartman.modules.cps.vo.WorkstationRealTimeStatusVO; import com.qianwen.smartman.modules.cps.vo.WorkstationSubmitVO; import com.qianwen.smartman.modules.cps.vo.WorkstationVO; import com.qianwen.smartman.modules.cps.vo.WorkstationWorkbenchVO; import com.qianwen.smartman.modules.dnc.dto.WorkstationDirectoryDto; import com.qianwen.smartman.modules.dnc.service.IDncFixedSpaceService; import com.qianwen.smartman.modules.dnc.service.IDncWsRelationTdService; import com.qianwen.smartman.modules.dnc.service.ITransferDirectoryGroupService; import com.qianwen.smartman.modules.dnc.service.ITransferDirectoryService; import com.qianwen.smartman.modules.dnc.vo.SpaceRootNodeVO; import com.qianwen.smartman.modules.dnc.vo.WorkstationTdVO; import com.qianwen.smartman.modules.fms.entity.FmsRealTimeTray; import com.qianwen.smartman.modules.fms.enums.FmsOrderEnum; import com.qianwen.smartman.modules.fms.enums.OrderStatusEnum; 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; @Service /* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/WorkstationServiceImpl.class */ public class WorkstationServiceImpl extends BaseServiceImpl implements IWorkstationService { private static final Pattern CHINESE = Pattern.compile("^[A-Za-z0-9]+$"); private final IMachineService machineService; private final IWorkstationOfMachineService workstationOfMachineService; private final IWorkstationWcsService workstationWcsService; private final ICommonGroupOfItemService commonGroupOfItemService; private final ICommonGroupService commonGroupService; private final ICalendarService calendarService; private final WorkstationMapper workstationMapper; private final OssBuilder ossBuilder; private final IDmpVariablesService dmpVariablesService; private final ITransferDirectoryService transferDirectoryService; private final ITransferDirectoryGroupService transferDirectoryGroupService; private final IWorkstationWorkbenchService workbenchService; private final IDncWsRelationTdService wsRelationTdService; private final IDncFixedSpaceService dncFixedSpaceService; private final InsertWorkstationProducer workstationProducer; private final IWorkstationDynamicCollectService dynamicCollectService; 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 WorkstationServiceImpl(final IMachineService machineService, final IWorkstationOfMachineService workstationOfMachineService, final IWorkstationWcsService workstationWcsService, final ICommonGroupOfItemService commonGroupOfItemService, final ICommonGroupService commonGroupService, final ICalendarService calendarService, final WorkstationMapper workstationMapper, final OssBuilder ossBuilder, final IDmpVariablesService dmpVariablesService, final ITransferDirectoryService transferDirectoryService, final ITransferDirectoryGroupService transferDirectoryGroupService, final IWorkstationWorkbenchService workbenchService, final IDncWsRelationTdService wsRelationTdService, final IDncFixedSpaceService dncFixedSpaceService, final InsertWorkstationProducer workstationProducer, final IWorkstationDynamicCollectService dynamicCollectService) { this.machineService = machineService; this.workstationOfMachineService = workstationOfMachineService; this.workstationWcsService = workstationWcsService; this.commonGroupOfItemService = commonGroupOfItemService; this.commonGroupService = commonGroupService; this.calendarService = calendarService; this.workstationMapper = workstationMapper; this.ossBuilder = ossBuilder; this.dmpVariablesService = dmpVariablesService; this.transferDirectoryService = transferDirectoryService; this.transferDirectoryGroupService = transferDirectoryGroupService; this.workbenchService = workbenchService; this.wsRelationTdService = wsRelationTdService; this.dncFixedSpaceService = dncFixedSpaceService; this.workstationProducer = workstationProducer; this.dynamicCollectService = dynamicCollectService; } 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 // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService public WorkstationWcsDmpDTO queryDateTypeState(Integer code, String workstationId) { return ((WorkstationMapper) this.baseMapper).queryDateTypeState(code, workstationId); } @Override // org.springblade.modules.cps.service.IWorkstationService public List queryDmpList(String workstationId) { return ((WorkstationMapper) this.baseMapper).queryDmpList(workstationId); } @Override // org.springblade.modules.cps.service.IWorkstationService @Transactional(rollbackFor = {Exception.class}) public WorkstationVO submit(WorkstationSubmitVO workstationSubmitVO) { 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.POSTING_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())) { WorkstationCreateMessageDTO dto = WorkstationCreateMessageDTO.builder().workstationId(workstation.getId().toString()).operationTime(DateUtil.now()).build(); this.workstationProducer.sendInsertWorkstationMessage(dto); } return workstationVO; } 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 // org.springblade.modules.cps.service.IWorkstationService public Boolean changeCollectSwitch(Long workstationId, Integer collectSwitch) { return this.machineService.changeCollectSwitch(workstationId, collectSwitch); } @Override // org.springblade.modules.cps.service.IWorkstationService @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)); /* 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.POSTING_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.POSTING_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 // org.springblade.modules.cps.service.IWorkstationService 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, Integer.valueOf(LocalDate.now().getYear())); workstationVOS.forEach(workstationVO -> { String calendarName = workstationVO.getCalendarName(); if (Func.isBlank(calendarName)) { workstationVO.setCalendarName("系统日历"); } }); return workstationVOIPage.setRecords(workstationVOS); } @Override // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService public List getFmsWorkstation(final List workstationIds) { List commonGroupIds = this.commonGroupService.list(Lambda.eq((v0) -> { return v0.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 // org.springblade.modules.cps.service.IWorkstationService public Boolean changeCalendarCode(WorkstationChangeCalendarVO workstationChangeCalendarVO) { Workstation workstation = (Workstation) getById(workstationChangeCalendarVO.getWorkstationId()); workstation.setCalendarCodeWaiting(workstationChangeCalendarVO.getCalendarCodeWaiting()); return Boolean.valueOf(updateById(workstation)); } @Override // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService @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 // org.springblade.modules.cps.service.IWorkstationService @Transactional(rollbackFor = {Exception.class}) public Boolean deleteGroup(Long groupId) { if (this.commonGroupOfItemService.count(Lambda.eq((v0) -> { return v0.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 // org.springblade.modules.cps.service.IWorkstationService @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 // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService 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())); } @Override // org.springblade.modules.cps.service.IWorkstationService public List getRealTimeProperties(Long workstationId, Long machineId) { List properties = new ArrayList<>(); Map map = WorkstationCache.getWorkstationRealTime(String.valueOf(workstationId)); List list = this.dmpVariablesService.getDmpVariablesByWorkstationId(workstationId); if (CollectionUtil.isNotEmpty(list)) { list.forEach(dmpVariablesVO -> { RealTimeStatusVO vo = new RealTimeStatusVO(); vo.setKey(dmpVariablesVO.getName()); vo.setName(dmpVariablesVO.getDescription()); vo.setUnit(dmpVariablesVO.getDmpType()); vo.setSort(dmpVariablesVO.getIdx()); vo.setWcsDataType(dmpVariablesVO.getWcsDataType()); vo.setBigScreen(dmpVariablesVO.getBigScreen()); vo.setRealTimeData(dmpVariablesVO.getRealTimeData()); if (map.containsKey(dmpVariablesVO.getName())) { TelemetryDataResponseDTO t = (TelemetryDataResponseDTO) MapUtils.getObject(map, dmpVariablesVO.getName()); vo.setValue(t.getV()); } properties.add(vo); }); } return properties; } public Map> getRealTimeProperties(List workstationIdList) { Map> properties = new HashMap<>(); List list = this.dmpVariablesService.getDmpVariablesByWorkstationIds(workstationIdList); if (Func.isNotEmpty(list)) { Map> dmpVariablesMap =list.stream().collect(Collectors.groupingBy((v0) -> { return v0.getWorkstationId(); })); dmpVariablesMap.forEach((k, v) -> { ArrayList arrayList = new ArrayList<>(); Map map = WorkstationCache.getWorkstationRealTime(String.valueOf(k)); v.forEach(dmpVariablesVO -> { RealTimeStatusVO vo = new RealTimeStatusVO(); vo.setKey(dmpVariablesVO.getName()); vo.setName(dmpVariablesVO.getDescription()); vo.setUnit(dmpVariablesVO.getDmpType()); vo.setSort(dmpVariablesVO.getIdx()); vo.setWcsDataType(dmpVariablesVO.getWcsDataType()); vo.setBigScreen(dmpVariablesVO.getBigScreen()); vo.setRealTimeData(dmpVariablesVO.getRealTimeData()); if (map.containsKey(dmpVariablesVO.getName())) { TelemetryDataResponseDTO t = (TelemetryDataResponseDTO) MapUtils.getObject(map, dmpVariablesVO.getName()); vo.setValue(t.getV()); } arrayList.add(vo); }); properties.put(k, arrayList); }); } return properties; } @Override // org.springblade.modules.cps.service.IWorkstationService public IPage 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 // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService public List listWorkStationByGroupId(List ids) { return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids); } @Override // org.springblade.modules.cps.service.IWorkstationService public List listWorkStationByGroup(List ids) { return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids.stream().map((v0) -> { return String.valueOf(v0); }).collect(Collectors.toList())); } @Override // org.springblade.modules.cps.service.IWorkstationService public Set findByIndexAndDateAndTypeAndYear(Integer year, String queryDate, Integer shiftIndex, Integer code) { return ((WorkstationMapper) this.baseMapper).findByIndexAndDateAndTypeAndYear(year, queryDate, shiftIndex, code); } @Override // org.springblade.modules.cps.service.IWorkstationService public List findByMachineShortCode(String code) { return ((WorkstationMapper) this.baseMapper).findByMachineShortCode(code); } @Override // org.springblade.modules.cps.service.IWorkstationService public List workStationList(List ids) { return list(new QueryWrapper().lambda().in(Workstation::getId, ids).orderByAsc(Workstation::getName)); } @Override // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService public ProductionCalendarDay getDayShift(Long workstationId, String calendarDate) { return ((WorkstationMapper) this.baseMapper).getDayShift(workstationId, calendarDate); } @Override // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService 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)); 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 // org.springblade.modules.cps.service.IWorkstationService public List assemblyWorkstationData(List workstationIds, Map realTimeTrayMap, List realTimeTrayList, List positionList) { List fmsWorkstationList = new ArrayList<>(); List informationList = new ArrayList<>(); workstationIds.forEach(id -> { MachineInformationVO machineInformationVO = this.workbenchService.listWorkstationWorkbench(Long.valueOf(Func.toLong(id))); informationList.add(machineInformationVO); }); List informationVOS = informationList.stream().filter(s -> { return Func.isNotEmpty(s.getDeviceType()); }).collect(Collectors.toList()); Map> workstationMap = informationVOS.stream().collect(Collectors.groupingBy((v0) -> { return v0.getDeviceType(); })); workstationMap.forEach((key, value) -> { dealWorkstation(fmsWorkstationList, value, key, realTimeTrayList, positionList); }); return fmsWorkstationList; } @Override // org.springblade.modules.cps.service.IWorkstationService public WorkMachineEasyVO getWorkMachine(String workstationId) { return ((WorkstationMapper) this.baseMapper).getWorkMachine(workstationId); } @Override // org.springblade.modules.cps.service.IWorkstationService 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 // org.springblade.modules.cps.service.IWorkstationService public List listMachine(Integer status, String keyword) { return ((WorkstationMapper) this.baseMapper).listMachine(status, keyword); } @Override // org.springblade.modules.cps.service.IWorkstationService public List getWorkstationListInMaintainOrRepairById(Long orderProcessId, Set workstationIdList) { return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairById(orderProcessId, workstationIdList); } @Override // org.springblade.modules.cps.service.IWorkstationService public List getWorkstationListInMaintainOrRepairByIdList(List orderProcessIdList, Set workstationIdList) { return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairByIdList(orderProcessIdList, workstationIdList); } @Override // org.springblade.modules.cps.service.IWorkstationService 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().intValue(), query.getSize().intValue(), result.size()); if (result.size() == 0) { return page; } if (query.getSize().intValue() == -1) { page.setRecords(result); } else if (result.size() < ((query.getCurrent().intValue() - 1) * query.getSize().intValue()) + query.getSize().intValue()) { page.setRecords(result.subList((query.getCurrent().intValue() - 1) * query.getSize().intValue(), result.size())); } else { page.setRecords(result.subList((query.getCurrent().intValue() - 1) * query.getSize().intValue(), ((query.getCurrent().intValue() - 1) * query.getSize().intValue()) + query.getSize().intValue())); } return page; } private List buildProperties(List list, List deviceStatus) { List dataList = new ArrayList<>(); if (Func.isEmpty(list)) { return dataList; } Map> realTimePropertiesMap = getRealTimeProperties( list.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList())); return list.stream().filter(i -> { boolean filter = Boolean.TRUE.booleanValue(); 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; } }