diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/step/context/MesProductionProcessContextStepServiceBak.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/step/context/MesProductionProcessContextStepServiceBak.java new file mode 100644 index 0000000..9ad2191 --- /dev/null +++ b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/step/context/MesProductionProcessContextStepServiceBak.java @@ -0,0 +1,712 @@ +package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step.context; + +import cn.estsh.i3plus.ext.mes.pcn.api.base.IMesEquipmentExtService; +import cn.estsh.i3plus.ext.mes.pcn.api.base.IMesProdOrgExtService; +import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProductionProcessContextStepService; +import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesQueueOrderPushService; +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.IFsmRouteDataService; +import cn.estsh.i3plus.mes.pcn.api.iservice.base.IConfigService; +import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService; +import cn.estsh.i3plus.platform.common.tool.TimeTool; +import cn.estsh.i3plus.pojo.base.codemaker.SnowflakeIdMaker; +import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; +import cn.estsh.i3plus.pojo.mes.bean.*; +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.util.MesExtEnumUtil; +import com.alibaba.fastjson.JSONObject; +import com.alibaba.fastjson.TypeReference; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.BeanUtils; +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 : 获取生产过程上下文对象接口实现【BASE】 + * @Author : wangjie + **/ +@Slf4j +@Service("mesProductionProcessContextStepServiceBak") +public class MesProductionProcessContextStepServiceBak extends BaseStepService implements IMesProductionProcessContextStepService { + + @Autowired + private IMesProdOrgExtService prodOrgExtService; + + @Autowired + private IMesEquipmentExtService equipmentExtService; + + @Autowired + private IFsmRouteDataService fsmRouteDataService; + + @Autowired + private IConfigService configService; + + @Autowired + private IMesQueueOrderPushService queueOrderPushService; + + @Autowired + private SnowflakeIdMaker snowflakeIdMaker; + + private String getContextKey(StationRequestBean reqBean) { + return getFsmBusikey(reqBean, new StringJoiner(MesPcnExtConstWords.COLON).add(MesPcnExtConstWords.PRODUCTION_PROCESS_CONTEXT).add(MesPcnExtConstWords.BASE_DATA_CONTEXT).toString()); + } + + private String getContextKey(String organizeCode, String workCenterCode, String workCellCode) { + return new StringJoiner(MesPcnExtConstWords.COLON).add(organizeCode).add(workCenterCode).add(workCellCode).add(MesPcnExtConstWords.PRODUCTION_PROCESS_CONTEXT).add(MesPcnExtConstWords.BASE_DATA_CONTEXT).toString(); + } + + //清除上下文中的所有基础数据 + @Override + public void flushProductionProcessContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean)); + } + + //存储生产过程上下文对象【工步根据业务实际情况执行,配置错误等情况无需执行】 + @Override + public Boolean dispatchProductionProcessContext(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + if (!productionProcessContext.getIsNeedCache()) return true; + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.BASE_DATA_CONTEXT, JSONObject.toJSONString(productionProcessContext)); + } + + //获取生产过程上下文对象 + @Override + public MesProductionProcessContext getProductionProcessContext(StationRequestBean reqBean, Boolean isCheckProcess) { + + MesProductionProcessContext productionProcessContext = getProductionProcessContextBaseData(reqBean, isCheckProcess); + + //验证组织模型有效性 + return checkBaseData(reqBean, productionProcessContext, isCheckProcess); + + } + + //获取生产过程上下文对象 + @Override + public MesProductionProcessContext getProductionProcessContext(StationRequestBean reqBean) { + + MesProductionProcessContext productionProcessContext = getProductionProcessContextBaseData(reqBean, true); + + //验证组织模型有效性 + return checkBaseData(reqBean, productionProcessContext, true); + + } + + //获取生产过程上下文对象 + private MesProductionProcessContext getProductionProcessContextBaseData(StationRequestBean reqBean, Boolean isCheckProcess) { + + //获取缓存的生产过程上下文对象 + MesProductionProcessContext productionProcessContext = (MesProductionProcessContext) getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.BASE_DATA_CONTEXT, MesProductionProcessContext.class); + + if (null == productionProcessContext) productionProcessContext = new MesProductionProcessContext(reqBean.getOrganizeCode()); + + //生产过程上下文对象结果初始化 + productionProcessContext.success(); + + //生产过程上下文对象赋值生产线信息 + if (StringUtils.isEmpty(productionProcessContext.getWorkCenterJson())) productionProcessContext.workCenterJson(prodOrgExtService.getWorkCenterDb(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode())); + + //生产过程上下文对象赋值工位信息 + if (StringUtils.isEmpty(productionProcessContext.getWorkCellJson())) productionProcessContext.workCellJson(prodOrgExtService.getWorkCellDb(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), true)); + + //生产过程上下文对象赋值工序工艺信息 + if (isCheckProcess && (StringUtils.isEmpty(productionProcessContext.getProcessCode()) || !productionProcessContext.getProcessCode().equals(reqBean.getProcessCode()))) processContext(reqBean, productionProcessContext); + + //生产过程上下文对象赋值生产过程控制全局密码 + if (StringUtils.isEmpty(productionProcessContext.getFinishCode()) || StringUtils.isEmpty(productionProcessContext.getCraftJumpCode()) || + StringUtils.isEmpty(productionProcessContext.getAssemblySkipCode()) || StringUtils.isEmpty(productionProcessContext.getAssemblyCavitySkipCode()) || + StringUtils.isEmpty(productionProcessContext.getSortSuspiciousCode())) productionPwdContext(reqBean, productionProcessContext); + + return productionProcessContext; + + } + + //获取工序工艺信息 + @Override + public MesProductionProcessContext processContext(StationRequestBean reqBean) { + return processContext(reqBean, getProductionProcessContext(reqBean)); + } + + //获取工序工艺信息 + @Override + public MesProductionProcessContext processContext(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + + if (!productionProcessContext.getSuccess()) return productionProcessContext; + + if (!StringUtils.isEmpty(productionProcessContext.getProcessCode()) && productionProcessContext.getProcessCode().equals(reqBean.getProcessCode())) return productionProcessContext; + + MesProcessCraftCfg processCraftCfg = fsmRouteDataService.handleFsmProcessCraftData(reqBean, reqBean.getProcessCode()); + + //生产过程上下文对象赋值当前工艺工序,未配置默认赋值工序代码,不强验证 + productionProcessContext.processCode(reqBean.getProcessCode(), null != processCraftCfg ? processCraftCfg.getProcessName() : reqBean.getProcessCode()); + + return productionProcessContext.craftCode((null != processCraftCfg && !StringUtils.isEmpty(processCraftCfg.getCraftCode())) ? processCraftCfg.getCraftCode() : reqBean.getProcessCode(), + (null != processCraftCfg && !StringUtils.isEmpty(processCraftCfg.getCraftName())) ? processCraftCfg.getCraftName() : productionProcessContext.getProcessName()); + + } + + //获取生产过程控制全局密码 + @Override + public MesProductionProcessContext productionPwdContext(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + List configList = configService.doCachedConfigList(MesPcnExtConstWords.PRODUCTION_PWD_CFG, reqBean.getOrganizeCode()); + Map> cfgKeyMap = CollectionUtils.isEmpty(configList) ? null : configList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getCfgKey()))).collect(Collectors.groupingBy(MesConfig::getCfgKey)); + return productionProcessContext.finishCode((!CollectionUtils.isEmpty(cfgKeyMap) && cfgKeyMap.containsKey(MesPcnExtConstWords.CAVITY_FINISH_CODE)) ? cfgKeyMap.get(MesPcnExtConstWords.CAVITY_FINISH_CODE).get(0).getCfgValue() : MesPcnExtConstWords.CAVITY_FINISH_CODE) + .craftJumpCode((!CollectionUtils.isEmpty(cfgKeyMap) && cfgKeyMap.containsKey(MesPcnExtConstWords.CRAFT_JUMP_CODE)) ? cfgKeyMap.get(MesPcnExtConstWords.CRAFT_JUMP_CODE).get(0).getCfgValue() : MesPcnExtConstWords.CRAFT_JUMP_CODE) + .assemblySkipCode((!CollectionUtils.isEmpty(cfgKeyMap) && cfgKeyMap.containsKey(MesPcnExtConstWords.ASSEMBLY_SKIP_CODE)) ? cfgKeyMap.get(MesPcnExtConstWords.ASSEMBLY_SKIP_CODE).get(0).getCfgValue() : MesPcnExtConstWords.ASSEMBLY_SKIP_CODE) + .assemblyCavitySkipCode((!CollectionUtils.isEmpty(cfgKeyMap) && cfgKeyMap.containsKey(MesPcnExtConstWords.ASSEMBLY_CAVITY_SKIP_CODE)) ? cfgKeyMap.get(MesPcnExtConstWords.ASSEMBLY_CAVITY_SKIP_CODE).get(0).getCfgValue() : MesPcnExtConstWords.ASSEMBLY_CAVITY_SKIP_CODE) + .sortSuspiciousCode((!CollectionUtils.isEmpty(cfgKeyMap) && cfgKeyMap.containsKey(MesPcnExtConstWords.SORT_SUSPICIOUS_CODE)) ? cfgKeyMap.get(MesPcnExtConstWords.SORT_SUSPICIOUS_CODE).get(0).getCfgValue() : MesPcnExtConstWords.SORT_SUSPICIOUS_CODE); + } + + //验证组织模型有效性 + @Override + public MesProductionProcessContext checkBaseData(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext, Boolean isCheckProcess) { + + if (StringUtils.isEmpty(productionProcessContext.getWorkCenterJson())) return productionProcessContext.message(String.format("请检查组织模型生产线[%s]信息的有效性!", reqBean.getWorkCenterCode())); + + if (StringUtils.isEmpty(MesExtEnumUtil.WORK_CENTER_TYPE.valueOfDescription(productionProcessContext.getWorkCenter().getCenterType()))) return productionProcessContext.message(String.format("请检查组织模型生产线,生产线[%s]信息未设置产线类型!", reqBean.getWorkCenterCode())); + + if (StringUtils.isEmpty(productionProcessContext.getWorkCellJson())) return productionProcessContext.message(String.format("请检查组织模型生产线[%s]工位[%s]信息的有效性!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode())); + + if (isCheckProcess && StringUtils.isEmpty(productionProcessContext.getProcessCode())) return productionProcessContext.message(String.format("请检查工序信息,生产线[%s]工位[%s]对应工序代码[%s]的有效性!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), reqBean.getProcessCode())); + + return productionProcessContext; + + } + + //获取工位设备集合信息 + @Override + public MesProductionProcessContext getCellEquipmentList(StationRequestBean reqBean) { + return getCellEquipmentList(reqBean, getProductionProcessContext(reqBean)); + } + + //获取工位设备集合信息 + @Override + public MesProductionProcessContext getCellEquipmentList(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + + if (!productionProcessContext.getSuccess()) return productionProcessContext; + + //生产过程上下文对象赋值设备信息 + if (StringUtils.isEmpty(productionProcessContext.getCellEquipListJson())) productionProcessContext.cellEquipListJson(equipmentExtService.getCellEquipmentList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode())); + + return productionProcessContext; + + } + + //获取工位当前设备信息 + @Override + public MesProductionProcessContext dispatchCurCellEquipment(StationRequestBean reqBean) { + return dispatchCurCellEquipment(reqBean, getCellEquipmentList(reqBean)); + } + + //获取工位当前设备信息 + @Override + public MesProductionProcessContext dispatchCurCellEquipment(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + + if (!productionProcessContext.getSuccess()) return productionProcessContext; + + return dispatchCurCellEquipment(reqBean, productionProcessContext, getStepParams(reqBean)); + + } + + //获取工位当前设备信息 + @Override + public MesProductionProcessContext dispatchCurCellEquipment(StationRequestBean reqBean, Optional> stepParamMap) { + return dispatchCurCellEquipment(reqBean, getCellEquipmentList(reqBean), stepParamMap); + } + + //获取工位当前设备信息 + @Override + public MesProductionProcessContext dispatchCurCellEquipment(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext, Optional> stepParamMap) { + + if (!productionProcessContext.getSuccess()) return productionProcessContext; + + if (StringUtils.isEmpty(productionProcessContext.getCellEquipListJson())) getCellEquipmentList(reqBean, productionProcessContext); + + //获取当前工步的设备参数 + String equipmentCode = (null != stepParamMap && stepParamMap.isPresent() && stepParamMap.get().containsKey(MesPcnExtConstWords.EQUIPMENT_CODE_UC)) ? stepParamMap.get().get(MesPcnExtConstWords.EQUIPMENT_CODE_UC).getParamValue() : null; + + //判断生产过程上下文对象是否存在当前设备信息 + if (!StringUtils.isEmpty(productionProcessContext.getCurCellEquipJson()) && (StringUtils.isEmpty(equipmentCode) || equipmentCode.equals(productionProcessContext.getCurCellEquip().getEquipmentCode()))) return productionProcessContext; + + //从工位设备集合信息中获取当前设备信息 + MesCellEquipContext cellEquipmentContext = productionProcessContext.filterCurCellEquip(equipmentCode); + + //保存上下文工位扫描监控信息【设备信息】 + if (null != cellEquipmentContext) dispatchScanMonitorContext(reqBean, + dispatchScanMonitorContext(reqBean, true).equipment(cellEquipmentContext.getEquipId(), cellEquipmentContext.getEquipmentCode(), cellEquipmentContext.getEquipmentName()), false); + + //生产过程上下文对象赋值当前设备代码 + if (null != cellEquipmentContext) return productionProcessContext.curCellEquipJson(cellEquipmentContext.kepwareFlagJson(equipmentExtService.getEquipmentChannelList(reqBean.getOrganizeCode(), cellEquipmentContext.getEquipmentCode()))); + + return StringUtils.isEmpty(equipmentCode) ? productionProcessContext.message(String.format("请检查组织模型,生产线[%s]工位[%s]未维护设备信息!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode())) : + productionProcessContext.message(String.format("请检查组织模型,生产线[%s]工位[%s]未维护工步参数[%s]配置的设备[%s]!", reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), MesPcnExtConstWords.EQUIPMENT_CODE_UC, equipmentCode)); + + } + + //获取设备数据变量接口逻辑信息 + @Override + public MesProductionProcessContext getEquipmentVariableCfgList(StationRequestBean reqBean) { + return getEquipmentVariableCfgList(dispatchCurCellEquipment(reqBean)); + } + + //获取设备数据变量接口逻辑信息 + @Override + public MesProductionProcessContext getEquipmentVariableCfgList(MesProductionProcessContext productionProcessContext) { + + if (!productionProcessContext.getSuccess()) return productionProcessContext; + + //判断生产过程上下文对象是否存在数据变量接口逻辑信息 + if (!CollectionUtils.isEmpty(productionProcessContext.getEquipVariableCfgListByVct())) return productionProcessContext; + + MesCellEquipContext cellEquipmentContext = productionProcessContext.getCurCellEquip(); + + if (null == cellEquipmentContext || !productionProcessContext.getSuccess()) return productionProcessContext; + + List equipmentVariableCfgList = equipmentExtService.getEquipmentVariableCfgList(productionProcessContext.getOrganizeCode(), cellEquipmentContext.getVariableCfgType()); + + //生产过程上下文对象赋值设备数据变量接口逻辑集合信息 + if (!CollectionUtils.isEmpty(equipmentVariableCfgList)) productionProcessContext.equipVariableCfgJson(equipmentVariableCfgList); + + return productionProcessContext; + + } + + //根据变量类别搜集设备数据变量接口逻辑信息 + @Override + public List collectEquipmentVariableCfgList(List equipmentVariableCfgList, String... variableCategory) { + List variableCategoryList = null == variableCategory ? null : Arrays.asList(variableCategory); + return (CollectionUtils.isEmpty(equipmentVariableCfgList) || CollectionUtils.isEmpty(variableCategoryList)) ? null : equipmentVariableCfgList.stream().filter(o -> (null != o && variableCategoryList.contains(o.getVariableCategory()))).collect(Collectors.toList()); + } + + //验证设备数据变量接口逻辑信息中是否存在必要的变量类型信息 + @Override + public MesProductionProcessContext checkNecessaryEquipmentVariableCfg(MesProductionProcessContext productionProcessContext, MesCellEquipContext cellEquipContext, List equipmentVariableCfgList, String... variableCategory) { + List variableCategoryList = null == variableCategory ? null : Arrays.asList(variableCategory); + Optional optional = (CollectionUtils.isEmpty(equipmentVariableCfgList) || CollectionUtils.isEmpty(variableCategoryList)) ? null : equipmentVariableCfgList.stream().filter(o -> (null != o && variableCategoryList.contains(o.getVariableCategory()))).findFirst(); + return (null != optional && optional.isPresent()) ? productionProcessContext : productionProcessContext.message(String.format("请检查设备数据变量接口逻辑信息,设备[%s]未配置变量配置类型[%s]变量类别%s相关的数据变量接口逻辑信息!", cellEquipContext.getEquipmentName(), cellEquipContext.getVariableCfgType(), variableCategoryList.toString())); + } + + //验证设备数据变量接口逻辑信息中是否存在必要的变量类型信息,并且参考值不能为空 + @Override + public MesProductionProcessContext checkNecessaryEquipmentVariableCfgAndValue(MesProductionProcessContext productionProcessContext, MesCellEquipContext cellEquipContext, List equipmentVariableCfgList, String... variableCategory) { + List variableCategoryList = null == variableCategory ? null : Arrays.asList(variableCategory); + List filterList = (CollectionUtils.isEmpty(equipmentVariableCfgList) || CollectionUtils.isEmpty(variableCategoryList)) ? null : equipmentVariableCfgList.stream().filter(o -> (null != o && variableCategoryList.contains(o.getVariableCategory()))).collect(Collectors.toList()); + Optional optional = CollectionUtils.isEmpty(filterList) ? null : filterList.stream().filter(o -> (null != o && StringUtils.isEmpty(o.getValue()))).findFirst(); + return (!CollectionUtils.isEmpty(filterList) && (null == optional || !optional.isPresent())) ? productionProcessContext : productionProcessContext.message(String.format("请检查设备数据变量接口逻辑信息,设备[%s]未配置有效的变量配置类型[%s]变量类别%s相关的数据变量接口逻辑信息!", cellEquipContext.getEquipmentName(), cellEquipContext.getVariableCfgType(), variableCategoryList.toString())); + } + + //搜集设备数据变量接口逻辑信息中的二级变量 + @Override + public List collectCategoryLevelTwoList(List equipmentVariableCfgList) { + return CollectionUtils.isEmpty(equipmentVariableCfgList) ? null : + (equipmentVariableCfgList.stream().filter(o -> null != o).map(MesEquipmentVariableCfg::getCategoryLevelTwo).collect(Collectors.toList())).stream().filter(o -> !StringUtils.isEmpty(o)).distinct().collect(Collectors.toList()); + } + + //获取设备数据变量信息 + @Override + public MesProductionProcessContext getEquipmentVariableList(StationRequestBean reqBean, Integer variableType) { + return getEquipmentVariableList(getEquipmentVariableCfgList(reqBean), variableType); + } + + //获取设备数据变量信息 + @Override + public MesProductionProcessContext getEquipmentVariableList(MesProductionProcessContext productionProcessContext, Integer variableType) { + + if (!productionProcessContext.getSuccess() || StringUtils.isEmpty(variableType)) return productionProcessContext; + + MesCellEquipContext cellEquipmentContext = productionProcessContext.getCurCellEquip(); + + //判断生产过程上下文对象是否存在数据变量信息 + if (!CollectionUtils.isEmpty(productionProcessContext.getEquipVariableListByEquVt(cellEquipmentContext.getEquipmentCode(), variableType))) return productionProcessContext; + + List equipmentVariableDbList = equipmentExtService.getEquipmentVariableList(productionProcessContext.getOrganizeCode(), cellEquipmentContext.getEquipmentCode(), variableType); + + //生产过程上下文对象赋值设备数据变量信息 + if (null != equipmentVariableDbList) productionProcessContext.equipVariableJson(equipmentVariableDbList); + + return productionProcessContext; + + } + + //获取设备数据变量信息 + @Override + public List findEquipmentVariableList(MesProductionProcessContext productionProcessContext, Integer variableType) { + + if (!productionProcessContext.getSuccess() || StringUtils.isEmpty(variableType)) return null; + + MesCellEquipContext cellEquipmentContext = productionProcessContext.getCurCellEquip(); + + //判断生产过程上下文对象是否存在数据变量信息 + List equipmentVariableDbList = productionProcessContext.getEquipVariableListByEquVt(cellEquipmentContext.getEquipmentCode(), variableType); + if (!CollectionUtils.isEmpty(equipmentVariableDbList)) return equipmentVariableDbList; + + equipmentVariableDbList = equipmentExtService.getEquipmentVariableList(productionProcessContext.getOrganizeCode(), cellEquipmentContext.getEquipmentCode(), variableType); + + //生产过程上下文对象赋值设备数据变量信息 + if (null != equipmentVariableDbList) productionProcessContext.equipVariableJson(equipmentVariableDbList); + + return equipmentVariableDbList; + + } + + //根据变量类型与二级变量获取设备数据变量信息 + @Override + public List findEquipmentVariableList(MesProductionProcessContext productionProcessContext, Integer variableType, List categoryLevelTwoList) { + List equipmentVariableList = findEquipmentVariableList(productionProcessContext, variableType); + return findEquipmentVariableList(equipmentVariableList, variableType, categoryLevelTwoList); + } + + //获取设备数据变量信息 + @Override + public List findEquipmentVariableList(List equipmentVariableList, Integer variableType, List categoryLevelTwoList) { + return (CollectionUtils.isEmpty(equipmentVariableList) || CollectionUtils.isEmpty(categoryLevelTwoList)) ? null : + equipmentVariableList.stream().filter(o -> (null != o && categoryLevelTwoList.contains(o.getCategoryLevelTwo()) && o.getVariableType().compareTo(variableType) == 0)).collect(Collectors.toList()); + } + + //验证设备数据变量信息是否为空 + @Override + public MesProductionProcessContext checkIsEmptyEquipmentVariableList(MesProductionProcessContext productionProcessContext, MesCellEquipContext cellEquipContext, List equipmentVariableList, MesExtEnumUtil.EQUIP_VARIABLE_TYPE variableType, List categoryLevelTwoList) { + if (!CollectionUtils.isEmpty(equipmentVariableList)) return productionProcessContext; + return productionProcessContext.message(String.format("请检查设备数据变量信息,根据设备[%s]对应的数据变量接口逻辑信息,未配置变量类型[%s]二级变量%s相关的数据变量信息!", cellEquipContext.getEquipmentName(), variableType.getDescription(), categoryLevelTwoList.toString())); + } + + //查询工位设备装配件规则信息 + @Override + public List findAssemblyNosortCfgList(StationRequestBean reqBean) { + String assemblyNosortCfgJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.ASSEMBLY_NOSORT_CFG_CONTEXT); + return !StringUtils.isEmpty(assemblyNosortCfgJson) ? JSONObject.parseArray(assemblyNosortCfgJson, MesProductionAssemblyNosortContext.class) : null; + } + + //存储设备的装配件清单 + @Override + public Boolean dispatchAssemblyNosortCfgContext(StationRequestBean reqBean, List assemblyNosortCfgList) { + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.ASSEMBLY_NOSORT_CFG_CONTEXT, JSONObject.toJSONString(assemblyNosortCfgList)); + } + + //获取上下文零件数据信息 + @Override + public Map getPartDataContext(StationRequestBean reqBean) { + String partDataJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PART_DATA_CONTEXT); + return !StringUtils.isEmpty(partDataJson) ? JSONObject.parseObject(partDataJson, new TypeReference>() {}) : null; + } + + //获取上下文零件数据信息 + @Override + public Map getPartDataExtContext(StationRequestBean reqBean) { + String partDataJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PART_DATA_CONTEXT); + return !StringUtils.isEmpty(partDataJson) ? JSONObject.parseObject(partDataJson, new TypeReference>() {}) : null; + } + + //获取上下文零件数据信息 + @Override + public Map getPartDataContext(StationRequestBean reqBean, Boolean isExt) { + String partDataJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PART_DATA_CONTEXT); + return !StringUtils.isEmpty(partDataJson) ? + (!isExt ? JSONObject.parseObject(partDataJson, new TypeReference>() {}) : JSONObject.parseObject(partDataJson, new TypeReference>() {})) : null; + } + + //保存上下文零件数据信息 [JSON]Map + @Override + public Boolean dispatchPartDataContext(StationRequestBean reqBean, Map partDataMap) { + if (CollectionUtils.isEmpty(partDataMap)) return false; + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PART_DATA_CONTEXT, JSONObject.toJSONString(partDataMap)); + } + + //删除上下文零件数据信息 + @Override + public void removePartDataContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PART_DATA_CONTEXT); + } + + //获取手动选择的腔数及工单信息上下文 + @Override + public List getFunctionChooseCavityOrderContext(StationRequestBean reqBean) { + String chooseCavityOrderJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_CAVITY_ORDER); + return !StringUtils.isEmpty(chooseCavityOrderJson) ? JSONObject.parseArray(chooseCavityOrderJson, StationKvBean.class) : null; + } + + //保存选择/扫描/读取的腔数及工单信息上下文 腔数=工单个数 数据格式: [StationKvBean(key=cavity, name=腔数, value=3, seq=0), StationKvBean(key=cellMessageSource, name=工位信息来源, value=10, seq=1), StationKvBean(key=workOrderNo, name=加工单, value=工单1;工单2;工单3, seq=2)] + @Override + public Boolean dispatchFunctionChooseCavityOrderContext(StationRequestBean reqBean, List resultList) { + if (CollectionUtils.isEmpty(resultList)) return false; + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_CAVITY_ORDER, JSONObject.toJSONString(resultList)); + } + + //删除手动选择的腔数及工单信息上下文 + @Override + public void removeFunctionChooseCavityOrderContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_CAVITY_ORDER); + } + + //获取手动选择的腔数及零件信息上下文 + @Override + public List getFunctionChooseCavityPartContext(StationRequestBean reqBean) { + String chooseCavityPartJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_CAVITY_PART); + return !StringUtils.isEmpty(chooseCavityPartJson) ? JSONObject.parseArray(chooseCavityPartJson, StationKvBean.class) : null; + } + + //保存选择/扫描/读取的腔数及零件信息上下文 腔数=工单个数 数据格式: [StationKvBean(key=cavity, name=腔数, value=3, seq=0), StationKvBean(key=cellMessageSource, name=工位信息来源, value=10, seq=1), StationKvBean(key=partNo, name=零件编码, value=零件1;零件2;零件3, seq=2)] + @Override + public Boolean dispatchFunctionChooseCavityPartContext(StationRequestBean reqBean, List resultList) { + if (CollectionUtils.isEmpty(resultList)) return false; + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_CAVITY_PART, JSONObject.toJSONString(resultList)); + } + + //删除手动选择的腔数及工单信息上下文 + @Override + public void removeFunctionChooseCavityPartContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_CAVITY_PART); + } + + //获取上下文工位扫描监控信息, 没有就重新封装工位扫描监控信息, 同时处理基础上下文信息 【其他地方调用 isSave 必须传 true 】 + @Override + public MesScanMonitorContext dispatchScanMonitorContext(StationRequestBean reqBean, Boolean isSave) { + + MesScanMonitorContext scanMonitorContext = getScanMonitorContext(reqBean); + + //封装工位扫描监控信息, 同时处理基础上下文信息 + if (null == scanMonitorContext) { + + //获取生产过程上下文对象 + MesProductionProcessContext productionProcessContext = getProductionProcessContext(reqBean); + + //存储生产过程上下文对象 + dispatchProductionProcessContext(reqBean, productionProcessContext); + + scanMonitorContext = new MesScanMonitorContext(reqBean.getOrganizeCode(), + productionProcessContext.getProcessCode(), productionProcessContext.getProcessName(), productionProcessContext.getCraftCode(), productionProcessContext.getCraftName()); + + MesWorkCell workCell = productionProcessContext.getWorkCell(); + + if (null != workCell) BeanUtils.copyProperties(workCell, scanMonitorContext); + + if (isSave) dispatchScanMonitorContext(reqBean, scanMonitorContext, true); + + } + + return scanMonitorContext; + + } + + //保存上下文工位扫描监控信息 + @Override + public Boolean dispatchScanMonitorContext(StationRequestBean reqBean) { + MesScanMonitorContext scanMonitorContext = dispatchScanMonitorContext(reqBean, false); + return dispatchScanMonitorContext(reqBean, scanMonitorContext, true); + } + + //保存上下文工位扫描监控信息 + private Boolean dispatchScanMonitorContext(StationRequestBean reqBean, MesScanMonitorContext scanMonitorContext, Boolean isSetMouldRecordId) { + if (null == scanMonitorContext) return false; + //开模记录ID, 工序开始时间 + if (isSetMouldRecordId) scanMonitorContext.mouldRecordId(snowflakeIdMaker.nextId()).startDateTime(TimeTool.getNowTime(true)); + log.info("工厂{}生产线{}工位{}:工序缓存工位扫描监控信息:{}", reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode(), JSONObject.toJSONString(scanMonitorContext)); + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.SCAN_MONITOR_CONTEXT, JSONObject.toJSONString(scanMonitorContext)); + } + + //获取上下文工位扫描监控信息 + private MesScanMonitorContext getScanMonitorContext(StationRequestBean reqBean) { + String scanMonitorContextJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.SCAN_MONITOR_CONTEXT); + return !StringUtils.isEmpty(scanMonitorContextJson) ? JSONObject.parseObject(scanMonitorContextJson, MesScanMonitorContext.class) : null; + } + + //获取上下文工位扫描监控信息的开模记录ID + @Override + public String getScanMonitorContextMouldRecordId(StationRequestBean reqBean) { + MesScanMonitorContext scanMonitorContext = getScanMonitorContext(reqBean); + return (null != scanMonitorContext && !StringUtils.isEmpty(scanMonitorContext.getMouldRecordId())) ? scanMonitorContext.getMouldRecordId().toString() : null; + } + + //获取上下文工位扫描监控信息 + @Override + public MesScanMonitorContext getScanMonitorContext(String organizeCode, String workCenterCode, String workCellCode) { + String scanMonitorContextJson = getFsmBusiData(organizeCode, getContextKey(organizeCode, workCenterCode, workCellCode), MesPcnExtConstWords.SCAN_MONITOR_CONTEXT); + return !StringUtils.isEmpty(scanMonitorContextJson) ? JSONObject.parseObject(scanMonitorContextJson, MesScanMonitorContext.class) : null; + } + + //删除上下文工位扫描监控信息 + @Override + public void removeScanMonitorContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.SCAN_MONITOR_CONTEXT); + } + + //获取生产线类型 + @Override + public Integer getCenterType(StationRequestBean reqBean) { + if (!StringUtils.isEmpty(reqBean.getCenterType())) return reqBean.getCenterType(); + MesProductionProcessContext productionProcessContext = getProductionProcessContext(reqBean, false); + //获取生产过程上下文对象有异常信息 抛出异常 + if (!productionProcessContext.getSuccess()) stepExpSendMsgAndThrowEx(reqBean, new StationResultBean().writeDbLog(), productionProcessContext.getMessage()); + dispatchProductionProcessContext(reqBean, productionProcessContext); + reqBean.setCenterType(productionProcessContext.getWorkCenter().getCenterType()); + return reqBean.getCenterType(); + } + + //获取生产线下的工位集合 + @Override + public Map dispatchWorkCellMap(StationRequestBean reqBean) { + String workCellMapJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.WORK_CELL_MAP_CONTEXT); + if (!StringUtils.isEmpty(workCellMapJson)) return JSONObject.parseObject(workCellMapJson, new TypeReference>() {}); + List workCellList = prodOrgExtService.getWorkCellList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode()); + Map workCellMap = CollectionUtils.isEmpty(workCellList) ? null : workCellList.stream().filter(o -> null != o).collect(Collectors.toMap(MesWorkCell::getWorkCellCode, o -> o)); + if (!CollectionUtils.isEmpty(workCellList)) dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.WORK_CELL_MAP_CONTEXT, JSONObject.toJSONString(workCellMap)); + return workCellMap; + } + + //获取包装规则信息 + @Override + public Map getPackageRuleContext(StationRequestBean reqBean) { + String packageRuleContextJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PACKAGE_RULE_CONTEXT); + return !StringUtils.isEmpty(packageRuleContextJson) ? JSONObject.parseObject(packageRuleContextJson, new TypeReference>() {}): null; + } + + //保存包装规则信息 + @Override + public Boolean dispatchPackageRuleContext(StationRequestBean reqBean, Map packageRuleContextMap) { + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PACKAGE_RULE_CONTEXT, JSONObject.toJSONString(packageRuleContextMap)); + } + + //删除包装规则信息 + @Override + public void removePackageRuleContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PACKAGE_RULE_CONTEXT); + } + + //获取设备点检上下文对象 + @Override + public MesEquipSpotCheckContext dispatchEquipSpotCheckContext(StationRequestBean reqBean, String equipmentCode) { + String item = new StringJoiner(MesPcnExtConstWords.AND).add(MesPcnExtConstWords.EQUIP_SPOT_CHECK_CONTEXT).add(equipmentCode).toString(); + String equipSpotCheckContextJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), item); + if (!StringUtils.isEmpty(equipSpotCheckContextJson)) return JSONObject.parseObject(equipSpotCheckContextJson, MesEquipSpotCheckContext.class); + MesEquipSpotCheckContext equipSpotCheckContext = equipmentExtService.getEquipSpotCheckContext(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), equipmentCode); + if (null != equipSpotCheckContext) dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), item, JSONObject.toJSONString(equipSpotCheckContext)); + return equipSpotCheckContext; + } + + //获取选择/扫描零件发运组信息上下文 + @Override + public List getFunctionChooseShippingGroupContext(StationRequestBean reqBean) { + String chooseCavityOrderJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_SHIPPING_GROUP); + return !StringUtils.isEmpty(chooseCavityOrderJson) ? JSONObject.parseArray(chooseCavityOrderJson, StationKvBean.class) : null; + } + + //保存选择/扫描零件发运组信息上下文 腔数=工单个数 数据格式: [StationKvBean(key=shippingGroupCode, name=零件发运组代码, value=xxx, seq=0), StationKvBean(key=cellMessageSource, name=工位信息来源, value=10, seq=1)] + @Override + public Boolean dispatchFunctionChooseShippingGroupContext(StationRequestBean reqBean, List resultList) { + if (CollectionUtils.isEmpty(resultList)) return false; + return dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_SHIPPING_GROUP, JSONObject.toJSONString(resultList)); + } + + //删除选择/扫描零件发运组信息上下文 + @Override + public void removeFunctionChooseShippingGroupContext(StationRequestBean reqBean) { + removeFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.FUNCTION_CHOOSE_SHIPPING_GROUP); + } + + //处理加工不可用规则 + @Override + public MesProductionProcessContext dispatchProdRuleIgnoreCfgContext(StationRequestBean reqBean) { + return dispatchProdRuleIgnoreCfgContext(reqBean, getCellEquipmentList(reqBean)); + } + + //处理加工不可用规则 + @Override + public MesProductionProcessContext dispatchProdRuleIgnoreCfgContext(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + MesCellEquipContext cellEquipmentContext = productionProcessContext.getCurCellEquip(); + if (null == cellEquipmentContext) cellEquipmentContext = dispatchCurCellEquipment(reqBean, productionProcessContext).getCurCellEquip(); + if (!productionProcessContext.getSuccess() || !StringUtils.isEmpty(productionProcessContext.getProdRuleIgnoreCfg())) return productionProcessContext; + + List prodRuleIgnoreCfgList; + if (getCenterType(reqBean).compareTo(MesExtEnumUtil.WORK_CENTER_TYPE.NOSORT.getValue()) == 0) { + //如果是非排序线, 则根据工位当前设备代码查询加工不可用规则信息 + prodRuleIgnoreCfgList = equipmentExtService.getProdRuleIgnoreCfgListByEquip(reqBean.getOrganizeCode(), cellEquipmentContext.getEquipmentCode()); + } else if (!StringUtils.isEmpty(productionProcessContext.getWorkCell().getIsEndWorkCell()) && productionProcessContext.getWorkCell().getIsEndWorkCell().compareTo(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) == 0) { + //如果是排序线末道工位,需要查询生产线所有设备的不可用规则, 因为末道工位可能会补装配前道 + prodRuleIgnoreCfgList = equipmentExtService.getProdRuleIgnoreCfgListByCenter(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode()); + } else { + //如果是排序线,需要查询当前工位下所有设备的不可用规则, 排序线一个工位对应多个设备, 例如不同扭距枪的装配件对应不同的设备 + prodRuleIgnoreCfgList = equipmentExtService.getProdRuleIgnoreCfgListByCell(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode()); + } + + //存储不可用规则到上下文 + if (!CollectionUtils.isEmpty(prodRuleIgnoreCfgList)) { + dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PROD_RULE_IGNORE_CFG_CONTEXT, JSONObject.toJSONString(prodRuleIgnoreCfgList)); + } + + productionProcessContext.prodRuleIgnoreCfg(!CollectionUtils.isEmpty(prodRuleIgnoreCfgList) ? CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValueStr() : CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValueStr()).isNeedCache(); + return productionProcessContext; + } + + //获取加工不可用规则 + @Override + public List getProdRuleIgnoreCfgContext(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + if (StringUtils.isEmpty(productionProcessContext.getProdRuleIgnoreCfg())) dispatchProductionProcessContext(reqBean, dispatchProdRuleIgnoreCfgContext(reqBean, productionProcessContext)); + if (!productionProcessContext.getSuccess()) return null; + if (StringUtils.isEmpty(productionProcessContext.getProdRuleIgnoreCfg()) || productionProcessContext.getProdRuleIgnoreCfg().equals(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValueStr())) return null; + String prodRuleIgnoreCfgContextJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.PROD_RULE_IGNORE_CFG_CONTEXT); + return !StringUtils.isEmpty(prodRuleIgnoreCfgContextJson) ? JSONObject.parseArray(prodRuleIgnoreCfgContextJson, MesProdRuleIgnoreCfg.class) : null; + } + + //获取加工不可用规则, key = 数据来源&来源ID + @Override + public Map> getProdRuleIgnoreCfgContextMap(StationRequestBean reqBean, MesProductionProcessContext productionProcessContext) { + List prodRuleIgnoreCfgList = getProdRuleIgnoreCfgContext(reqBean, productionProcessContext); + return CollectionUtils.isEmpty(prodRuleIgnoreCfgList) ? null : + prodRuleIgnoreCfgList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getDataSource()) && !StringUtils.isEmpty(o.getSourceId()))) + .collect(Collectors.groupingBy(o -> new StringJoiner(MesPcnExtConstWords.AND).add(o.getDataSource().toString()).add(o.getEquipmentCode()).add(o.getSourceId().toString()).toString())); + } + + //处理排序线推单配置上下文, 返回推送工位类型对应的配置信息 + @Override + public List dispatchQueueOrderPushCellCfgContext(StationRequestBean reqBean, Integer pushType) { + List queueOrderPushCellCfgList = dispatchQueueOrderPushCellCfgContext(reqBean); + return CollectionUtils.isEmpty(queueOrderPushCellCfgList) ? null : + queueOrderPushCellCfgList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getPushType()) && o.getPushType().compareTo(pushType) == 0)).collect(Collectors.toList()); + } + + //处理排序线推单配置上下文 + private List dispatchQueueOrderPushCellCfgContext(StationRequestBean reqBean) { + String queuePushCfgJson = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.QUEUE_PUSH_CFG_CONTEXT); + if (!StringUtils.isEmpty(queuePushCfgJson)) return JSONObject.parseArray(queuePushCfgJson, MesQueueOrderPushCellCfg.class); + //根据生产线代码查询生产队列推送工位配置信息 + List queueOrderPushCellCfgList = queueOrderPushService.getQueueOrderPushCellCfgList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode()); + //搜集该工位对应的配置信息 + List filterList = CollectionUtils.isEmpty(queueOrderPushCellCfgList) ? null : + queueOrderPushCellCfgList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getPushSourceCode()) && + !StringUtils.isEmpty(o.getPushType()) && !StringUtils.isEmpty(o.getWorkCellCode()) && o.getWorkCellCode().equals(reqBean.getWorkCellCode()))).collect(Collectors.toList()); + + if (CollectionUtils.isEmpty(filterList)) return null; + + //验证是否存在查询队列需要考虑竞争的代码, 赋值是否需要锁定 + for (MesQueueOrderPushCellCfg queueOrderPushCellCfg : filterList) { + if (null == queueOrderPushCellCfg || queueOrderPushCellCfg.getPushType().compareTo(MesExtEnumUtil.QUEUE_ORDER_CELL_PUSH_TYPE.SOURCE.getValue()) == 0) continue; + Optional optional = queueOrderPushCellCfgList.stream().filter(o -> (null != o + && !StringUtils.isEmpty(o.getWorkCellCode()) && !o.getWorkCellCode().equals(reqBean.getWorkCellCode()) + && !StringUtils.isEmpty(o.getPushType()) && o.getPushType().compareTo(MesExtEnumUtil.QUEUE_ORDER_CELL_PUSH_TYPE.TARGET.getValue()) == 0) + && !StringUtils.isEmpty(o.getPushSourceCode()) && o.getPushSourceCode().equals(queueOrderPushCellCfg.getPushSourceCode())).findFirst(); + if (null != optional && optional.isPresent()) queueOrderPushCellCfg.setIsNeedLock(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValueStr()); + } + + //保存排序线推单配置上下文 + if (!CollectionUtils.isEmpty(queueOrderPushCellCfgList)) dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.QUEUE_PUSH_CFG_CONTEXT, JSONObject.toJSONString(filterList)); + return filterList; + } + + @Override + public List disPatchWorkCellPartPrinterCfg(StationRequestBean reqBean, Boolean pcNosortPrinterCfg) { + if (!pcNosortPrinterCfg) return null; + String context = getFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.CELL_PART_PRINTER_CONTEXT); + if (!StringUtils.isEmpty(context)) return context.equals(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValueStr()) ? null : JSONObject.parseArray(context, MesWorkCellPartPrinterCfg.class); + List workCellPartPrinterCfgList = prodOrgExtService.getWorkCellPartPrinterCfgList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), reqBean.getWorkCellCode()); + dispatchFsmBusiData(reqBean.getOrganizeCode(), getContextKey(reqBean), MesPcnExtConstWords.CELL_PART_PRINTER_CONTEXT, + !CollectionUtils.isEmpty(workCellPartPrinterCfgList) ? JSONObject.toJSONString(workCellPartPrinterCfgList) : CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValueStr()); + return workCellPartPrinterCfgList; + } + +} diff --git a/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/context/MesProductionProcessContextBak.java b/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/context/MesProductionProcessContextBak.java new file mode 100644 index 0000000..ea0bec7 --- /dev/null +++ b/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/context/MesProductionProcessContextBak.java @@ -0,0 +1,338 @@ +package cn.estsh.i3plus.ext.mes.pcn.pojo.context; + +import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords; +import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; +import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentVariable; +import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentVariableCfg; +import cn.estsh.i3plus.pojo.mes.bean.MesWorkCell; +import cn.estsh.i3plus.pojo.mes.bean.MesWorkCenter; +import com.alibaba.fastjson.JSONObject; +import com.fasterxml.jackson.annotation.JsonIgnore; +import io.swagger.annotations.ApiParam; +import lombok.Data; +import org.springframework.util.CollectionUtils; +import org.springframework.util.StringUtils; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.TreeSet; +import java.util.stream.Collectors; + +/** + * 生产过程上下文对象 + */ +@Data +public class MesProductionProcessContextBak implements Serializable { + + private static final long serialVersionUID = -3254149531982045058L; + + @ApiParam("结果") + private Boolean success; + + @ApiParam("信息") + private String message; + + @ApiParam("是否需要重新存储") + private Boolean isNeedCache; + + @ApiParam("是否存在加工不可用规则") + private String prodRuleIgnoreCfg; + + @ApiParam("组织代码") + private String organizeCode; + + @ApiParam("finishCode码") + private String finishCode; + + @ApiParam("工艺强过码") + private String craftJumpCode; + + @ApiParam("装配件跳过码") + private String assemblySkipCode; + + @ApiParam("装配件整腔跳过码") + private String assemblyCavitySkipCode; + + @ApiParam("排序线可疑码") + private String sortSuspiciousCode; + + @ApiParam("生产线信息([Json]MesWorkCenter)") + private String workCenterJson; + + @ApiParam("工位信息([Json]MesWorkCell)") + private String workCellJson; + + @ApiParam("工位设备信息([Json]List)") + private String cellEquipListJson; + + @ApiParam("工序代码") + private String processCode; + + @ApiParam("工序名称") + private String processName; + + @ApiParam("工艺代码") + private String craftCode; + + @ApiParam("工艺名称") + private String craftName; + + @JsonIgnore + @ApiParam("当前工步参数的设备对象([Json]MesCellEquipContext)") + private String curStepParamEquipJson; + + @ApiParam("当前工位设备对象([Json]MesCellEquipContext)") + private String curCellEquipJson; + + @ApiParam("变量接口逻辑信息([Json]List)") + private String equipVariableCfgJson; + + @ApiParam("设备变量集合信息([Json]List)") + private String equipVariableJson; + + //---------------------- 构造方法 --------------------------------------- + + public MesProductionProcessContextBak() {} + + public MesProductionProcessContextBak(String organizeCode) { + this.organizeCode = organizeCode; + } + + //---------------------- 信息初始化/赋值 --------------------------------------- + + //上下文信息结果初始化 + public MesProductionProcessContextBak success() { + this.success = true; + this.isNeedCache = false; + this.message = null; + return this; + } + + //手动赋结果 + public MesProductionProcessContextBak success(Boolean success) { + this.success = success; + return this; + } + + //手动赋是否缓存的标志（大部分工步最后都会保存上下文,最终实际根据此标志识别是否需要保存） + public MesProductionProcessContextBak isNeedCache() { + this.isNeedCache = true; + return this; + } + + //手动赋是否存在加工不可用规则 + public MesProductionProcessContextBak prodRuleIgnoreCfg(String prodRuleIgnoreCfg) { + this.prodRuleIgnoreCfg = prodRuleIgnoreCfg; + return this; + } + + //上下文信息结果信息赋值后给工步使用 + public MesProductionProcessContextBak message(String message) { + this.success = false; + this.message = message; + return this; + } + + //---------------------- 生产过程控制全局密码 --------------------------------------- + + //上下文赋值finishCode码 + public MesProductionProcessContextBak finishCode(String finishCode) { + this.finishCode = finishCode; + return this.isNeedCache(); + } + + //上下文赋值工艺强过码 + public MesProductionProcessContextBak craftJumpCode(String craftJumpCode) { + this.craftJumpCode = craftJumpCode; + return this.isNeedCache(); + } + + //上下文赋值装配件跳过码 + public MesProductionProcessContextBak assemblySkipCode(String assemblySkipCode) { + this.assemblySkipCode = assemblySkipCode; + return this.isNeedCache(); + } + + //上下文赋值装配件整腔跳过码 + public MesProductionProcessContextBak assemblyCavitySkipCode(String assemblyCavitySkipCode) { + this.assemblyCavitySkipCode = assemblyCavitySkipCode; + return this.isNeedCache(); + } + + //排序线可疑码 + public MesProductionProcessContextBak sortSuspiciousCode(String sortSuspiciousCode) { + this.sortSuspiciousCode = sortSuspiciousCode; + return this.isNeedCache(); + } + + + //---------------------- 生产线对象 --------------------------------------- + + //从上下文中取出生产线对象 + public MesWorkCenter getWorkCenter() { + return !StringUtils.isEmpty(this.workCenterJson) ? JSONObject.parseObject(this.workCenterJson, MesWorkCenter.class) : null; + } + + //上下文赋值生产线对象 + public MesProductionProcessContextBak workCenterJson(MesWorkCenter workCenter) { + if (StringUtils.isEmpty(workCenter.getIsCheckOrderQty())) workCenter.setIsCheckOrderQty(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCenter.getIsIgnoreQc())) workCenter.setIsCheckOrderQty(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCenter.getIsPushQueue())) workCenter.setIsPushQueue(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + this.workCenterJson = null != workCenter ? JSONObject.toJSONString(workCenter) : null; + return this.isNeedCache(); + } + + //---------------------- 工位对象 --------------------------------------- + + //从上下文中取出工位对象 + public MesWorkCell getWorkCell() { + return !StringUtils.isEmpty(this.workCellJson) ? JSONObject.parseObject(this.workCellJson, MesWorkCell.class) : null; + } + + //上下文赋值工位对象 + public MesProductionProcessContextBak workCellJson(MesWorkCell workCell) { + if (StringUtils.isEmpty(workCell.getIsCheckSeq())) workCell.setIsCheckSeq(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCell.getIsCheckCraft())) workCell.setIsCheckCraft(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCell.getIsSeqScan())) workCell.setIsCheckSeq(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCell.getIsResetScan())) workCell.setIsResetScan(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCell.getNoCalcOrderQty())) workCell.setNoCalcOrderQty(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + if (StringUtils.isEmpty(workCell.getIsEndWorkCell())) workCell.setIsEndWorkCell(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); + this.workCellJson = null != workCell ? JSONObject.toJSONString(workCell) : null; + return this.isNeedCache(); + } + + //---------------------- 工序/工艺信息 --------------------------------------- + + //上下文赋值工序信息 + public MesProductionProcessContextBak processCode(String processCode, String processName) { + this.processCode = processCode; + this.processName = processName; + return this.isNeedCache(); + } + + //上下文赋值工艺信息 + public MesProductionProcessContextBak craftCode(String craftCode, String craftName) { + this.craftCode = craftCode; + this.craftName = craftName; + return this.isNeedCache(); + } + + //---------------------- 工位设备对象集合 --------------------------------------- + + //从上下文中取出工位设备对象集合 + private List getCellEquipList() { + return !StringUtils.isEmpty(this.cellEquipListJson) ? JSONObject.parseArray(this.cellEquipListJson, MesCellEquipContext.class) : null; + } + + //上下文赋值工位设备对象集合 + public MesProductionProcessContextBak cellEquipListJson(List cellEquipList) { + this.cellEquipListJson = !CollectionUtils.isEmpty(cellEquipList) ? JSONObject.toJSONString(cellEquipList) : null; + return this.isNeedCache(); + } + + //---------------------- 工位当前设备 --------------------------------------- + + //从上下文中的工位设备对象集合中取出当前要使用的设备 + public MesCellEquipContext filterCurCellEquip() { + List cellEquipList = getCellEquipList(); + if (CollectionUtils.isEmpty(cellEquipList) || cellEquipList.size() == 1) return filterCurCellEquip(cellEquipList); + return filterCurCellEquip(cellEquipList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getSeq()))).sorted(Comparator.comparing(MesCellEquipContext::getSeq)).collect(Collectors.toList())); + } + + //从上下文中的工位设备对象集合中根据设备代码取出当前要使用的设备 + public MesCellEquipContext filterCurCellEquip(String equipmentCode) { + if (StringUtils.isEmpty(equipmentCode)) return filterCurCellEquip(); + List cellEquipList = getCellEquipList(); + return filterCurCellEquip(CollectionUtils.isEmpty(cellEquipList) ? null : cellEquipList.stream().filter(o -> (null != o && o.getEquipmentCode().equals(equipmentCode))).collect(Collectors.toList())); + } + + //从上下文中的工位设备对象集合中取出第一个设备 + private MesCellEquipContext filterCurCellEquip(List cellEquipContextList) { + return !CollectionUtils.isEmpty(cellEquipContextList) ? cellEquipContextList.get(0) : null; + } + + //从上下文中取出工位当前要使用的设备 + public MesCellEquipContext getCurCellEquip() { + return !StringUtils.isEmpty(this.curCellEquipJson) ? JSONObject.parseObject(this.curCellEquipJson, MesCellEquipContext.class) : null; + } + + //上下文赋值工位当前要使用的设备 + public MesProductionProcessContextBak curCellEquipJson(MesCellEquipContext curEquip) { + //未配置则默认1腔 + if (StringUtils.isEmpty(curEquip.getCavity()) || curEquip.getCavity().compareTo(MesPcnExtConstWords.ZERO) == 0) curEquip.setCavity(MesPcnExtConstWords.ONE); + //未配置则默认没有装配件 + if (StringUtils.isEmpty(curEquip.getBindQty())) curEquip.setBindQty(MesPcnExtConstWords.ZERO); + this.curCellEquipJson = null != curEquip ? JSONObject.toJSONString(curEquip) : null; + return this.isNeedCache(); + } + + //---------------------- 数据变量接口逻辑集合 --------------------------------------- + + //从上下文中取出设备数据变量接口逻辑集合 + private List getEquipVariableCfgList() { + return !StringUtils.isEmpty(this.equipVariableCfgJson) ? JSONObject.parseArray(this.equipVariableCfgJson, MesEquipmentVariableCfg.class) : null; + } + + //从上下文的设备数据变量接口逻辑对象集合中取出当前设备信息的逻辑类型对应的接口逻辑对象集合 + public List getEquipVariableCfgListByVct() { + MesCellEquipContext cellEquipContext = getCurCellEquip(); + return null != cellEquipContext ? getEquipVariableCfgListByVct(cellEquipContext.getVariableCfgType()) : null; + } + + //从上下文的设备数据变量接口逻辑对象集合中取出当前设备信息的逻辑类型对应的接口逻辑对象集合 + public List getEquipVariableCfgListByVct(String variableCfgType) { + List equipmentVariableCfgList = getEquipVariableCfgList(); + return (StringUtils.isEmpty(variableCfgType) || CollectionUtils.isEmpty(equipmentVariableCfgList)) ? null : + equipmentVariableCfgList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getCategoryLevelTwo()) && o.getVariableCfgType().equals(variableCfgType))).collect(Collectors.toList()); + } + + //上下文赋值数据变量接口逻辑对象集合 + public MesProductionProcessContextBak equipVariableCfgJson(List equipmentVariableCfgList) { + if (CollectionUtils.isEmpty(equipmentVariableCfgList)) return this; + if (!StringUtils.isEmpty(this.equipVariableCfgJson)) equipmentVariableCfgList.addAll(getEquipVariableCfgList()); + equipmentVariableCfgList.stream().filter(o -> null != o).forEach(o -> { + if (StringUtils.isEmpty(o.getModifyDatetime())) o.setModifyDatetime(o.getCreateDatetime()); + }); + equipmentVariableCfgList = equipmentVariableCfgList.stream().filter(o -> null != o).sorted(Comparator.comparing(MesEquipmentVariableCfg::getModifyDatetime).reversed()).collect(Collectors.toList()); + equipmentVariableCfgList = equipmentVariableCfgList.stream().filter(o -> null != o).distinct().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(MesEquipmentVariableCfg::getId))), ArrayList::new)); + this.equipVariableCfgJson = JSONObject.toJSONString(equipmentVariableCfgList); + return this.isNeedCache(); + } + + //---------------------- 数据变量对象集合 --------------------------------------- + + //从上下文中取出设备数据变量对象集合 + private List getEquipVariableList() { + return !StringUtils.isEmpty(this.equipVariableJson) ? JSONObject.parseArray(this.equipVariableJson, MesEquipmentVariable.class) : null; + } + + //从上下文的设备数据变量对象集合中取出当前设备对应具体变量类型的数据变量对象集合 + public List getEquipVariableListByEquVt(Integer variableType) { + MesCellEquipContext cellEquipContext = getCurCellEquip(); + return (null != cellEquipContext && !StringUtils.isEmpty(variableType)) ? getEquipVariableListByEquVt(cellEquipContext.getEquipmentCode(), variableType) : null; + } + + //从上下文的设备数据变量对象集合中取出当前设备对应具体变量类型的数据变量对象集合 + public List getEquipVariableListByEquVt(String equipmentCode, Integer variableType) { + List equipmentVariableList = getEquipVariableList(); + return (StringUtils.isEmpty(equipmentCode) || null == variableType || CollectionUtils.isEmpty(equipmentVariableList)) ? null : + equipmentVariableList.stream().filter(o -> (null != o && o.getEquipmentCode().equals(equipmentCode) && o.getVariableType().compareTo(variableType) == 0)).collect(Collectors.toList()); + } + + //上下文赋值数据变量对象集合 + public MesProductionProcessContextBak equipVariableJson(List equipmentVariableList) { + equipmentVariableList = CollectionUtils.isEmpty(equipmentVariableList) ? null : equipmentVariableList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getCategoryLevelTwo()))).collect(Collectors.toList()); + if (CollectionUtils.isEmpty(equipmentVariableList)) return this; + if (!StringUtils.isEmpty(this.equipVariableJson)) equipmentVariableList.addAll(getEquipVariableList()); + equipmentVariableList.stream().filter(o -> null != o).forEach(o -> { + if (StringUtils.isEmpty(o.getModifyDatetime())) o.setModifyDatetime(o.getCreateDatetime()); + }); + equipmentVariableList = equipmentVariableList.stream().filter(o -> null != o).sorted(Comparator.comparing(MesEquipmentVariable::getModifyDatetime).reversed()).collect(Collectors.toList()); + equipmentVariableList = equipmentVariableList.stream().filter(o -> null != o).distinct().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(MesEquipmentVariable::getId))), ArrayList::new)); + this.equipVariableJson = JSONObject.toJSONString(equipmentVariableList); + return this.isNeedCache(); + } + +}