Merge remote-tracking branch 'origin/dev-wuhan' into dev-wuhan

tags/yfai-pcn-ext-v2.3
yxw 8 months ago
commit 9b018ceb28

@ -0,0 +1,10 @@
package cn.estsh.i3plus.ext.mes.pcn.api.busi;
import io.swagger.annotations.ApiOperation;
public interface IMesCustomerSnTransformService {
@ApiOperation(value = "通用汽车客制化58位条码转换")
String transformBarCodeGm(String barCode);
}

@ -18,6 +18,12 @@ public interface IMesProduceSnExtService {
@ApiOperation(value = "根据零件条码查询零件条码信息")
List<MesProduceSn> getProduceSnList(String organizeCode, String productSn);
@ApiOperation(value = "根据客户条码查询零件条码信息[排序]")
MesProduceSn getProduceSnByCustSn(String organizeCode, String custSn);
@ApiOperation(value = "根据产品条码查询零件条码信息[排序]")
MesProduceSn getProduceSn(String organizeCode, String productSn, String workOrderNo);
@ApiOperation(value = "根据零件条码ID查询零件条码信息")
MesProduceSn getProduceSn(String organizeCode, Long id);
@ -31,6 +37,9 @@ public interface IMesProduceSnExtService {
List<MesQueueOrder> getQueueOrderList(String organizeCode, String workCenterCode, String workCellCode, List<String> productSnList);
@ApiOperation(value = "根据零件条码,生产线,工位查询工位队列信息")
MesQueueOrder getQueueOrder(String organizeCode, String workCenterCode, String workCellCode, String productSn);
@ApiOperation(value = "根据零件条码,生产线,工位查询工位队列信息")
Map<String, List<MesQueueOrder>> getQueueOrderMap(String organizeCode, String workCenterCode, String workCellCode, List<String> productSnList);
@ApiOperation(value = "根据零件条码ID修改条码状态,工位")

@ -1,10 +1,10 @@
package cn.estsh.i3plus.ext.mes.pcn.api.busi;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import io.swagger.annotations.ApiOperation;
import java.util.List;
import java.util.Map;
public interface IMesWorkOrderExtService {
@ -14,13 +14,23 @@ public interface IMesWorkOrderExtService {
@ApiOperation(value = "根据生产工单ID查询生产工单信息")
MesWorkOrder getWorkOrder(String organizeCode, Long id);
@ApiOperation(value = "根据生产工单号查询生产工单信息")
MesWorkOrder getWorkOrder(String organizeCode, String workOrderNo);
@ApiOperation(value = "根据生产工单顺序号,生产线代码查询上一个生产工单信息")
MesWorkOrder getWorkOrder(String organizeCode, String workCenterCode, Long produceSeq);
@ApiOperation(value = "根据生产工单顺序号,生产线代码, 零件生产组代码查询上一个生产工单信息【排序】")
MesWorkOrder getWorkOrder(String organizeCode, String workCenterCode, Long produceSeq, String partProdGroupCode);
MesWorkOrder insert(MesWorkOrder item);
void update(MesWorkOrder item);
@ApiOperation(value = "根据生产工单ID查询生产工单信息")
List<MesWorkOrder> getWorkOrderListByShiftCode(String organizeCode, String workCenterCode, String shiftCode);
@ApiOperation(value = "根据条码集合 查询生产工单/产品条码/队列数据(排序)")
Map<String, Map<String, Object>> getWorkOrderMapSort(String organizeCode, String workCenterCode, String workCellCode, List<String> snList);
}

@ -0,0 +1,42 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesCustomerSnTransformService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
@Slf4j
@Service
public class MesCustomerSnTransformService implements IMesCustomerSnTransformService {
//通用汽车客制化58位条码转换
@Override
public String transformBarCodeGm(String barCode) {
if (StringUtils.isEmpty(barCode)) return barCode;
if (barCode.length() != MesPcnExtConstWords.CUSTOMER_SN_LENGTH_GM) return barCode;
String a = barCode.substring(0, 3);
String b = barCode.substring(5, 20);
String c = barCode.substring(20, 29);
String d = barCode.substring(29, 41);
String e = barCode.substring(41, 58);
return a + (char)30 + "06" + (char)29 + b + (char)29 + c + (char)29 + d + (char)29 + e + (char)30 + (char)04;
/*public static void main(String[] args) {
String barCode = "[)>06Y4110000000000XP2638975612V545238347T1A24240A2B4C0242";
String a = barCode.substring(0, 3);
String b = barCode.substring(5, 20);
String c = barCode.substring(20, 29);
String d = barCode.substring(29, 41);
String e = barCode.substring(41, 58);
String sn = a + (char)30 + "06" + (char)29 + b + (char)29 + c + (char)29 + d + (char)29 + e + (char)30 + (char)04;
System.out.println(barCode + "长度" + barCode.length());
System.out.println(a + "长度" + a.length());
System.out.println(b + "长度" + b.length());
System.out.println(c + "长度" + c.length());
System.out.println(d + "长度" + d.length());
System.out.println(e + "长度" + e.length());
System.out.println(sn + "长度" + sn.length());
}*/
}
}

@ -61,6 +61,29 @@ public class MesProduceSnExtService implements IMesProduceSnExtService {
return produceSnRepository.findByHqlWhere(packBean);
}
@Override
public MesProduceSn getProduceSnByCustSn(String organizeCode, String custSn) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(custSn)) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(custSn, MesPcnExtConstWords.CUST_SN, packBean);
return produceSnRepository.getByProperty(packBean);
}
@Override
public MesProduceSn getProduceSn(String organizeCode, String productSn, String workOrderNo) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(productSn)) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(productSn, MesPcnExtConstWords.PRODUCT_SN, packBean);
DdlPreparedPack.getStringEqualPack(workOrderNo, MesPcnExtConstWords.WORK_ORDER_NO, packBean);
return produceSnRepository.getByProperty(packBean);
}
//根据零件条码ID查询零件条码信息
@Override
public MesProduceSn getProduceSn(String organizeCode, Long id) {
@ -108,6 +131,20 @@ public class MesProduceSnExtService implements IMesProduceSnExtService {
//根据零件条码,生产线,工位查询工位队列信息
@Override
public MesQueueOrder getQueueOrder(String organizeCode, String workCenterCode, String workCellCode, String productSn) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(productSn)) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(workCenterCode, MesPcnExtConstWords.WORK_CENTER_CODE, packBean);
DdlPreparedPack.getStringEqualPack(workCellCode, MesPcnExtConstWords.WORK_CELL_CODE, packBean);
DdlPreparedPack.getStringEqualPack(productSn, MesPcnExtConstWords.PRODUCT_SN, packBean);
return queueOrderRepository.getByProperty(packBean);
}
//根据零件条码,生产线,工位查询工位队列信息
@Override
public Map<String, List<MesQueueOrder>> getQueueOrderMap(String organizeCode, String workCenterCode, String workCellCode, List<String> productSnList) {
List<MesQueueOrder> queueOrderList = getQueueOrderList(organizeCode, workCenterCode, workCellCode, productSnList);

@ -1,5 +1,7 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesCustomerSnTransformService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProduceSnExtService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesWorkOrderExtService;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.aspect.MonitorLog;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
@ -7,6 +9,7 @@ import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesQueueOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.repository.MesWorkOrderRepository;
import cn.hutool.core.date.DateUtil;
@ -16,9 +19,7 @@ import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.*;
import java.util.stream.Collectors;
@Slf4j
@ -28,6 +29,12 @@ public class MesWorkOrderExtService implements IMesWorkOrderExtService {
@Autowired
private MesWorkOrderRepository workOrderRepository;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IMesCustomerSnTransformService customerSnTransformService;
//根据生产工单号集合 查询生产工单数据
@Override
public List<MesWorkOrder> getWorkOrderList(String organizeCode, List<String> workOrderNoList) {
@ -53,6 +60,14 @@ public class MesWorkOrderExtService implements IMesWorkOrderExtService {
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), id});
}
@Override
public MesWorkOrder getWorkOrder(String organizeCode, String workOrderNo) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(workOrderNo)) return null;
return workOrderRepository.getByProperty(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.WORK_ORDER_NO},
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), workOrderNo});
}
//根据生产工单顺序号,生产线代码查询上一个生产工单信息
@Override
public MesWorkOrder getWorkOrder(String organizeCode, String workCenterCode, Long produceSeq) {
@ -64,6 +79,17 @@ public class MesWorkOrderExtService implements IMesWorkOrderExtService {
return workOrderRepository.getByProperty(packBean);
}
//根据生产工单顺序号,生产线代码,零件生产组代码查询上一个生产工单信息
@Override
public MesWorkOrder getWorkOrder(String organizeCode, String workCenterCode, Long produceSeq, String partProdGroupCode) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(workCenterCode) || StringUtils.isEmpty(partProdGroupCode) || StringUtils.isEmpty(produceSeq) || produceSeq.compareTo(0L) == 0) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(workCenterCode, MesPcnExtConstWords.WORK_CENTER_CODE, packBean);
DdlPreparedPack.getNumberSmallerPack(produceSeq, MesPcnExtConstWords.PRODUCE_SEQ, packBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{MesPcnExtConstWords.PRODUCE_SEQ}, packBean);
return workOrderRepository.getByProperty(packBean);
}
@Override
@MonitorLog
public MesWorkOrder insert(MesWorkOrder item) {
@ -89,4 +115,63 @@ public class MesWorkOrderExtService implements IMesWorkOrderExtService {
return workOrderRepository.findByHqlWhere(packBean);
}
@Override
public Map<String, Map<String, Object>> getWorkOrderMapSort(String organizeCode, String workCenterCode, String workCellCode, List<String> snList) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(workCenterCode) || StringUtils.isEmpty(workCellCode) || CollectionUtils.isEmpty(snList)) return null;
snList = snList.size() == 1 ? snList : snList.stream().filter(o -> !StringUtils.isEmpty(o)).distinct().collect(Collectors.toList());
Map<String, Map<String, Object>> workOrderMap = new HashMap<>();
for (String sn : snList) {
if (StringUtils.isEmpty(sn)) continue;
Map<String, Object> itemMap = new HashMap<>();
if (sn.length() == MesPcnExtConstWords.CUSTOMER_SN_LENGTH_GM) {
MesProduceSn produceSn = produceSnExtService.getProduceSnByCustSn(organizeCode, customerSnTransformService.transformBarCodeGm(sn));
if (null == produceSn || StringUtils.isEmpty(produceSn.getWorkOrderNo())) {
itemMap.put(MesPcnExtConstWords.MESSAGE, String.format("请检查工单及客户条码信息,客户条码[%s]信息无效!", sn));
continue;
} else itemMap.put(MesProduceSn.class.getSimpleName(), produceSn);
MesWorkOrder workOrder = getWorkOrder(organizeCode, produceSn.getWorkOrderNo());
if (null == workOrder) {
itemMap.put(MesPcnExtConstWords.MESSAGE, String.format("请检查工单信息,客户条码[%s]对应的加工单[%s]信息不存在!", sn, produceSn.getWorkOrderNo()));
continue;
} else itemMap.put(MesWorkOrder.class.getSimpleName(), workOrder);
MesQueueOrder queueOrder = produceSnExtService.getQueueOrder(organizeCode, workCenterCode, workCellCode, produceSn.getProductSn());
if (null == queueOrder) itemMap.put(MesPcnExtConstWords.MESSAGE, String.format("请检查工位队列信息,客户条码[%s]工位队列信息不存在!", sn));
else itemMap.put(MesQueueOrder.class.getSimpleName(), queueOrder);
} else {
MesProduceSn produceSn = produceSnExtService.getProduceSn(organizeCode, sn, sn);
if (null == produceSn) produceSn = produceSnExtService.getProduceSnByCustSn(organizeCode, sn);
if (null == produceSn) {
itemMap.put(MesPcnExtConstWords.MESSAGE, String.format("请检查工单及产品条码信息,加工单[%s]不存在产品条码信息!", sn));
continue;
} else itemMap.put(MesProduceSn.class.getSimpleName(), produceSn);
MesWorkOrder workOrder = getWorkOrder(organizeCode, produceSn.getWorkOrderNo());
if (null == workOrder) {
itemMap.put(MesPcnExtConstWords.MESSAGE, String.format("请检查工单信息,加工单[%s]信息无效!", produceSn.getWorkOrderNo()));
continue;
} else itemMap.put(MesWorkOrder.class.getSimpleName(), workOrder);
MesQueueOrder queueOrder = produceSnExtService.getQueueOrder(organizeCode, workCenterCode, workCellCode, produceSn.getProductSn());
if (null == queueOrder) itemMap.put(MesPcnExtConstWords.MESSAGE, String.format("请检查工位队列信息,加工单[%s]工位队列信息不存在!", produceSn.getWorkOrderNo()));
else itemMap.put(MesQueueOrder.class.getSimpleName(), queueOrder);
}
workOrderMap.put(sn, itemMap);
}
return workOrderMap;
}
}

@ -0,0 +1,151 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.*;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPartContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesQueueOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderAssembly;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @Description :
* @Author : wangjie
**/
@Slf4j
@Service("mesProduceSeqCheckStepService")
public class MesProduceSeqCheckCustOrderNoStepService extends MesProduceSeqCheckStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesWorkOrderExtService workOrderExtService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IMesAssemblyExtService assemblyExtService;
@Override
public StepResult execute(StationRequestBean reqBean) {
StationResultBean resultBean = new StationResultBean();
StepResult stepResult = StepResult.getSuccessComplete();
//获取上下文信息
MesProductionProcessContext productionProcessContext = productionProcessContextStepService.dispatchCurCellEquipment(reqBean);
//获取生产过程上下文对象有异常信息 抛出异常
if (!productionProcessContext.getSuccess()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), productionProcessContext.getMessage());
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//获取上下文产出零件信息
List<MesProductionPartContext> productionPartContextList = productionDispatchContextStepService.getProductionPartContext(reqBean);
//验证是否存在加工单
if (!checkIsExistWorkOrder(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前无加工单信息,无需进行顺序防错验证!");
//验证工位是否设置需要顺序防错
if (!isNeedCheckProduceSeq(productionPartContextList))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("生产线[%s]工位[%s]未设置顺序防错,无需进行顺序防错验证!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode()));
//验证是否存在工艺强过码, 存在则保存 并返回强过的加工单
List<String> workOrderNoList2Jump = doHandleCraftJumpCode(reqBean, productionPartContextList);
if (!CollectionUtils.isEmpty(workOrderNoList2Jump))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList2Jump.toString()), stepResult, String.format("加工单%s跳过顺序防错验证成功!", workOrderNoList2Jump.toString()));
//验证是否已经全部通过
if (!isExistNeedCheckProduceSeq(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean, stepResult, "加工单均已通过顺序防错验证!");
//顺序防错验证处理
doHandleProduceSeqCheck(reqBean, resultBean, stepResult, productionProcessContext, productionPartContextList);
return stepResult;
}
//顺序防错验证处理
private void doHandleProduceSeqCheck(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, List<MesProductionPartContext> productionPartContextList) {
List<String> workOrderNoList = new ArrayList<>();
for (MesProductionPartContext productionPartContext : productionPartContextList) {
if (null == productionPartContext || StringUtils.isEmpty(productionPartContext.getWorkOrderNo()) || productionPartContext.getCheckSeqResult().compareTo(MesPcnExtConstWords.ZERO) != 0) continue;
//顺序防错验证
Boolean result = doProduceSeqCheckSort(reqBean, stepResult, productionProcessContext, productionPartContext);
if (!result) productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue());
else productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
workOrderNoList.add(productionPartContext.getWorkOrderNo());
}
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
if (stepResult.isCompleted()) this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), String.format("加工单%s顺序防错验证成功!", workOrderNoList.toString()), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT);
else this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), stepResult.getMsg(), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.EXP_TEXT);
}
//前道工艺防错验证 【排序】
private Boolean doProduceSeqCheckSort(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesProductionPartContext productionPartContext) {
String message = StringUtils.isEmpty(stepResult.getMsg()) ? MesPcnExtConstWords.EMPTY : stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON;
//根据生产工单顺序号,生产线代码,零件生产组代码查询上一个生产工单信息
MesWorkOrder workOrder = workOrderExtService.getWorkOrder(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), productionPartContext.getProduceSeq(), productionPartContext.getPartProdGroupCode());
if (null == workOrder) return true;
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.PROCESS.getValue()) < 0)
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]工单状态[%s]",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus()))).isCompleted();
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.CLOSE.getValue()) >= 0) return true;
//根据生产工单,生产线,工位查询工位队列信息
List<MesQueueOrder> queueOrderList = produceSnExtService.getQueueOrderList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrder.getWorkOrderNo());
Optional<MesQueueOrder> optional = CollectionUtils.isEmpty(queueOrderList) ? null : queueOrderList.stream().filter(o -> (null != o && o.getStatus().compareTo(MesExtEnumUtil.QUEUE_ORDER_STATUS.CREATE.getValue()) == 0)).findFirst();
if (null == optional || !optional.isPresent()) return true;
//根据未完成零件条码获取生产工单装配件清单
List<String> productSnList = queueOrderList.stream().filter(o -> (null != o && o.getStatus().compareTo(MesExtEnumUtil.QUEUE_ORDER_STATUS.CREATE.getValue()) == 0)).map(MesQueueOrder::getProductSn).collect(Collectors.toList());
List<MesWorkOrderAssembly> workOrderAssemblyList = assemblyExtService.getWorkOrderAssemblyList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrder.getWorkOrderNo(), productSnList);
Map<String, List<MesWorkOrderAssembly>> productSnMap = CollectionUtils.isEmpty(workOrderAssemblyList) ? null : workOrderAssemblyList.stream().filter(o -> null != o).collect(Collectors.groupingBy(MesWorkOrderAssembly::getProductSn));
if (CollectionUtils.isEmpty(productSnMap)) return true;
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]在当前工位[%s]存在未完成队列条码%s",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), reqBean.getWorkCellCode(), productSnMap.keySet().toString())).isCompleted();
}
}

@ -0,0 +1,145 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.*;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPartContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.util.StationKvBeanUtil;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.model.StationKvBean;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description :
* @Author : wangjie
**/
@Slf4j
@Service("mesProduceSeqCheckNosortStepService")
public class MesProduceSeqCheckNosortStepService extends MesProduceSeqCheckStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesWorkOrderExtService workOrderExtService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IMesAssemblyExtService assemblyExtService;
@Override
public StepResult execute(StationRequestBean reqBean) {
StationResultBean resultBean = new StationResultBean();
StepResult stepResult = StepResult.getSuccessComplete();
//获取上下文信息
MesProductionProcessContext productionProcessContext = productionProcessContextStepService.dispatchCurCellEquipment(reqBean);
//获取生产过程上下文对象有异常信息 抛出异常
if (!productionProcessContext.getSuccess()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), productionProcessContext.getMessage());
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//获取上下文产出零件信息
List<MesProductionPartContext> productionPartContextList = productionDispatchContextStepService.getProductionPartContext(reqBean);
//验证是否存在加工单
if (!checkIsExistWorkOrder(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前无加工单信息,无需进行顺序防错验证!");
//验证工位是否设置需要顺序防错
if (!isNeedCheckProduceSeq(productionPartContextList))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("生产线[%s]工位[%s]未设置顺序防错,无需进行顺序防错验证!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode()));
//验证是否存在工艺强过码, 存在则保存 并返回强过的加工单
List<String> workOrderNoList2Jump = doHandleCraftJumpCode(reqBean, productionPartContextList);
if (!CollectionUtils.isEmpty(workOrderNoList2Jump))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList2Jump.toString()), stepResult, String.format("加工单%s跳过顺序防错验证成功!", workOrderNoList2Jump.toString()));
//验证是否已经全部通过
if (!isExistNeedCheckProduceSeq(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean, stepResult, "加工单均已通过顺序防错验证!");
//顺序防错验证处理
doHandleProduceSeqCheck(reqBean, resultBean, stepResult, productionProcessContext, productionPartContextList);
//删除手动选择的腔数及工单信息上下文
if (!stepResult.isCompleted()) productionProcessContextStepService.removeFunctionChooseCavityOrderContext(reqBean);
else {
//保存选择/扫描/读取的腔数及工单信息上下文 [并标记已验证过顺序防错]
productionProcessContextStepService.dispatchFunctionChooseCavityOrderContext(reqBean, StationKvBeanUtil.addStationKvBeanList(new ArrayList<>(),
new StationKvBean(MesPcnExtConstWords.CAVITY, "腔数", String.valueOf(productionPartContextList.size())),
new StationKvBean(MesPcnExtConstWords.CELL_MESSAGE_SOURCE, "工位信息来源", MesExtEnumUtil.CELL_MESSAGE_SOURCE.READ.getValueStr()),
new StationKvBean(MesPcnExtConstWords.CRAFT_JUMP_CODE, "是否已验证顺序防错", CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValueStr()),
new StationKvBean(MesPcnExtConstWords.WORK_ORDER_NO, "加工单", productionPartContextList.stream().filter(o -> null != o).map(MesProductionPartContext::getWorkOrderNo).collect(Collectors.joining(MesPcnExtConstWords.SEMICOLON)))));
}
return stepResult;
}
//顺序防错验证处理
private void doHandleProduceSeqCheck(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, List<MesProductionPartContext> productionPartContextList) {
List<String> workOrderNoList = new ArrayList<>();
for (MesProductionPartContext productionPartContext : productionPartContextList) {
if (null == productionPartContext || StringUtils.isEmpty(productionPartContext.getWorkOrderNo()) || productionPartContext.getCheckSeqResult().compareTo(MesPcnExtConstWords.ZERO) != 0) continue;
//顺序防错验证
Boolean result = doProduceSeqCheckNosort(reqBean, stepResult, productionProcessContext, productionPartContext);
if (!result) productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue());
else productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
workOrderNoList.add(productionPartContext.getWorkOrderNo());
}
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
if (stepResult.isCompleted()) this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), String.format("加工单%s顺序防错验证成功!", workOrderNoList.toString()), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT);
else this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), stepResult.getMsg(), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.EXP_TEXT);
}
//前道工艺防错验证 【非排序】
private Boolean doProduceSeqCheckNosort(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesProductionPartContext productionPartContext) {
String message = StringUtils.isEmpty(stepResult.getMsg()) ? MesPcnExtConstWords.EMPTY : stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON;
//根据生产工单顺序号,生产线代码查询上一个生产工单信息
MesWorkOrder workOrder = workOrderExtService.getWorkOrder(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), productionPartContext.getProduceSeq());
if (null == workOrder) return true;
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.CLOSE.getValue()) >= 0) return true;
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]工单状态[%s]",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus()))).isCompleted();
}
}

@ -0,0 +1,151 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.*;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPartContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesQueueOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderAssembly;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @Description :
* @Author : wangjie
**/
@Slf4j
@Service("mesProduceSeqCheckSortStepService")
public class MesProduceSeqCheckSortStepService extends MesProduceSeqCheckStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesWorkOrderExtService workOrderExtService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IMesAssemblyExtService assemblyExtService;
@Override
public StepResult execute(StationRequestBean reqBean) {
StationResultBean resultBean = new StationResultBean();
StepResult stepResult = StepResult.getSuccessComplete();
//获取上下文信息
MesProductionProcessContext productionProcessContext = productionProcessContextStepService.dispatchCurCellEquipment(reqBean);
//获取生产过程上下文对象有异常信息 抛出异常
if (!productionProcessContext.getSuccess()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), productionProcessContext.getMessage());
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//获取上下文产出零件信息
List<MesProductionPartContext> productionPartContextList = productionDispatchContextStepService.getProductionPartContext(reqBean);
//验证是否存在加工单
if (!checkIsExistWorkOrder(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前无加工单信息,无需进行顺序防错验证!");
//验证工位是否设置需要顺序防错
if (!isNeedCheckProduceSeq(productionPartContextList))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("生产线[%s]工位[%s]未设置顺序防错,无需进行顺序防错验证!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode()));
//验证是否存在工艺强过码, 存在则保存 并返回强过的加工单
List<String> workOrderNoList2Jump = doHandleCraftJumpCode(reqBean, productionPartContextList);
if (!CollectionUtils.isEmpty(workOrderNoList2Jump))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList2Jump.toString()), stepResult, String.format("加工单%s跳过顺序防错验证成功!", workOrderNoList2Jump.toString()));
//验证是否已经全部通过
if (!isExistNeedCheckProduceSeq(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean, stepResult, "加工单均已通过顺序防错验证!");
//顺序防错验证处理
doHandleProduceSeqCheck(reqBean, resultBean, stepResult, productionProcessContext, productionPartContextList);
return stepResult;
}
//顺序防错验证处理
private void doHandleProduceSeqCheck(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, List<MesProductionPartContext> productionPartContextList) {
List<String> workOrderNoList = new ArrayList<>();
for (MesProductionPartContext productionPartContext : productionPartContextList) {
if (null == productionPartContext || StringUtils.isEmpty(productionPartContext.getWorkOrderNo()) || productionPartContext.getCheckSeqResult().compareTo(MesPcnExtConstWords.ZERO) != 0) continue;
//顺序防错验证
Boolean result = doProduceSeqCheckSort(reqBean, stepResult, productionProcessContext, productionPartContext);
if (!result) productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue());
else productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
workOrderNoList.add(productionPartContext.getWorkOrderNo());
}
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
if (stepResult.isCompleted()) this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), String.format("加工单%s顺序防错验证成功!", workOrderNoList.toString()), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT);
else this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), stepResult.getMsg(), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.EXP_TEXT);
}
//前道工艺防错验证 【排序】
private Boolean doProduceSeqCheckSort(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesProductionPartContext productionPartContext) {
String message = StringUtils.isEmpty(stepResult.getMsg()) ? MesPcnExtConstWords.EMPTY : stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON;
//根据生产工单顺序号,生产线代码,零件生产组代码查询上一个生产工单信息
MesWorkOrder workOrder = workOrderExtService.getWorkOrder(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), productionPartContext.getProduceSeq(), productionPartContext.getPartProdGroupCode());
if (null == workOrder) return true;
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.PROCESS.getValue()) < 0)
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]工单状态[%s]",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus()))).isCompleted();
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.CLOSE.getValue()) >= 0) return true;
//根据生产工单,生产线,工位查询工位队列信息
List<MesQueueOrder> queueOrderList = produceSnExtService.getQueueOrderList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrder.getWorkOrderNo());
Optional<MesQueueOrder> optional = CollectionUtils.isEmpty(queueOrderList) ? null : queueOrderList.stream().filter(o -> (null != o && o.getStatus().compareTo(MesExtEnumUtil.QUEUE_ORDER_STATUS.CREATE.getValue()) == 0)).findFirst();
if (null == optional || !optional.isPresent()) return true;
//根据未完成零件条码获取生产工单装配件清单
List<String> productSnList = queueOrderList.stream().filter(o -> (null != o && o.getStatus().compareTo(MesExtEnumUtil.QUEUE_ORDER_STATUS.CREATE.getValue()) == 0)).map(MesQueueOrder::getProductSn).collect(Collectors.toList());
List<MesWorkOrderAssembly> workOrderAssemblyList = assemblyExtService.getWorkOrderAssemblyList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrder.getWorkOrderNo(), productSnList);
Map<String, List<MesWorkOrderAssembly>> productSnMap = CollectionUtils.isEmpty(workOrderAssemblyList) ? null : workOrderAssemblyList.stream().filter(o -> null != o).collect(Collectors.groupingBy(MesWorkOrderAssembly::getProductSn));
if (CollectionUtils.isEmpty(productSnMap)) return true;
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]在当前工位[%s]存在未完成队列条码%s",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), reqBean.getWorkCellCode(), productSnMap.keySet().toString())).isCompleted();
}
}

@ -1,22 +1,18 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.*;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionDispatchContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPartContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.mes.pcn.util.StationKvBeanUtil;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.IStepService;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesQueueOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderAssembly;
import cn.estsh.i3plus.pojo.mes.model.StationKvBean;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@ -25,9 +21,7 @@ import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @Description :
@ -43,15 +37,6 @@ public class MesProduceSeqCheckStepService extends BaseStepService {
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesWorkOrderExtService workOrderExtService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IMesAssemblyExtService assemblyExtService;
@Override
public StepResult execute(StationRequestBean reqBean) {
@ -68,44 +53,19 @@ public class MesProduceSeqCheckStepService extends BaseStepService {
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//获取上下文产出零件信息
List<MesProductionPartContext> productionPartContextList = productionDispatchContextStepService.getProductionPartContext(reqBean);
//验证是否存在加工单
if (!checkIsExistWorkOrder(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前无加工单信息,无需进行顺序防错验证!");
//从上下文中取出生产线对象
MesWorkCenter workCenter = productionProcessContext.getWorkCenter();
//验证工位是否设置需要顺序防错
if (!isNeedCheckProduceSeq(productionPartContextList))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("生产线[%s]工位[%s]未设置顺序防错,无需进行顺序防错验证!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode()));
//排序线 生产工单顺序防错工步
if (MesExtEnumUtil.WORK_CENTER_TYPE.SORT.getValue() == workCenter.getCenterType()) return ((IStepService) SpringContextsUtil.getBean("mesProduceSeqCheckSortStepService")).executeInState(reqBean);
//验证是否存在工艺强过码, 存在则保存 并返回强过的加工单
List<String> workOrderNoList2Jump = doHandleCraftJumpCode(reqBean, productionPartContextList);
if (!CollectionUtils.isEmpty(workOrderNoList2Jump))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList2Jump.toString()), stepResult, String.format("加工单%s跳过顺序防错验证成功!", workOrderNoList2Jump.toString()));
//验证是否已经全部通过
if (!isExistNeedCheckProduceSeq(productionPartContextList)) return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean, stepResult, "加工单均已通过顺序防错验证!");
//顺序防错验证处理
doHandleProduceSeqCheck(reqBean, resultBean, stepResult, productionProcessContext, productionProcessContext.getWorkCenter(), productionPartContextList);
//删除手动选择的腔数及工单信息上下文
if (!stepResult.isCompleted()) productionProcessContextStepService.removeFunctionChooseCavityOrderContext(reqBean);
else {
//保存选择/扫描/读取的腔数及工单信息上下文 [并标记已验证过顺序防错]
productionProcessContextStepService.dispatchFunctionChooseCavityOrderContext(reqBean, StationKvBeanUtil.addStationKvBeanList(new ArrayList<>(),
new StationKvBean(MesPcnExtConstWords.CAVITY, "腔数", String.valueOf(productionPartContextList.size())),
new StationKvBean(MesPcnExtConstWords.CELL_MESSAGE_SOURCE, "工位信息来源", MesExtEnumUtil.CELL_MESSAGE_SOURCE.READ.getValueStr()),
new StationKvBean(MesPcnExtConstWords.CRAFT_JUMP_CODE, "是否已验证顺序防错", CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValueStr()),
new StationKvBean(MesPcnExtConstWords.WORK_ORDER_NO, "加工单", productionPartContextList.stream().filter(o -> null != o).map(MesProductionPartContext::getWorkOrderNo).collect(Collectors.joining(MesPcnExtConstWords.SEMICOLON)))));
}
return stepResult;
//非排序线 生产工单顺序防错工步
return ((IStepService) SpringContextsUtil.getBean("mesProduceSeqCheckNosortStepService")).executeInState(reqBean);
}
//验证是否存在加工单
private Boolean checkIsExistWorkOrder(List<MesProductionPartContext> productionPartContextList) {
public Boolean checkIsExistWorkOrder(List<MesProductionPartContext> productionPartContextList) {
if (CollectionUtils.isEmpty(productionPartContextList)) return false;
@ -116,21 +76,21 @@ public class MesProduceSeqCheckStepService extends BaseStepService {
}
//验证工位是否设置需要前道防错
private Boolean isNeedCheckProduceSeq(List<MesProductionPartContext> productionPartContextList) {
public Boolean isNeedCheckProduceSeq(List<MesProductionPartContext> productionPartContextList) {
Optional<MesProductionPartContext> optional = productionPartContextList.stream().filter(o -> (null != o &&
o.getIsFinishCode().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0 && o.getIsCheckSeq().compareTo(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) == 0)).findFirst();
return (null == optional || !optional.isPresent()) ? false : true;
}
//验证是否已经全部通过
private Boolean isExistNeedCheckProduceSeq(List<MesProductionPartContext> productionPartContextList) {
public Boolean isExistNeedCheckProduceSeq(List<MesProductionPartContext> productionPartContextList) {
Optional<MesProductionPartContext> optional = productionPartContextList.stream().filter(o -> (null != o &&
o.getIsFinishCode().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0 && o.getCheckSeqResult().compareTo(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) != 0)).findFirst();
return (null == optional || !optional.isPresent()) ? false : true;
}
//验证是否存在工艺强过码, 存在则保存 并返回强过的加工单
private List<String> doHandleCraftJumpCode(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
public List<String> doHandleCraftJumpCode(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
List<String> workOrderNoList2Jump = null;
@ -153,91 +113,4 @@ public class MesProduceSeqCheckStepService extends BaseStepService {
}
//顺序防错验证处理
private void doHandleProduceSeqCheck(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCenter workCenter, List<MesProductionPartContext> productionPartContextList) {
List<String> workOrderNoList = new ArrayList<>();
for (MesProductionPartContext productionPartContext : productionPartContextList) {
if (null == productionPartContext || StringUtils.isEmpty(productionPartContext.getWorkOrderNo()) || productionPartContext.getCheckSeqResult().compareTo(MesPcnExtConstWords.ZERO) != 0) continue;
//顺序防错验证
Boolean result = doProduceSeqCheck(reqBean, stepResult, productionProcessContext, workCenter, productionPartContext);
if (!result) productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue());
else productionPartContext.setCheckSeqResult(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
workOrderNoList.add(productionPartContext.getWorkOrderNo());
}
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
if (stepResult.isCompleted()) this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), String.format("加工单%s顺序防错验证成功!", workOrderNoList.toString()), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT);
else this.sendMessage(reqBean, resultBean.writeDbLog().scanInfo(workOrderNoList.toString()), stepResult.getMsg(), MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.EXP_TEXT);
}
//顺序防错验证
private Boolean doProduceSeqCheck(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCenter workCenter, MesProductionPartContext productionPartContext) {
//排序
if (workCenter.getCenterType().compareTo(MesExtEnumUtil.WORK_CENTER_TYPE.SORT.getValue()) == 0) return doProduceSeqCheckSort(reqBean, stepResult, productionProcessContext, productionPartContext);
//非排序
return doProduceSeqCheckNosort(reqBean, stepResult, productionProcessContext, productionPartContext);
}
//前道工艺防错验证 【排序】
private Boolean doProduceSeqCheckSort(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesProductionPartContext productionPartContext) {
String message = StringUtils.isEmpty(stepResult.getMsg()) ? MesPcnExtConstWords.EMPTY : stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON;
//根据生产工单顺序号,生产线代码查询上一个生产工单信息
MesWorkOrder workOrder = workOrderExtService.getWorkOrder(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), productionPartContext.getProduceSeq());
if (null == workOrder) return true;
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.PROCESS.getValue()) < 0)
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]工单状态[%s]",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus()))).isCompleted();
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.CLOSE.getValue()) >= 0) return true;
//根据生产工单,生产线,工位查询工位队列信息
List<MesQueueOrder> queueOrderList = produceSnExtService.getQueueOrderList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrder.getWorkOrderNo());
Optional<MesQueueOrder> optional = CollectionUtils.isEmpty(queueOrderList) ? null : queueOrderList.stream().filter(o -> (null != o && o.getStatus().compareTo(MesExtEnumUtil.QUEUE_ORDER_STATUS.CREATE.getValue()) == 0)).findFirst();
if (null == optional || !optional.isPresent()) return true;
//根据未完成零件条码获取生产工单装配件清单
List<String> productSnList = queueOrderList.stream().filter(o -> (null != o && o.getStatus().compareTo(MesExtEnumUtil.QUEUE_ORDER_STATUS.CREATE.getValue()) == 0)).map(MesQueueOrder::getProductSn).collect(Collectors.toList());
List<MesWorkOrderAssembly> workOrderAssemblyList = assemblyExtService.getWorkOrderAssemblyList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrder.getWorkOrderNo(), productSnList);
Map<String, List<MesWorkOrderAssembly>> productSnMap = CollectionUtils.isEmpty(workOrderAssemblyList) ? null : workOrderAssemblyList.stream().filter(o -> null != o).collect(Collectors.groupingBy(MesWorkOrderAssembly::getProductSn));
if (CollectionUtils.isEmpty(productSnMap))return true;
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]在当前工位[%s]存在未完成队列条码%s",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), reqBean.getWorkCellCode(), productSnMap.keySet().toString())).isCompleted();
}
//前道工艺防错验证 【非排序】
private Boolean doProduceSeqCheckNosort(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesProductionPartContext productionPartContext) {
String message = StringUtils.isEmpty(stepResult.getMsg()) ? MesPcnExtConstWords.EMPTY : stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON;
//根据生产工单顺序号,生产线代码查询上一个生产工单信息
MesWorkOrder workOrder = workOrderExtService.getWorkOrder(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), productionPartContext.getProduceSeq());
if (null == workOrder) return true;
if (workOrder.getWorkOrderStatus().compareTo(MesExtEnumUtil.ORDER_STATUS.CLOSE.getValue()) >= 0) return true;
return stepResult.isCompleted(false).msg(String.format("%s加工单[%s]生产顺序号[%s]顺序防错验证失败,前一个加工单[%s]生产顺序号[%s]工单状态[%s]",
message, productionPartContext.getWorkOrderNo(), productionPartContext.getProduceSeq(), workOrder.getWorkOrderNo(), workOrder.getProduceSeq(), MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus()))).isCompleted();
}
}

@ -1,182 +0,0 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProduceSnExtService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionDispatchContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipVariableCollectContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPsInContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.api.iservice.base.IConfigService;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.pojo.mes.bean.MesConfig;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCell;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description :
* @Author : wangjie
**/
@Slf4j
@Service("mesProductSnCheckNosortStepService")
public class MesProductSnCheckNosortStepService extends BaseStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IConfigService configService;
@Override
public StepResult execute(StationRequestBean reqBean) {
StationResultBean resultBean = new StationResultBean();
StepResult stepResult = StepResult.getSuccessComplete();
//获取上下文信息
MesProductionProcessContext productionProcessContext = productionProcessContextStepService.dispatchCurCellEquipment(reqBean);
//获取生产过程上下文对象有异常信息 抛出异常
if (!productionProcessContext.getSuccess()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), productionProcessContext.getMessage());
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//获取上下文扫/读信息:主条码
List<MesEquipVariableCollectContext> equipVariableCollectContextList = productionDispatchContextStepService.getScanProductSnContext(reqBean);
//没有待验证的主条码, 并且存在已验证过的主条码,默认放行
if (CollectionUtils.isEmpty(equipVariableCollectContextList) && productionDispatchContextStepService.checkProductionPsInIsExistContext(reqBean))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前没有需要验证的主条码,且存在已验证主条码信息,当前工步默认放行!");
//没有待验证的主条码
if (CollectionUtils.isEmpty(equipVariableCollectContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前没有需要验证的主条码!");
//清除本次已获取得到的主条码信息
productionDispatchContextStepService.removeScanProductSnContext(reqBean);
//搜集主条码值
List<String> productSnList = equipVariableCollectContextList.stream().filter(o -> null != o).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
//获取上下文的工位
MesWorkCell workCell = productionProcessContext.getWorkCell();
//验证上下文中主条码的有效性 封装 读/扫主条件信息到进料主条码数据信息中
List<MesProductionPsInContext> productionPsInContextList = new ArrayList<>();
if (!checkProduceSnValid(reqBean, resultBean, stepResult, productionProcessContext, workCell, productSnList, equipVariableCollectContextList, productionPsInContextList).isCompleted())
return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("验证失败!原因:%s!", stepResult.getMsg()));
//获取进料主条码数据信息
List<MesProductionPsInContext> productionPsInContext = productionDispatchContextStepService.getProductionPsInContext(reqBean);
if (!CollectionUtils.isEmpty(productionPsInContext)) productionPsInContextList.addAll(productionPsInContext);
//保存进料主条码数据
productionDispatchContextStepService.dispatchProductionPsInContext(reqBean, productionPsInContextList);
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(productSnList.toString()), stepResult, String.format("主条码%s验证条码状态成功!", productSnList.toString()));
}
private List<String> filterEquipVariableCollectContextList(MesProductionProcessContext productionProcessContext, List<MesEquipVariableCollectContext> equipVariableCollectContextList) {
return equipVariableCollectContextList.stream().filter(o -> (null != o && !o.getEquipVariableValue().equals(productionProcessContext.getFinishCode()))).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
}
//获取进料主条码数据信息
private StepResult checkProduceSnValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCell workCell,
List<String> productSnList, List<MesEquipVariableCollectContext> equipVariableCollectContextList, List<MesProductionPsInContext> productionPsInContextList) {
//根据零件条码查询零件条码信息
Map<String, List<MesProduceSn>> produceSnMap = produceSnExtService.getProduceSnMap(reqBean.getOrganizeCode(), productSnList);
for (MesEquipVariableCollectContext equipVariableCollectContext : equipVariableCollectContextList) {
if (null == equipVariableCollectContext || StringUtils.isEmpty(equipVariableCollectContext.getEquipVariableValue())) continue;
if (CollectionUtils.isEmpty(produceSnMap) || !produceSnMap.containsKey(equipVariableCollectContext.getEquipVariableValue()))
productionPsInContextList.add(new MesProductionPsInContext(reqBean.getOrganizeCode(), equipVariableCollectContext.getEquipVariableValue()).messageSource(equipVariableCollectContext.getMessageSource()));
else createProductionPsInContext(reqBean, resultBean, stepResult, workCell, equipVariableCollectContext, produceSnMap.get(equipVariableCollectContext.getEquipVariableValue()), productionPsInContextList);
}
return stepResult;
}
private StepResult createProductionPsInContext(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult,
MesWorkCell workCell, MesEquipVariableCollectContext equipVariableCollectContext, List<MesProduceSn> produceSnList, List<MesProductionPsInContext> productionPsInContextList) {
String suffixMsg = !StringUtils.isEmpty(stepResult.getMsg()) ? stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON : MesPcnExtConstWords.EMPTY;
List<MesProduceSn> unknowList = produceSnList.stream().filter(o -> (null != o && o.getSnStatus().compareTo(MesExtEnumUtil.PRODUCE_SN_STATUS.UNKNOW.getValue()) == 0)).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(unknowList) && unknowList.size() > 1) {
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]信息异常,存在[%s]条[未知]状态的记录", suffixMsg, equipVariableCollectContext.getEquipVariableValue(), unknowList.size()));
}
if (!CollectionUtils.isEmpty(unknowList) && checkAllowUnknowCenterCfg(reqBean) && (unknowList.size() > 1 || (!unknowList.get(0).getWorkCenterCode().equals(reqBean.getWorkCenterCode()) || !unknowList.get(0).getWorkCellCode().equals(reqBean.getWorkCellCode())))) {
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]信息条码状态已被%s标记[未知]", suffixMsg, equipVariableCollectContext.getEquipVariableValue(),
unknowList.stream().filter(o -> null != o).map(o -> new StringJoiner(MesPcnExtConstWords.AND).add(o.getWorkCenterCode()).add(o.getWorkCellCode()).toString()).collect(Collectors.joining(MesPcnExtConstWords.SEMICOLON))));
}
produceSnList = produceSnList.stream().filter(o -> null != o).sorted(Comparator.comparing(MesProduceSn::getCreateDatetime).reversed()).collect(Collectors.toList());
MesProduceSn produceSn = produceSnList.get(0);
if (produceSn.getQcStatus().compareTo(MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue()) != 0 && produceSn.getQcStatus().compareTo(MesExtEnumUtil.PRODUCE_QC_STATUS.SUSPICIOUS_TO_QUALIFIED.getValue()) != 0)
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]质量状态[%s]", suffixMsg, equipVariableCollectContext.getEquipVariableValue(), MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(produceSn.getQcStatus())));
if (produceSn.getSnStatus().compareTo(MesExtEnumUtil.PRODUCE_SN_STATUS.ASSEMBLY_BACK.getValue()) > 0)
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]条码状态[%s]", suffixMsg, equipVariableCollectContext.getEquipVariableValue(), MesExtEnumUtil.PRODUCE_SN_STATUS.valueOfDescription(produceSn.getSnStatus())));
//正常条码
if (produceSn.getSnStatus().compareTo(MesExtEnumUtil.PRODUCE_SN_STATUS.UNKNOW.getValue()) != 0) {
productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSn).messageSource(equipVariableCollectContext.getMessageSource()));
return stepResult;
}
//未知条码【工序为空 代表新做的工序没有加工完成】
if (StringUtils.isEmpty(produceSn.getProcessCode()) && produceSnList.size() > 1) {
productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSnList.get(1)).messageSource(equipVariableCollectContext.getMessageSource()).relateId(produceSn.getId()));
return stepResult;
}
//未知条码【工序为空 代表新做的工序没有加工完成】【只有一条条码记录 代表是打印的条码自进自出直接被标记为未知】
if (StringUtils.isEmpty(produceSn.getProcessCode())) {
productionPsInContextList.add(new MesProductionPsInContext(reqBean.getOrganizeCode(), equipVariableCollectContext.getEquipVariableValue()).messageSource(equipVariableCollectContext.getMessageSource()).relateId(produceSn.getId()));
return stepResult;
}
//未知条码【工序不为空 代表已完成的工序被重做后没有加工完成】
productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSn).messageSource(equipVariableCollectContext.getMessageSource()).relateId(produceSn.getId()));
return stepResult;
}
//允许扫描其他工位的未知条码的生产线配置, 配置则表示不需要验证未知条码
private Boolean checkAllowUnknowCenterCfg(StationRequestBean reqBean) {
List<MesConfig> configList = configService.doCachedConfigList(MesPcnExtConstWords.ALLOW_UNKNOW_CENTER_CFG, reqBean.getOrganizeCode());
if (CollectionUtils.isEmpty(configList)) return true;
List<String> allowUnknowCenterList = Arrays.asList(configList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getCfgValue()))).map(MesConfig::getCfgValue).collect(Collectors.joining(MesPcnExtConstWords.COMMA)).split(MesPcnExtConstWords.COMMA));
return (!CollectionUtils.isEmpty(allowUnknowCenterList) && allowUnknowCenterList.contains(reqBean.getWorkCenterCode())) ? false : true;
}
}

@ -1,175 +0,0 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProduceSnExtService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionDispatchContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipVariableCollectContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPsInContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesQueueOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCell;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @Description :
* @Author : wangjie
**/
@Slf4j
@Service("mesProductSnCheckSortStepService")
public class MesProductSnCheckSortStepService extends BaseStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Override
public StepResult execute(StationRequestBean reqBean) {
StationResultBean resultBean = new StationResultBean();
StepResult stepResult = StepResult.getSuccessComplete();
//获取上下文信息
MesProductionProcessContext productionProcessContext = productionProcessContextStepService.dispatchCurCellEquipment(reqBean);
//获取生产过程上下文对象有异常信息 抛出异常
if (!productionProcessContext.getSuccess()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), productionProcessContext.getMessage());
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//获取上下文扫/读信息:主条码
List<MesEquipVariableCollectContext> equipVariableCollectContextList = productionDispatchContextStepService.getScanProductSnContext(reqBean);
//没有待验证的主条码, 并且存在已验证过的主条码,默认放行
if (CollectionUtils.isEmpty(equipVariableCollectContextList) && productionDispatchContextStepService.checkProductionPsInIsExistContext(reqBean))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前没有需要验证的主条码,且存在已验证主条码信息,当前工步默认放行!");
//没有待验证的主条码
if (CollectionUtils.isEmpty(equipVariableCollectContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前没有需要验证的主条码!");
//清除本次已获取得到的主条码信息
productionDispatchContextStepService.removeScanProductSnContext(reqBean);
//搜集主条码值
List<String> productSnList = equipVariableCollectContextList.stream().filter(o -> null != o).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
//验证上下文中主条码的有效性
Map<String, List<MesProduceSn>> produceSnMap = checkProduceSnValid(reqBean, resultBean, stepResult, productionProcessContext, productSnList);
if (!stepResult.isCompleted()) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("验证失败!原因:%s!", stepResult.getMsg()));
//验证上下文中主条码的工位队列的有效性
Map<String, List<MesQueueOrder>> queueOrderMap = checkQueueOrderValid(reqBean, resultBean, stepResult, productionProcessContext, productSnList);
if (!stepResult.isCompleted()) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("验证失败!原因:%s!", stepResult.getMsg()));
//获取上下文的工位
MesWorkCell workCell = productionProcessContext.getWorkCell();
//封装 读/扫主条件信息到进料主条码数据信息中
List<MesProductionPsInContext> productionPsInContextList = new ArrayList<>();
if (!CollectionUtils.isEmpty(productSnList)) equipVariableCollectContextList.stream().filter(o -> null != o).forEach(o -> productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSnMap.get(o.getEquipVariableValue()).get(0)).messageSource(o.getMessageSource()).relateId(queueOrderMap.get(o).get(0).getId())));
//获取进料主条码数据信息
List<MesProductionPsInContext> productionPsInContext = productionDispatchContextStepService.getProductionPsInContext(reqBean);
if (!CollectionUtils.isEmpty(productionPsInContext)) productionPsInContextList.addAll(productionPsInContext);
//保存进料主条码数据
productionDispatchContextStepService.dispatchProductionPsInContext(reqBean, productionPsInContextList);
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(productSnList.toString()), stepResult, String.format("主条码%s验证条码状态成功!", productSnList.toString()));
}
private List<String> filterEquipVariableCollectContextList(MesProductionProcessContext productionProcessContext, List<MesEquipVariableCollectContext> equipVariableCollectContextList) {
return equipVariableCollectContextList.stream().filter(o -> (null != o && !o.getEquipVariableValue().equals(productionProcessContext.getFinishCode()))).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
}
//验证上下文中主条码的有效性
private Map<String, List<MesProduceSn>> checkProduceSnValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, List<String> productSnList) {
//根据零件条码查询零件条码信息
Map<String, List<MesProduceSn>> produceSnMap = produceSnExtService.getProduceSnMap(reqBean.getOrganizeCode(), productSnList);
//循环获取进料主条码数据信息
productSnList.stream().filter(o -> null != o).forEach(o -> checkProduceSnValid(reqBean, stepResult, productionProcessContext, produceSnMap, o));
return !stepResult.isCompleted() ? null : produceSnMap;
}
//验证上下文中主条码的有效性
private Map<String, List<MesQueueOrder>> checkQueueOrderValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, List<String> productSnList) {
//根据零件条码查询工位队列信息
Map<String, List<MesQueueOrder>> queueOrderMap = produceSnExtService.getQueueOrderMap(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), productSnList);
//循环获取进料主条码数据信息
productSnList.stream().filter(o -> null != o).forEach(o -> checkQueueOrderValid(reqBean, stepResult, productionProcessContext, queueOrderMap, o));
return !stepResult.isCompleted() ? null : queueOrderMap;
}
//验证上下文中主条码的有效性
private StepResult checkProduceSnValid(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, Map<String, List<MesProduceSn>> produceSnMap, String productSn) {
String suffixMsg = !StringUtils.isEmpty(stepResult.getMsg()) ? stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON : MesPcnExtConstWords.EMPTY;
if (CollectionUtils.isEmpty(produceSnMap) || !produceSnMap.containsKey(productSn))
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]信息不存在", suffixMsg, productSn));
if (produceSnMap.get(productSn).size() != 1)
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]信息存在重复", suffixMsg, productSn));
if (MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue() != produceSnMap.get(productSn).get(0).getQcStatus())
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]质量状态[%s]", suffixMsg, productSn, MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(produceSnMap.get(productSn).get(0).getQcStatus())));
if (MesExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getValue() <= produceSnMap.get(productSn).get(0).getSnStatus() || MesExtEnumUtil.PRODUCE_SN_STATUS.UNKNOW.getValue() == produceSnMap.get(productSn).get(0).getSnStatus())
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]条码状态[%s]", suffixMsg, productSn, MesExtEnumUtil.PRODUCE_SN_STATUS.valueOfDescription(produceSnMap.get(productSn).get(0).getSnStatus())));
return stepResult;
}
//验证工位队列有效性
private StepResult checkQueueOrderValid(StationRequestBean reqBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, Map<String, List<MesQueueOrder>> queueOrderMap, String productSn) {
String suffixMsg = !StringUtils.isEmpty(stepResult.getMsg()) ? stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON : MesPcnExtConstWords.EMPTY;
if (CollectionUtils.isEmpty(queueOrderMap) || !queueOrderMap.containsKey(productSn))
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]工位队列信息不存在", suffixMsg, productSn));
if (queueOrderMap.get(productSn).size() != 1)
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]工位队列信息存在重复", suffixMsg, productSn));
if (MesExtEnumUtil.QUEUE_ORDER_STATUS.FINISH.getValue() == queueOrderMap.get(productSn).get(0).getStatus())
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]工位队列状态[%s]", suffixMsg, productSn, MesExtEnumUtil.QUEUE_ORDER_STATUS.valueOfDescription(queueOrderMap.get(productSn).get(0).getStatus())));
return stepResult;
}
}

@ -1,9 +1,18 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProduceSnExtService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionDispatchContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipVariableCollectContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPsInContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.api.iservice.base.IConfigService;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.IStepService;
import cn.estsh.i3plus.pojo.mes.bean.MesConfig;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCell;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
@ -13,6 +22,11 @@ import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description :
@ -25,6 +39,15 @@ public class MesProductSnCheckStepService extends BaseStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private IConfigService configService;
@Override
public StepResult execute(StationRequestBean reqBean) {
@ -44,12 +67,124 @@ public class MesProductSnCheckStepService extends BaseStepService {
//从上下文中取出生产线对象
MesWorkCenter workCenter = productionProcessContext.getWorkCenter();
//排序线 主条码验证工步
if (MesExtEnumUtil.WORK_CENTER_TYPE.SORT.getValue() == workCenter.getCenterType()) return ((IStepService) SpringContextsUtil.getBean("mesProductSnCheckSortStepService")).executeInState(reqBean);
if (MesExtEnumUtil.WORK_CENTER_TYPE.SORT.getValue() == workCenter.getCenterType()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), "排序线不支持此工步!");
//获取上下文扫/读信息:主条码
List<MesEquipVariableCollectContext> equipVariableCollectContextList = productionDispatchContextStepService.getScanProductSnContext(reqBean);
//没有待验证的主条码, 并且存在已验证过的主条码,默认放行
if (CollectionUtils.isEmpty(equipVariableCollectContextList) && productionDispatchContextStepService.checkProductionPsInIsExistContext(reqBean))
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前没有需要验证的主条码,且存在已验证主条码信息,当前工步默认放行!");
//没有待验证的主条码
if (CollectionUtils.isEmpty(equipVariableCollectContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前没有需要验证的主条码!");
//清除本次已获取得到的主条码信息
productionDispatchContextStepService.removeScanProductSnContext(reqBean);
//搜集主条码值
List<String> productSnList = equipVariableCollectContextList.stream().filter(o -> null != o).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
//获取上下文的工位
MesWorkCell workCell = productionProcessContext.getWorkCell();
//验证上下文中主条码的有效性 封装 读/扫主条件信息到进料主条码数据信息中
List<MesProductionPsInContext> productionPsInContextList = new ArrayList<>();
if (!checkProduceSnValid(reqBean, resultBean, stepResult, productionProcessContext, workCell, productSnList, equipVariableCollectContextList, productionPsInContextList).isCompleted())
return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, String.format("验证失败!原因:%s!", stepResult.getMsg()));
//获取进料主条码数据信息
List<MesProductionPsInContext> productionPsInContext = productionDispatchContextStepService.getProductionPsInContext(reqBean);
if (!CollectionUtils.isEmpty(productionPsInContext)) productionPsInContextList.addAll(productionPsInContext);
//保存进料主条码数据
productionDispatchContextStepService.dispatchProductionPsInContext(reqBean, productionPsInContextList);
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(productSnList.toString()), stepResult, String.format("主条码%s验证条码状态成功!", productSnList.toString()));
}
private List<String> filterEquipVariableCollectContextList(MesProductionProcessContext productionProcessContext, List<MesEquipVariableCollectContext> equipVariableCollectContextList) {
return equipVariableCollectContextList.stream().filter(o -> (null != o && !o.getEquipVariableValue().equals(productionProcessContext.getFinishCode()))).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
}
//获取进料主条码数据信息
private StepResult checkProduceSnValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCell workCell,
List<String> productSnList, List<MesEquipVariableCollectContext> equipVariableCollectContextList, List<MesProductionPsInContext> productionPsInContextList) {
//根据零件条码查询零件条码信息
Map<String, List<MesProduceSn>> produceSnMap = produceSnExtService.getProduceSnMap(reqBean.getOrganizeCode(), productSnList);
for (MesEquipVariableCollectContext equipVariableCollectContext : equipVariableCollectContextList) {
if (null == equipVariableCollectContext || StringUtils.isEmpty(equipVariableCollectContext.getEquipVariableValue())) continue;
if (CollectionUtils.isEmpty(produceSnMap) || !produceSnMap.containsKey(equipVariableCollectContext.getEquipVariableValue()))
productionPsInContextList.add(new MesProductionPsInContext(reqBean.getOrganizeCode(), equipVariableCollectContext.getEquipVariableValue()).messageSource(equipVariableCollectContext.getMessageSource()));
else createProductionPsInContext(reqBean, resultBean, stepResult, workCell, equipVariableCollectContext, produceSnMap.get(equipVariableCollectContext.getEquipVariableValue()), productionPsInContextList);
}
return stepResult;
}
private StepResult createProductionPsInContext(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult,
MesWorkCell workCell, MesEquipVariableCollectContext equipVariableCollectContext, List<MesProduceSn> produceSnList, List<MesProductionPsInContext> productionPsInContextList) {
String suffixMsg = !StringUtils.isEmpty(stepResult.getMsg()) ? stepResult.getMsg() + MesPcnExtConstWords.SEMICOLON : MesPcnExtConstWords.EMPTY;
List<MesProduceSn> unknowList = produceSnList.stream().filter(o -> (null != o && o.getSnStatus().compareTo(MesExtEnumUtil.PRODUCE_SN_STATUS.UNKNOW.getValue()) == 0)).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(unknowList) && unknowList.size() > 1) {
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]信息异常,存在[%s]条[未知]状态的记录", suffixMsg, equipVariableCollectContext.getEquipVariableValue(), unknowList.size()));
}
if (!CollectionUtils.isEmpty(unknowList) && checkAllowUnknowCenterCfg(reqBean) && (unknowList.size() > 1 || (!unknowList.get(0).getWorkCenterCode().equals(reqBean.getWorkCenterCode()) || !unknowList.get(0).getWorkCellCode().equals(reqBean.getWorkCellCode())))) {
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]信息条码状态已被%s标记[未知]", suffixMsg, equipVariableCollectContext.getEquipVariableValue(),
unknowList.stream().filter(o -> null != o).map(o -> new StringJoiner(MesPcnExtConstWords.AND).add(o.getWorkCenterCode()).add(o.getWorkCellCode()).toString()).collect(Collectors.joining(MesPcnExtConstWords.SEMICOLON))));
}
produceSnList = produceSnList.stream().filter(o -> null != o).sorted(Comparator.comparing(MesProduceSn::getCreateDatetime).reversed()).collect(Collectors.toList());
MesProduceSn produceSn = produceSnList.get(0);
if (produceSn.getQcStatus().compareTo(MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue()) != 0 && produceSn.getQcStatus().compareTo(MesExtEnumUtil.PRODUCE_QC_STATUS.SUSPICIOUS_TO_QUALIFIED.getValue()) != 0)
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]质量状态[%s]", suffixMsg, equipVariableCollectContext.getEquipVariableValue(), MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(produceSn.getQcStatus())));
if (produceSn.getSnStatus().compareTo(MesExtEnumUtil.PRODUCE_SN_STATUS.ASSEMBLY_BACK.getValue()) > 0)
return stepResult.isCompleted(false).msg(String.format("%s主条码[%s]条码状态[%s]", suffixMsg, equipVariableCollectContext.getEquipVariableValue(), MesExtEnumUtil.PRODUCE_SN_STATUS.valueOfDescription(produceSn.getSnStatus())));
//正常条码
if (produceSn.getSnStatus().compareTo(MesExtEnumUtil.PRODUCE_SN_STATUS.UNKNOW.getValue()) != 0) {
//非排序线 主条码验证工步
return ((IStepService) SpringContextsUtil.getBean("mesProductSnCheckNosortStepService")).executeInState(reqBean);
productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSn).messageSource(equipVariableCollectContext.getMessageSource()));
return stepResult;
}
//未知条码【工序为空 代表新做的工序没有加工完成】
if (StringUtils.isEmpty(produceSn.getProcessCode()) && produceSnList.size() > 1) {
productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSnList.get(1)).messageSource(equipVariableCollectContext.getMessageSource()).relateId(produceSn.getId()));
return stepResult;
}
//未知条码【工序为空 代表新做的工序没有加工完成】【只有一条条码记录 代表是打印的条码自进自出直接被标记为未知】
if (StringUtils.isEmpty(produceSn.getProcessCode())) {
productionPsInContextList.add(new MesProductionPsInContext(reqBean.getOrganizeCode(), equipVariableCollectContext.getEquipVariableValue()).messageSource(equipVariableCollectContext.getMessageSource()).relateId(produceSn.getId()));
return stepResult;
}
//未知条码【工序不为空 代表已完成的工序被重做后没有加工完成】
productionPsInContextList.add(new MesProductionPsInContext(workCell, produceSn).messageSource(equipVariableCollectContext.getMessageSource()).relateId(produceSn.getId()));
return stepResult;
}
//允许扫描其他工位的未知条码的生产线配置, 配置则表示不需要验证未知条码
private Boolean checkAllowUnknowCenterCfg(StationRequestBean reqBean) {
List<MesConfig> configList = configService.doCachedConfigList(MesPcnExtConstWords.ALLOW_UNKNOW_CENTER_CFG, reqBean.getOrganizeCode());
if (CollectionUtils.isEmpty(configList)) return true;
List<String> allowUnknowCenterList = Arrays.asList(configList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getCfgValue()))).map(MesConfig::getCfgValue).collect(Collectors.joining(MesPcnExtConstWords.COMMA)).split(MesPcnExtConstWords.COMMA));
return (!CollectionUtils.isEmpty(allowUnknowCenterList) && allowUnknowCenterList.contains(reqBean.getWorkCenterCode())) ? false : true;
}
}

@ -13,6 +13,7 @@ import cn.estsh.i3plus.mes.pcn.util.StationKvBeanUtil;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.model.StationKvBean;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
@ -24,9 +25,8 @@ import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
/**
@ -82,15 +82,15 @@ public class MesWorkOrderCheckNosortStepService extends MesWorkOrderCheckStepSer
List<MesProductionPartContext> cachedProductionPartContextList = productionDispatchContextStepService.getProductionPartContext(reqBean);
//非扫描场景 清除历史产出零件信息
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() != equipVariableCollectContextList.get(0).getMessageSource() && !CollectionUtils.isEmpty(cachedProductionPartContextList)) deleteBusiData(reqBean);
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() != equipVariableCollectContextList.get(0).getMessageSource() && !CollectionUtils.isEmpty(cachedProductionPartContextList)) removeBusiData(reqBean);
//验证扫描信息是否属于工艺强过码
Boolean isCraftJumpCode = doMatchCraftJumpCode(productionProcessContext, equipVariableCollectContextList);
Boolean isCraftJumpCode = matchCraftJumpCode(productionProcessContext, equipVariableCollectContextList);
//验证是否支持跳过
Boolean isAllowJump = checkIsAllowJump(cachedProductionPartContextList);
//不属于工艺强过码,如果此前存在工艺验证失败的数据 则清除此前的产出零件信息
//不属于工艺强过码,如果此前存在顺序验证失败的数据 则清除此前的产出零件信息
if (!isCraftJumpCode && isAllowJump) {
//删除上下文产出零件信息
productionDispatchContextStepService.removeProductionPartContext(reqBean);
@ -119,14 +119,17 @@ public class MesWorkOrderCheckNosortStepService extends MesWorkOrderCheckStepSer
//扫描场景下合并历史产出零件信息
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() == equipVariableCollectContextList.get(0).getMessageSource() && !CollectionUtils.isEmpty(cachedProductionPartContextList)) productionPartContextList.addAll(cachedProductionPartContextList);
//验证是否全部为空腔
if (checkIsAllFinishCode(reqBean, productionPartContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前加工单信息全部为空腔,已清除当前的空腔数据!");
//保存零件数据信息
if (!firstMouldNoReadStepService.savePartDataMap(reqBean, resultBean, stepResult, productionProcessContext, productionPartContextList, true).isCompleted()) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, stepResult.getMsg());
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
//更新展示组件MODULE_CONTENT内容
doCacheMoudleContext(reqBean, productionPartContextList);
//存储展示组件MODULE_CONTENT内容
productionDispatchContextStepService.dispatchModuleContentContext(reqBean, getModuleContextData(reqBean, productionPartContextList));
//当前工位使用的设备
MesCellEquipContext cellEquipmentContext = productionProcessContext.getCurCellEquip();
@ -135,10 +138,6 @@ public class MesWorkOrderCheckNosortStepService extends MesWorkOrderCheckStepSer
stepResult, false, MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT,
String.format("当前扫描信息加工单[%s]验证工单状态成功,已知腔数[%s],还需要再连续扫描[%s]次加工单!", equipVariableCollectContextList.get(0).getEquipVariableValue(), cellEquipmentContext.getCavity(), cellEquipmentContext.getCavity() - productionPartContextList.size()));
//验证是否全部为空腔
if (doCheckIsAllFinishCode(reqBean, productionPartContextList))
return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前加工单信息全部为空腔,已清除当前的空腔数据!");
} finally {
//删除手动选择的腔数及工单信息上下文 [结果失败并且非扫描场景]
@ -162,13 +161,6 @@ public class MesWorkOrderCheckNosortStepService extends MesWorkOrderCheckStepSer
}
//验证扫描信息是否属于工艺强过码
private Boolean doMatchCraftJumpCode(MesProductionProcessContext productionProcessContext, List<MesEquipVariableCollectContext> equipVariableCollectContextList) {
if (equipVariableCollectContextList.size() != 1 || MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() != equipVariableCollectContextList.get(0).getMessageSource()) return false;
if (!equipVariableCollectContextList.get(0).getEquipVariableValue().equals(productionProcessContext.getCraftJumpCode())) return false;
return true;
}
//验证是否支持跳过
private Boolean checkIsAllowJump(List<MesProductionPartContext> productionPartContextList) {
Optional<MesProductionPartContext> optional = CollectionUtils.isEmpty(productionPartContextList) ? null : productionPartContextList.stream().filter(o -> (null != o && o.getCheckSeqResult().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0)).findFirst();
@ -184,4 +176,75 @@ public class MesWorkOrderCheckNosortStepService extends MesWorkOrderCheckStepSer
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
}
//验证工单的有效性
private StepResult checkWorkOrderValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCenter workCenter,
List<MesEquipVariableCollectContext> equipVariableCollectContextList, List<MesProductionPartContext> productionPartContextList) {
//搜集生产工单号
List<String> filterList = equipVariableCollectContextList.stream().filter(o -> (null != o)).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
List<String> workOrderNoList = filterList.stream().filter(o -> (!StringUtils.isEmpty(o) && !o.equals(productionProcessContext.getFinishCode()))).distinct().collect(Collectors.toList());
//获取生产工单信息
List<MesWorkOrder> workOrderList = workOrderExtService.getWorkOrderList(reqBean.getOrganizeCode(), workOrderNoList);
Map<String, List<MesWorkOrder>> workOrderMap = CollectionUtils.isEmpty(workOrderList) ? null : workOrderList.stream().filter(o -> null != o).collect(Collectors.groupingBy(MesWorkOrder::getWorkOrderNo));
if (!CollectionUtils.isEmpty(workOrderNoList)) {
for (String workOrderNo : workOrderNoList) {
if (StringUtils.isEmpty(workOrderNo)) continue;
List<MesWorkOrder> workOrderDbList = CollectionUtils.isEmpty(workOrderMap) ? null : workOrderMap.get(workOrderNo);
if (CollectionUtils.isEmpty(workOrderDbList))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单号[%s]无效!", workOrderNo));
if (workOrderDbList.size() != 1)
return stepResult.isCompleted(false).msg(String.format("请检查生产工单信息,加工单号[%s]存在重复!", workOrderNo));
if (!MesExtEnumUtil.ORDER_STATUS.checkAllowStatus(workCenter.getCenterType(), workOrderDbList.get(0).getWorkOrderStatus()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息工单状态[%s]!", workOrderNo, MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrderDbList.get(0).getWorkOrderStatus())));
if (!workOrderDbList.get(0).getWorkCenterCode().equals(reqBean.getWorkCenterCode()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息所属生产线[%s]与当前生产线[%s]不一致!", workOrderNo, workOrderDbList.get(0).getWorkCenterCode(), reqBean.getWorkCenterCode()));
}
}
//封装产出零件信息
equipVariableCollectContextList.stream().filter(o -> null != o).forEach(o -> {
MesProductionPartContext productionPartContext = new MesProductionPartContext()
.copyPartNo((!CollectionUtils.isEmpty(workOrderMap) && workOrderMap.containsKey(o.getEquipVariableValue())) ? workOrderMap.get(o.getEquipVariableValue()).get(0) : null, o.getMessageSource())
.isCheck(productionProcessContext.getWorkCell());
if (equipVariableCollectContextList.get(0).getIsConsume().compareTo(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) == 0) productionPartContext.checkSeqResult(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
productionPartContextList.add(productionPartContext);
});
return stepResult;
}
//封装展示组件MODULE_CONTENT内容
private List<List<StationKvBean>> getModuleContextData(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
List<List<StationKvBean>> dataList = new ArrayList<>();
List<MesProductionPartContext> orderList = filterProductionPartContext(productionPartContextList, true);
List<MesProductionPartContext> finishCodeList = filterProductionPartContext(productionPartContextList, false);
AtomicReference<Integer> index = new AtomicReference<>(0);
if (!CollectionUtils.isEmpty(orderList)) {
orderList.forEach(o -> StationKvBeanUtil.addStationKvBeanList(dataList, new ArrayList<>(),
new StationKvBean(MesPcnExtConstWords.WORK_ORDER_NO, "工单号", o.getWorkOrderNo()), new StationKvBean(MesPcnExtConstWords.PART_NO, "零件编码", o.getPartNo()),
new StationKvBean(MesPcnExtConstWords.QTY, "完成数/工单数", new StringJoiner(MesPcnExtConstWords.SLANT_R).add(String.valueOf(o.getCompleteQty().intValue())).add(String.valueOf(o.getQty().intValue())).toString()),
new StationKvBean(MesPcnExtConstWords.CAVITY, "腔数", new StringJoiner(MesPcnExtConstWords.SLANT_R).add(String.valueOf(index.updateAndGet(v -> v + 1))).add(String.valueOf(productionPartContextList.size())).toString())));
}
if (!CollectionUtils.isEmpty(finishCodeList)) {
StationKvBeanUtil.addStationKvBeanList(dataList, new ArrayList<>(), new StationKvBean(MesPcnExtConstWords.CAVITY_FINISH_CODE, "空腔数", String.valueOf(finishCodeList.size())));
}
return dataList;
}
}

@ -3,14 +3,17 @@ package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionDispatchContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesWorkOrderExtService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesCellEquipContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipVariableCollectContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPartContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.*;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.actor.shipping.dispatch.IFsmCommonService;
import cn.estsh.i3plus.mes.pcn.util.StationKvBeanUtil;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesQueueOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.model.StationKvBean;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
@ -19,9 +22,10 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
/**
@ -73,33 +77,71 @@ public class MesWorkOrderCheckSortStepService extends MesWorkOrderCheckStepServi
//从上下文中取出生产线对象
MesWorkCenter workCenter = productionProcessContext.getWorkCenter();
//排序线: 存在已验证的主条码信息时, 验证扫描信息是否属于工艺强过码, 保存到读/扫主条码上下文中
// if (productionDispatchContextStepService.checkProductionPsInIsExistContext(reqBean) && doMatchCraftJumpCode(reqBean, equipVariableCollectContextList))
// return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(MesExtEnumUtil.WORK_CELL_SCAN_MONITOR_LOG_TYPE.SCAN.getValue()).scanInfo(equipVariableCollectContextList.get(0).getEquipVariableValue()),
// stepResult, String.format("当前扫描信息工艺强过码[%s]!", equipVariableCollectContextList.get(0).getEquipVariableValue()));
//获取上下文产出零件信息
List<MesProductionPartContext> cachedProductionPartContextList = productionDispatchContextStepService.getProductionPartContext(reqBean);
//获取工单对应的条码数据信息
List<MesProductionPsInContext> cachedProductionPsInContextList = productionDispatchContextStepService.getProductionPsInContext(reqBean);
//非扫描场景 清除历史产出零件信息
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() != equipVariableCollectContextList.get(0).getMessageSource() && !CollectionUtils.isEmpty(cachedProductionPartContextList)) cachedProductionPartContextList = deleteBusiData(reqBean);
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() != equipVariableCollectContextList.get(0).getMessageSource() &&
(!CollectionUtils.isEmpty(cachedProductionPartContextList) || !CollectionUtils.isEmpty(cachedProductionPsInContextList))) cachedProductionPartContextList = removeBusiData(reqBean);
//验证扫描信息是否属于工艺强过码
Boolean isCraftJumpCode = matchCraftJumpCode(productionProcessContext, equipVariableCollectContextList);
//验证是否支持跳过
Boolean isAllowJump = checkIsAllowJump(cachedProductionPartContextList, cachedProductionPsInContextList);
//不属于工艺强过码,如果此前存在顺序或者工艺验证失败的数据 则清除此前的产出零件信息
if (!isCraftJumpCode && isAllowJump) {
//删除上下文产出零件信息/产品条码数据
removeProductionPartAndPsInContext(reqBean);
cachedProductionPartContextList = null;
cachedProductionPsInContextList = null;
}
//当前不允许跳过
if (isCraftJumpCode && !isAllowJump)
return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(MesPcnEnumUtil.WORK_CELL_SCAN_MONITOR_LOG_TYPE.SCAN.getValue()).
scanInfo(equipVariableCollectContextList.get(0).getEquipVariableValue()), stepResult, String.format("当前扫描信息工艺强过码[%s],当前没有可以跳过的加工单信息!", equipVariableCollectContextList.get(0).getEquipVariableValue()));
//允许跳过,先更新数据
if (isCraftJumpCode && isAllowJump) {
updateProductionPartAndPsInContextList(reqBean, cachedProductionPartContextList, cachedProductionPsInContextList, equipVariableCollectContextList.get(0).getEquipVariableValue());
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(MesPcnEnumUtil.WORK_CELL_SCAN_MONITOR_LOG_TYPE.SCAN.getValue()).
scanInfo(equipVariableCollectContextList.get(0).getEquipVariableValue()), stepResult, String.format("当前扫描信息工艺强过码[%s]!", equipVariableCollectContextList.get(0).getEquipVariableValue()));
}
//验证工单的有效性
List<MesProductionPartContext> productionPartContextList = new ArrayList<>();
if (!checkWorkOrderValid(reqBean, resultBean, stepResult, productionProcessContext, workCenter, equipVariableCollectContextList, productionPartContextList).isCompleted()) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, stepResult.getMsg());
List<MesProductionPsInContext> productionPsInContextList = new ArrayList<>();
if (!checkWorkOrderValid(reqBean, resultBean, stepResult, productionProcessContext, workCenter,
equipVariableCollectContextList, productionPartContextList, productionPsInContextList).isCompleted()) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, stepResult.getMsg());
//扫描场景下合并历史产出零件信息/产品条码信息
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() == equipVariableCollectContextList.get(0).getMessageSource() &&
(!CollectionUtils.isEmpty(cachedProductionPartContextList) || !CollectionUtils.isEmpty(productionPsInContextList))) {
productionPartContextList.addAll(cachedProductionPartContextList);
productionPsInContextList.addAll(cachedProductionPsInContextList);
}
//验证是否全部为空腔
if (checkIsAllFinishCode(reqBean, productionPartContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前加工单信息全部为空腔,已清除当前的空腔数据!");
//扫描场景下合并历史产出零件信息
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() == equipVariableCollectContextList.get(0).getMessageSource() && productionDispatchContextStepService.checkProductionPsInIsExistContext(reqBean)) cachedProductionPartContextList = deleteBusiData(reqBean);
if (MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() == equipVariableCollectContextList.get(0).getMessageSource() && !CollectionUtils.isEmpty(cachedProductionPartContextList)) productionPartContextList.addAll(cachedProductionPartContextList);
//验证是否存在相同的零件生产组的加工单, 存在则清除已缓存的数据
if (checkPartProdGroupCodeIsExistRepeat(reqBean, productionPartContextList, cachedProductionPartContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "不支持生产相同的零件生产组的加工单,已清除当前的加工单数据!");
//保存零件数据信息
if (!firstMouldNoReadStepService.savePartDataMap(reqBean, resultBean, stepResult, productionProcessContext, productionPartContextList, true).isCompleted()) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, stepResult.getMsg());
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
//保存上下文产品条码信息
productionDispatchContextStepService.dispatchProductionPsInContext(reqBean, productionPsInContextList);
//更新展示组件MODULE_CONTENT内容
doCacheMoudleContext(reqBean, productionPartContextList);
//存储展示组件MODULE_CONTENT内容
productionDispatchContextStepService.dispatchModuleContentContext(reqBean, getModuleContextData(reqBean, productionPartContextList));
//当前工位使用的设备
MesCellEquipContext cellEquipmentContext = productionProcessContext.getCurCellEquip();
@ -108,9 +150,6 @@ public class MesWorkOrderCheckSortStepService extends MesWorkOrderCheckStepServi
MesPcnEnumUtil.STATION_BUSI_TYPE.MESSAGE, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT, String.format("当前扫描信息加工单[%s]验证工单状态成功,已知腔数[%s],还需要再连续扫描[%s]次加工单!",
equipVariableCollectContextList.get(0).getEquipVariableValue(), cellEquipmentContext.getCavity(), cellEquipmentContext.getCavity() - productionPartContextList.size()));
//验证是否全部为空腔
if (doCheckIsAllFinishCode(reqBean, productionPartContextList)) return stepNonCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "当前加工单信息全部为空腔,已清除当前的空腔数据!");
String workOrderStr = equipVariableCollectContextList.stream().filter(o -> null != o).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList()).toString();
return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog().scanInfo(workOrderStr), stepResult, String.format("当前%s加工单%s验证工单状态成功%s!",
MesExtEnumUtil.CELL_MESSAGE_SOURCE.valueOfDescription(equipVariableCollectContextList.get(0).getMessageSource()), workOrderStr,
@ -118,4 +157,128 @@ public class MesWorkOrderCheckSortStepService extends MesWorkOrderCheckStepServi
}
//验证是否支持跳过
private Boolean checkIsAllowJump(List<MesProductionPartContext> productionPartContextList, List<MesProductionPsInContext> cachedProductionPsInContextList) {
Optional<MesProductionPartContext> optional1 = CollectionUtils.isEmpty(productionPartContextList) ? null : productionPartContextList.stream().filter(o -> (null != o && o.getCheckSeqResult().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0)).findFirst();
Optional<MesProductionPsInContext> optional2 = CollectionUtils.isEmpty(cachedProductionPsInContextList) ? null : cachedProductionPsInContextList.stream().filter(o -> (null != o && o.getCheckCraftResult().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0)).findFirst();
if (null != optional1 && optional1.isPresent()) return true;
if (null != optional2 && optional2.isPresent()) return true;
return false;
}
//验证扫描信息属于工艺强过码 并且支持跳过,进行数据变更
private void updateProductionPartAndPsInContextList(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList, List<MesProductionPsInContext> cachedProductionPsInContextList, String craftJumpCode) {
productionPartContextList.forEach(o -> {
if (o.getCheckSeqResult().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0) {
o.setCraftJumpCode(craftJumpCode);
}
});
cachedProductionPsInContextList.forEach(o -> {
if (o.getCheckCraftResult().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0) o.setCraftJumpCode(craftJumpCode);
});
//保存上下文产出零件信息
productionDispatchContextStepService.dispatchProductionPartContext(reqBean, productionPartContextList);
}
//验证工单的有效性
private StepResult checkWorkOrderValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCenter workCenter,
List<MesEquipVariableCollectContext> equipVariableCollectContextList, List<MesProductionPartContext> productionPartContextList, List<MesProductionPsInContext> productionPsInContextList) {
//搜集生产工单号
List<String> filterList = equipVariableCollectContextList.stream().filter(o -> (null != o)).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
List<String> workOrderNoList = filterList.stream().filter(o -> (!StringUtils.isEmpty(o) && !o.equals(productionProcessContext.getFinishCode()))).distinct().collect(Collectors.toList());
Map<String, Map<String, Object>> workOrderMap = workOrderExtService.getWorkOrderMapSort(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), workOrderNoList);
for (String workOrderNo : workOrderNoList) {
if (StringUtils.isEmpty(workOrderNo)) continue;
Map<String, Object> itemMap = CollectionUtils.isEmpty(workOrderMap) ? null : workOrderMap.get(workOrderNo);
if (CollectionUtils.isEmpty(itemMap))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单号[%s]无效!", workOrderNo));
if (itemMap.containsKey(MesPcnExtConstWords.MESSAGE))
return stepResult.isCompleted(false).msg((String) itemMap.get(MesPcnExtConstWords.MESSAGE));
MesWorkOrder workOrder = (MesWorkOrder) itemMap.get(MesWorkOrder.class.getSimpleName());
if (!MesExtEnumUtil.ORDER_STATUS.checkAllowStatus(workCenter.getCenterType(), workOrder.getWorkOrderStatus()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息工单状态[%s]!", workOrderNo, MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus())));
if (!workOrder.getWorkCenterCode().equals(reqBean.getWorkCenterCode()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息所属生产线[%s]与当前生产线[%s]不一致!", workOrderNo, workOrder.getWorkCenterCode(), reqBean.getWorkCenterCode()));
if (StringUtils.isEmpty(workOrder.getPartProdGroupCode()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息未关联零件生产组!", workOrderNo));
MesProduceSn produceSn = (MesProduceSn) itemMap.get(MesProduceSn.class.getSimpleName());
if (MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue() != produceSn.getQcStatus())
return stepResult.isCompleted(false).msg(String.format("请检查产品条码信息,产品条码[%s]质量状态[%s]", produceSn.getProductSn(), MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(produceSn.getQcStatus())));
if (MesExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getValue() <= produceSn.getSnStatus() || MesExtEnumUtil.PRODUCE_SN_STATUS.UNKNOW.getValue() == produceSn.getSnStatus())
return stepResult.isCompleted(false).msg(String.format("请检查产品条码信息,产品条码[%s]条码状态[%s]", produceSn.getProductSn(), MesExtEnumUtil.PRODUCE_SN_STATUS.valueOfDescription(produceSn.getSnStatus())));
MesQueueOrder queueOrder = (MesQueueOrder) itemMap.get(MesQueueOrder.class.getSimpleName());
if (MesExtEnumUtil.QUEUE_ORDER_STATUS.FINISH.getValue() == queueOrder.getStatus())
return stepResult.isCompleted(false).msg(String.format("请检查产品条码工位队列信息,产品条码[%s]工位队列状态[%s]", queueOrder.getProductSn(), MesExtEnumUtil.QUEUE_ORDER_STATUS.valueOfDescription(queueOrder.getStatus())));
//封装产成零件
MesProductionPartContext productionPartContext = new MesProductionPartContext().copyPartNo(workOrder, equipVariableCollectContextList.get(0).getMessageSource()).isCheck(productionProcessContext.getWorkCell());
productionPartContextList.add(productionPartContext);
//封装产品条码
productionPsInContextList.add(new MesProductionPsInContext(productionProcessContext.getWorkCell(), produceSn).messageSource(equipVariableCollectContextList.get(0).getMessageSource()).relateId(queueOrder.getId()));
}
//封装空腔
equipVariableCollectContextList.stream().filter(o -> (null != o && o.getEquipVariableValue().equals(productionProcessContext.getFinishCode()))).forEach(o -> {
productionPartContextList.add(new MesProductionPartContext().isFinishCode());
productionPsInContextList.add(new MesProductionPsInContext().isFinishCode());
});
return stepResult;
}
//封装展示组件MODULE_CONTENT内容
private List<List<StationKvBean>> getModuleContextData(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
List<List<StationKvBean>> dataList = new ArrayList<>();
List<MesProductionPartContext> orderList = filterProductionPartContext(productionPartContextList, true);
List<MesProductionPartContext> finishCodeList = filterProductionPartContext(productionPartContextList, false);
AtomicReference<Integer> index = new AtomicReference<>(0);
if (!CollectionUtils.isEmpty(orderList)) {
orderList.forEach(o -> StationKvBeanUtil.addStationKvBeanList(dataList, new ArrayList<>(),
new StationKvBean(MesPcnExtConstWords.WORK_ORDER_NO, "工单号", o.getWorkOrderNo()), new StationKvBean(MesPcnExtConstWords.PART_NO, "零件编码", o.getPartNo()),
new StationKvBean(MesPcnExtConstWords.QTY, "工单数", String.valueOf(o.getQty().intValue())),
new StationKvBean(MesPcnExtConstWords.CAVITY, "腔数", new StringJoiner(MesPcnExtConstWords.SLANT_R).add(String.valueOf(index.updateAndGet(v -> v + 1))).add(String.valueOf(productionPartContextList.size())).toString())));
}
if (!CollectionUtils.isEmpty(finishCodeList)) {
StationKvBeanUtil.addStationKvBeanList(dataList, new ArrayList<>(), new StationKvBean(MesPcnExtConstWords.CAVITY_FINISH_CODE, "空腔数", String.valueOf(finishCodeList.size())));
}
return dataList;
}
//删除上下文产出零件信息/产品条码数据
private Boolean removeProductionPartAndPsInContext(StationRequestBean reqBean) {
//删除上下文产出零件信息
productionDispatchContextStepService.removeProductionPartContext(reqBean);
//删除上下文产品条码信息
productionDispatchContextStepService.removeProductionPsInContext(reqBean);
return true;
}
//验证是否存在相同的零件生产组的加工单, 存在则清除已缓存的数据
private Boolean checkPartProdGroupCodeIsExistRepeat(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList, List<MesProductionPartContext> cachedProductionPartContextList) {
List<String> partProdGroupCodeList = (productionPartContextList.stream().filter(o -> (null != o &&
!StringUtils.isEmpty(o.getPartProdGroupCode()))).map(MesProductionPartContext::getPartProdGroupCode).collect(Collectors.toList())).stream().filter(o -> !StringUtils.isEmpty(o)).distinct().collect(Collectors.toList());
if (!CollectionUtils.isEmpty(partProdGroupCodeList) && partProdGroupCodeList.size() == productionPartContextList.size()) return false;
//删除上下文产出零件信息/产品条码数据
if (!CollectionUtils.isEmpty(cachedProductionPartContextList)) removeProductionPartAndPsInContext(reqBean);
return true;
}
}

@ -2,19 +2,13 @@ package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionDispatchContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesWorkOrderExtService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipVariableCollectContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionPartContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.actor.shipping.dispatch.IFsmCommonService;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.IStepService;
import cn.estsh.i3plus.mes.pcn.util.StationKvBeanUtil;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.model.StationKvBean;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
import cn.estsh.i3plus.pojo.mes.model.StepResult;
@ -24,10 +18,9 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
@ -44,15 +37,6 @@ public class MesWorkOrderCheckStepService extends BaseStepService {
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesWorkOrderExtService workOrderExtService;
@Autowired
private IFsmCommonService fsmCommonService;
@Autowired
private MesFirstMouldNoReadStepService firstMouldNoReadStepService;
@Override
public StepResult execute(StationRequestBean reqBean) {
@ -80,7 +64,7 @@ public class MesWorkOrderCheckStepService extends BaseStepService {
}
public List<MesProductionPartContext> deleteBusiData(StationRequestBean reqBean) {
public List<MesProductionPartContext> removeBusiData(StationRequestBean reqBean) {
productionDispatchContextStepService.removeProductionPartContext(reqBean);
productionDispatchContextStepService.removeProductionPsInContext(reqBean);
productionDispatchContextStepService.removeProductionPsOutContext(reqBean);
@ -88,98 +72,24 @@ public class MesWorkOrderCheckStepService extends BaseStepService {
return null;
}
//验证是否全部为空腔
public Boolean doCheckIsAllFinishCode(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
Optional<MesProductionPartContext> optional = productionPartContextList.stream().filter(o -> (null != o && o.getIsFinishCode().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0)).findFirst();
if (null != optional && optional.isPresent()) return false;
//删除上下文产出零件信息
productionDispatchContextStepService.removeProductionPartContext(reqBean);
//验证扫描信息是否属于工艺强过码
public Boolean matchCraftJumpCode(MesProductionProcessContext productionProcessContext, List<MesEquipVariableCollectContext> equipVariableCollectContextList) {
if (equipVariableCollectContextList.size() != 1 || MesExtEnumUtil.CELL_MESSAGE_SOURCE.SCAN.getValue() != equipVariableCollectContextList.get(0).getMessageSource()) return false;
if (!equipVariableCollectContextList.get(0).getEquipVariableValue().equals(productionProcessContext.getCraftJumpCode())) return false;
return true;
}
//验证工单的有效性
public StepResult checkWorkOrderValid(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, MesProductionProcessContext productionProcessContext, MesWorkCenter workCenter,
List<MesEquipVariableCollectContext> equipVariableCollectContextList, List<MesProductionPartContext> productionPartContextList) {
//搜集生产工单号
List<String> filterList = equipVariableCollectContextList.stream().filter(o -> (null != o)).map(MesEquipVariableCollectContext::getEquipVariableValue).collect(Collectors.toList());
List<String> workOrderNoList = filterList.stream().filter(o -> (!StringUtils.isEmpty(o) && !o.equals(productionProcessContext.getFinishCode()))).distinct().collect(Collectors.toList());
//获取生产工单信息
List<MesWorkOrder> workOrderList = workOrderExtService.getWorkOrderList(reqBean.getOrganizeCode(), workOrderNoList);
Map<String, List<MesWorkOrder>> workOrderMap = CollectionUtils.isEmpty(workOrderList) ? null : workOrderList.stream().filter(o -> null != o).collect(Collectors.groupingBy(MesWorkOrder::getWorkOrderNo));
//根据值分组数据
Map<String, List<MesEquipVariableCollectContext>> amountMap = equipVariableCollectContextList.stream().filter(o -> (null != o)).collect(Collectors.groupingBy(MesEquipVariableCollectContext::getEquipVariableValue));
if (!CollectionUtils.isEmpty(workOrderNoList)) {
for (String workOrderNo : workOrderNoList) {
if (StringUtils.isEmpty(workOrderNo)) continue;
List<MesWorkOrder> workOrderDbList = CollectionUtils.isEmpty(workOrderMap) ? null : workOrderMap.get(workOrderNo);
if (CollectionUtils.isEmpty(workOrderDbList))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单号[%s]无效!", workOrderNo));
if (workOrderDbList.size() != 1)
return stepResult.isCompleted(false).msg(String.format("请检查生产工单信息,加工单号[%s]存在重复!", workOrderNo));
if (!MesExtEnumUtil.ORDER_STATUS.checkAllowStatus(workCenter.getCenterType(), workOrderDbList.get(0).getWorkOrderStatus()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息工单状态[%s]!", workOrderNo, MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrderDbList.get(0).getWorkOrderStatus())));
if (!workOrderDbList.get(0).getWorkCenterCode().equals(reqBean.getWorkCenterCode()))
return stepResult.isCompleted(false).msg(String.format("请检查工单信息,加工单[%s]信息所属生产线[%s]与当前生产线[%s]不一致!", workOrderNo, workOrderDbList.get(0).getWorkCenterCode(), reqBean.getWorkCenterCode()));
}
}
//封装产出零件信息
equipVariableCollectContextList.stream().filter(o -> null != o).forEach(o -> {
MesProductionPartContext productionPartContext = new MesProductionPartContext()
.copyPartNo((!CollectionUtils.isEmpty(workOrderMap) && workOrderMap.containsKey(o.getEquipVariableValue())) ? workOrderMap.get(o.getEquipVariableValue()).get(0) : null, o.getMessageSource())
.isCheck(productionProcessContext.getWorkCell());
if (equipVariableCollectContextList.get(0).getIsConsume().compareTo(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) == 0) productionPartContext.checkSeqResult(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
productionPartContextList.add(productionPartContext);
});
return stepResult.obj(filterList);
}
public void doCacheMoudleContext(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
//存储展示组件MODULE_CONTENT内容
productionDispatchContextStepService.dispatchModuleContentContext(reqBean, getModuleContextData(reqBean, productionPartContextList));
}
//封装展示组件MODULE_CONTENT内容
public List<List<StationKvBean>> getModuleContextData(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
List<List<StationKvBean>> dataList = new ArrayList<>();
List<MesProductionPartContext> orderList = filterProductionPartContext(productionPartContextList, true);
List<MesProductionPartContext> finishCodeList = filterProductionPartContext(productionPartContextList, false);
AtomicReference<Integer> index = new AtomicReference<>(0);
if (!CollectionUtils.isEmpty(orderList)) {
orderList.forEach(o -> StationKvBeanUtil.addStationKvBeanList(dataList, new ArrayList<>(),
new StationKvBean(MesPcnExtConstWords.WORK_ORDER_NO, "工单号", o.getWorkOrderNo()), new StationKvBean(MesPcnExtConstWords.PART_NO, "零件编码", o.getPartNo()),
new StationKvBean(MesPcnExtConstWords.QTY, "完成数/工单数", new StringJoiner(MesPcnExtConstWords.SLANT_R).add(String.valueOf(o.getCompleteQty().intValue())).add(String.valueOf(o.getQty().intValue())).toString()),
new StationKvBean(MesPcnExtConstWords.CAVITY, "腔数", new StringJoiner(MesPcnExtConstWords.SLANT_R).add(String.valueOf(index.updateAndGet(v -> v + 1))).add(String.valueOf(productionPartContextList.size())).toString())));
}
if (!CollectionUtils.isEmpty(finishCodeList)) {
StationKvBeanUtil.addStationKvBeanList(dataList, new ArrayList<>(), new StationKvBean(MesPcnExtConstWords.CAVITY_FINISH_CODE, "空腔数", String.valueOf(finishCodeList.size())));
}
return dataList;
}
//根据是否空腔搜集数据
public List<MesProductionPartContext> filterProductionPartContext(List<MesProductionPartContext> productionPartContextList, Boolean flag) {
return flag ? productionPartContextList.stream().filter(o -> (null != o && o.getIsFinishCode().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0)).collect(Collectors.toList()) :
productionPartContextList.stream().filter(o -> (null != o && o.getIsFinishCode().compareTo(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) == 0)).collect(Collectors.toList());
}
//验证是否全部为空腔
public Boolean checkIsAllFinishCode(StationRequestBean reqBean, List<MesProductionPartContext> productionPartContextList) {
Optional<MesProductionPartContext> optional = productionPartContextList.stream().filter(o -> (null != o && o.getIsFinishCode().compareTo(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) == 0)).findFirst();
if (null != optional && optional.isPresent()) return false;
return true;
}
}

@ -79,8 +79,6 @@ public class MesWorkOrderReadStepService extends BaseStepService {
}
//广州非排序无读工单场景
@Override
public StepResult execute(StationRequestBean reqBean) {
@ -97,8 +95,6 @@ public class MesWorkOrderReadStepService extends BaseStepService {
//当前工序已存在读取待验证的加工单信息
if (productionDispatchContextStepService.checkScanWorkOrderNoIsExistContext(reqBean)) return stepResult;
//TODO 后面增加工艺强过码 通过按钮触发 写入 ScanWorkOrderNoContext 数据类型:扫描信息 直接放行
//获取生产过程上下文对象有异常信息 抛出异常
if (!productionProcessContextStepService.getEquipmentVariableCfgList(productionProcessContext).getSuccess()) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), productionProcessContext.getMessage());

@ -8,6 +8,7 @@ import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesProductionProcessContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter;
import cn.estsh.i3plus.pojo.mes.model.StationKvBean;
import cn.estsh.i3plus.pojo.mes.model.StationRequestBean;
import cn.estsh.i3plus.pojo.mes.model.StationResultBean;
@ -69,10 +70,15 @@ public class MesWorkOrderScanStepService extends BaseStepService {
//存储生产过程上下文对象
productionProcessContextStepService.dispatchProductionProcessContext(reqBean, productionProcessContext);
//从上下文中取出生产线对象
MesWorkCenter workCenter = productionProcessContext.getWorkCenter();
//如果没有扫描信息, 取手选工单信息, 封装扫/读信息:加工单信息
List<MesEquipVariableCollectContext> equipVariableCollectContextList;
//优先验证扫描加工单
if (!StringUtils.isEmpty(scanInfo)) equipVariableCollectContextList = doHandleScanWorkOrderNoContext(reqBean, stepResult, scanInfo);
else equipVariableCollectContextList = doHandleScanWorkOrderNoContext(reqBean, stepResult);
//选择加工单
else equipVariableCollectContextList = doHandleScanWorkOrderNoContext(reqBean, stepResult, workCenter);
//扫描信息为空
if (CollectionUtils.isEmpty(equipVariableCollectContextList)) stepSendGuideAndThrowEx(reqBean, resultBean.writeDbLog(MesPcnEnumUtil.WORK_CELL_SCAN_MONITOR_LOG_TYPE.PROCESS.getValue()), "请扫描加工单!");
@ -101,7 +107,10 @@ public class MesWorkOrderScanStepService extends BaseStepService {
}
//封装扫/读信息:加工单信息 (选择)
private List<MesEquipVariableCollectContext> doHandleScanWorkOrderNoContext(StationRequestBean reqBean, StepResult stepResult) {
private List<MesEquipVariableCollectContext> doHandleScanWorkOrderNoContext(StationRequestBean reqBean, StepResult stepResult, MesWorkCenter workCenter) {
//排序线不支持选择加工单
if (workCenter.getCenterType().compareTo(MesExtEnumUtil.WORK_CENTER_TYPE.NOSORT.getValue()) != 0) return null;
//获取手动选择的腔数及工单信息上下文, 扫描的加工单也会存入其中
List<StationKvBean> chooseCavityOrder = productionProcessContextStepService.getFunctionChooseCavityOrderContext(reqBean);

@ -108,7 +108,7 @@ public class MesEquipVariableCollectContext implements Serializable {
//读取信息赋值
public void copyValue(MesEquipmentLog equipmentLog) {
if (null == equipmentLog) return;
BeanUtils.copyProperties(equipmentLog, this);
BeanUtils.copyProperties(equipmentLog, this, "categoryLevelTwo");
this.messageSource = MesExtEnumUtil.CELL_MESSAGE_SOURCE.READ.getValue();
}

@ -45,6 +45,12 @@ public class MesProductionPartContext implements Serializable {
@ApiParam("完成数量【不能用于业务计算】")
private Double completeQty;
@ApiParam("工单状态")
private Integer workOrderStatus;
@ApiParam("生产线代码")
private String workCenterCode;
@ApiParam("生产版本")
private String productVersion;
@ -67,6 +73,9 @@ public class MesProductionPartContext implements Serializable {
@ApiParam("是否空腔")
private Integer isFinishCode = CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue();
@ApiParam("零件生产组代码")
private String partProdGroupCode;
@ApiParam("信息来源")
private Integer messageSource;
@ -93,6 +102,10 @@ public class MesProductionPartContext implements Serializable {
@ApiParam("顺序防错结果")
private Integer checkSeqResult = MesPcnExtConstWords.ZERO;
//默认未验证, 验证失败需要同时标记【checkSeqResult】,但验证成功不需要标记【checkSeqResult】, 目前使用场景【通用汽车顺序防错验证客户订单号的流水号】
@ApiParam("附加客制化顺序防错结果")
private Integer customCheckSeqResult = MesPcnExtConstWords.ZERO;
//默认否
@ApiParam("业务验证之后需要清除的数据标志")
private Integer busiCheckToDelete = CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue();
@ -120,6 +133,11 @@ public class MesProductionPartContext implements Serializable {
return messageSource(messageSource);
}
public MesProductionPartContext isFinishCode() {
this.isFinishCode = CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue();
return this;
}
public MesProductionPartContext foreignKey(Integer foreignKey) {
this.foreignKey = foreignKey;
return this;

@ -43,6 +43,9 @@ public class MesProductionPsInContext implements Serializable {
@ApiParam("客户条码")
private String custSn;
@ApiParam("条码质量状态")
private Integer qcStatus;
@ApiParam("零件条码状态【用于发送设备加工参数】")
private Integer snStatus;

@ -178,6 +178,9 @@ public class MesPcnExtConstWords {
// 设备计数点位固定二级变量
public static final String SHOT_COUNTER = "shot_counter";
// 客制化条码长度:通用
public static final Integer CUSTOMER_SN_LENGTH_GM = 58;
// 时间格式
public static final String DATE_FORMAT_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
public static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

Loading…
Cancel
Save