package com.qianwen.smartman.modules.cps.service.impl;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.excel.write.merge.AbstractMergeStrategy;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.google.common.collect.Lists;
|
import java.lang.invoke.SerializedLambda;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Optional;
|
import java.util.Set;
|
import java.util.UUID;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.smartman.common.cache.DictCache;
|
import com.qianwen.smartman.common.cache.RegionCache;
|
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
|
import com.qianwen.smartman.common.cache.cps.WorkstationOfMachineCache;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.CommonGroupConstant;
|
import com.qianwen.smartman.common.constant.DateConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.constant.ExtCacheConstant;
|
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.ListUtils;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
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.smartman.modules.cps.convert.MachineConvert;
|
import com.qianwen.smartman.modules.cps.convert.WorkstationWcsConvert;
|
import com.qianwen.smartman.modules.cps.dto.DeviceMaintainInDTO;
|
import com.qianwen.smartman.modules.cps.dto.DeviceSimpleDTO;
|
import com.qianwen.smartman.modules.cps.dto.EmployeeNameDTO;
|
import com.qianwen.smartman.modules.cps.dto.MachineExtDTO;
|
import com.qianwen.smartman.modules.cps.dto.WorkstationWcsDTO;
|
import com.qianwen.smartman.modules.cps.entity.CommonGroupOfItem;
|
import com.qianwen.smartman.modules.cps.entity.DeviceType;
|
import com.qianwen.smartman.modules.cps.entity.Machine;
|
import com.qianwen.smartman.modules.cps.entity.Workstation;
|
import com.qianwen.smartman.modules.cps.entity.WorkstationOfMachine;
|
import com.qianwen.smartman.modules.cps.entity.WorkstationWcs;
|
import com.qianwen.smartman.modules.cps.excel.MachineExcel;
|
import com.qianwen.smartman.modules.cps.excel.MachineImport;
|
import com.qianwen.smartman.modules.cps.mapper.MachineMapper;
|
import com.qianwen.smartman.modules.cps.mapper.WorkstationWcsMapper;
|
import com.qianwen.smartman.modules.cps.service.ICommonGroupOfItemService;
|
import com.qianwen.smartman.modules.cps.service.ICommonGroupService;
|
import com.qianwen.smartman.modules.cps.service.IDeviceTypeService;
|
import com.qianwen.smartman.modules.cps.service.IEmployeeService;
|
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.utils.ThrowFun;
|
import com.qianwen.smartman.modules.cps.vo.IdsVO;
|
import com.qianwen.smartman.modules.cps.vo.MachineDetailVO;
|
import com.qianwen.smartman.modules.cps.vo.MachineListVO;
|
import com.qianwen.smartman.modules.cps.vo.MachineSelectVO;
|
import com.qianwen.smartman.modules.cps.vo.MachineSubmitVO;
|
import com.qianwen.smartman.modules.cps.vo.MachineUpdateVO;
|
import com.qianwen.smartman.modules.cps.vo.MachineVO;
|
import com.qianwen.smartman.modules.cps.vo.WorkstationSubmitVO;
|
import com.qianwen.smartman.modules.dnc.enums.DncEnums;
|
import com.qianwen.smartman.modules.dnc.vo.HmiDeviceVO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
|
import com.qianwen.smartman.modules.tpm.entity.MaintainPlan;
|
import com.qianwen.smartman.modules.tpm.entity.RepairApply;
|
import com.qianwen.smartman.modules.tpm.entity.RepairRecord;
|
import com.qianwen.smartman.modules.tpm.enums.DeviceRepairStatusEnum;
|
import com.qianwen.smartman.modules.tpm.enums.MaintainPlanStatusEnum;
|
import com.qianwen.smartman.modules.tpm.enums.MaintainStatusEnum;
|
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
|
import com.qianwen.smartman.modules.tpm.enums.RepairRecordEnum;
|
import com.qianwen.smartman.modules.tpm.service.IMaintainPlanService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/MachineServiceImpl.class */
|
public class MachineServiceImpl extends BaseServiceImpl<MachineMapper, Machine> implements IMachineService {
|
private static final Logger log = LoggerFactory.getLogger(MachineServiceImpl.class);
|
private static final Pattern NUMBER = Pattern.compile("[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*");
|
private static final Pattern CHINESE = Pattern.compile("^[A-Za-z0-9]+$");
|
@Autowired
|
private IWorkstationOfMachineService workstationOfMachineService;
|
@Autowired
|
@Lazy
|
private IMaintainPlanService maintainPlanService;
|
@Autowired
|
private ICommonGroupService commonGroupService;
|
@Autowired
|
private OssBuilder ossBuilder;
|
@Autowired
|
@Lazy
|
private IDeviceTypeService typeService;
|
@Autowired
|
private ICommonGroupOfItemService itemService;
|
@Autowired
|
@Lazy
|
private IWorkstationService workstationService;
|
@Autowired
|
private WorkstationWcsMapper workstationWcsMapper;
|
@Autowired
|
private ICodeGeneratorService codeGeneratorService;
|
@Autowired
|
private IEmployeeService employeeService;
|
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
@Transactional(rollbackFor = {Exception.class})
|
public MachineVO insert(MachineVO machineVO) {
|
checkMachine(machineVO.id, machineVO.getMachineCode());
|
checkStopMachineByCode(machineVO.getMachineCode());
|
Machine machine = MachineConvert.INSTANCE.convert(machineVO);
|
machine.setMaintenanceStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
|
machine.setRepairStatus(Integer.valueOf(RepairRecordEnum.R1.getType()));
|
save(machine);
|
saveCommonGroupItem(Lists.newArrayList(new Machine[]{machine}));
|
return MachineConvert.INSTANCE.convert(machine);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public Boolean changeCollectSwitch(Long workstationId, Integer collectSwitch) {
|
((MachineMapper) this.baseMapper).changeCollectSwitch(workstationId, collectSwitch, AuthUtil.getTenantId());
|
if (0 == collectSwitch.intValue()) {
|
WorkstationOfMachine workstationOfMachineServiceOne = this.workstationOfMachineService.getWorkstationOfMachineByWorkstationId(workstationId);
|
if (Func.isNotEmpty(workstationOfMachineServiceOne)) {
|
WorkstationCache.clearWorkstationParamTypeCache(String.valueOf(workstationOfMachineServiceOne.getMachineId()));
|
}
|
}
|
return true;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<WorkstationWcsDTO> getWorkstationWcsByMachineId(Long machineId, String paramName) {
|
List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery().eq(WorkstationOfMachine::getMachineId, machineId));
|
|
List<Long> workstationIdList =workstationOfMachineList.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
List<WorkstationWcs> workstationWcsList = this.workstationWcsMapper.getWorkstationWcsByName(workstationIdList, paramName);
|
return WorkstationWcsConvert.INSTANCE.convertToDTOList(workstationWcsList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public Boolean updateBrand(Long id, String brand) {
|
Machine machine = (Machine) getById(id);
|
machine.setBrand(brand);
|
boolean updateById = updateById(machine);
|
if (updateById) {
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
}
|
return Boolean.valueOf(updateById);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public MachineDetailVO detailMachine(Long id) {
|
MachineDetailVO machineDetailVO = ((MachineMapper) this.baseMapper).selectMachineDetail(id);
|
if (Func.isNotEmpty(machineDetailVO)) {
|
machineDetailVO.setMachineLifeStatusName(DictCache.getValue(DictEnum.MACHINE_LIFE_STATUS.getName(), machineDetailVO.getMachineLifeStatus()));
|
machineDetailVO.setManagementClassName(DictCache.getValue(DictEnum.MACHINE_MANAGEMENT_CLASS, machineDetailVO.getManagementClass()));
|
machineDetailVO.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), machineDetailVO.getMachineUseStatus()));
|
List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery().eq(WorkstationOfMachine::getMachineId, machineDetailVO.getId()));
|
if (Func.isNotEmpty(workstationOfMachineList)) {
|
List<Workstation> workstationList = this.workstationService.listByIds(workstationOfMachineList.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList()));
|
Optional.ofNullable(workstationList).ifPresent(workstations -> {
|
List<String> workstationCodeList = workstations.stream().map((v0) -> {
|
return v0.getCode();
|
}).collect(Collectors.toList());
|
List<String> workstationNameList = workstations.stream().map((v0) -> {
|
return v0.getName();
|
}).collect(Collectors.toList());
|
String code = workstationCodeList.stream().reduce((a, b) -> {
|
return a.concat(";").concat(b);
|
}).orElse("");
|
String name = workstationNameList.stream().reduce((a2, b2) -> {
|
return a2.concat(";").concat(b2);
|
}).orElse("");
|
machineDetailVO.setWorkstationCode(code);
|
machineDetailVO.setWorkstationName(name);
|
});
|
}
|
}
|
return machineDetailVO;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
@Transactional(rollbackFor = {Exception.class})
|
public Machine createMachine(MachineSubmitVO machineSubmitVO) {
|
String pinCode = machineSubmitVO.getPinCode();
|
if (Func.isNotBlank(pinCode)) {
|
checkPinCode(pinCode, null);
|
boolean matches = CHINESE.matcher(pinCode).matches();
|
if (!matches) {
|
throw new ServiceException(MessageUtils.message("machine.ping.code.chinese.characters.exist", new Object[0]));
|
}
|
}
|
String shortCode = machineSubmitVO.getShortCode();
|
if (Func.isNotBlank(shortCode)) {
|
validShortCode(shortCode, null);
|
boolean matches2 = CHINESE.matcher(shortCode).matches();
|
if (!matches2) {
|
throw new ServiceException(MessageUtils.message("machine.short.code.chinese.characters.exist", new Object[0]));
|
}
|
}
|
if (Func.isBlank(machineSubmitVO.getMachineCode())) {
|
String code = this.codeGeneratorService.getGeneratorCode(machineSubmitVO, MetaTypeEnum.MACHINE.getCode());
|
log.info("机器编码规则生成的code:{}", code + " ," + code.length());
|
machineSubmitVO.setMachineCode(code);
|
}
|
checkMachine(null, machineSubmitVO.getMachineCode());
|
checkStopMachine(machineSubmitVO.getMachineCode());
|
Machine machine = MachineConvert.INSTANCE.convert(machineSubmitVO);
|
machine.setMaintenanceStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
|
machine.setRepairStatus(Integer.valueOf(DeviceRepairStatusEnum.NORMAL.getType()));
|
machine.setExtendId(UUID.randomUUID().toString());
|
machine.setExternalKey(machineSubmitVO.getMachineCode());
|
save(machine);
|
saveWorkstation(machineSubmitVO, machine);
|
CommonGroupOfItem commonGroupOfItem = CommonGroupOfItem.builder().groupId(machine.getGroupId()).itemId(machine.getId()).extendId(machine.getExtendId()).groupType(CommonGroupTypeEnum.MACHINE.getName()).groupCategory(CommonGroupConstant.DEFAULT_CATEGORY).build();
|
this.itemService.save(commonGroupOfItem);
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
return machine;
|
}
|
|
@Transactional(rollbackFor = {Exception.class})
|
public void saveWorkstation(MachineSubmitVO machineSubmitVO, Machine machine) {
|
if (1 == machineSubmitVO.getLinkWay().intValue()) {
|
WorkstationSubmitVO workstationSaveVO = new WorkstationSubmitVO();
|
workstationSaveVO.setCode(machineSubmitVO.getMachineCode());
|
workstationSaveVO.setName(machineSubmitVO.getMachineName());
|
workstationSaveVO.setGroupId(CommonGroupConstant.DEFAULT_WORKSTATION_ID);
|
workstationSaveVO.setLinkWay(0);
|
workstationSaveVO.setMachineId(machine.getId());
|
workstationSaveVO.setType(0);
|
this.workstationService.submit(workstationSaveVO);
|
}
|
}
|
|
private void validShortCode(String shortCode, Long id) {
|
int len = shortCode.length();
|
if (len < 4 || len > 8) {
|
throw new ServiceException(String.format(MessageUtils.message("cps.tpm.machine.short.code.length", new Object[0]), 4, 8));
|
}
|
|
Long count = Long.valueOf(count(Wrappers.<Machine>lambdaQuery().eq(Machine::getShortCode, shortCode).ne(Func.isNotEmpty(id), Machine::getId, id)));
|
if (count.longValue() > 0) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.machine.short.code.exists", new Object[0]));
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public IPage<MachineListVO> pageMachine(MachineSelectVO machineSelectVO, Query query) {
|
String machineName = machineSelectVO.getMachineName();
|
String machineCode = machineSelectVO.getMachineCode();
|
Long machineTypeId = machineSelectVO.getMachineTypeId();
|
Long groupId = machineSelectVO.getGroupId();
|
Integer status = machineSelectVO.getStatus();
|
IPage<MachineListVO> page = ((MachineMapper) this.baseMapper).pageMachine(Condition.getPage(query), machineName, machineCode, machineTypeId, groupId, CommonGroupConstant.ALL_MACHINE_ID, status == null ? CommonConstant.ENABLE : status);
|
List<MachineListVO> records = page.getRecords();
|
List<MachineListVO> collect = records.stream().peek(c -> {
|
c.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), c.getMachineUseStatus()));
|
}).collect(Collectors.toList());
|
page.setRecords(collect);
|
return page;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean updateMachine(MachineUpdateVO vo) {
|
Long id = vo.getId();
|
int nums = ((MachineMapper) this.baseMapper).typeAndonRecord(Lists.newArrayList(new Long[]{id})).intValue();
|
if (nums > 0) {
|
throw new ServiceException(MessageUtils.message("machine.andon.not.update", new Object[0]));
|
}
|
String machineCode = vo.getMachineCode();
|
checkMachine(id, machineCode);
|
String pinCode = vo.getPinCode();
|
if (Func.isNotBlank(pinCode)) {
|
checkPinCode(pinCode, id);
|
}
|
String shortCode = vo.getShortCode();
|
if (Func.isNotBlank(shortCode)) {
|
validShortCode(shortCode, id);
|
}
|
Machine machine = MachineConvert.INSTANCE.convert(vo);
|
boolean updateById = updateById(machine);
|
Long groupId = machine.getGroupId();
|
if (!Func.isNull(groupId)) {
|
this.itemService.update(Wrappers.<CommonGroupOfItem>lambdaUpdate()
|
.set(CommonGroupOfItem::getGroupId, groupId)
|
.set(CommonGroupOfItem::getExtendId, machine.getExtendId())
|
.eq(CommonGroupOfItem::getItemId, machine.getId()));
|
/*
|
this.itemService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
|
return v0.getGroupId();
|
}, groupId)).set((v0) -> {
|
return v0.getExtendId();
|
}, machine.getExtendId())).eq((v0) -> {
|
return v0.getItemId();
|
}, machine.getId()));*/
|
}
|
if (updateById) {
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
}
|
return Boolean.valueOf(updateById);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void renewMachineRepairStatus(Long machineId, Integer maintenanceStatus) {
|
Machine machine = (Machine)getOne(new QueryWrapper<Machine>().lambda().eq(Machine::getId, machineId));
|
|
if (machine != null) {
|
machine.setRepairStatus(maintenanceStatus);
|
updateById(machine);
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void updateMachineRepairPriority(Long deviceId, List<RepairRecord> toBeConfirmedRecordList, List<RepairApply> inMaintenanceApplyList, List<RepairApply> toBeRepairedApplyList) {
|
if (Func.isNotEmpty(toBeConfirmedRecordList)) {
|
renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.TO_BE_CONFIRM.getType()));
|
} else if (Func.isNotEmpty(inMaintenanceApplyList)) {
|
renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType()));
|
} else if (Func.isNotEmpty(toBeRepairedApplyList)) {
|
renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.TO_BE_REPAIRED.getType()));
|
} else {
|
renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.NORMAL.getType()));
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void renewMachineRepairTime(Long deviceId) {
|
Machine machine = (Machine) getById(deviceId);
|
if (machine != null) {
|
machine.setLastRepairTime(LocalDateTime.now());
|
updateById(machine);
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void createRepairApplyUpdateMachine(Long deviceId, Integer maintenanceStatus) {
|
Machine machine = (Machine) getById(deviceId);
|
if (machine != null) {
|
if (Func.isNull(machine.getRepairStatus())) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.machine.repair.status.is.not.empty", new Object[0]));
|
}
|
if (machine.getRepairStatus().equals(Integer.valueOf(DeviceRepairStatusEnum.NORMAL.getType()))) {
|
renewMachineRepairStatus(deviceId, maintenanceStatus);
|
}
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void implementRepairApply(Long deviceId, Integer maintenanceStatus) {
|
Machine machine = (Machine) getById(deviceId);
|
if (Func.isNull(machine.getRepairStatus())) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.machine.repair.status.is.not.empty", new Object[0]));
|
}
|
if (!machine.getRepairStatus().equals(Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType())) || !machine.getRepairStatus().equals(Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType()))) {
|
renewMachineRepairStatus(deviceId, maintenanceStatus);
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void updateDeviceMaintainStatus(Long deviceId, Integer status, Long planId, LocalDateTime nextMaintainTime) {
|
List<MaintainPlan> checkList = checkExistPlanStatus(deviceId, null);
|
List<MaintainPlan> checkTimeList = (List) checkList.stream().sorted(Comparator.comparing((v0) -> {
|
return v0.getMaintainDate();
|
})).collect(Collectors.toList());
|
DeviceMaintainInDTO deviceMaintainInDTO = new DeviceMaintainInDTO();
|
deviceMaintainInDTO.setDeviceId(deviceId);
|
if (checkList.isEmpty()) {
|
deviceMaintainInDTO.setMaintainStatus(Integer.valueOf(MaintainPlanStatusEnum.T1.getType()));
|
} else {
|
deviceMaintainInDTO.setMaintainStatus(Integer.valueOf(MaintainPlanStatusEnum.of(checkList.get(0).getPlanStatus()).getType()));
|
}
|
if (checkTimeList.isEmpty()) {
|
deviceMaintainInDTO.setNextMaintainTime(null);
|
} else {
|
deviceMaintainInDTO.setNextMaintainTime(checkTimeList.get(0).getMaintainDate());
|
}
|
updateDeviceMaintain(deviceMaintainInDTO);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void updateDeviceMaintain(DeviceMaintainInDTO deviceMaintainInDTO) {
|
Machine one = (Machine) getById(deviceMaintainInDTO.getDeviceId());
|
if (one == null) {
|
throw new ServiceException(MessageUtils.message("machine.not.exists", new Object[0]));
|
}
|
one.setLastMaintainTime(deviceMaintainInDTO.getLastMaintainTime());
|
one.setMaintenanceStatus(deviceMaintainInDTO.getMaintainStatus());
|
one.setNextMaintainTime(deviceMaintainInDTO.getNextMaintainTime());
|
updateById(one);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public void updateDeviceMaintainStatus(Long deviceId, Long planId, LocalDateTime lastMaintainTime) {
|
List<MaintainPlan> checkList = checkExistPlanStatus(deviceId, null);
|
List<MaintainPlan> checkTimeList = (List) checkList.stream().sorted(Comparator.comparing((v0) -> {
|
return v0.getMaintainDate();
|
})).collect(Collectors.toList());
|
DeviceMaintainInDTO deviceMaintainInDTO = new DeviceMaintainInDTO();
|
deviceMaintainInDTO.setDeviceId(deviceId);
|
if (checkList.isEmpty()) {
|
deviceMaintainInDTO.setMaintainStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
|
} else {
|
deviceMaintainInDTO.setMaintainStatus(checkList.get(0).getPlanStatus());
|
}
|
if (checkTimeList.isEmpty()) {
|
deviceMaintainInDTO.setNextMaintainTime(null);
|
} else {
|
deviceMaintainInDTO.setNextMaintainTime(checkTimeList.get(0).getMaintainDate());
|
}
|
if (lastMaintainTime != null) {
|
deviceMaintainInDTO.setLastMaintainTime(lastMaintainTime);
|
}
|
updateDeviceMaintain(deviceMaintainInDTO);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<DeviceSimpleDTO> deviceListByDeviceTypeId(Long deviceTypeId) {
|
return ((MachineMapper) this.baseMapper).deviceListByDeviceTypeId(deviceTypeId);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<DeviceSimpleDTO> deviceListByDeviceIdList(List<Long> deviceIdList) {
|
return ((MachineMapper) this.baseMapper).deviceListByDeviceIdList(deviceIdList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public BladeFile exportMachine(MachineSelectVO vo) {
|
List<MachineDetailVO> vos = ((MachineMapper) this.baseMapper).listMachineDetail(vo.getMachineName(), vo.getMachineCode(), vo.getMachineTypeId(), vo.getGroupId(), CommonGroupConstant.ALL_MACHINE_ID, vo.getStatus());
|
List<MachineDetailVO> list = (List) vos.stream().peek(c -> {
|
c.setMachineLifeStatusName(DictCache.getValue(DictEnum.MACHINE_LIFE_STATUS.getName(), c.getMachineLifeStatus()));
|
c.setManagementClassName(DictCache.getValue(DictEnum.MACHINE_MANAGEMENT_CLASS, c.getManagementClass()));
|
c.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), c.getMachineUseStatus()));
|
}).collect(Collectors.toList());
|
List<MachineExcel> excels = MachineConvert.INSTANCE.convertVO(list);
|
String fileName = String.format("%s-%s.xlsx", "机器管理", DateUtil.time());
|
MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "机器管理数据表", excels, MachineExcel.class);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
@Transactional(rollbackFor = {Exception.class})
|
public BladeFile importMachine(MultipartFile file) {
|
List<MachineImport> rawData = ExcelUtil.read(file, 0, 2, MachineImport.class);
|
ThrowFun.isTrue(Func.isEmpty(rawData)).throwMessage(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
|
ThrowFun.isTrue(rawData.size() > 200).throwMessage(MessageUtils.message("excel.import.size.failed", new Object[0]));
|
Map<String, Integer> machineCodeMap = new HashMap<>(rawData.size());
|
Set<String> machineCodes = new HashSet<>(rawData.size());
|
Map<String, Integer> pinMap = new HashMap<>(rawData.size());
|
Set<String> pinCodes = new HashSet<>(rawData.size());
|
Map<String, Integer> shortMap = new HashMap<>(rawData.size());
|
Set<String> shortCodes = new HashSet<>(rawData.size());
|
buildMap(rawData, machineCodeMap, machineCodes, pinMap, pinCodes, shortMap, shortCodes);
|
List<MachineImport> failExcel = Lists.newArrayList();
|
List<DeviceType> deviceTypeList = Lists.newArrayList();
|
List<Workstation> workstationList = this.workstationService.list(Wrappers.<Workstation>lambdaQuery().eq(Workstation::getStatus, CommonConstant.ENABLE));
|
Map<String, Workstation> workstationMap = workstationList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getCode();
|
}, v -> {
|
return v;
|
}));
|
HashMap<String, Long> commonGroupNameMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.MACHINE.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
HashMap<String, Long> organizationNameMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
HashMap<String, Long> commonGroupNameStatusMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY, CommonConstant.ENABLE);
|
Map<String, Long> commonGroupNameDisableMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY, CommonConstant.DEACTIVATE);
|
EmployeeNameDTO employeeNameMap = this.employeeService.getEmployeeNameMap();
|
for (MachineImport data : rawData) {
|
boolean validImport = validImport(data, machineCodeMap, machineCodes, pinCodes, pinMap, shortCodes, shortMap, failExcel, deviceTypeList, commonGroupNameMap, organizationNameMap, workstationMap, commonGroupNameStatusMap, commonGroupNameDisableMap, employeeNameMap);
|
if (validImport) {
|
break;
|
}
|
}
|
if (Func.isNotEmpty(failExcel)) {
|
return exportFailFile(failExcel);
|
}
|
Map<String, Long> typeMap = deviceTypeList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getCode();
|
}, (v0) -> {
|
return v0.getId();
|
},(v1, v2) -> {
|
return v1;
|
}));
|
saveExportMachine(rawData, typeMap, commonGroupNameMap, organizationNameMap, employeeNameMap);
|
return null;
|
}
|
|
public void saveExportMachine(List<MachineImport> rawData, Map<String, Long> typeMap, HashMap<String, Long> commonGroupNameMap, HashMap<String, Long> organizationNameMap, EmployeeNameDTO employeeNameMap) {
|
List<Machine> collect = rawData.stream().map(c -> {
|
Machine machine = MachineConvert.INSTANCE.convert(c);
|
String machineTypeName = c.getMachineTypeName();
|
String machineTypeCode = c.getMachineTypeCode();
|
if (Func.isNotBlank(machineTypeName) && Func.isNotBlank(machineTypeCode)) {
|
Long machineTypeId = (Long) typeMap.get(machineTypeCode);
|
machine.setMachineTypeId(machineTypeId);
|
}
|
String groupName = c.getGroupName();
|
if (Func.isNotBlank(groupName) && !CommonGroupConstant.ALL_NAME.equals(groupName)) {
|
Long groupId = (Long) commonGroupNameMap.get(groupName);
|
machine.setGroupId(groupId);
|
} else if (CommonGroupConstant.ALL_NAME.equals(groupName)) {
|
machine.setGroupId(CommonGroupConstant.DEFAULT_MACHINE_ID);
|
} else {
|
machine.setGroupId(CommonGroupConstant.DEFAULT_MACHINE_ID);
|
}
|
String organizationName = c.getOrganizationName();
|
if (Func.isNotBlank(organizationName)) {
|
Long organizationId = (Long) organizationNameMap.get(organizationName);
|
machine.setOrganizationId(organizationId);
|
}
|
String lifeStatusName = c.getMachineLifeStatusName();
|
if (Func.isNotBlank(lifeStatusName)) {
|
String lifeStatus = DictCache.getKey(DictEnum.MACHINE_LIFE_STATUS, lifeStatusName);
|
machine.setMachineLifeStatus(Integer.valueOf(Integer.parseInt(lifeStatus)));
|
}
|
String managementClassName = c.getManagementClassName();
|
if (Func.isNotBlank(managementClassName)) {
|
String managementClass = DictCache.getKey(DictEnum.MACHINE_MANAGEMENT_CLASS, managementClassName);
|
machine.setManagementClass(Integer.valueOf(Integer.parseInt(managementClass)));
|
}
|
String useStatusName = c.getMachineUseStatusName();
|
if (Func.isNotBlank(useStatusName)) {
|
String useStatus = DictCache.getKey(DictEnum.MACHINE_USE_STATUS, useStatusName);
|
machine.setMachineUseStatus(Integer.valueOf(Integer.parseInt(useStatus)));
|
}
|
String employeeName = c.getEmployeeName();
|
if (Func.isNotEmpty(employeeName)) {
|
machine.setEmployeeId(employeeNameMap.getEmployeeNameMap().get(employeeName));
|
}
|
machine.setMaintenanceStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
|
machine.setRepairStatus(Integer.valueOf(RepairRecordEnum.R1.getType()));
|
machine.setExtendId(UUID.randomUUID().toString());
|
return machine;
|
}).collect(Collectors.toList());
|
saveBatch(collect);
|
saveCommonGroupItem(collect);
|
saveWorkstationOfMachine(collect);
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
}
|
|
private BladeFile exportFailFile(List<MachineImport> failExcel) {
|
MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "machineFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "机器表", failExcel, (Object) null, (AbstractMergeStrategy) null);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
private void buildMap(List<MachineImport> rawData, Map<String, Integer> machineCodeMap, Set<String> machineCodes, Map<String, Integer> pinMap, Set<String> pinCodes, Map<String, Integer> shortMap, Set<String> shortCodes) {
|
QueryWrapper<Machine> machineCodeQuery = Wrappers.<Machine>query().select(new String[]{"machine_code"});
|
QueryWrapper<Machine> pinCodeQuery = Wrappers.<Machine>query().select(new String[]{"pin_code"});
|
QueryWrapper<Machine> shortCodeQuery = Wrappers.<Machine>query().select(new String[]{"short_code"});
|
boolean flag1 = false;
|
boolean flag2 = false;
|
boolean flag3 = false;
|
for (MachineImport data : rawData) {
|
String machineCode = data.getMachineCode();
|
if (Func.isNotBlank(machineCode)) {
|
if (machineCodeMap.containsKey(machineCode)) {
|
machineCodeMap.put(machineCode, Integer.valueOf(machineCodeMap.get(machineCode).intValue() + 1));
|
} else {
|
machineCodeMap.put(machineCode, 1);
|
}
|
if (flag1) {
|
machineCodeQuery.or();
|
}
|
flag1 = true;
|
machineCodeQuery.nested(i -> {
|
i.eq("machine_code", machineCode);
|
//QueryWrapper queryWrapper = (QueryWrapper) i.eq("machine_code", machineCode);
|
});
|
machineCodeQuery.apply("status =1", new Object[0]);
|
}
|
String pinCode = data.getPinCode();
|
if (Func.isNotBlank(pinCode)) {
|
if (pinMap.containsKey(pinCode)) {
|
pinMap.put(pinCode, Integer.valueOf(pinMap.get(pinCode).intValue() + 1));
|
} else {
|
pinMap.put(pinCode, 1);
|
}
|
if (flag2) {
|
pinCodeQuery.or();
|
}
|
flag2 = true;
|
pinCodeQuery.nested(i2 -> {
|
i2.eq("pin_code", pinCode);
|
});
|
pinCodeQuery.apply("status =1", new Object[0]);
|
}
|
String shortCode = data.getShortCode();
|
if (Func.isNotBlank(shortCode)) {
|
if (shortMap.containsKey(shortCode)) {
|
shortMap.put(shortCode, Integer.valueOf(shortMap.get(shortCode).intValue() + 1));
|
} else {
|
shortMap.put(shortCode, 1);
|
}
|
if (flag3) {
|
shortCodeQuery.or();
|
}
|
flag3 = true;
|
shortCodeQuery.nested(i3 -> {
|
i3.eq("short_code", shortCode);
|
});
|
shortCodeQuery.apply("status =1", new Object[0]);
|
}
|
}
|
String sqlSegment1 = machineCodeQuery.getSqlSegment();
|
if (Func.isNotBlank(sqlSegment1)) {
|
List<String> machineCodeList = listObjs(machineCodeQuery, String::valueOf);
|
if (Func.isNotEmpty(machineCodeList)) {
|
machineCodes.addAll(machineCodeList);
|
}
|
}
|
String sqlSegment2 = pinCodeQuery.getSqlSegment();
|
if (Func.isNotBlank(sqlSegment2)) {
|
List<String> pinCodeList = listObjs(pinCodeQuery, String::valueOf);
|
if (Func.isNotEmpty(pinCodeList)) {
|
pinCodes.addAll(pinCodeList);
|
}
|
}
|
String sqlSegment3 = shortCodeQuery.getSqlSegment();
|
if (Func.isNotBlank(sqlSegment3)) {
|
List<String> shortCodeList = listObjs(shortCodeQuery, String::valueOf);
|
if (Func.isNotEmpty(shortCodeList)) {
|
shortCodes.addAll(shortCodeList);
|
}
|
}
|
}
|
|
public void saveWorkstationOfMachine(List<Machine> collect) {
|
collect.forEach(machine -> {
|
if ("是".equals(machine.getLinkWay())) {
|
WorkstationSubmitVO workstationSaveVO = new WorkstationSubmitVO();
|
workstationSaveVO.setCode(machine.getMachineCode());
|
workstationSaveVO.setName(machine.getMachineName());
|
workstationSaveVO.setMachineCode(machine.getMachineCode());
|
workstationSaveVO.setMachineName(machine.getMachineName());
|
workstationSaveVO.setGroupId(CommonGroupConstant.DEFAULT_WORKSTATION_ID);
|
workstationSaveVO.setLinkWay(0);
|
workstationSaveVO.setType(0);
|
workstationSaveVO.setMachineId(machine.getId());
|
this.workstationService.submit(workstationSaveVO);
|
}
|
});
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean delete(IdsVO vo, Integer type) {
|
if (StatusType.REMOVE.getType().equals(type)) {
|
WorkstationOfMachineCache.clearWorkStationMachineCache(vo.getIds());
|
Integer nums = ((MachineMapper) this.baseMapper).typeAndonRecord(Func.toLongList(vo.getIds()));
|
if (nums.intValue() > 0) {
|
throw new ServiceException(MessageUtils.message("machine.andon.not.remove", new Object[0]));
|
}
|
removeByIds(Func.toLongList(vo.getIds()));
|
this.workstationOfMachineService.remove(Wrappers.<WorkstationOfMachine>lambdaQuery().in(WorkstationOfMachine::getMachineId, vo.getIds()));
|
this.itemService.remove( Wrappers.<CommonGroupOfItem>lambdaQuery().in(CommonGroupOfItem::getItemId, vo.getIds()));
|
CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
|
CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
|
}
|
return Boolean.valueOf(changeStatus(Func.toLongList(vo.getIds()), CommonConstant.DEACTIVATE));
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<HmiDeviceVO> getHmiWorkstation(String machineId) {
|
List<HmiDeviceVO> hmiDeviceVOList = new ArrayList<>();
|
Machine machine = (Machine) getById(machineId);
|
if (machine == null) {
|
throw new ServiceException("机器不存在");
|
}
|
List<WorkstationOfMachine> list = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery().eq(WorkstationOfMachine::getMachineId, machineId));
|
|
if (Func.isNotEmpty(list)) {
|
List<Long> workstationIds = list.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
if (Func.isNotEmpty(workstationIds)) {
|
List<Workstation> workstations = this.workstationService.listByIds(workstationIds);
|
for (Workstation workstation : workstations) {
|
HmiDeviceVO hmiDeviceVO = new HmiDeviceVO();
|
hmiDeviceVO.setWorkstationId(String.valueOf(workstation.getId()));
|
hmiDeviceVO.setWorkstationName(workstation.getName());
|
Integer supportCncRw = workstation.getSupportCncRw();
|
if (DncEnums.SupportCncRw.Support.getCode().equals(supportCncRw)) {
|
hmiDeviceVO.setFileLocations(Arrays.asList(1, 2));
|
} else {
|
hmiDeviceVO.setFileLocations(Collections.singletonList(2));
|
}
|
hmiDeviceVOList.add(hmiDeviceVO);
|
}
|
}
|
}
|
return hmiDeviceVOList;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<MachineExtDTO> getMachineByWorkStation(List<Long> workstationIds) {
|
return ((MachineMapper) this.baseMapper).getMachineByWorkStation(workstationIds);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public String queryDateTypeState(Long workstationId) {
|
return ((MachineMapper) this.baseMapper).queryDateTypeState(WcsDataTypeEnums.WcsDataType.STATE.getCode(), workstationId);
|
}
|
|
private boolean validImport(MachineImport data, Map<String, Integer> machineCodeMap, Set<String> machineCodes, Set<String> pinCodes, Map<String, Integer> pinMap, Set<String> shortCodes, Map<String, Integer> shortMap, List<MachineImport> failExcel, List<DeviceType> deviceTypeList, HashMap<String, Long> commonGroupNameMap, HashMap<String, Long> organizationNameMap, Map<String, Workstation> workstationMap, HashMap<String, Long> commonGroupNameStatusMap, Map<String, Long> commonGroupNameDisableMap, EmployeeNameDTO employeeNameMap) {
|
boolean validMachineCode = validMachineCode(data, machineCodeMap, machineCodes, failExcel);
|
if (validMachineCode) {
|
return true;
|
}
|
boolean validMachineName = validMachineName(data, failExcel);
|
if (validMachineName) {
|
return true;
|
}
|
boolean validLinkWay = validLinkWay(data, workstationMap, failExcel);
|
if (validLinkWay) {
|
return true;
|
}
|
boolean validWorkstationBind = validWorkstationBind(data, workstationMap, failExcel);
|
if (validWorkstationBind) {
|
return true;
|
}
|
String pinCode = data.getPinCode();
|
if (Func.isNotBlank(pinCode)) {
|
boolean valid = validPinCodeImport(pinCode, data, failExcel, pinCodes, pinMap);
|
if (valid) {
|
return true;
|
}
|
}
|
String shortCode = data.getShortCode();
|
if (Func.isNotBlank(shortCode)) {
|
boolean valid2 = validShortCodeImport(shortCode, data, failExcel, shortCodes, shortMap);
|
if (valid2) {
|
return true;
|
}
|
}
|
String typeCode = data.getMachineTypeCode();
|
String typeName = data.getMachineTypeName();
|
if (Func.isNotBlank(typeName) && Func.isBlank(typeCode)) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.type.code.error", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
if (Func.isNotBlank(typeName) && Func.isNotBlank(typeCode)) {
|
DeviceType type = this.typeService.getOne(Wrappers.<DeviceType>lambdaQuery().eq(DeviceType::getName, typeName)
|
.eq(DeviceType::getCode, typeCode));
|
if (Func.isEmpty(type)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.type.not.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
deviceTypeList.add(type);
|
}
|
String groupName = data.getGroupName();
|
if (Func.isNotBlank(groupName) && !commonGroupNameMap.containsKey(groupName)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.group.not.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
String voltage = data.getVoltage();
|
if (Func.isNotBlank(voltage)) {
|
boolean valid3 = checkNumberFormat(voltage, data, failExcel);
|
if (valid3) {
|
return true;
|
}
|
}
|
String dimensions = data.getDimensions();
|
if (Func.isNotBlank(dimensions)) {
|
boolean valid4 = checkNumberFormat(dimensions, data, failExcel);
|
if (valid4) {
|
return true;
|
}
|
}
|
String netWeight = data.getNetWeight();
|
if (Func.isNotBlank(netWeight)) {
|
boolean valid5 = checkNumberFormat(netWeight, data, failExcel);
|
if (valid5) {
|
return true;
|
}
|
}
|
String power = data.getPower();
|
if (Func.isNotBlank(power)) {
|
boolean valid6 = checkNumberFormat(power, data, failExcel);
|
if (valid6) {
|
return true;
|
}
|
}
|
String invoiceValue = data.getInvoiceValue();
|
if (Func.isNotBlank(invoiceValue)) {
|
boolean valid7 = checkNumberFormat(invoiceValue, data, failExcel);
|
if (valid7) {
|
return true;
|
}
|
}
|
String ovfa = data.getOvfa();
|
if (Func.isNotBlank(ovfa)) {
|
boolean valid8 = checkNumberFormat(ovfa, data, failExcel);
|
if (valid8) {
|
return true;
|
}
|
}
|
String netAssetValue = data.getNetAssetValue();
|
if (Func.isNotBlank(netAssetValue)) {
|
boolean valid9 = checkNumberFormat(netAssetValue, data, failExcel);
|
if (valid9) {
|
return true;
|
}
|
}
|
String productionTime = data.getProductionTime();
|
if (Func.isNotBlank(productionTime)) {
|
boolean valid10 = checkTimeFormat(productionTime, data, failExcel);
|
if (valid10) {
|
return true;
|
}
|
}
|
String deliveryTime = data.getDeliveryTime();
|
if (Func.isNotBlank(deliveryTime)) {
|
boolean valid11 = checkTimeFormat(deliveryTime, data, failExcel);
|
if (valid11) {
|
return true;
|
}
|
}
|
String turnToFixedAssetsTime = data.getTurnToFixedAssetsTime();
|
if (Func.isNotBlank(turnToFixedAssetsTime)) {
|
boolean valid12 = checkTimeFormat(turnToFixedAssetsTime, data, failExcel);
|
if (valid12) {
|
return true;
|
}
|
}
|
String lifeStatusName = data.getMachineLifeStatusName();
|
if (Func.isNotBlank(lifeStatusName)) {
|
String lifeStatus = DictCache.getKey(DictEnum.MACHINE_LIFE_STATUS, lifeStatusName);
|
if (Func.isBlank(lifeStatus)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.life.status.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
}
|
String managementClassName = data.getManagementClassName();
|
if (Func.isNotBlank(managementClassName)) {
|
String managementClass = DictCache.getKey(DictEnum.MACHINE_MANAGEMENT_CLASS, managementClassName);
|
if (Func.isBlank(managementClass)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.management.class.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
}
|
String organizationName = data.getOrganizationName();
|
if (Func.isNotBlank(organizationName)) {
|
if (!commonGroupNameStatusMap.containsKey(organizationName)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.organization.not.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (commonGroupNameDisableMap.containsKey(data.getOrganizationName())) {
|
data.setFailReason(MessageUtils.message("cps.organization.already.exist.stop.status", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
}
|
String useStatusName = data.getMachineUseStatusName();
|
if (Func.isNotBlank(useStatusName)) {
|
String useStatus = DictCache.getKey(DictEnum.MACHINE_USE_STATUS, useStatusName);
|
if (Func.isBlank(useStatus)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.use.status.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
}
|
String employeeName = data.getEmployeeName();
|
if (Func.isNotEmpty(employeeName)) {
|
if (!employeeNameMap.getEmployeeNameMap().containsKey(employeeName)) {
|
data.setFailReason(MessageUtils.message("cps.employee.name.is.not.exist", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (employeeNameMap.getRepeatEmployeeNameMap().containsKey(employeeName)) {
|
data.setFailReason(StrUtil.format(MessageUtils.message("cps.employee.name.already.exists", new Object[0]), new Object[]{employeeName}));
|
failExcel.add(data);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
return false;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public MachineDetailVO detailByCode(String machineCode) {
|
MachineDetailVO machineDetailVO = ((MachineMapper) this.baseMapper).selectMachineDetailByCode(machineCode);
|
if (Func.isNotEmpty(machineDetailVO)) {
|
machineDetailVO.setMachineLifeStatusName(DictCache.getValue(DictEnum.MACHINE_LIFE_STATUS.getName(), machineDetailVO.getMachineLifeStatus()));
|
machineDetailVO.setManagementClassName(DictCache.getValue(DictEnum.MACHINE_MANAGEMENT_CLASS, machineDetailVO.getManagementClass()));
|
machineDetailVO.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), machineDetailVO.getMachineUseStatus()));
|
List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery()
|
.eq(WorkstationOfMachine::getMachineId, machineDetailVO.getId()));
|
if (Func.isNotEmpty(workstationOfMachineList)) {
|
List<Workstation> workstationList = this.workstationService.listByIds(workstationOfMachineList.stream().map(WorkstationOfMachine::getWorkstationId).collect(Collectors.toList()));
|
Optional.ofNullable(workstationList).ifPresent(workstations -> {
|
String code = ((Workstation) ListUtils.getFirst(workstations)).getCode();
|
String name = ((Workstation) ListUtils.getFirst(workstations)).getName();
|
Long workstationId = ((Workstation) ListUtils.getFirst(workstations)).getId();
|
machineDetailVO.setWorkstationCode(code);
|
machineDetailVO.setWorkstationName(name);
|
machineDetailVO.setWorkstationId(workstationId);
|
});
|
}
|
}
|
return machineDetailVO;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public IPage<MachineListVO> pageMachineByParam(MachineSelectVO machineSelectVO, Query query) {
|
IPage<MachineListVO> page = ((MachineMapper) this.baseMapper).pageMachineByParam(Condition.getPage(query), machineSelectVO);
|
List<MachineListVO> records = page.getRecords();
|
List<MachineListVO> collect = (List) records.stream().peek(c -> {
|
c.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), c.getMachineUseStatus()));
|
}).collect(Collectors.toList());
|
page.setRecords(collect);
|
return page;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<MachineVO> listNoBand() {
|
return ((MachineMapper) this.baseMapper).listNoBand();
|
}
|
|
@Override // org.springblade.modules.cps.service.IMachineService
|
public List<MachineVO> listHaveBand() {
|
return ((MachineMapper) this.baseMapper).listHaveBand();
|
}
|
|
private boolean validMachineCode(MachineImport data, Map<String, Integer> machineCodeMap, Set<String> machineCodes, List<MachineImport> failExcel) {
|
String machineCode = data.getMachineCode();
|
if (Func.isBlank(machineCode)) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.code.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (machineCodes.contains(machineCode)) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.code.code.same", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else {
|
Integer nums = machineCodeMap.getOrDefault(machineCode, 1);
|
if (nums.intValue() > 1) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.code.code.same", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (checkStopImportMachine(machineCode)) {
|
data.setFailReason(MessageUtils.message("machine.code.already.exist.stop.status", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
}
|
|
private boolean validMachineName(MachineImport data, List<MachineImport> failExcel) {
|
String machineName = data.getMachineName();
|
if (Func.isBlank(machineName)) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.name.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
return false;
|
}
|
|
private boolean validLinkWay(MachineImport data, Map<String, Workstation> workstationMap, List<MachineImport> failExcel) {
|
String linkWay = data.getLinkWay();
|
if (Func.isNotEmpty(linkWay)) {
|
if (!"是".equals(linkWay) && !"否".equals(linkWay)) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.linkWay.not.correct", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if ("是".equals(linkWay)) {
|
String machineCode = data.getMachineCode();
|
if (workstationMap.containsKey(machineCode)) {
|
data.setFailReason(MessageUtils.message("cps.workstation.code.already.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
return false;
|
} else {
|
return false;
|
}
|
}
|
return false;
|
}
|
|
private boolean validWorkstationBind(MachineImport data, Map<String, Workstation> workstationMap, List<MachineImport> failExcel) {
|
Workstation workstation = workstationMap.get(data.getMachineCode());
|
if (Func.isNotEmpty(workstation)) {
|
long count = this.workstationOfMachineService.count(Wrappers.<WorkstationOfMachine>lambdaQuery()
|
.eq(WorkstationOfMachine::getWorkstationId, workstation.getId()));
|
/*
|
long count = this.workstationOfMachineService.count((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getWorkstationId();
|
}, workstation.getId()));*/
|
if (count > 0) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.workstation.already.bound", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
return false;
|
}
|
return false;
|
}
|
|
private boolean validPinCodeImport(String pinCode, MachineImport data, List<MachineImport> failExcel, Set<String> pinCodes, Map<String, Integer> pinMap) {
|
int len = pinCode.length();
|
if (len < 4 || len > 6) {
|
data.setFailReason(String.format(MessageUtils.message("cps.tpm.machine.pin.code.length", new Object[0]), 4, 6));
|
failExcel.add(data);
|
return true;
|
}
|
boolean matches = CHINESE.matcher(pinCode).matches();
|
if (!matches) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.ping.code.have.chinese", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
return false;
|
}
|
|
private boolean validShortCodeImport(String shortCode, MachineImport data, List<MachineImport> failExcel, Set<String> shortCodes, Map<String, Integer> shortMap) {
|
int len = shortCode.length();
|
if (len < 4 || len > 8) {
|
data.setFailReason(String.format(MessageUtils.message("cps.tpm.machine.short.code.length", new Object[0]), 4, 8));
|
failExcel.add(data);
|
return true;
|
} else if (Func.isNotEmpty(shortCodes) && shortCodes.contains(shortCode)) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.short.code.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (Func.isNotEmpty(shortMap) && shortMap.getOrDefault(shortCode, 1).intValue() > 1) {
|
data.setFailReason(MessageUtils.message("cps.tpm.machine.short.code.excel.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else {
|
boolean matches = CHINESE.matcher(shortCode).matches();
|
if (!matches) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.short.code.have.chinese", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
return false;
|
}
|
}
|
|
private boolean checkTimeFormat(String time, MachineImport data, List<MachineImport> failExcel) {
|
if (Func.isNotBlank(time)) {
|
try {
|
DateUtil.parse(time, DateConstant.PATTERN_DATE);
|
return false;
|
} catch (Exception e) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.time.error", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private boolean checkNumberFormat(String number, MachineImport data, List<MachineImport> failExcel) {
|
if (Func.isNotBlank(number)) {
|
boolean matches = NUMBER.matcher(number).matches();
|
if (!matches) {
|
data.setFailReason(MessageUtils.message("excel.import.machine.number.error", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
return false;
|
}
|
return false;
|
}
|
|
private boolean checkStopImportMachine(String machineCode) {
|
Machine machine = getOne(Wrappers.<Machine>lambdaQuery().eq(Machine::getMachineCode, machineCode).eq(Machine::getStatus, CommonConstant.DEACTIVATE));
|
|
if (machine != null) {
|
return Boolean.TRUE.booleanValue();
|
}
|
return Boolean.FALSE.booleanValue();
|
}
|
|
private void checkStopMachine(String machineCode) {
|
Machine machine = getOne(Wrappers.<Machine>lambdaQuery().eq(Machine::getMachineCode, machineCode).eq(Machine::getStatus, CommonConstant.DEACTIVATE));
|
/*
|
Machine machine = (Machine) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getMachineCode();
|
}, machineCode)).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.DEACTIVATE));*/
|
if (machine != null) {
|
throw new ServiceException(MessageUtils.message("machine.code.already.exist.stop.status", new Object[0]));
|
}
|
}
|
|
private void checkStopMachineByCode(String workstationCode) {
|
Machine machine = getOne(Wrappers.<Machine>lambdaQuery().eq(Machine::getMachineCode, workstationCode).eq(Machine::getStatus, CommonConstant.DEACTIVATE));
|
if (machine != null) {
|
throw new ServiceException(MessageUtils.message("machine.machine.workstation.already.exist.stop.status", new Object[0]));
|
}
|
}
|
|
private void checkMachine(Long id, String machineCode) {
|
Long count = Long.valueOf(count(Wrappers.<Machine>lambdaQuery().ne(Func.isNotEmpty(id), Machine::getId, id)
|
.eq(Machine::getMachineCode, machineCode)
|
.eq(Machine::getStatus, CommonConstant.ENABLE)));
|
/*
|
Long count = Long.valueOf(count((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(id), (v0) -> {
|
return v0.getId();
|
}, id).eq((v0) -> {
|
return v0.getMachineCode();
|
}, machineCode)).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)));*/
|
if (count.longValue() > 0) {
|
throw new ServiceException(MessageUtils.message("machine.code.already.exists", new Object[0]));
|
}
|
}
|
|
private void checkPinCode(String pinCode, Long id) {
|
int len = pinCode.length();
|
if (len < 4 || len > 6) {
|
throw new ServiceException(String.format(MessageUtils.message("cps.tpm.machine.pin.code.length", new Object[0]), 4, 6));
|
}
|
}
|
|
private void saveCommonGroupItem(List<Machine> machines) {
|
if (Func.isNotEmpty(machines)) {
|
List<CommonGroupOfItem> collect = (List) machines.stream().map(c -> {
|
return CommonGroupOfItem.builder().groupId(c.getGroupId()).itemId(c.getId()).extendId(c.getExtendId()).groupType(CommonGroupTypeEnum.MACHINE.getName()).groupCategory(CommonGroupConstant.DEFAULT_CATEGORY).build();
|
}).collect(Collectors.toList());
|
this.itemService.saveBatch(collect);
|
}
|
}
|
|
private List<MaintainPlan> checkExistPlanStatus(Long deviceId, Long id) {
|
List<MaintainPlan> maintainPlanList = this.maintainPlanService.list(Wrappers.<MaintainPlan>query().lambda()
|
.eq(Func.isNotEmpty(AuthUtil.getTenantId()), MaintainPlan::getTenantId, AuthUtil.getTenantId())
|
.eq(MaintainPlan::getDeviceId, deviceId)
|
.notIn(
|
Func.isNotEmpty(id), MaintainPlan::getId, new Object[] { id })
|
.notIn(MaintainPlan::getPlanStatus, new Object[] { Integer.valueOf(MaintainPlanStatusEnum.T5.getType()) })
|
.orderByDesc(MaintainPlan::getPlanStatus));
|
/*
|
List<MaintainPlan> maintainPlanList = this.maintainPlanService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
|
return v0.getTenantId();
|
}, AuthUtil.getTenantId()).eq((v0) -> {
|
return v0.getDeviceId();
|
}, deviceId)).notIn(Func.isNotEmpty(id), (v0) -> {
|
return v0.getId();
|
}, new Object[]{id}).notIn((v0) -> {
|
return v0.getPlanStatus();
|
}, new Object[]{Integer.valueOf(MaintainPlanStatusEnum.T5.getType())})).orderByDesc((v0) -> {
|
return v0.getPlanStatus();
|
}));*/
|
return maintainPlanList;
|
}
|
}
|
