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<WorkstationMapper, Workstation> 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<WorkstationWcsDmpDTO> 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<DmpVariablesVO> 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<CommonGroupOfItem> itemList = this.commonGroupOfItemService.list(Wrappers.<CommonGroupOfItem>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.<Machine>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<WorkstationWorkbenchVO> workbenchVOList = workstationSubmitVO.getWorkbenchVOList();
|
List<WorkstationWorkbench> workstationWorkbenchList = new ArrayList<>();
|
Map<String, List<WorkstationWorkbenchVO>> 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<WorkstationWorkbenchVO> workbenchList2 = workstationSubmitVO.getWorkbenchVOList();
|
List<Long> deleteWorkbenchIdList = new ArrayList<>();
|
List<WorkstationWorkbench> 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<Long> 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.<WorkstationOfMachine>lambdaQuery().in(WorkstationOfMachine::getWorkstationId, workstationIds));
|
this.commonGroupOfItemService.remove(Wrappers.<CommonGroupOfItem>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<WorkstationVO> listPage(IPage<WorkstationVO> workstationVOIPage, String keyWord, Long groupId, Integer status, Integer type) {
|
List<String> 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<WorkstationVO> 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<WorkstationVO> getWorkstationByGroupIds(final List<String> groupIds) {
|
List<WorkstationVO> 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<FmsWorkBench> 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<FmsWorkstation> getFmsWorkstation(final List<Long> workstationIds) {
|
List<Long> commonGroupIds = this.commonGroupService.list(Lambda.eq((v0) -> {
|
return v0.getGroupTag();
|
}, FmsOrderEnum.FMS_BELTLINE.getCode())).stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<FmsWorkstation> 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<Workstation> list = list(new QueryWrapper<Workstation>().lambda().isNotNull(Workstation::getCalendarCodeWaiting));
|
List<Workstation> 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<Long> workstationIdList) {
|
CommonGroup commonGroup = (CommonGroup) this.commonGroupService.getById(groupId);
|
List<CommonGroupOfItem> list = this.commonGroupOfItemService.list( Wrappers.<CommonGroupOfItem>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<WorkstationImport> 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<String, Long> commonGroupNameMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.WORKSTATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
List<Machine> machineList = this.machineService.list(Wrappers.<Machine>lambdaQuery().eq(Machine::getStatus, CommonConstant.ENABLE));
|
List<String> calendarCodeList = this.calendarService.getCalendarList(AuthUtil.getTenantId()).stream().map((v0) -> {
|
return v0.getCode();
|
}).collect(Collectors.toList());
|
Boolean flag = Boolean.TRUE;
|
HashMap<String, String> pinCodeMap = new HashMap<>();
|
HashMap<String, String> shortCodeMap = new HashMap<>();
|
Map<String, String> importPinCodeMap = new HashMap<>();
|
Map<String, String> importShortCodeMap = new HashMap<>();
|
List<String> workstationCodeList = new ArrayList<>();
|
List<String> machineCodeList = new ArrayList<>();
|
List<MachineVO> machineVOList = this.machineService.listHaveBand();
|
Set<String> 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<WorkstationVO> workstationVOIPage = listPage(Condition.getPage(query), keyWord, groupId, null, null);
|
List<WorkstationVO> records = workstationVOIPage.getRecords();
|
List<WorkstationExcel> 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<WorkstationRealTimeStatusVO> getRealTimeStatus(WorkstationRealTimeStatusDTO dto, Query query) {
|
List<String> workStationGroupIdList = dto.getWorkStationGroupIdList();
|
if (workStationGroupIdList.size() == 1) {
|
List<String> workStationGroupIdByParentList = getCommonGroupIds(workStationGroupIdList, new ArrayList<>()).stream().map(item -> {
|
return String.valueOf(item.getId());
|
}).collect(Collectors.toList());
|
dto.getWorkStationGroupIdList().addAll(workStationGroupIdByParentList);
|
}
|
List<WorkstationRealTimeStatusVO> result = this.baseMapper.getWorkstationListByWorkStationGroupIdList(new Page<WorkstationRealTimeStatusVO>().setSize(-1L), dto);
|
return manualBuildIPage(query, buildProperties(result, dto.getDeviceStatus()));
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public List<RealTimeStatusVO> getRealTimeProperties(Long workstationId, Long machineId) {
|
List<RealTimeStatusVO> properties = new ArrayList<>();
|
Map<String, Object> map = WorkstationCache.getWorkstationRealTime(String.valueOf(workstationId));
|
List<DmpVariablesVO> 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<Long, List<RealTimeStatusVO>> getRealTimeProperties(List<Long> workstationIdList) {
|
Map<Long, List<RealTimeStatusVO>> properties = new HashMap<>();
|
List<DmpVariablesVO> list = this.dmpVariablesService.getDmpVariablesByWorkstationIds(workstationIdList);
|
if (Func.isNotEmpty(list)) {
|
Map<Long, List<DmpVariablesVO>> dmpVariablesMap =list.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
dmpVariablesMap.forEach((k, v) -> {
|
ArrayList<RealTimeStatusVO> arrayList = new ArrayList<>();
|
Map<String, Object> 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<Workstation> listWorkStationOnShiftIndex(List<String> 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<Workstation> listWorkStationOnShift(List<Long> ids, LocalDate localDate, List<Integer> 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<String> 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<Workstation> listWorkStationByGroupId(List<String> ids) {
|
return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids);
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public List<Workstation> listWorkStationByGroup(List<Long> 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<Long> 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<Long> findByMachineShortCode(String code) {
|
return ((WorkstationMapper) this.baseMapper).findByMachineShortCode(code);
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public List<Workstation> workStationList(List<Long> ids) {
|
return list(new QueryWrapper<Workstation>().lambda().in(Workstation::getId, ids).orderByAsc(Workstation::getName));
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public Map<Long, GroupWorkDTO> queryGroupWorkStation(List<Long> ids) {
|
List<GroupWorkDTO> 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<Long> productionLineList(Long groupId) {
|
List<Long> ids = Lists.newArrayList();
|
CommonGroup commonGroup = (CommonGroup) this.commonGroupService.getById(groupId);
|
if (commonGroup != null) {
|
String code = commonGroup.getCode();
|
List<CommonGroup> commonGroupList = this.commonGroupService.list(Wrappers.<CommonGroup>lambdaQuery()
|
.eq(CommonGroup::getGroupCategory, CommonGroupConstant.DEFAULT_CATEGORY)
|
.eq(CommonGroup::getGroupType, CommonGroupTypeEnum.WORKSTATION.getName())
|
.likeRight(CommonGroup::getCode, code));
|
if (Func.isNotEmpty(commonGroupList)) {
|
List<Long> 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<WorkstationDmpDTO> getDmpVar(String workstationId) {
|
return ((WorkstationMapper) this.baseMapper).getDmpVar(workstationId);
|
}
|
|
private void checkWorkstationImport(WorkstationImport workstationImport, List<Machine> machineList, List<String> calendarCodeList, HashMap<String, Long> commonGroupNameMap, CodeMapDTO codeMapDTO, Set<String> machineCodeSet) {
|
List<String> codeList = codeMapDTO.getWorkstationCodeList();
|
List<String> machineCodeList = codeMapDTO.getMachineCodeList();
|
codeMapDTO.getPinCodeMap();
|
Map<String, String> shortCodeMap = codeMapDTO.getShortCodeMap();
|
Map<String, String> importPinCodeMap = codeMapDTO.getImportPinCodeMap();
|
Map<String, String> importShortCodeMap = codeMapDTO.getImportShortCodeMap();
|
Map<String, Machine> machineDeaMap = null;
|
List<Machine> deactivateList = this.machineService.list( Wrappers.<Machine>lambdaQuery().eq(Machine::getStatus, CommonConstant.DEACTIVATE));
|
if (Func.isNotEmpty(deactivateList)) {
|
machineDeaMap = deactivateList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getMachineCode();
|
}, Function.identity()));
|
}
|
List<String> machineShortCodeList = machineList.stream().map((v0) -> {
|
return v0.getShortCode();
|
}).distinct().collect(Collectors.toList());
|
Map<String, Machine> 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.<Workstation>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.<Machine>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.<ProductionCalendar>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.<CommonGroupOfItem>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<DmpVariablesVO> getDmpVariables(String workstationId, String machineId) {
|
if (Func.isBlank(machineId)) {
|
throw new ServiceException(MessageUtils.message("workstation.not.turn.on.acquisition.function", new Object[0]));
|
}
|
List<DmpVariablesVO> 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.<Workstation>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.<Workstation>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.<Workstation>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<CommonGroup> getCommonGroupIds(List<String> idList, List<CommonGroup> list) {
|
List<CommonGroup> commonGroupList = this.commonGroupService.list(Lambda.in((v0) -> {
|
return v0.getParentId();
|
}, idList));
|
if (Func.isEmpty(commonGroupList)) {
|
return list;
|
}
|
List<String> 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<FmsWorkstation> assemblyWorkstationData(List<String> workstationIds, Map<String, FmsRealTimeTray> realTimeTrayMap, List<FmsRealTimeTray> realTimeTrayList, List<String> positionList) {
|
List<FmsWorkstation> fmsWorkstationList = new ArrayList<>();
|
List<MachineInformationVO> informationList = new ArrayList<>();
|
workstationIds.forEach(id -> {
|
MachineInformationVO machineInformationVO = this.workbenchService.listWorkstationWorkbench(Long.valueOf(Func.toLong(id)));
|
informationList.add(machineInformationVO);
|
});
|
List<MachineInformationVO> informationVOS = informationList.stream().filter(s -> {
|
return Func.isNotEmpty(s.getDeviceType());
|
}).collect(Collectors.toList());
|
Map<Integer, List<MachineInformationVO>> 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<FmsWorkstationGroupVO> fmsTreeWorkstation(FmsWorkstationQueryVO queryVO) {
|
WorkTypeEnum workTypeEnum;
|
List<CommonGroup> allSubGroup = this.commonGroupService.getAllSubGroup(CommonGroupConstant.WARE_ROOT, CommonGroupTypeEnum.WORKSTATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
if (Func.isEmpty(allSubGroup)) {
|
return new ArrayList<>();
|
}
|
List<Long> groupIds = allSubGroup.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<FmsWorkstationGroupVO> fmsWorkstationGroupVOS = CommonGroupConvert.INSTANCE.convertFmsList(allSubGroup);
|
List<CommonGroupOfItem> list = this.commonGroupOfItemService.list(Wrappers.<CommonGroupOfItem>lambdaQuery().in(CommonGroupOfItem::getGroupId, groupIds));
|
Map<Long, CommonGroupOfItem> groupOfItemMap = list.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getItemId();
|
}, item -> {
|
return item;
|
}));
|
List<Long> workstationIds = list.stream().map((v0) -> {
|
return v0.getItemId();
|
}).collect(Collectors.toList());
|
List<FmsWorkstationGroupVO> 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<Workstation> workstations = list(Wrappers.<Workstation>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<FmsWorkstationGroupVO> 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<Workstation> listMachine(Integer status, String keyword) {
|
return ((WorkstationMapper) this.baseMapper).listMachine(status, keyword);
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public List<WorkstationVO> getWorkstationListInMaintainOrRepairById(Long orderProcessId, Set<Long> workstationIdList) {
|
return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairById(orderProcessId, workstationIdList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public List<WorkstationVO> getWorkstationListInMaintainOrRepairByIdList(List<Long> orderProcessIdList, Set<Long> workstationIdList) {
|
return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairByIdList(orderProcessIdList, workstationIdList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IWorkstationService
|
public IPage<WorkstationRealTimeStatusVO> pageH5(Query query, WorkstationPageQueryVO workstationPageQueryVO) {
|
IPage<WorkstationVO> workstationVOIPage = listPage(new Page<WorkstationVO>().setSize(-1L), workstationPageQueryVO.getKeyWord(), null, workstationPageQueryVO.getStatus(), workstationPageQueryVO.getType());
|
IPage<WorkstationRealTimeStatusVO> convert = WorkstationConvert.INSTANCE.convertPage(workstationVOIPage);
|
List<WorkstationRealTimeStatusVO> result = buildProperties(convert.getRecords(), workstationPageQueryVO.getDeviceStatus());
|
return manualBuildIPage(query, result);
|
}
|
|
private IPage<WorkstationRealTimeStatusVO> manualBuildIPage(Query query, List<WorkstationRealTimeStatusVO> result) {
|
Page<WorkstationRealTimeStatusVO> 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<WorkstationRealTimeStatusVO> buildProperties(List<WorkstationRealTimeStatusVO> list, List<Integer> deviceStatus) {
|
List<WorkstationRealTimeStatusVO> dataList = new ArrayList<>();
|
if (Func.isEmpty(list)) {
|
return dataList;
|
}
|
Map<Long, List<RealTimeStatusVO>> 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<RealTimeStatusVO> properties = realTimePropertiesMap.get(i.getId());
|
if (Func.isNotEmpty(deviceStatus)) {
|
if (Func.isEmpty(properties)) {
|
filter = false;
|
} else {
|
Iterator<RealTimeStatusVO> 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<FmsWorkstationGroupVO> roots, List<FmsWorkstationGroupVO> fmsWorkstationGroupVOS) {
|
if (Func.isEmpty(roots)) {
|
return;
|
}
|
List<FmsWorkstationGroupVO> itemGroups = new ArrayList<>();
|
for (FmsWorkstationGroupVO vo : roots) {
|
List<FmsWorkstationGroupVO> 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<FmsWorkstation> fmsWorkstationList, List<MachineInformationVO> informationVOList, Integer key, List<FmsRealTimeTray> realTimeTrayList, List<String> 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<WorkstationWorkbench> workbenchList = workstation.getWorkstationList();
|
if (Func.isNotEmpty(workbenchList)) {
|
if (!WorkTypeEnum.HANDLE.getCode().equals(key)) {
|
fmsWorkstation.setWorkBenchList(workbenchList.stream().map(s -> {
|
List<FmsRealTimeTray> 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<FmsRealTimeTray> 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<FmsRealTimeTray> 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<String, Object> workstationAllCollect = WorkstationCache.getWorkstationAllCollect(workstationId);
|
if (!workstationAllCollect.isEmpty()) {
|
return (TelemetryDataResponseDTO) workstationAllCollect.get(name);
|
}
|
return null;
|
}
|
}
|
