package com.qianwen.smartman.modules.smis.service.impl;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.temporal.ChronoUnit;
|
import java.time.temporal.TemporalAccessor;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.UUID;
|
import java.util.function.Function;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
import javax.servlet.http.HttpServletResponse;
|
|
import org.apache.commons.collections.MapUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.jetbrains.annotations.NotNull;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import com.alibaba.excel.write.merge.AbstractMergeStrategy;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.google.common.collect.Lists;
|
import com.qianwen.core.cache.utils.CacheUtil;
|
import com.qianwen.core.excel.util.ExcelUtil;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.mp.support.Condition;
|
import com.qianwen.core.mp.support.Query;
|
import com.qianwen.core.oss.model.BladeFile;
|
import com.qianwen.core.secure.utils.AuthUtil;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.core.tool.utils.StringUtil;
|
import com.qianwen.license.common.LicenseExtraModel;
|
import com.qianwen.license.common.LicenseVerify;
|
import com.qianwen.smartman.common.cache.DictCache;
|
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
|
import com.qianwen.smartman.common.constant.CalendarConstant;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.CommonGroupConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.constant.ExtCacheConstant;
|
import com.qianwen.smartman.common.constant.MachineConstant;
|
import com.qianwen.smartman.common.constant.MdcConstant;
|
import com.qianwen.smartman.common.enums.CommonGroupTypeEnum;
|
import com.qianwen.smartman.common.enums.DictEnum;
|
import com.qianwen.smartman.common.enums.StatusType;
|
import com.qianwen.smartman.common.enums.WcsDataTypeEnums;
|
import com.qianwen.smartman.common.license.LicenseWrapper;
|
import com.qianwen.smartman.common.mqtt.MqttMessageSender;
|
import com.qianwen.smartman.common.utils.Lambda;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.common.utils.ValidatorUtils;
|
import com.qianwen.smartman.common.websocket.entity.FmsWorkBench;
|
import com.qianwen.smartman.modules.smis.convert.CommonGroupConvert;
|
import com.qianwen.smartman.modules.smis.convert.WorkstationConvert;
|
import com.qianwen.smartman.modules.smis.convert.WorkstationWorkbenchConvert;
|
import com.qianwen.smartman.modules.smis.dto.CodeMapDTO;
|
import com.qianwen.smartman.modules.smis.dto.WorkstationRealTimeStatusDTO;
|
import com.qianwen.smartman.modules.smis.dto.WorkstationWcsDmpDTO;
|
import com.qianwen.smartman.modules.smis.entity.CommonGroup;
|
import com.qianwen.smartman.modules.smis.entity.CommonGroupOfItem;
|
import com.qianwen.smartman.modules.smis.entity.Machine;
|
import com.qianwen.smartman.modules.smis.entity.ProductionCalendar;
|
import com.qianwen.smartman.modules.smis.entity.ProductionCalendarDay;
|
import com.qianwen.smartman.modules.smis.entity.Workstation;
|
import com.qianwen.smartman.modules.smis.entity.WorkstationOfMachine;
|
import com.qianwen.smartman.modules.smis.entity.WorkstationWorkbench;
|
import com.qianwen.smartman.modules.smis.enums.WorkTypeEnum;
|
import com.qianwen.smartman.modules.smis.excel.WorkstationExcel;
|
import com.qianwen.smartman.modules.smis.excel.WorkstationImport;
|
import com.qianwen.smartman.modules.smis.mapper.WorkstationMapper;
|
import com.qianwen.smartman.modules.smis.message.dto.TelemetryDataResponseDTO;
|
import com.qianwen.smartman.modules.smis.message.producer.InsertWorkstationProducer;
|
import com.qianwen.smartman.modules.smis.service.ICalendarService;
|
import com.qianwen.smartman.modules.smis.service.ICommonGroupOfItemService;
|
import com.qianwen.smartman.modules.smis.service.ICommonGroupService;
|
import com.qianwen.smartman.modules.smis.service.IMachineService;
|
import com.qianwen.smartman.modules.smis.service.IWorkstationOfMachineService;
|
import com.qianwen.smartman.modules.smis.service.IWorkstationService;
|
import com.qianwen.smartman.modules.smis.service.IWorkstationWcsService;
|
import com.qianwen.smartman.modules.smis.service.IWorkstationWorkbenchService;
|
import com.qianwen.smartman.modules.smis.service.WorkstationDatapointsService;
|
import com.qianwen.smartman.modules.smis.vo.DmpVariablesVO;
|
import com.qianwen.smartman.modules.smis.vo.FmsWorkstationGroupVO;
|
import com.qianwen.smartman.modules.smis.vo.FmsWorkstationQueryVO;
|
import com.qianwen.smartman.modules.smis.vo.MachineDetailVO;
|
import com.qianwen.smartman.modules.smis.vo.MachineVO;
|
import com.qianwen.smartman.modules.smis.vo.RealTimeStatusVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkMachineEasyVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationChangeCalendarVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationDatapointsVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationOfWorkbenchVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationPageQueryVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationRealTimeStatusVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationSubmitVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationVO;
|
import com.qianwen.smartman.modules.smis.vo.WorkstationWorkbenchVO;
|
import com.qianwen.smartman.modules.mdc.dto.GroupWorkDTO;
|
import com.qianwen.smartman.modules.mdc.dto.WorkstationDmpDTO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import com.qianwen.smartman.modules.tdengine.service.IWorkstationDynamicCollectService;
|
|
import cn.hutool.core.util.ObjectUtil;
|
|
@Service
|
public class WorkstationServiceImpl extends BaseServiceImpl<WorkstationMapper, Workstation> implements IWorkstationService {
|
private static final Pattern CHINESE = Pattern.compile("^[A-Za-z0-9]+$");
|
@Autowired
|
private IMachineService machineService;
|
@Autowired
|
private IWorkstationOfMachineService workstationOfMachineService;
|
@Autowired
|
private IWorkstationWcsService workstationWcsService;
|
@Autowired
|
private ICommonGroupOfItemService commonGroupOfItemService;
|
@Autowired
|
private ICommonGroupService commonGroupService;
|
@Autowired
|
private ICalendarService calendarService;
|
@Autowired
|
private WorkstationMapper workstationMapper;
|
@Autowired
|
private OssBuilder ossBuilder;
|
|
|
@Autowired
|
private IWorkstationWorkbenchService workbenchService;
|
|
@Autowired
|
private InsertWorkstationProducer workstationProducer;
|
@Autowired
|
private IWorkstationDynamicCollectService dynamicCollectService;
|
@Autowired
|
private MqttMessageSender mqttMsgSender;
|
@Autowired
|
private WorkstationDatapointsService wsDpService;
|
@Autowired
|
private LicenseWrapper licenseWrapper;
|
@Autowired
|
private WorkstationDatapointsService dataPointService;
|
|
private final String NAME = "默认工作台";
|
private final Integer SORT = 1;
|
private final Integer DEFAULT = 1;
|
private final Integer NOT_DEFAULT = 0;
|
private final String ALL_WORKSTATION_GROUP = CommonGroupConstant.ALL_NAME;
|
private final Integer FTP_CORRELATION_DIRECTORY = 1;
|
private final Integer FTP_SAME_DIRECTORY = 2;
|
|
|
public static Long getTimeDifference(LocalDateTime startTime, LocalDateTime endTime) {
|
if (Func.isEmpty(startTime)) {
|
return 0L;
|
}
|
LocalDateTime tempDateTime = LocalDateTime.from((TemporalAccessor) startTime);
|
long seconds = tempDateTime.until(endTime, ChronoUnit.SECONDS);
|
return Long.valueOf(seconds);
|
}
|
|
@Override
|
public List<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
|
public WorkstationWcsDmpDTO queryDateTypeState(Integer code, String workstationId) {
|
return this.baseMapper.queryDateTypeState(code, workstationId);
|
}
|
|
@Override
|
public List<DmpVariablesVO> queryDmpList(String workstationId) {
|
return ((WorkstationMapper) this.baseMapper).queryDmpList(workstationId);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public WorkstationVO submit(WorkstationSubmitVO workstationSubmitVO) {
|
|
checkLicenseCount();
|
|
checkWorkstation(workstationSubmitVO);
|
if (Func.isEmpty(workstationSubmitVO.getId())) {
|
checkUnableWorkstation(workstationSubmitVO);
|
}
|
Workstation workstation = WorkstationConvert.INSTANCE.convert(workstationSubmitVO);
|
workstation.setTransmissionMethod(workstationSubmitVO.getTransmissionMethod());
|
if (Func.isEmpty(workstation.getCalendarCode())) {
|
workstation.setCalendarCode(CalendarConstant.DEFAULT_CALENDAR);
|
}
|
if (workstation.getCalendarCode().equals(workstation.getCalendarCodeWaiting())) {
|
workstation.setCalendarCodeWaiting(null);
|
}
|
saveOrUpdate(workstation);
|
if (Func.isNotEmpty(workstationSubmitVO.getGroupId())) {
|
List<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.COLLECT_WORKSTATION, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
String redisKey = ExtCacheConstant.CPS_CACHE.concat(":").concat(":").concat(WorkstationCache.CRC);
|
CacheUtil.clear(redisKey, Boolean.FALSE);
|
WorkstationVO workstationVO = WorkstationConvert.INSTANCE.convertSaveVO(workstationSubmitVO);
|
workstationVO.setId(workstation.getId());
|
|
if (Func.isNull(workstationSubmitVO.getId())) {//新增工位，发送消息，post应用打固定点
|
//WorkstationCreateMessageDTO dto = WorkstationCreateMessageDTO.builder().workstationId(workstation.getId().toString()).operationTime(DateUtil.now()).build();
|
//this.workstationProducer.sendInsertWorkstationMessage(dto);
|
workstationProducer.sendInsertWorkstationMessage(workstation.getId());
|
|
}
|
return workstationVO;
|
}
|
|
/**
|
* 验证许可中配置的设备数量
|
*/
|
void checkLicenseCount() {
|
|
Wrapper<Workstation> wrapper = Wrappers.lambdaQuery(Workstation.class).eq(Workstation::getIsDeleted, 0);
|
Long count = workstationMapper.selectCount(wrapper);
|
|
|
Long machineAmount = licenseWrapper.getWorkstationAmount();
|
if(count >= machineAmount) {
|
throw new ServiceException("工位数超过许可上限数:"+ machineAmount);
|
}
|
}
|
/*
|
private void submitWorkstationFtpDirectory(WorkstationSubmitVO workstationSubmitVO, Workstation workstation) {
|
if (Func.isEmpty(workstationSubmitVO.getId()) && Func.isNotEmpty(workstationSubmitVO.getFtpDirectoryType())) {
|
WorkstationTdVO workstationTdVO = new WorkstationTdVO();
|
workstationTdVO.setWorkstationId(String.valueOf(workstation.getId()));
|
workstationTdVO.setWorkstationName(workstation.getName());
|
workstationTdVO.setWorkstationGroupId(String.valueOf(workstationSubmitVO.getGroupId()));
|
if (this.FTP_CORRELATION_DIRECTORY.equals(workstationSubmitVO.getFtpDirectoryType())) {
|
workstationTdVO.setType(this.FTP_CORRELATION_DIRECTORY);
|
if (Func.isNotEmpty(workstationSubmitVO.getDirectoryId())) {
|
workstationTdVO.setDirectorTransferId(workstationSubmitVO.getDirectoryId());
|
}
|
} else {
|
workstationTdVO.setType(this.FTP_SAME_DIRECTORY);
|
}
|
if (Objects.equals(workstationSubmitVO.getFtpDirectoryType(), CommonConstant.ASSOCIATED_DIRECTORY)) {
|
this.transferDirectoryService.judgeAndSaveWorkStationFtp(String.valueOf(workstationSubmitVO.getMachineId()), workstation.getId(), workstationSubmitVO.getDirectoryId());
|
}
|
this.wsRelationTdService.relationFtpDirectory(workstationTdVO);
|
}
|
}*/
|
|
private void submitWorkstationMachine(WorkstationSubmitVO workstationSubmitVO, Workstation workstation) {
|
if (Func.isEmpty(workstationSubmitVO.getId()) && Func.isNotEmpty(workstationSubmitVO.getType()) && 0 == workstationSubmitVO.getType().intValue()) {
|
if (1 == workstationSubmitVO.getLinkWay().intValue()) {
|
MachineVO machineVO = MachineVO.builder().machineCode(workstationSubmitVO.getMachineCode()).machineName(workstationSubmitVO.getMachineName()).groupId(CommonGroupConstant.DEFAULT_MACHINE_ID).brand(workstationSubmitVO.getMachineBrand()).collectSwitch(workstationSubmitVO.getCollectSwitch()).extendId(UUID.randomUUID().toString()).machinePinCode(workstationSubmitVO.getMachinePinCode()).machineShortCode(workstationSubmitVO.getMachineShortCode()).externalKey(workstationSubmitVO.getMachineCode()).build();
|
MachineVO insert = this.machineService.insert(machineVO);
|
WorkstationOfMachine workstationOfMachine = new WorkstationOfMachine(workstation.getId(), insert.getId());
|
this.workstationOfMachineService.save(workstationOfMachine);
|
workstationSubmitVO.setMachineId(insert.getId());
|
workstationSubmitVO.setExtendId(insert.getExtendId());
|
return;
|
}
|
if (Func.isEmpty(workstationSubmitVO.getMachineId())) {
|
Machine machine1 = this.machineService.getOne(Wrappers.<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
|
public Boolean changeCollectSwitch(Long workstationId, Integer collectSwitch) {
|
return this.machineService.changeCollectSwitch(workstationId, collectSwitch);
|
}
|
|
@Override
|
@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));
|
|
//20250324新增，删除工位对应的数据点位配置。
|
dataPointService.removeByWorkstation(workstationIds);
|
/*
|
this.workstationOfMachineService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getWorkstationId();
|
}, workstationIds));
|
this.commonGroupOfItemService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getItemId();
|
}, workstationIds));*/
|
WorkstationCache.clearWorkstationCache();
|
CacheUtil.clear(ExtCacheConstant.COLLECT_WORKSTATION, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(redisKey, Boolean.FALSE);
|
}
|
changeStatus(workstationIds, CommonConstant.DEACTIVATE);
|
WorkstationCache.clearWorkstationCache();
|
CacheUtil.clear(ExtCacheConstant.COLLECT_WORKSTATION, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(redisKey, Boolean.FALSE);
|
return true;
|
}
|
|
@Override
|
public IPage<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, LocalDate.now().getYear());
|
workstationVOS.forEach(workstationVO -> {
|
String calendarName = workstationVO.getCalendarName();
|
if (Func.isBlank(calendarName)) {
|
workstationVO.setCalendarName("系统日历");
|
}
|
});
|
return workstationVOIPage.setRecords(workstationVOS);
|
}
|
|
@Override
|
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
|
public List<FmsWorkstation> getFmsWorkstation(final List<Long> workstationIds) {
|
List<Long> commonGroupIds = this.commonGroupService.list(Lambda.eq(CommonGroup::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
|
public Boolean changeCalendarCode(WorkstationChangeCalendarVO workstationChangeCalendarVO) {
|
Workstation workstation = getById(workstationChangeCalendarVO.getWorkstationId());
|
workstation.setCalendarCodeWaiting(workstationChangeCalendarVO.getCalendarCodeWaiting());
|
return Boolean.valueOf(updateById(workstation));
|
}
|
|
@Override
|
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
|
@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
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean deleteGroup(Long groupId) {
|
if (this.commonGroupOfItemService.count(Lambda.eq(CommonGroupOfItem::getGroupId, groupId)) > 0) {
|
throw new ServiceException(MessageUtils.message("cps.common.group.production.line.delete.fail", new Object[0]));
|
}
|
//this.transferDirectoryGroupService.deleteWorkstationGroup(groupId);
|
this.commonGroupService.deleteGroup(groupId);
|
return true;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public BladeFile importWorkstation(List<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
|
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
|
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()));
|
}
|
|
|
|
/**
|
* 获取实时数据展示的数据点列表
|
* @param workstationIdList 工位id集合
|
* @return map(工位id -> 数据点集合)
|
*/
|
public Map<Long, List<RealTimeStatusVO>> getRealTimeProperties(List<Long> workstationIdList) {
|
Map<Long, List<RealTimeStatusVO>> properties = new HashMap<>();
|
|
//yangys修改，改为数据点位的方式
|
for(Long workstationId: workstationIdList) {
|
|
Map<String, Object> map = WorkstationCache.getWorkstationRealTime(String.valueOf(workstationId));//应该有数据，因为缓存没有，内部直接查的queryLastParameter
|
|
JSONObject cfgRow;
|
ArrayList<RealTimeStatusVO> arrayList = new ArrayList<>();
|
|
WorkstationDatapointsVO dpVO = wsDpService.getDatapoints(workstationId);
|
if(dpVO!=null && ObjectUtil.isNotEmpty(dpVO.getDpHead())) {
|
|
String prop;
|
JSONArray dpCfgJson = JSONArray.parseArray(dpVO.getDpConfig());
|
for(int i=0;i<dpCfgJson.size();i++) {
|
cfgRow = dpCfgJson.getJSONObject(i);
|
|
RealTimeStatusVO vo = new RealTimeStatusVO();
|
prop = cfgRow.getString("dpName");
|
vo.setKey(prop);
|
/*
|
label = prop;
|
if(StringUtils.equals("DeviceStatus", prop)) {
|
label = "状态";
|
}else if(StringUtils.equals("Output", prop)) {
|
label = "产量";
|
}else if(StringUtils.equals("AlarmNo", prop)) {
|
label = "告警号";
|
}*/
|
vo.setName(cfgRow.getString("dpLabel"));
|
vo.setSort(i);
|
vo.setBigScreen(false);
|
vo.setRealTimeData(true);
|
|
if (map.containsKey(vo.getKey())) {
|
TelemetryDataResponseDTO t = (TelemetryDataResponseDTO) MapUtils.getObject(map, vo.getKey());
|
vo.setValue(t.getV());
|
}
|
|
arrayList.add(vo);
|
}
|
}
|
properties.put(workstationId, arrayList);
|
}
|
return properties;
|
}
|
|
@Override
|
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
|
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
|
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
|
public List<Workstation> listWorkStationByGroupId(List<String> ids) {
|
return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids);
|
}
|
|
@Override
|
public List<Workstation> listWorkStationByGroup(List<Long> ids) {
|
return ((WorkstationMapper) this.baseMapper).listWorkStationByGroupId(ids.stream().map((v0) -> {
|
return String.valueOf(v0);
|
}).collect(Collectors.toList()));
|
}
|
|
@Override
|
public Set<Long> findByIndexAndDateAndTypeAndYear(Integer year, String queryDate, Integer shiftIndex, Integer code) {
|
return ((WorkstationMapper) this.baseMapper).findByIndexAndDateAndTypeAndYear(year, queryDate, shiftIndex, code);
|
}
|
|
@Override
|
public List<Long> findByMachineShortCode(String code) {
|
return ((WorkstationMapper) this.baseMapper).findByMachineShortCode(code);
|
}
|
|
@Override
|
public List<Workstation> workStationList(List<Long> ids) {
|
return list(new QueryWrapper<Workstation>().lambda().in(Workstation::getId, ids).orderByAsc(Workstation::getName));
|
}
|
|
@Override
|
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
|
public ProductionCalendarDay getDayShift(Long workstationId, String calendarDate) {
|
return ((WorkstationMapper) this.baseMapper).getDayShift(workstationId, calendarDate);
|
}
|
|
@Override
|
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
|
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
|
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
|
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));*/
|
List<CommonGroup> commonGroupList = this.commonGroupService.list(Lambda.<CommonGroup>in(CommonGroup::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
|
public WorkMachineEasyVO getWorkMachine(String workstationId) {
|
return ((WorkstationMapper) this.baseMapper).getWorkMachine(workstationId);
|
}
|
|
@Override
|
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
|
public List<Workstation> listMachine(Integer status, String keyword) {
|
return ((WorkstationMapper) this.baseMapper).listMachine(status, keyword);
|
}
|
|
@Override
|
public List<WorkstationVO> getWorkstationListInMaintainOrRepairById(Long orderProcessId, Set<Long> workstationIdList) {
|
return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairById(orderProcessId, workstationIdList);
|
}
|
|
@Override
|
public List<WorkstationVO> getWorkstationListInMaintainOrRepairByIdList(List<Long> orderProcessIdList, Set<Long> workstationIdList) {
|
return ((WorkstationMapper) this.baseMapper).getWorkstationListInMaintainOrRepairByIdList(orderProcessIdList, workstationIdList);
|
}
|
|
@Override
|
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(), query.getSize(), result.size());
|
if (result.size() == 0) {
|
return page;
|
}
|
if (query.getSize() == -1) {
|
page.setRecords(result);
|
} else if (result.size() < ((query.getCurrent() - 1) * query.getSize()) + query.getSize()) {
|
page.setRecords(result.subList((query.getCurrent() - 1) * query.getSize(), result.size()));
|
} else {
|
page.setRecords(result.subList((query.getCurrent() - 1) * query.getSize(), ((query.getCurrent() - 1) * query.getSize()) + query.getSize()));
|
}
|
return page;
|
}
|
|
private List<WorkstationRealTimeStatusVO> buildProperties(List<WorkstationRealTimeStatusVO> list, List<Integer> deviceStatus) {
|
List<WorkstationRealTimeStatusVO> dataList = new ArrayList<>();
|
if (Func.isEmpty(list)) {
|
return dataList;
|
}
|
//TODO，格式太差
|
Map<Long, List<RealTimeStatusVO>> realTimePropertiesMap = getRealTimeProperties( list.stream().map(WorkstationRealTimeStatusVO::getId).collect(Collectors.toList()));
|
|
return list.stream().filter(i -> {
|
boolean filter = true;
|
if (Func.isEmpty(i.getMachineId())) {
|
filter = false;
|
}
|
List<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;
|
}
|
}
|
