package com.mes.base.engineering.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.mes.base.engineering.entity.request.EngineerImportRequest;
|
import com.mes.base.engineering.entity.request.EngineerRequest;
|
import com.mes.base.engineering.service.AbstractEngineeringService;
|
import com.mes.base.glassinfo.service.GlassInfoService;
|
import com.mes.base.rawqueue.service.EngineeringRawQueueService;
|
import com.mes.engineering.Engineering;
|
import com.mes.flowcard.FlowCardInfo;
|
import com.mes.glassinfo.GlassInfo;
|
import com.mes.glassinfo.request.GlassInfoImportRequest;
|
import com.mes.hollow.formula.HollowFormulaDetails;
|
import com.mes.rawqueue.EngineeringRawQueue;
|
import com.mes.rawqueue.request.EngineeringRawQueueImportRequest;
|
import com.mes.sysconst.Const;
|
import com.mes.tempering.param.TemperingParameter;
|
import com.mes.tools.EntityTool;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
/**
|
* (Engineering)表服务实现类
|
*
|
* @author makejava
|
* @since 2025-06-02 17:48:38
|
*/
|
@Service
|
@Slf4j
|
@ConditionalOnProperty(name = "engineering.mode", havingValue = "lm", matchIfMissing = true)
|
public class LmEngineeringServiceImpl extends AbstractEngineeringService {
|
|
@Resource
|
GlassInfoService glassInfoService;
|
|
@Resource
|
EngineeringRawQueueService engineeringRawQueueService;
|
|
/**
|
* mes主动调用导入工程
|
*
|
* @param request
|
* @return
|
*/
|
@Override
|
public EngineerImportRequest mesImportEngineer(EngineerRequest request) {
|
EngineerImportRequest importRequest = new EngineerImportRequest();
|
Engineering engineering = baseMapper.queryEngineeringByErp(request.getEngineerId());
|
List<GlassInfoImportRequest> glassInfoList = baseMapper.queryGlassListByErp(request.getEngineerId());
|
List<EngineeringRawQueueImportRequest> rawQueueList = baseMapper.queryRawListByErp(request.getEngineerId());
|
BeanUtil.copyProperties(engineering, importRequest);
|
importRequest.setGlassInfolList(glassInfoList);
|
importRequest.setEngineeringRawQueueList(rawQueueList);
|
return importRequest;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean importEngineerList(EngineerImportRequest request) {
|
Engineering engineering = EntityTool.convertSingle(request, Engineering.class);
|
engineering.setState(Const.TASK_STATE_NEW);
|
List<GlassInfo> glassInfoList = EntityTool.batchConvert(request.getGlassInfolList(), GlassInfo.class);
|
List<EngineeringRawQueue> engineeringRawQueueList = EntityTool.batchConvert(request.getEngineeringRawQueueList(), EngineeringRawQueue.class);
|
engineeringRawQueueList.stream().forEach(e -> e.setState(Const.TASK_STATE_NEW));
|
List<FlowCardInfo> flowCardInfoList = EntityTool.batchConvert(request.getFlowCardInfoList(), FlowCardInfo.class);
|
List<HollowFormulaDetails> hollowFormulaDetails = EntityTool.batchConvert(request.getHollowFormulaDetailsList(), HollowFormulaDetails.class);
|
List<TemperingParameter> temperingParameter = EntityTool.batchConvert(request.getTemperingParameterList(), TemperingParameter.class);
|
//起码保证玻璃小片数据不为null
|
if (CollectionUtil.isNotEmpty(glassInfoList)) {
|
this.save(engineering);
|
glassInfoService.saveBatch(glassInfoList);
|
engineeringRawQueueService.saveBatch(engineeringRawQueueList);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public List<String> queryEngineerIdList(EngineerRequest request) {
|
// 获取可执行的工程信息
|
List<Engineering> engineeringList = this.list(new LambdaQueryWrapper<Engineering>().in(Engineering::getState, Const.TASK_STATE_NEW, Const.TASK_STATE_PAUSE));
|
return engineeringList.stream().map(Engineering::getEngineerId).collect(Collectors.toList());
|
}
|
|
@Override
|
public List<String> queryNotFinishEngineerIdList() {
|
return this.listObjs(new LambdaQueryWrapper<Engineering>()
|
.select(Engineering::getEngineerId)
|
.ne(Engineering::getState, Const.TASK_STATE_SUCCESS)).stream()
|
.map(Object::toString)
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* 领取的工程任务并返回原片队列
|
*
|
* @param request
|
* @return
|
*/
|
@Override
|
public List<EngineeringRawQueue> queryEngineeringRawQueueList(EngineerRequest request) {
|
//向前端返回mes原片对列表
|
return engineeringRawQueueService.list(new LambdaQueryWrapper<EngineeringRawQueue>()
|
.eq(EngineeringRawQueue::getEngineeringId, request.getEngineerId())
|
.orderByAsc(EngineeringRawQueue::getRawSequence));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean startTask(EngineerRequest request) {
|
//避免任务重复发生
|
boolean checkFlag = checkEngineering(request);
|
if (!checkFlag) {
|
return Boolean.FALSE;
|
}
|
//将工程状态更新
|
return this.update(new LambdaUpdateWrapper<Engineering>().set(Engineering::getState, Const.TASK_STATE_START)
|
.set(Engineering::getWorkLine, request.getWorkLine())
|
.eq(Engineering::getEngineerId, request.getEngineerId()).in(Engineering::getState, Const.TASK_STATE_NEW, Const.TASK_STATE_PAUSE));
|
}
|
|
@Override
|
public Boolean pauseTask(EngineerRequest request) {
|
return this.update(new LambdaUpdateWrapper<Engineering>()
|
.set(Engineering::getState, Const.TASK_STATE_PAUSE)
|
.eq(Engineering::getEngineerId, request.getEngineerId())
|
.eq(Engineering::getWorkLine, request.getWorkLine())
|
);
|
}
|
|
@Override
|
public Boolean finishTask(EngineerRequest request) {
|
return this.update(new LambdaUpdateWrapper<Engineering>()
|
.set(Engineering::getState, Const.TASK_STATE_SUCCESS)
|
.eq(Engineering::getEngineerId, request.getEngineerId())
|
.eq(Engineering::getWorkLine, request.getWorkLine())
|
);
|
}
|
|
@Override
|
public boolean checkEngineering(EngineerRequest request) {
|
//避免任务重复发生
|
int runningCount = this.count(new LambdaQueryWrapper<Engineering>()
|
.eq(Engineering::getState, Const.TASK_STATE_START)
|
.eq(Engineering::getWorkLine, request.getWorkLine()));
|
if (runningCount > 0) {
|
log.info("有正在执行的工程，请确保无正在执行的任务后进行操作");
|
return Boolean.FALSE;
|
}
|
int anotherLineCount = this.count(new LambdaQueryWrapper<Engineering>()
|
.eq(Engineering::getEngineerId, request.getEngineerId())
|
.ne(Engineering::getWorkLine, request.getWorkLine()));
|
if (anotherLineCount > 0) {
|
log.info("其他线路已领取有正在执行的工程，无法领取该工程");
|
return Boolean.FALSE;
|
}
|
return Boolean.TRUE;
|
}
|
}
|
