红外焊超差预警

uat-temp-wj-250124-equ-check-step
王杰 3 months ago
parent 548ba84f08
commit 1a5c2272e7

@ -1,6 +1,7 @@
package cn.estsh.i3plus.ext.mes.pcn.api.base;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesCellEquipContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipSpotCheckContext;
import cn.estsh.i3plus.pojo.mes.bean.*;
import io.swagger.annotations.ApiOperation;
@ -26,8 +27,6 @@ public interface IMesEquipmentExtService {
@ApiOperation(value = "根据设备代码查询设备通道集合")
List<MesEquipmentChannel> getEquipmentChannelList(String organizeCode, String equipmentCode);
List<MesCavityGroupDetailCfg> getMesCavityGroupDetailCfgList(String organizeCode, String equipmentCode);
@ApiOperation(value = "根据设备代码查询生产设备信息")
MesEquipment getMesEquipment(String organizeCode, String equipmentCode);
@ -43,5 +42,7 @@ public interface IMesEquipmentExtService {
@ApiOperation(value = "根据ID查询设备信息")
MesEquipment getMesEquipmentByEquipId(String organizeCode, Integer equipId);
@ApiOperation(value = "根据设备代码查询设备点检上下文")
MesEquipSpotCheckContext getEquipSpotCheckContext(String organizeCode, String workCenterCode, String equipmentCode);
}

@ -29,6 +29,9 @@ public interface IMesEquipmentLogExtService {
@ApiOperation(value = "根据设备ID,是否常变值状态,设备数据变量ID集合,变量类型 查询设备ID分表采集数据")
List<MesEquipVariableCollectContext> getEquipmentLogCollectList(String organizeCode, Integer equipId, Integer needNewValue, Integer variableType, List<Long> equipVariableIdList);
@ApiOperation(value = "根据设备ID,是否常变值状态,变量类型查询设备ID分表采集数据, 再根据设备数据变量ID集合过滤数据")
List<MesEquipVariableCollectContext> getEquipmentLogCollectListThenFilter(String organizeCode, Integer equipId, Integer needNewValue, Integer variableType, List<Long> equipVariableIdList);
@ApiOperation(value = "根据设备ID, 批量写入设备LOG明细数据")
void insertBatchEquipmentLogDetail(String organizeCode, Integer equipId, String userInfo, MesEquipmentRecord mesEquipmentRecord, List<MesEquipmentLog> equipmentLogList);
}

@ -164,4 +164,6 @@ public interface IMesProductionProcessContextStepService {
@ApiOperation(value = "删除包装规则信息")
void removePackageRuleContext(StationRequestBean reqBean);
@ApiOperation(value = "获取设备点检上下文对象")
MesEquipSpotCheckContext dispatchEquipSpotCheckContext(StationRequestBean reqBean, String equipmentCode);
}

@ -6,6 +6,7 @@ import cn.estsh.i3plus.pojo.base.bean.ListPager;
import cn.estsh.i3plus.pojo.base.common.Pager;
import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentSpotCheck;
import cn.estsh.i3plus.pojo.mes.bean.MesSpotCheckOrder;
import cn.estsh.i3plus.pojo.mes.bean.MesSpotCheckOrderResult;
import io.swagger.annotations.ApiOperation;
import java.util.List;
@ -45,7 +46,6 @@ public interface IMesSpotCheckOrderService {
*
*
* @param spotCheckOrder
* @param pager
* @return
*/
@ApiOperation("查询设备点检")
@ -107,4 +107,13 @@ public interface IMesSpotCheckOrderService {
@ApiOperation(value = "删除点检单", notes = "删除点检单")
void deleteBatchIds(Long[] ids, String userName, String organizeCode);
@ApiOperation("根据生产线代码,设备代码,点检项目ID集合 查询每个点检项目ID对应的最新的未完成的单据")
List<MesSpotCheckOrder> getSpotCheckOrderList(String organizeCode, String workCenterCode, String equipmentCode, List<Long> spotCheckIdList);
@ApiOperation("根据设备点检单据ID集合查询设备点检单据明细信息")
List<MesSpotCheckOrderResult> getSpotCheckOrderResultList(String organizeCode, List<Long> spotCheckOrderIdList);
@ApiOperation("根据设备点检单据ID集合查询后搜集点检项类型为自动类型的明细信息")
List<MesSpotCheckOrderResult> getSpotCheckOrderResultAutoItemTypeList(String organizeCode, List<Long> spotCheckOrderIdList);
}

@ -2,12 +2,14 @@ package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.base;
import cn.estsh.i3plus.ext.mes.pcn.api.base.IMesEquipmentExtService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesCellEquipContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesEquipSpotCheckContext;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
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.*;
import cn.estsh.i3plus.pojo.mes.repository.*;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@ -40,7 +42,13 @@ public class MesEquipmentExtService implements IMesEquipmentExtService {
private MesEquipmentChannelRepository equipmentChannelRepository;
@Autowired
private MesCavityGroupDetailCfgRepository mesCavityGroupDetailCfgRepository;
private MesEquipmentSpotCheckRepository equipmentSpotCheckRepository;
@Autowired
private MesEquipmentSpotCheckPartRepository equipmentSpotCheckPartRepository;
@Autowired
private MesEquipmentSpotCheckDetailRepository equipmentSpotCheckDetailRepository;
@Override
public List<MesCellEquipContext> getCellEquipmentList(String organizeCode, String workCenterCode, String workCellCode) {
@ -105,15 +113,6 @@ public class MesEquipmentExtService implements IMesEquipmentExtService {
}
@Override
public List<MesCavityGroupDetailCfg> getMesCavityGroupDetailCfgList(String organizeCode, String equipmentCode) {
//获取腔组数据信息集合
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(equipmentCode, "equipmentCode", packBean);
return mesCavityGroupDetailCfgRepository.findByHqlWhere(packBean);
}
@Override
public MesEquipment getMesEquipment(String organizeCode, String equipmentCode) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(equipmentCode)) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
@ -155,4 +154,52 @@ public class MesEquipmentExtService implements IMesEquipmentExtService {
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.EQUIP_ID},
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), equipId});
}
@Override
public MesEquipSpotCheckContext getEquipSpotCheckContext(String organizeCode, String workCenterCode, String equipmentCode) {
MesEquipSpotCheckContext equipSpotCheckContext = new MesEquipSpotCheckContext();
//查询设备点检主数据
List<MesEquipmentSpotCheck> equipmentSpotCheckList = equipmentSpotCheckRepository.findByProperty(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.WORK_CENTER_CODE, MesPcnExtConstWords.EQUIP_CODE},
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), workCenterCode, equipmentCode});
//搜集点检方式:非加工前 的设备点检主数据
equipmentSpotCheckList = CollectionUtils.isEmpty(equipmentSpotCheckList) ? null :
equipmentSpotCheckList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getSpotCheckType()) && o.getSpotCheckType().compareTo(MesExtEnumUtil.EQUIPMENT_CHECK_INSPECTION_METHOD.BEFORE_PROCESSING.getValue()) != 0)).collect(Collectors.toList());
if (CollectionUtils.isEmpty(equipmentSpotCheckList)) return equipSpotCheckContext;
//查询设备点检明细数据
List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList = equipmentSpotCheckDetailRepository.findByProperty(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.EQUIP_CODE, MesPcnExtConstWords.SPOT_CHECK_ITEM_TYPE},
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), equipmentCode, MesExtEnumUtil.SPOT_CHECK_ITEM_TYPE.AUTO.getValue()});
if (CollectionUtils.isEmpty(equipmentSpotCheckDetailList)) return equipSpotCheckContext;
//点检方式:全部点检
List<Long> pidList = equipmentSpotCheckList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getSpotCheckType()) &&
o.getSpotCheckType().compareTo(MesExtEnumUtil.EQUIPMENT_CHECK_INSPECTION_METHOD.ALL_INSPECTIONS.getValue()) == 0)).map(MesEquipmentSpotCheck::getId).collect(Collectors.toList());
//只需要缓存全部点检类型的明细数据
if (!CollectionUtils.isEmpty(pidList)) {
equipmentSpotCheckDetailList = equipmentSpotCheckDetailList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getPid()) && pidList.contains(o.getPid()))).collect(Collectors.toList());
//剔除没有明细数据的全部点检类型的主数据
List<Long> detailPidList = CollectionUtils.isEmpty(equipmentSpotCheckDetailList) ? null :
equipmentSpotCheckDetailList.stream().filter(o -> null != o).map(MesEquipmentSpotCheckDetail::getPid).collect(Collectors.toList());
List<Long> noDetailPidList = CollectionUtils.isEmpty(detailPidList) ? pidList : pidList.stream().filter(o -> (StringUtils.isEmpty(o) && !detailPidList.contains(o))).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(noDetailPidList)) equipmentSpotCheckList = equipmentSpotCheckList.stream().filter(o -> (null != o && !noDetailPidList.contains(o.getId()))).collect(Collectors.toList());
}
//当没有全部点检类型的明细数据时 判断是否存在加工后类型的设备点检主数据, 只需要缓存加工后类型的设备点检主数据
if (CollectionUtils.isEmpty(equipmentSpotCheckDetailList)) equipmentSpotCheckList = equipmentSpotCheckList.stream().filter(o -> (null != o &&
!StringUtils.isEmpty(o.getSpotCheckType()) && o.getSpotCheckType().compareTo(MesExtEnumUtil.EQUIPMENT_CHECK_INSPECTION_METHOD.AFTER_PROCESSING.getValue()) == 0)).collect(Collectors.toList());
//判断经过搜集数据之后是否还存在设备点检主数据
if (CollectionUtils.isEmpty(equipmentSpotCheckList)) return equipSpotCheckContext;
//查询设备点检主数据关联零件表数据
List<MesEquipmentSpotCheckPart> equipmentSpotCheckPartList = equipmentSpotCheckPartRepository.findByProperty(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.EQUIP_CODE},
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), equipmentCode});
return equipSpotCheckContext.isExistSpot().equipmentSpotCheckJson(equipmentSpotCheckList).equipmentSpotCheckDetailJson(equipmentSpotCheckDetailList).equipmentSpotCheckPartJson(equipmentSpotCheckPartList);
}
}

@ -746,4 +746,33 @@ public class MesSpotCheckOrderService implements IMesSpotCheckOrderService {
}
}
@Override
public List<MesSpotCheckOrder> getSpotCheckOrderList(String organizeCode, String workCenterCode, String equipmentCode, List<Long> spotCheckIdList) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(workCenterCode) || StringUtils.isEmpty(equipmentCode) || CollectionUtils.isEmpty(spotCheckIdList)) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(workCenterCode, MesPcnExtConstWords.WORK_CENTER_CODE, packBean);
DdlPreparedPack.getStringEqualPack(equipmentCode, MesPcnExtConstWords.EQUIP_CODE, packBean);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.SPOT_CHECK_ORDER_STATUS.CREATE.getValue(), MesPcnExtConstWords.STATUS, packBean);
if (spotCheckIdList.size() == 1) DdlPreparedPack.getNumEqualPack(spotCheckIdList.get(0), MesPcnExtConstWords.SPOT_CHECK_ID, packBean);
else DdlPreparedPack.getInPackList(spotCheckIdList, MesPcnExtConstWords.SPOT_CHECK_ID, packBean);
return spotCheckOrderRepository.findByHqlWhere(packBean);
}
@Override
public List<MesSpotCheckOrderResult> getSpotCheckOrderResultList(String organizeCode, List<Long> spotCheckOrderIdList) {
if (StringUtils.isEmpty(organizeCode) || CollectionUtils.isEmpty(spotCheckOrderIdList)) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
if (spotCheckOrderIdList.size() == 1) DdlPreparedPack.getNumEqualPack(spotCheckOrderIdList.get(0), MesPcnExtConstWords.PID, packBean);
else DdlPreparedPack.getInPackList(spotCheckOrderIdList, MesPcnExtConstWords.PID, packBean);
return spotCheckOrderResultRepository.findByHqlWhere(packBean);
}
@Override
public List<MesSpotCheckOrderResult> getSpotCheckOrderResultAutoItemTypeList(String organizeCode, List<Long> spotCheckOrderIdList) {
List<MesSpotCheckOrderResult> spotCheckOrderResultList = getSpotCheckOrderResultList(organizeCode, spotCheckOrderIdList);
return CollectionUtils.isEmpty(spotCheckOrderIdList) ? null :
spotCheckOrderResultList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getSpotCheckItemType()) &&
o.getSpotCheckItemType().compareTo(MesExtEnumUtil.SPOT_CHECK_ITEM_TYPE.AUTO.getValue()) == 0)).collect(Collectors.toList());
}
}

@ -117,6 +117,16 @@ public class MesEquipmentLogExtService implements IMesEquipmentLogExtService {
return filterEquipVariableCollectContextList(equipVariableCollectContextList, needNewValue);
}
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public List<MesEquipVariableCollectContext> getEquipmentLogCollectListThenFilter(String organizeCode, Integer equipId, Integer needNewValue, Integer variableType, List<Long> equipVariableIdList) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(equipId) || CollectionUtils.isEmpty(equipVariableIdList) || StringUtils.isEmpty(variableType)) return null;
List<MesEquipVariableCollectContext> equipVariableCollectContextList = equipmentLogDao.queryMesEquipmentLog(organizeCode, equipId, variableType);
equipVariableCollectContextList = CollectionUtils.isEmpty(equipVariableCollectContextList) ? null :
equipVariableCollectContextList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getEquipVariableId()) && equipVariableIdList.contains(o.getEquipVariableId()))).collect(Collectors.toList());
return filterEquipVariableCollectContextList(equipVariableCollectContextList, needNewValue);
}
private List<MesEquipVariableCollectContext> filterEquipVariableCollectContextList(List<MesEquipVariableCollectContext> equipVariableCollectContextList, Integer needNewValue) {
if (CollectionUtils.isEmpty(equipVariableCollectContextList)) return equipVariableCollectContextList;

@ -0,0 +1,422 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesEquipmentLogExtService;
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.spot.IMesSpotCheckOrderService;
import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
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.api.iservice.busi.ISyncFuncService;
import cn.estsh.i3plus.mes.pcn.serviceimpl.fsm.BaseStepService;
import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.platform.common.tool.MathOperation;
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.base.enumutil.MesPcnEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.*;
import cn.estsh.i3plus.pojo.mes.model.GenSerialNoModel;
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.repository.MesSpotCheckOrderRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesSpotCheckOrderResultRepository;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
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 :
* @Author : wangjie
**/
@Slf4j
@Service("mesEquipSpotCheckAlarmStepService")
public class MesEquipSpotCheckAlarmStepService extends BaseStepService {
@Autowired
private IMesProductionProcessContextStepService productionProcessContextStepService;
@Autowired
private IMesProductionDispatchContextStepService productionDispatchContextStepService;
@Autowired
private IMesEquipmentLogExtService equipmentLogExtService;
@Autowired
private IMesSpotCheckOrderService spotCheckOrderService;
@Autowired
private MesSpotCheckOrderRepository spotCheckOrderRepository;
@Autowired
private MesSpotCheckOrderResultRepository spotCheckOrderResultRepository;
@Autowired
private ISyncFuncService syncFuncService;
@Autowired
private SnowflakeIdMaker snowflakeIdMaker;
@Override
public void title(StationRequestBean reqBean) {
this.sendMessage(reqBean, new StationResultBean().resultObj(MesPcnExtConstWords.STEP_DISABLE_SCAN), String.format("工步: %s", reqBean.getStepName()), MesPcnEnumUtil.STATION_BUSI_TYPE.STEP_TITLE, MesPcnEnumUtil.STATION_DATA_TYPE.TITLE);
}
@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());
//当前工位使用的设备
MesCellEquipContext cellEquipContext = productionProcessContext.getCurCellEquip();
//获取上下文产出条码数据信息集合
List<MesProductionPsOutContext> productionPsOutContextList = productionDispatchContextStepService.getProductionPsOutContext(reqBean);
if (CollectionUtils.isEmpty(productionPsOutContextList)) stepExpSendMsgAndThrowEx(reqBean, resultBean.writeDbLog(), "当前不存在产出零件条码信息,请重置工序解决!");
//搜集产成零件号[去重]
List<String> partNoList = (productionPsOutContextList.stream().filter(o -> null != o).map(MesProductionPsOutContext::getPartNo).collect(Collectors.toList()))
.stream().filter(o -> !StringUtils.isEmpty(o)).distinct().collect(Collectors.toList());
//获取设备点检上下文对象
MesEquipSpotCheckContext equipSpotCheckContext = productionProcessContextStepService.dispatchEquipSpotCheckContext(reqBean, cellEquipContext.getEquipmentCode());
if (null == equipSpotCheckContext || equipSpotCheckContext.getIsExistSpot().equals(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValueStr())) {
return stepDynamicsCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, true,
MesPcnEnumUtil.STATION_BUSI_TYPE.RUNNING_INFO, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT, String.format("设备代码[%s]未维护点检主数据,跳过设备点检超差预警!", cellEquipContext.getEquipmentCode()));
}
//点检主数据主表集合
List<MesEquipmentSpotCheck> equipmentSpotCheckList = equipSpotCheckContext.getEquipmentSpotCheckList();
//设备点检主数据明细表集合
List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList = equipSpotCheckContext.getEquipmentSpotCheckDetailList();
//设备点检主数据关联零件表集合
List<MesEquipmentSpotCheckPart> equipmentSpotPartList = equipSpotCheckContext.getEquipmentSpotCheckPartList();
//根据零件搜集需要执行的点检主数据
equipmentSpotCheckList = filterEquipmentSpotCheckList(equipmentSpotCheckList, equipmentSpotPartList, partNoList);
if (CollectionUtils.isEmpty(equipmentSpotCheckList)) {
return stepDynamicsCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, true,
MesPcnEnumUtil.STATION_BUSI_TYPE.RUNNING_INFO, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT, String.format("设备代码[%s]产成零件号%s未维护点检主数据,跳过设备点检超差预警!", cellEquipContext.getEquipmentCode(), partNoList.toString()));
}
//根据点检方式搜集设备点检主数据[加工后]
List<MesEquipmentSpotCheck> equipmentSpotCheckList2After = filterEquipmentSpotCheckList(equipmentSpotCheckList, MesExtEnumUtil.EQUIPMENT_CHECK_INSPECTION_METHOD.AFTER_PROCESSING.getValue());
//根据点检方式搜集设备点检主数据[全部点检]
List<MesEquipmentSpotCheck> equipmentSpotCheckList2All = filterEquipmentSpotCheckList(equipmentSpotCheckList, MesExtEnumUtil.EQUIPMENT_CHECK_INSPECTION_METHOD.ALL_INSPECTIONS.getValue());
//搜集点检方式加工后的设备点检主数据的ID集合; 根据生产线代码,设备代码,点检项目ID集合查询 每个点检项目ID对应的最新的未完成的单据
List<MesSpotCheckOrder> spotCheckOrderList2After = CollectionUtils.isEmpty(equipmentSpotCheckList2After) ? null :
spotCheckOrderService.getSpotCheckOrderList(reqBean.getOrganizeCode(), reqBean.getWorkCenterCode(), cellEquipContext.getEquipmentCode(), filterSpotCheckIdList(equipmentSpotCheckList2After));
//搜集点检方式加工后的设备点检单据的ID集合; 根据设备点检单据ID集合查询后搜集点检项类型为自动类型的明细信息
List<MesSpotCheckOrderResult> spotCheckOrderResultList2After = CollectionUtils.isEmpty(spotCheckOrderList2After) ? null :
spotCheckOrderService.getSpotCheckOrderResultAutoItemTypeList(reqBean.getOrganizeCode(), filterSpotCheckOrderIdList(spotCheckOrderList2After));
//搜集点检方式全部点检的设备点检主数据的ID集合; 根据全部点检的设备点检主数据的ID集合搜集明细集合
List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList2All = filterEquipmentSpotCheckDetailList(equipmentSpotCheckDetailList, filterSpotCheckIdList(equipmentSpotCheckList2All));
//将明细主数据封装成单据明细数据
List<MesSpotCheckOrderResult> spotCheckOrderResultList2All = packSpotCheckOrderResultList(reqBean, cellEquipContext, equipmentSpotCheckDetailList2All);
if (CollectionUtils.isEmpty(spotCheckOrderResultList2After) || CollectionUtils.isEmpty(spotCheckOrderResultList2All)) {
return stepDynamicsCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, true,
MesPcnEnumUtil.STATION_BUSI_TYPE.RUNNING_INFO, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT,
String.format("设备代码[%s]产成零件号%s未关联加工后类型的单据或全部点检类型的主数据,跳过设备点检超差预警!", cellEquipContext.getEquipmentCode(), partNoList.toString()));
}
//根据设备ID,是否常变值状态,变量类型查询设备ID分表采集数据, 再根据设备数据变量ID集合过滤数据; 采集后的数据进行分组
Map<Long, String> equipVariableCollectMap = groupByEquipVariableCollectContext(equipmentLogExtService.getEquipmentLogCollectListThenFilter(
reqBean.getOrganizeCode(), cellEquipContext.getEquipId(), MesExtEnumUtil.EQUIP_VARIABLE_NEED_NEW_VALUE.FALSE.getValue(), MesExtEnumUtil.EQUIP_VARIABLE_TYPE.PROCESS_FINISH.getValue(),
filterEquipmentVariableIdList(spotCheckOrderResultList2All, spotCheckOrderResultList2After)));
if (CollectionUtils.isEmpty(equipVariableCollectMap)) {
return stepDynamicsCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, true,
MesPcnEnumUtil.STATION_BUSI_TYPE.RUNNING_INFO, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT,
String.format("根据设备代码[%s]产成零件号%s维护的设备点检明细清单未读取到有效的点位值,跳过设备点检超差预警!", cellEquipContext.getEquipmentCode(), partNoList.toString()));
}
//保存点检数据, 判断是否超差
Boolean isTolerance2After = saveSpotCheckOrderResultListValue(reqBean, cellEquipContext, spotCheckOrderResultList2After, equipVariableCollectMap, spotCheckOrderList2After, null, null);
Boolean isTolerance2All = saveSpotCheckOrderResultListValue(reqBean, cellEquipContext, spotCheckOrderResultList2All, equipVariableCollectMap, null, equipmentSpotCheckDetailList2All, equipmentSpotCheckList2All);
//超差则标记可疑
if (isTolerance2After || isTolerance2All) {
//获取上下文加工结果
String productResult = productionDispatchContextStepService.getProductResultContext(reqBean);
if (StringUtils.isEmpty(productResult) || productResult.equals(MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue() + MesPcnExtConstWords.EMPTY)) {
//保存上下文加工结果:零件可疑
productionDispatchContextStepService.dispatchProductResultContext(reqBean, MesExtEnumUtil.PRODUCE_QC_STATUS.SUSPICIOUS.getValue() + MesPcnExtConstWords.EMPTY);
}
}
//超差结果不发送给客户端显示
return stepDynamicsCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, true,
MesPcnEnumUtil.STATION_BUSI_TYPE.RUNNING_INFO, MesPcnEnumUtil.STATION_DATA_TYPE.TEXT,
String.format("设备代码[%s]产成零件号%s设备点检超差预警执行结果[是否超差: %s]!", cellEquipContext.getEquipmentCode(), partNoList.toString(), isTolerance2After || isTolerance2All));
}
//根据零件搜集需要执行的点检主数据
private List<MesEquipmentSpotCheck> filterEquipmentSpotCheckList(List<MesEquipmentSpotCheck> equipmentSpotCheckList, List<MesEquipmentSpotCheckPart> equipmentSpotPartList, List<String> partNoList) {
//搜集设备点检主数据关联零件表集合的PID
List<Long> pidList2Part = CollectionUtils.isEmpty(equipmentSpotPartList) ? null : equipmentSpotPartList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getPid()))).map(MesEquipmentSpotCheckPart::getPid).collect(Collectors.toList());
//搜集设备点检主数据关联零件表集合中与当前产成零件相关的PID
List<Long> pidList2CurPart = CollectionUtils.isEmpty(equipmentSpotPartList) ? null : equipmentSpotPartList.stream().filter(o -> (null != o &&
!StringUtils.isEmpty(o.getPid()) && !StringUtils.isEmpty(o.getPartNo()) && partNoList.contains(o.getPartNo()))).map(MesEquipmentSpotCheckPart::getPid).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(pidList2Part)) {
//搜集未关联任何零件的设备点检主数据
List<MesEquipmentSpotCheck> equipmentSpotCheckList2WithOutPart = equipmentSpotCheckList.stream().filter(o -> (null != o && !pidList2Part.contains(o.getId()))).collect(Collectors.toList());
//搜集关联当前产成零件的设备点检主数据
List<MesEquipmentSpotCheck> equipmentSpotCheckList2CurPart = CollectionUtils.isEmpty(pidList2CurPart) ? null : equipmentSpotCheckList.stream().filter(o -> (null != o && pidList2CurPart.contains(o.getId()))).collect(Collectors.toList());
//合并过滤的设备点检主数据
List<MesEquipmentSpotCheck> filterList = new ArrayList<>();
if (!CollectionUtils.isEmpty(equipmentSpotCheckList2WithOutPart)) filterList.addAll(equipmentSpotCheckList2WithOutPart);
if (!CollectionUtils.isEmpty(equipmentSpotCheckList2CurPart)) filterList.addAll(equipmentSpotCheckList2CurPart);
return filterList;
} else return equipmentSpotCheckList;
}
//根据点检方式搜集设备点检主数据
private List<MesEquipmentSpotCheck> filterEquipmentSpotCheckList(List<MesEquipmentSpotCheck> equipmentSpotCheckList, Integer spotCheckType) {
return equipmentSpotCheckList.stream().filter(o -> (null != o && o.getSpotCheckType().compareTo(spotCheckType) == 0)).collect(Collectors.toList());
}
//搜集设备点检主数据的ID集合
private List<Long> filterSpotCheckIdList(List<MesEquipmentSpotCheck> equipmentSpotCheckList) {
return CollectionUtils.isEmpty(equipmentSpotCheckList) ? null : equipmentSpotCheckList.stream().filter(o -> null != o).map(MesEquipmentSpotCheck::getId).collect(Collectors.toList());
}
//搜集设备点检单据的ID集合
private List<Long> filterSpotCheckOrderIdList(List<MesSpotCheckOrder> spotCheckOrderList) {
return CollectionUtils.isEmpty(spotCheckOrderList) ? null : spotCheckOrderList.stream().filter(o -> null != o).map(MesSpotCheckOrder::getId).collect(Collectors.toList());
}
//根据设备点检主数据的ID集合搜集明细集合
private List<MesEquipmentSpotCheckDetail> filterEquipmentSpotCheckDetailList(List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList, List<Long> spotCheckIdList) {
return (CollectionUtils.isEmpty(equipmentSpotCheckDetailList) || CollectionUtils.isEmpty(spotCheckIdList)) ? null :
equipmentSpotCheckDetailList.stream().filter(o -> (null != o && spotCheckIdList.contains(o.getPid()))).collect(Collectors.toList());
}
//搜集设备数据变量ID集合
private List<Long> filterEquipmentVariableIdList(List<MesSpotCheckOrderResult> spotCheckOrderResultList2After, List<MesSpotCheckOrderResult> spotCheckOrderResultList2All) {
List<Long> equipmentVariableIdList = new ArrayList<>();
addSetEquipVariableId(equipmentVariableIdList, spotCheckOrderResultList2After);
addRealEquipVariableId(equipmentVariableIdList, spotCheckOrderResultList2After);
addSetEquipVariableId(equipmentVariableIdList, spotCheckOrderResultList2All);
addRealEquipVariableId(equipmentVariableIdList, spotCheckOrderResultList2All);
if (!CollectionUtils.isEmpty(equipmentVariableIdList)) equipmentVariableIdList = equipmentVariableIdList.stream().filter(o -> !StringUtils.isEmpty(o)).distinct().collect(Collectors.toList());
return equipmentVariableIdList;
}
//搜集设备数据变量ID集合[设定值]
private void addSetEquipVariableId(List<Long> equipmentVariableIdList, List<MesSpotCheckOrderResult> spotCheckOrderResultList) {
if (CollectionUtils.isEmpty(spotCheckOrderResultList)) return;
List<Long> setIdList = spotCheckOrderResultList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getSetEquipVariableId()))).map(MesSpotCheckOrderResult::getSetEquipVariableId).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(setIdList)) equipmentVariableIdList.addAll(setIdList);
}
//搜集设备数据变量ID集合[实际值]
private void addRealEquipVariableId(List<Long> equipmentVariableIdList, List<MesSpotCheckOrderResult> spotCheckOrderResultList) {
if (CollectionUtils.isEmpty(spotCheckOrderResultList)) return;
List<Long> realIdList = spotCheckOrderResultList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getRealEquipVariableId()))).map(MesSpotCheckOrderResult::getRealEquipVariableId).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(realIdList)) equipmentVariableIdList.addAll(realIdList);
}
//将明细主数据封装成单据明细数据
private List<MesSpotCheckOrderResult> packSpotCheckOrderResultList(StationRequestBean reqBean, MesCellEquipContext cellEquipContext, List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList) {
if (CollectionUtils.isEmpty(equipmentSpotCheckDetailList)) return null;
List<MesSpotCheckOrderResult> spotCheckOrderResultList = new ArrayList<>();
for (MesEquipmentSpotCheckDetail equipmentSpotCheckDetail : equipmentSpotCheckDetailList) {
if (null == equipmentSpotCheckDetail) continue;
MesSpotCheckOrderResult spotCheckOrderResult = new MesSpotCheckOrderResult();
BeanUtils.copyProperties(equipmentSpotCheckDetail, spotCheckOrderResult, MesPcnExtConstWords.BASE_BEAN_FIELDS);
spotCheckOrderResult.setOrganizeCode(reqBean.getOrganizeCode());
spotCheckOrderResult.setWorkCenterCode(reqBean.getWorkCenterCode());
spotCheckOrderResult.setWorkCellCode(reqBean.getWorkCellCode());
spotCheckOrderResult.setSpotCheckItemId(equipmentSpotCheckDetail.getId());
spotCheckOrderResult.setTaskItemName(equipmentSpotCheckDetail.getSpotCheckItemName());
spotCheckOrderResult.setSpotCheckStandardValue(equipmentSpotCheckDetail.getStandardValue());
spotCheckOrderResultList.add(spotCheckOrderResult);
}
return spotCheckOrderResultList;
}
//采集后的数据进行分组
private Map<Long, String> groupByEquipVariableCollectContext(List<MesEquipVariableCollectContext> equipVariableCollectContextList) {
equipVariableCollectContextList = equipVariableCollectContextList.stream().filter(o -> (null != o && !StringUtils.isEmpty(o.getEquipVariableValue())))
.distinct().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(MesEquipVariableCollectContext::getEquipVariableId))), ArrayList::new));
return CollectionUtils.isEmpty(equipVariableCollectContextList) ? null :
equipVariableCollectContextList.stream().filter(o -> null != o).collect(Collectors.toMap(MesEquipVariableCollectContext::getEquipVariableId, MesEquipVariableCollectContext::getEquipVariableValue));
}
//保存点检数据, 判断是否超差
private Boolean saveSpotCheckOrderResultListValue(StationRequestBean reqBean, MesCellEquipContext cellEquipContext, List<MesSpotCheckOrderResult> spotCheckOrderResultList, Map<Long, String> equipVariableCollectMap,
List<MesSpotCheckOrder> spotCheckOrderList, List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList, List<MesEquipmentSpotCheck> equipmentSpotCheckList) {
if (CollectionUtils.isEmpty(spotCheckOrderResultList)) return false;
//判断点检方式: true=全部点检 false=加工后
Boolean isAllCheck = CollectionUtils.isEmpty(spotCheckOrderList) ? true : false;
Map<Long, MesSpotCheckOrder> spotCheckOrderMap;
Map<Long, MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailMap = null;
Map<Long, MesEquipmentSpotCheck> equipmentSpotCheckMap = null;
if (isAllCheck) {
//全部点检基于主数据
spotCheckOrderMap = new HashMap<>();
equipmentSpotCheckDetailMap = equipmentSpotCheckDetailList.stream().filter(o -> null != o).collect(Collectors.toMap(MesEquipmentSpotCheckDetail::getId, o -> o));
equipmentSpotCheckMap = equipmentSpotCheckList.stream().filter(o -> null != o).collect(Collectors.toMap(MesEquipmentSpotCheck::getId, o -> o));
} else {
//加工后基于单据
spotCheckOrderMap = spotCheckOrderList.stream().filter(o -> null != o).collect(Collectors.toMap(MesSpotCheckOrder::getId, o -> o));
}
String nowTime = TimeTool.getNowTime(true);
//当前类型的超差结果
Boolean isTolerance = false;
//点检项结果
Boolean spotCheckResult;
for (MesSpotCheckOrderResult spotCheckOrderResult : spotCheckOrderResultList) {
if (null == spotCheckOrderResult) continue;
//判断是否超差
if (checkIsTolerance(spotCheckOrderResult.getMaxValue(), spotCheckOrderResult.getMinValue(), spotCheckOrderResult.getSpotCheckSetValue()) ||
checkIsTolerance(spotCheckOrderResult.getMaxValue(), spotCheckOrderResult.getMinValue(), spotCheckOrderResult.getSpotCheckSetValue())) {
isTolerance = true;
spotCheckResult = false;
} else {
spotCheckResult = true;
}
if (!isAllCheck) {
//加工后:修改点检项结果
spotCheckOrderResultRepository.updateByPropertiesNoSync(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.ID},
new Object[]{reqBean.getOrganizeCode(), spotCheckOrderResult.getId()},
new String[]{MesPcnExtConstWords.SET_VALUE_RECORD_TYPE, MesPcnExtConstWords.REAL_VALUE_RECORD_TYPE, MesPcnExtConstWords.SPOT_CHECK_SET_VALUE,
MesPcnExtConstWords.SPOT_CHECK_REAL_VALUE, MesPcnExtConstWords.IS_TOLERANCE, MesPcnExtConstWords.SPOT_CHECK_RESULT,
MesPcnExtConstWords.MODIFY_USER, MesPcnExtConstWords.MODIFY_DATE_TIME, MesPcnExtConstWords.SYSTEM_SYNC_STATUS, MesPcnExtConstWords.SYSTEM_SYNC_DATE_TIME},
new Object[]{MesExtEnumUtil.SPOT_VALUE_RECORD_TYPE.EQUIPMENT_INPUT.getValue(), MesExtEnumUtil.SPOT_VALUE_RECORD_TYPE.EQUIPMENT_INPUT.getValue(),
equipVariableCollectMap.get(spotCheckOrderResult.getSetEquipVariableId()), equipVariableCollectMap.get(spotCheckOrderResult.getRealEquipVariableId()),
!spotCheckResult ? CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue() : MesPcnExtConstWords.ZERO,
!spotCheckResult ? MesExtEnumUtil.SPOT_CHECK_ORDER_RESULT_TYPE.NOK.getDescription() : MesExtEnumUtil.SPOT_CHECK_ORDER_RESULT_TYPE.OK.getDescription(),
reqBean.getUserInfo(), nowTime, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), MesPcnExtConstWords.EMPTY});
//加工后:如果NOK则修改点检单据结果,然后从spotCheckOrderMap集合中剔除该单据,key=单据ID; 剩下的均是OK的单据在最后再进行遍历修改OK结果
if (!spotCheckResult && spotCheckOrderMap.containsKey(spotCheckOrderResult.getPid())) {
spotCheckOrderRepository.updateByPropertiesNoSync(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.ID},
new Object[]{reqBean.getOrganizeCode(), spotCheckOrderResult.getPid()},
new String[]{MesPcnExtConstWords.SPOT_CHECK_ORDER_RESULT, MesPcnExtConstWords.SPOT_CHECK_TIME, MesPcnExtConstWords.SPOT_CHECK_USER, MesPcnExtConstWords.STATUS,
MesPcnExtConstWords.MODIFY_USER, MesPcnExtConstWords.MODIFY_DATE_TIME, MesPcnExtConstWords.SYSTEM_SYNC_STATUS, MesPcnExtConstWords.SYSTEM_SYNC_DATE_TIME},
new Object[]{MesExtEnumUtil.SPOT_CHECK_ORDER_RESULT_TYPE.NOK.getValue(), nowTime, reqBean.getUserInfo(), MesExtEnumUtil.SPOT_CHECK_ORDER_STATUS.COMPLETE.getValue(),
reqBean.getUserInfo(), nowTime, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), MesPcnExtConstWords.EMPTY});
spotCheckOrderMap.remove(spotCheckOrderResult.getPid());
}
} else {
//全部点检:NOK需要创建一个单据记录,并保存NOK的明细记录; OK情况下无须保存记录
spotCheckOrderResult.setSetValueRecordType(MesExtEnumUtil.SPOT_VALUE_RECORD_TYPE.EQUIPMENT_INPUT.getValue());
spotCheckOrderResult.setRealValueRecordType(MesExtEnumUtil.SPOT_VALUE_RECORD_TYPE.EQUIPMENT_INPUT.getValue());
spotCheckOrderResult.setSpotCheckSetValue(equipVariableCollectMap.get(spotCheckOrderResult.getSetEquipVariableId()));
spotCheckOrderResult.setSpotCheckRealValue(equipVariableCollectMap.get(spotCheckOrderResult.getRealEquipVariableId()));
if (!spotCheckResult) {
spotCheckOrderResult.setIsTolerance(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
spotCheckOrderResult.setSpotCheckResult(MesExtEnumUtil.SPOT_CHECK_ORDER_RESULT_TYPE.NOK.getDescription());
Long spotCheckId = equipmentSpotCheckDetailMap.get(spotCheckOrderResult.getSpotCheckItemId()).getPid();
MesSpotCheckOrder spotCheckOrder = spotCheckOrderMap.get(spotCheckId);
//判断是否已经保存过全部点检类型的NOK单据, 保存之后暂存到spotCheckOrderMap集合中, key=主数据ID
if (null == spotCheckOrder) {
spotCheckOrder = new MesSpotCheckOrder();
try {
List<String> resultList = syncFuncService.syncSerialNo(new GenSerialNoModel(MesCommonConstant.SPOT_CHECK_ORDER_NO_RULE), reqBean.getUserInfo(), reqBean.getOrganizeCode(), 1).getResultList();
spotCheckOrder.setSpotCheckOrderNo(resultList.get(0));
} catch (Exception e) {
spotCheckOrder.setSpotCheckOrderNo(snowflakeIdMaker.nextId() + MesPcnExtConstWords.EMPTY);
}
MesEquipmentSpotCheck equipmentSpotCheck = equipmentSpotCheckMap.get(spotCheckId);
spotCheckOrder.setSpotCheckCode(equipmentSpotCheck.getSpotCheckCode());
spotCheckOrder.setSpotCheckName(equipmentSpotCheck.getSpotCheckName());
spotCheckOrder.setSpotCheckOrderType(equipmentSpotCheck.getSpotCheckOrderType());
spotCheckOrder.setTriggerMode(equipmentSpotCheck.getTriggerMode());
spotCheckOrder.setOrganizeCode(reqBean.getOrganizeCode());
spotCheckOrder.setWorkCenterCode(reqBean.getWorkCenterCode());
spotCheckOrder.setWorkCellCode(reqBean.getWorkCellCode());
spotCheckOrder.setSpotCheckId(spotCheckId);
spotCheckOrder.setEquipCode(cellEquipContext.getEquipmentCode());
spotCheckOrder.setEquipName(cellEquipContext.getEquipmentName());
spotCheckOrder.setTaskResource(MesCommonConstant.SPOT_CHECK_ORDER_TASK_RESOURCE);
spotCheckOrder.setSpotCheckOrderResult(MesExtEnumUtil.SPOT_CHECK_ORDER_RESULT_TYPE.NOK.getValue());
spotCheckOrder.setSpotCheckTime(nowTime);
spotCheckOrder.setSpotCheckUser(reqBean.getUserInfo());
spotCheckOrder.setStatus(MesExtEnumUtil.SPOT_CHECK_ORDER_STATUS.COMPLETE.getValue());
ConvertBean.serviceModelInitialize(spotCheckOrder, reqBean.getUserInfo());
spotCheckOrderRepository.insert(spotCheckOrder);
spotCheckOrderMap.put(spotCheckId, spotCheckOrder);
}
spotCheckOrderResult.setPid(spotCheckOrder.getId());
spotCheckOrderResult.setSpotCheckOrderNo(spotCheckOrder.getSpotCheckOrderNo());
ConvertBean.serviceModelInitialize(spotCheckOrderResult, reqBean.getUserInfo());
spotCheckOrderResultRepository.insert(spotCheckOrderResult);
}
}
}
//加工后:spotCheckOrderMap集合中剩下的均是OK的单据, 遍历修改OK结果
if (!isAllCheck && !CollectionUtils.isEmpty(spotCheckOrderMap)) {
for (Long id : spotCheckOrderMap.keySet()) {
if (StringUtils.isEmpty(id)) continue;
spotCheckOrderRepository.updateByPropertiesNoSync(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.ID},
new Object[]{reqBean.getOrganizeCode(), id},
new String[]{MesPcnExtConstWords.SPOT_CHECK_ORDER_RESULT, MesPcnExtConstWords.SPOT_CHECK_TIME, MesPcnExtConstWords.SPOT_CHECK_USER, MesPcnExtConstWords.STATUS,
MesPcnExtConstWords.MODIFY_USER, MesPcnExtConstWords.MODIFY_DATE_TIME, MesPcnExtConstWords.SYSTEM_SYNC_STATUS, MesPcnExtConstWords.SYSTEM_SYNC_DATE_TIME},
new Object[]{MesExtEnumUtil.SPOT_CHECK_ORDER_RESULT_TYPE.OK.getValue(), nowTime, reqBean.getUserInfo(), MesExtEnumUtil.SPOT_CHECK_ORDER_STATUS.COMPLETE.getValue(),
reqBean.getUserInfo(), nowTime, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), MesPcnExtConstWords.EMPTY});
}
}
return isTolerance;
}
//判断是否超差
private Boolean checkIsTolerance(Double maxValue, Double minValue, String spotCheckSetValue) {
if (StringUtils.isEmpty(spotCheckSetValue)) return false;
Double value;
try {
value = Double.valueOf(spotCheckSetValue);
} catch (NumberFormatException e) {
return false;
}
if (!StringUtils.isEmpty(maxValue) && MathOperation.compareTo(maxValue, value) < 0) return true;
if (!StringUtils.isEmpty(minValue) && MathOperation.compareTo(minValue, value) > 0) return true;
return false;
}
}

@ -1,158 +0,0 @@
//package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.step;
//
//import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesEquipVariableRwExtService;
//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.apiservice.serviceimpl.rulematch.strategy.AbstractWriteVariableService;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.context.MesCellEquipContext;
//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.bean.DdlPackBean;
//import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
//import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
//import cn.estsh.i3plus.pojo.mes.bean.MesCavityGroupDetailCfg;
//import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentProdParamCfg;
//import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentVariable;
//import cn.estsh.i3plus.pojo.mes.bean.MesProdRouteOptParam;
//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.repository.MesCavityGroupDetailCfgRepository;
//import cn.estsh.i3plus.pojo.mes.repository.MesEquipmentProdParamCfgRepository;
//import cn.estsh.i3plus.pojo.mes.repository.MesEquipmentVariableRepository;
//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.Comparator;
//import java.util.List;
//import java.util.Map;
//import java.util.Optional;
//import java.util.stream.Collectors;
//
///**
// * @Description : 腔组发送加工参数
// * @Author : zxw
// **/
//@Slf4j
//@Service("mesSendCavityGroupParamsCmdStepService")
//public class MesSendCavityGroupParamsCmdStepService extends BaseStepService {
//
// @Autowired
// private IMesProductionProcessContextStepService productionProcessContextStepService;
//
// @Autowired
// private IMesProductionDispatchContextStepService productionDispatchContextStepService;
//
//
// @Autowired
// private IMesEquipVariableRwExtService equipVariableRwExtService;
// @Autowired
// private MesEquipmentVariableRepository mesEquipmentVariableRepository;
//
// @Autowired
// private MesEquipmentProdParamCfgRepository mesEquipmentProdParamCfgRepository;
//
//
// @Autowired
// private MesCavityGroupDetailCfgRepository mesCavityGroupDetailCfgRepository;
//
// @Override
// public StepResult execute(StationRequestBean reqBean) {
//
// StationResultBean resultBean = new StationResultBean();
//
// StepResult stepResult = StepResult.getSuccessComplete();
//
// //获取工步参数
// Optional<Map<String, MesProdRouteOptParam>> stepParamMap = getStepParams(reqBean);
//
// //获取上下文信息
// MesProductionProcessContext productionProcessContext = productionProcessContextStepService.dispatchCurCellEquipment(reqBean, stepParamMap);
//
// //当前工位使用的设备
// MesCellEquipContext cellEquipContext = productionProcessContext.getCurCellEquip();
//
// //获取腔组数据信息集合
// List<MesCavityGroupDetailCfg> mesCavityGroupDetailCfgs = productionProcessContext.getCavityGroupDetailList();
//
// mesCavityGroupDetailCfgs = mesCavityGroupDetailCfgs.stream().sorted(Comparator.comparingInt(MesCavityGroupDetailCfg::getSeq)).collect(Collectors.toList());
//
// if (CollectionUtils.isEmpty(mesCavityGroupDetailCfgs)) {
// return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(), stepResult, "未找到腔组信息!");
// }
// sendEquipParamsCmd(reqBean, resultBean, stepResult, stepParamMap, cellEquipContext, mesCavityGroupDetailCfgs);
//
// return stepSuccessCompleteAndSendMsgReturn(reqBean, resultBean.writeDbLog(MesPcnEnumUtil.WORK_CELL_SCAN_MONITOR_LOG_TYPE.PROCESS.getValue()), stepResult, "发送腔组加工参数成功!");
// }
//
// /**
// * 发送加工参数
// * @param reqBean
// * @param resultBean
// * @param stepResult
// * @param stepParamMap
// * @param cellEquipContext
// * @param mesCavityGroupDetailCfgs
// */
// private void sendEquipParamsCmd(StationRequestBean reqBean, StationResultBean resultBean, StepResult stepResult, Optional<Map<String, MesProdRouteOptParam>> stepParamMap, MesCellEquipContext cellEquipContext, List<MesCavityGroupDetailCfg> mesCavityGroupDetailCfgs) {
// int index = 0;
//
// for (MesCavityGroupDetailCfg mesCavityGroupDetailCfg : mesCavityGroupDetailCfgs) {
// index ++;
// // 获取加工参数
// DdlPackBean ddlPackBean = DdlPackBean.getDdlPackBean(reqBean.getOrganizeCode());
// DdlPreparedPack.getNumEqualPack(mesCavityGroupDetailCfg.getId(), "sourceId", ddlPackBean);
// List<MesEquipmentProdParamCfg> mesEquipmentProdParamCfgs = mesEquipmentProdParamCfgRepository.findByHqlWhere(ddlPackBean);
// for (MesEquipmentProdParamCfg mesEquipmentProdParamCfg : mesEquipmentProdParamCfgs) {//
// String strategyClass = getStrateClass(mesEquipmentProdParamCfg.getMatchRule());
// AbstractWriteVariableService equipVariableRwExtService = ((AbstractWriteVariableService) SpringContextsUtil.getBean(strategyClass));
//
// DdlPackBean paramPackBean = DdlPackBean.getDdlPackBean(reqBean.getOrganizeCode());
// DdlPreparedPack.getNumEqualPack(mesEquipmentProdParamCfg.getEquipVariableId(), "id", paramPackBean);
// MesEquipmentVariable mesEquipmentVariable = mesEquipmentVariableRepository.getByProperty(paramPackBean);
// if (mesEquipmentVariable == null) {
// continue;
// }
// execSendEquipParamsCmd(equipVariableRwExtService, reqBean, mesEquipmentProdParamCfg.getMatchRule(), mesEquipmentVariable, cellEquipContext.getKepwareFlag(mesEquipmentVariable.getChannel()), null, index);
// }
// }
// }
//
//
// private void execSendEquipParamsCmd(AbstractWriteVariableService equipVariableRwExtService, StationRequestBean reqBean,
// String value, MesEquipmentVariable equipmentVariable, String kepwareFlag, Integer foreignKey, Integer index) {
//
// equipVariableRwExtService.writeVariable(reqBean, value, equipmentVariable, kepwareFlag, foreignKey, index);
//
//
// }
//
// //最大重试次数[工步参数]
// private Integer getMaxRetryTimes(Optional<Map<String, MesProdRouteOptParam>> stepParamMap) {
// Integer maxRetryTimes = null;
// try {
// maxRetryTimes = (null != stepParamMap && stepParamMap.isPresent() && stepParamMap.get().containsKey(MesPcnExtConstWords.MAX_RETRY_TIMES)) ? Integer.valueOf(stepParamMap.get().get(MesPcnExtConstWords.MAX_RETRY_TIMES).getParamValue()) : null;
// } catch (NumberFormatException e) {
// }
// return !StringUtils.isEmpty(maxRetryTimes) ? maxRetryTimes : MesPcnExtConstWords.MAX_RETRY_TIMES_DEFAULT;
// }
//
// private String getStrateClass(String value) {
//
// String strategyClass = "commonWriteVariableService";
//
// if (value.contains("orderNo")) {
// strategyClass = "OrderWriteVariableService";
// } else if (value.contains("partNo")) {
// strategyClass = "PartWriteVariableService";
// } else if (value.contains("sn")) {
// strategyClass = "SnWriteVariableService";
// }
// return strategyClass;
// }
//}

@ -234,8 +234,7 @@ public class MesProductionProcessContextStepService extends BaseStepService impl
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())))
.cavityGroupDetailJson(equipmentExtService.getMesCavityGroupDetailCfgList(reqBean.getOrganizeCode(), cellEquipmentContext.getEquipmentCode()));
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));
@ -571,4 +570,15 @@ public class MesProductionProcessContextStepService extends BaseStepService impl
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;
}
}

@ -0,0 +1,80 @@
package cn.estsh.i3plus.ext.mes.pcn.pojo.context;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentSpotCheck;
import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentSpotCheckDetail;
import cn.estsh.i3plus.pojo.mes.bean.MesEquipmentSpotCheckPart;
import com.alibaba.fastjson.JSONObject;
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.List;
/**
*
*/
@Data
public class MesEquipSpotCheckContext implements Serializable {
private static final long serialVersionUID = -5475187758845705565L;
@ApiParam("是否存在设备点检数据")
private String isExistSpot = CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValueStr();
//不包含加工前类型的主表数据
@ApiParam("设备点检主数据主表([Json]MesEquipmentSpotCheck)")
private String equipmentSpotCheckJson;
//仅包含全部点检类型主表ID对应的自动类型的明细数据
@ApiParam("设备点检主数据明细表([Json]List<MesEquipmentSpotCheckDetail>)")
private String equipmentSpotCheckDetailJson;
@ApiParam("设备点检主数据关联零件表([Json]MesEquipmentSpotCheckPart)")
private String equipmentSpotCheckPartJson;
//上下文赋值存在设备点检数据
public MesEquipSpotCheckContext isExistSpot() {
this.isExistSpot = CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValueStr();
return this;
}
//从上下文中取出设备点检主数据主表集合
public List<MesEquipmentSpotCheck> getEquipmentSpotCheckList() {
return !StringUtils.isEmpty(this.equipmentSpotCheckJson) ? JSONObject.parseArray(this.equipmentSpotCheckJson, MesEquipmentSpotCheck.class) : null;
}
//从上下文中取出设备点检主数据明细表集合
public List<MesEquipmentSpotCheckDetail> getEquipmentSpotCheckDetailList() {
return !StringUtils.isEmpty(this.equipmentSpotCheckDetailJson) ? JSONObject.parseArray(this.equipmentSpotCheckDetailJson, MesEquipmentSpotCheckDetail.class) : null;
}
//从上下文中取出设备点检主数据关联零件表集合
public List<MesEquipmentSpotCheckPart> getEquipmentSpotCheckPartList() {
return !StringUtils.isEmpty(this.equipmentSpotCheckPartJson) ? JSONObject.parseArray(this.equipmentSpotCheckPartJson, MesEquipmentSpotCheckPart.class) : null;
}
//上下文赋值设备点检主数据主表集合
public MesEquipSpotCheckContext equipmentSpotCheckJson(List<MesEquipmentSpotCheck> equipmentSpotCheckList) {
if (CollectionUtils.isEmpty(equipmentSpotCheckList)) return this;
this.equipmentSpotCheckJson = JSONObject.toJSONString(equipmentSpotCheckList);
return this;
}
//上下文赋值设备点检主数据明细表集合
public MesEquipSpotCheckContext equipmentSpotCheckDetailJson(List<MesEquipmentSpotCheckDetail> equipmentSpotCheckDetailList) {
if (CollectionUtils.isEmpty(equipmentSpotCheckDetailList)) return this;
this.equipmentSpotCheckDetailJson = JSONObject.toJSONString(equipmentSpotCheckDetailList);
return this;
}
//上下文赋值设备点检主数据关联零件表集合
public MesEquipSpotCheckContext equipmentSpotCheckPartJson(List<MesEquipmentSpotCheckPart> equipmentSpotCheckPartList) {
if (CollectionUtils.isEmpty(equipmentSpotCheckPartList)) return this;
this.equipmentSpotCheckPartJson = JSONObject.toJSONString(equipmentSpotCheckPartList);
return this;
}
}

@ -1,7 +1,10 @@
package cn.estsh.i3plus.ext.mes.pcn.pojo.context;
import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
import cn.estsh.i3plus.pojo.mes.bean.*;
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 io.swagger.annotations.ApiParam;
import lombok.Data;
@ -77,8 +80,6 @@ public class MesProductionProcessContext implements Serializable {
@ApiParam("设备变量集合信息([Json]List<MesEquipmentVariable>)")
private String equipVariableJson;
@ApiParam("腔组信息([Json]List<MesCavityGroupDetailCfg>)")
private String cavityGroupDetailJson;
//---------------------- 构造方法 ---------------------------------------
public MesProductionProcessContext() {}
@ -300,17 +301,5 @@ public class MesProductionProcessContext implements Serializable {
this.equipVariableJson = JSONObject.toJSONString(equipmentVariableList);
return this.isNeedCache();
}
//从上下文中取出腔组信息
public List<MesCavityGroupDetailCfg> getCavityGroupDetailList() {
return !StringUtils.isEmpty(this.cavityGroupDetailJson) ? JSONObject.parseArray(this.cavityGroupDetailJson, MesCavityGroupDetailCfg.class) : null;
}
//上下文赋值数据变量对象集合
public MesProductionProcessContext cavityGroupDetailJson(List<MesCavityGroupDetailCfg> mesCavityGroupDetailCfgs) {
if (CollectionUtils.isEmpty(mesCavityGroupDetailCfgs)) return this;
if (!StringUtils.isEmpty(this.cavityGroupDetailJson)) mesCavityGroupDetailCfgs.addAll(getCavityGroupDetailList());
this.cavityGroupDetailJson = JSONObject.toJSONString(mesCavityGroupDetailCfgs);
return this.isNeedCache();
}
}

@ -85,6 +85,8 @@ public class MesPcnExtConstWords {
// 零件名称
public static final String PART_NAME = "partName";
// 设备代码
public static final String EQUIP_CODE = "equipCode";
// 设备代码
public static final String EQUIPMENT_CODE = "equipmentCode";
// 设备名称
public static final String EQUIPMENT_NAME = "equipmentName";
@ -323,6 +325,28 @@ public class MesPcnExtConstWords {
public static final String UNIT = "unit";
//包装规格数量
public static final String PACK_SPEC_QTY = "packSpecQty";
//点检类型
public static final String SPOT_CHECK_ITEM_TYPE = "spotCheckItemType";
//点检项目ID
public static final String SPOT_CHECK_ID = "spotCheckId";
//设定值录入方式
public static final String SET_VALUE_RECORD_TYPE = "setValueRecordType";
//实际值录入方式
public static final String REAL_VALUE_RECORD_TYPE = "realValueRecordType";
//设定值数值
public static final String SPOT_CHECK_SET_VALUE = "spotCheckSetValue";
//实际值数值
public static final String SPOT_CHECK_REAL_VALUE = "spotCheckRealValue";
//是否超差
public static final String IS_TOLERANCE = "isTolerance";
//点检结果
public static final String SPOT_CHECK_RESULT = "spotCheckResult";
//点检单据结果
public static final String SPOT_CHECK_ORDER_RESULT = "spotCheckOrderResult";
//点检单据时间
public static final String SPOT_CHECK_TIME = "spotCheckTime";
//点检人
public static final String SPOT_CHECK_USER = "spotCheckUser";
//BaseBean字段不包含工厂, 用于对象复制剔除属性BeanUtils.copyProperties(Object source, Object target, String... ignoreProperties)
@ -573,6 +597,8 @@ public class MesPcnExtConstWords {
public static final String PACKAGE_DATA_CONTEXT = "PACKAGE_DATA_CONTEXT";
// 打包规则上下文
public static final String PACKAGE_RULE_CONTEXT = "PACKAGE_RULE_CONTEXT";
// 设备点检上下文
public static final String EQUIP_SPOT_CHECK_CONTEXT = "EQUIP_SPOT_CHECK_CONTEXT";
// 上下文: 展示组件数据
public static final String MODULE_CONTENT_CONTEXT = "MODULE_CONTENT_CONTEXT";

Loading…
Cancel
Save