提交生产装配件清单，工单，零件清单

modules/i3plus-ext-mes-api/src/main/java/cn/estsh/i3plus/ext/mes/api/base/IMesBomService.java

@@ -45,5 +45,14 @@ public interface IMesBomService extends IBaseMesService<MesBom> {
     @ApiOperation(value = "递归查询bom数据")
     List<MesBom> findBomList(String organizeCode, MesPart mesPart, String bomVersion);
 
+    /**
+     * 根据生产版本和零件号查询bom
+     * @param organizeCode
+     * @param bomVersion
+     * @param partNo
+     * @return
+     */
+    MesBom findBom(String organizeCode, String bomVersion,String partNo);
+
 
 }

modules/i3plus-ext-mes-api/src/main/java/cn/estsh/i3plus/ext/mes/api/base/IMesBtoJobService.java

@@ -16,4 +16,11 @@ public interface IMesBtoJobService {
      * @param groupCodeList
      */
     void doCreateBto(String organizeCode, List<String> groupCodeList);
+
+    /**
+     * 武汉JIS按照零件生产组生成工单、零件清单、装配清单; 按包装圆整
+     * @param organizeCode
+     * @param groupCodeList
+     */
+    void doWhJisWorkOrder(String organizeCode, List<String> groupCodeList);
 }

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/schedulejob/MesWhJisCreateOrderJob.java

@@ -0,0 +1,82 @@
+package cn.estsh.i3plus.ext.mes.apiservice.schedulejob;
+
+import cn.estsh.i3plus.ext.mes.api.base.IMesBtoJobService;
+import cn.estsh.i3plus.mes.apiservice.schedulejob.BaseMesScheduleJob;
+import cn.estsh.impp.framework.boot.init.ApplicationProperties;
+import com.alibaba.fastjson.JSONObject;
+import io.swagger.annotations.ApiOperation;
+import org.apache.commons.lang3.StringUtils;
+import org.quartz.JobExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+/*
+入参
+{
+	"organizeCode": "CK01",
+	"partGroupCode": [
+		"CK01-Code",
+		"CK02-Code"
+	]
+
+}
+ */
+
+/**
+ * @Description : BTO生成工单
+ * @Reference :
+ * @Author : castle
+ * @CreateDate : 2024-05-10 11:03
+ * @Modify:
+ **/
+// 禁止 JOB 并发执行
+@Component
+@ApiOperation("武汉JIS生成工单")
+public class MesWhJisCreateOrderJob extends BaseMesScheduleJob {
+    public static final Logger LOGGER = LoggerFactory.getLogger(MesWhJisCreateOrderJob.class);
+
+    @Autowired
+    private IMesBtoJobService btoJobService;
+
+    public MesWhJisCreateOrderJob() {
+        super(MesWhJisCreateOrderJob.class, "武汉JIS生成工单");
+        this.setMultiInstance(true);
+    }
+
+    @Override
+    public void executeMesJob(JobExecutionContext context, ApplicationProperties applicationProperties) {
+        try {
+            String jobParam = this.getJobParam();
+
+            if (StringUtils.isBlank(jobParam)) {
+                throw new IllegalArgumentException("job参数为空，请检查参数");
+            }
+            Map<String, Object> paramMap;
+            try {
+                paramMap = (Map<String, Object>) JSONObject.parse(jobParam);
+            } catch (Exception e) {
+                LOGGER.error("参数格式不是JSON");
+                return;
+
+            }
+            if (CollectionUtils.isEmpty(paramMap)) {
+                LOGGER.error("BTO生成工单,没有配置参数");
+                return;
+            }
+            String organizeCode = (String) paramMap.get("organizeCode");
+            List<String> groupCodeList = (List<String>) paramMap.get("groupCode");
+            btoJobService.doCreateBto(organizeCode, groupCodeList);
+            LOGGER.info("BTO生成工单job结束 ----- end");
+
+        } catch (Exception e) {
+            LOGGER.error("BTO生成工单e:{}", Arrays.toString(e.getStackTrace()));
+        }
+    }
+
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesBomService.java

@@ -169,6 +169,15 @@ public class MesBomService extends BaseMesService<MesBom> implements IMesBomServ
         return new ArrayList<>(summaryBomMap.values());
     }
 
+    @Override
+    public MesBom findBom(String organizeCode, String bomVersion, String partNo) {
+        DdlPackBean bomPackBean = DdlPackBean.getDdlPackBean(organizeCode);
+        DdlPreparedPack.getStringEqualPack(partNo, "partNo", bomPackBean);
+        DdlPreparedPack.getStringEqualPack(bomVersion, "bomVersion", bomPackBean);
+        List<MesBom> bomList = this.baseRDao.findByHqlWhere(bomPackBean);
+        return bomList.isEmpty() ? null : bomList.get(0);
+    }
+
     /**
      * 递归展开 BOM
      *

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesBtoJobServiceImpl.java

@@ -45,6 +45,7 @@ public class MesBtoJobServiceImpl implements IMesBtoJobService {
     @Autowired
     private MesPartProdGroupWindowTimeRepository windowTimeRao;
 
+
     @Override
     public void doCreateBto(String organizeCode, List<String> groupCodeList) {
         //1. 根据 organizeCode 和 groupCodeList 查询零件生产组
@@ -58,6 +59,10 @@ public class MesBtoJobServiceImpl implements IMesBtoJobService {
             }
 
             List<MesPartProdGroupDetail> details = mesPartProdGroupService.findDetailByCode(prodGroup.getPartProdGroupCode(), organizeCode);
+            if (details.isEmpty()){
+                log.info("当前零件生产组:{}没有详情",prodGroup.getPartProdGroupCode());
+                return;
+            }
             List<String> custPartNoList = details.stream().map(MesPartProdGroupDetail::getCustPartNo).collect(Collectors.toList());
             List<MesCustSortInfo> sortInfoList = mesCustSoftInfoService.queryCustSortInfoList(prodGroup.getCustCode(), prodGroup.getCustOrganizeCode(), prodGroup.getCustInfoPoint(), organizeCode, custPartNoList);
 
@@ -85,6 +90,38 @@ public class MesBtoJobServiceImpl implements IMesBtoJobService {
         }
     }
 
+    @Override
+    public void doWhJisWorkOrder(String organizeCode, List<String> groupCodeList) {
+        //1.校验零件生产组是否有 -- return
+        List<MesPartProdGroup> mesPartProdGroups = mesPartProdGroupService.findMesPartProdGroups(organizeCode, groupCodeList);
+        if (mesPartProdGroups.isEmpty()){
+            log.info("当前配置的零件生产组代码:{},查询不到零件生产组信息",groupCodeList);
+        }
+        //2.循环遍历零件生产组
+        for (MesPartProdGroup prodGroup : mesPartProdGroups) {
+            //2. 根据生产组的infoPointCode 获取 过点信息MES_CUSTOMER_MESSAGE_POINT
+            MesCustomerMessagePoint messagePoint = mesCustomerMessagePointService.getPointByCode(prodGroup.getCustInfoPoint(),organizeCode);
+            if (messagePoint == null){
+                log.info("客户的信息点{}不存在",prodGroup.getCustInfoPoint());
+                continue;
+            }
+            List<MesPartProdGroupDetail> details = mesPartProdGroupService.findDetailByCode(prodGroup.getPartProdGroupCode(), organizeCode);
+            List<String> custPartNoList = details.stream().map(MesPartProdGroupDetail::getCustPartNo).collect(Collectors.toList());
+            List<MesCustSortInfo> sortInfoList = mesCustSoftInfoService.queryCustSortInfoList(prodGroup.getCustCode(), prodGroup.getCustOrganizeCode(), prodGroup.getCustInfoPoint(), organizeCode, custPartNoList);
+            if (sortInfoList.isEmpty()){
+                log.info("当前零件生产组:{}没有排序信息",prodGroup.getCustInfoPoint());
+                return;
+            }
+            //6. 根据零件生产组的RoundnessType 去做策略，现在只做 窗口时间 策略; 入参
+            String roundnessService = MesExtEnumUtil.SHIPPING_GROUP_ROUND_METHOD.valueOfService(prodGroup.getRoundMethod());
+            IRoundnessStrategy roundnessStrategy = (IRoundnessStrategy)SpringContextsUtil.getBean(roundnessService);
+            roundnessStrategy.execute(prodGroup,sortInfoList, details);
+        }
+
+
+    }
+
+
     /**
      * 排序信息不复用的时候
      * @param infoPointCode

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/roundness/MesPackageRoundnessService.java

@@ -0,0 +1,412 @@
+package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.roundness;
+
+import cn.estsh.i3plus.ext.mes.api.base.strategy.IRoundnessStrategy;
+import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.MesBomService;
+import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.MesCustSoftInfoServiceImpl;
+import cn.estsh.i3plus.ext.mes.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.mes.api.iservice.busi.ISyncFuncService;
+import cn.estsh.i3plus.platform.common.convert.ConvertBean;
+import cn.estsh.i3plus.platform.common.tool.TimeTool;
+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.bean.shipping.MesCustSortInfo;
+import cn.estsh.i3plus.pojo.mes.model.GenSerialNoModel;
+import cn.estsh.i3plus.pojo.mes.repository.*;
+import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * @Description : 按照包装圆整
+ * @Reference :
+ * @Author : Castle
+ * @CreateDate : 2024/6/2 21:22
+ * @Modify:
+ **/
+@Service
+public class MesPackageRoundnessService implements IRoundnessStrategy {
+
+    private static final Logger log = LoggerFactory.getLogger(MesPackageRoundnessService.class);
+    @Autowired
+    private IMesProdGroupPartBtoCountRepository btoCountRao;
+
+    @Autowired
+    private MesPartSapRepository mesPartSapRao;
+
+    @Autowired
+    private MesProductVersionRepository mesProductVersionRao;
+
+    @Autowired
+    private MesWorkOrderRepository mesWorkOrderRao;
+
+
+    @Autowired
+    private MesShiftRepository mesShiftRao;
+
+
+    @Autowired
+    private MesBomService mesBomService;
+
+    @Autowired
+    private MesBomRepository bomRao;
+
+    @Autowired
+    private MesProdRuleSortCfgRepository mesProdRuleSortCfgRao;
+
+    @Autowired
+    private MesWorkOrderPartRepository workOrderPartRao;
+
+    @Autowired
+    private MesWorkOrderAssemblyRepository workOrderAssemblyRao;
+
+    @Override
+    public void execute(MesPartProdGroup partProdGroup, List<MesCustSortInfo> sortInfoList, List<MesPartProdGroupDetail> details) {
+        try {
+            Map<String, MesPartProdGroupDetail> prodGroupDetailMap = details.stream().collect(Collectors.toMap(MesPartProdGroupDetail::getCustPartNo, Function.identity()));
+            //1.生产组中的圆整数量
+            double roundQty = Double.parseDouble(partProdGroup.getRoundQty());
+            //2.排序信息中的零件合计数量
+            double qty = sortInfoList.stream().map(MesCustSortInfo::getQty).reduce(Double::sum).get();
+            //3.当数量未达到圆整包装数时
+            if (qty < roundQty) {
+                //4.查看客户排序信息钟的最早的一条过点时间 + 生产组最晚生成时间是否已到达当前时间
+                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+                sortInfoList = sortInfoList.stream().sorted((sortInfo1, sortInfo2) -> {
+                    try {
+                        if (sdf.parse(sortInfo1.getMatchTime()).after(sdf.parse(sortInfo2.getMatchTime()))) {
+                            return 1;
+                        }
+                    } catch (ParseException e) {
+                        log.error("解析匹配时间报错:{}", e.getMessage());
+                    }
+                    return -1;
+                }).collect(Collectors.toList());
+
+                MesCustSortInfo sortInfo = sortInfoList.get(0);
+                //最晚延迟的时间
+                int latestCreationTime = Integer.parseInt(partProdGroup.getLatestCreationTime());
+                Calendar calendar = Calendar.getInstance();
+                calendar.setTime(sdf.parse(sortInfo.getMatchTime()));
+                calendar.add(Calendar.MINUTE, latestCreationTime);
+                Date laterTime = calendar.getTime();
+
+                if (laterTime.after(new Date())) {
+                    log.info("当前时间:{}没有达到最晚生成时间:{}", sdf.format(new Date()), sdf.format(laterTime));
+                    return;
+                } else {
+                    //如果最早来的排序信息的多点时间已经超过最晚生成时间，则圆整数为当前排序信息对应的合计数
+                    roundQty = qty;
+                }
+                //是否是头部零件
+                Integer isSeqInfoHeadPart = partProdGroup.getIsSeqInfoHeadPart();
+                if (isSeqInfoHeadPart == null || isSeqInfoHeadPart == CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) {
+                    log.info("非头零件不能按照包装圆整;零件生产组为:{}", partProdGroup.getPartProdGroupCode());
+                    return;
+                }
+
+                //扣减qty 生成工单
+                while (qty > 0) {
+                    //临时客户排序信息中的数量计数器
+                    double custSortRoundnessQty = roundQty;
+
+                    while (custSortRoundnessQty > 0) {
+                        sortInfo = sortInfoList.get(0);
+                        double custQty = sortInfo.getQty();
+                        //当客户排序信息中的数量大于剩余圆整数量要Break
+                        if (custQty > roundQty) {
+                            log.info("单笔订单数量大于圆整数量01,车号:{}", sortInfo.getVinCode());
+                            return;
+                        }
+                        if (custQty > custSortRoundnessQty) {
+                            log.info("单笔订单数量大于圆整数量02,车号:{}", sortInfo.getVinCode());
+                            return;
+                        }
+
+                        //查找该零件是否在生产组中
+                        MesPartProdGroupDetail mesPartProdGroupDetail = prodGroupDetailMap.get(sortInfo.getCustPartNo());
+                        if (mesPartProdGroupDetail == null) {
+                            log.info("生产组中未找到该零件:{}", sortInfo.getCustPartNo());
+                            return;
+                        }
+                        //生产零件号
+                        if (mesPartProdGroupDetail.getProductPartNo() == null) {
+                            mesPartProdGroupDetail.setProductPartNo(mesPartProdGroupDetail.getPartNo());
+                        }
+                        MesPartSap mesPart = this.getMesPart(mesPartProdGroupDetail.getProductPartNo(), partProdGroup.getOrganizeCode());
+
+                        if (mesPart == null) {
+                            log.info("{}工厂没有,零件:{}信息", partProdGroup.getOrganizeCode(), mesPartProdGroupDetail.getProductPartNo());
+                            return;
+                        }
+
+
+                        doCreateWorkOrder(partProdGroup,mesPartProdGroupDetail,mesPart,sortInfo);
+                    }
+                }
+
+
+            }
+        } catch (Exception e) {
+            log.error("按包装圆整出错:MesPackageRoundnessService", e);
+        }
+    }
+
+    private void doCreateWorkOrder(MesPartProdGroup partProdGroup, MesPartProdGroupDetail mesPartProdGroupDetail, MesPartSap partSap, MesCustSortInfo sortInfo) throws ParseException {
+
+        MesWorkOrder mesWorkOrder = new MesWorkOrder();
+
+        //工单版本号
+        mesWorkOrder.setProductVersion("1");
+        //工单类型
+        mesWorkOrder.setWorkOrderType(MesExtEnumUtil.ORDER_TYPE.SORT.getValue());
+        //订单序号=客户排序信息的序号
+        mesWorkOrder.setWorkOrderSeq(sortInfo.getCustInfoSeq().toString());
+        mesWorkOrder.setOrganizeCode(sortInfo.getOrganizeCode());
+        mesWorkOrder.setWorkCenterCode(mesPartProdGroupDetail.getWorkCenterCode());
+        mesWorkOrder.setWorkCellCode(mesPartProdGroupDetail.getWorkCellCode());
+
+        //来源
+        mesWorkOrder.setWorkOrderSource(sortInfo.getId().toString());
+
+        mesWorkOrder.setVinCode(sortInfo.getVinCode());
+        mesWorkOrder.setProductTime(sortInfo.getMatchTime());
+        mesWorkOrder.setPlanStartTime(sortInfo.getMatchTime());
+        mesWorkOrder.setPlanEndTime(sortInfo.getInfoPointTime());
+        //todo ptr信息
+        //mesWorkOrder.setPtrInfo(sortInfo.getRemark());
+        //客户订单号
+        mesWorkOrder.setCustOrderNo(sortInfo.getCustOrderCode());
+        //车型代码 todo
+        //mesWorkOrder.setCarModelCode(sortInfo.getCarModelCode());
+        //车型描述 mesWorkOrder.setCarName = vehicleClassCode
+
+        //备注取自于车型配置表中
+        //todo 根据VehicleNo车型代码，sortInfo.custCode,sortInfo.CustPlantCode,organizeCode 查询表TI_CIM_VEHICLE_MODEL的 remark 作为从车型配置表中获取打印备注信息
+
+        mesWorkOrder.setCustPartNo(sortInfo.getCustPartNo());
+//        mesWorkOrder.setCcrNo =  sortInfo.CcrNo
+//        mesWorkOrder.AssyCode = sortInfo.AssyCode
+//        mesWorkOrder.setVehicleYear = sortInfo.getVehicleYear()
+
+        // 11. 是否将生成日期减一天
+        // 班次 根据产线+计划时间匹配班次
+        DdlPackBean shiftPackBean = DdlPackBean.getDdlPackBean(mesPartProdGroupDetail.getOrganizeCode());
+        DdlPreparedPack.getStringEqualPack(mesPartProdGroupDetail.getWorkCenterCode(), "workCenterCode", shiftPackBean);
+        List<MesShift> shiftList = mesShiftRao.findByHqlWhere(shiftPackBean);
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        Date date = sdf.parse(sortInfo.getMatchTime());
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        int hours = calendar.get(Calendar.HOUR_OF_DAY);
+
+        int minutes = calendar.get(Calendar.MINUTE);
+        String shiftTime = String.format("%02d:%02d", hours, minutes);
+        if (!shiftList.isEmpty()) {
+            for (MesShift shift : shiftList) {
+                String startTime = shift.getStartTime().replace(":", "");
+                String endTime = shift.getEndTime().replace(":", "");
+                if ((shiftTime.compareTo(startTime) >= 0) && (shiftTime.compareTo(endTime) <= 0)) {
+                    mesWorkOrder.setShiftName(shift.getShiftName());
+                    mesWorkOrder.setShiftCode(shift.getShiftCode());
+                    break;
+                }
+            }
+        } else {
+            log.info("当前产线:{} 没有配置班次", mesPartProdGroupDetail.getWorkCenterCode());
+        }
+
+        //零件相关
+        mesWorkOrder.setPartNo(partSap.getPartNo());
+        mesWorkOrder.setPartName(partSap.getPartName());
+
+        // 13.生产版本 organizeCode + partNo
+        MesProductVersion prodVersion = getProdVersion(mesPartProdGroupDetail.getOrganizeCode(), partSap.getPartNo());
+        if (prodVersion == null) {
+            log.info("请配置工厂:{},partNo:{}的生产版本", mesPartProdGroupDetail.organizeCode, partSap.getPartNo());
+        } else {
+            String productVersion = prodVersion.getProductVersion();
+            mesWorkOrder.setProductVersion(productVersion);
+        }
+
+        //todo bom prodVersion.alternativePartList bom版本
+        MesBom bom = mesBomService.findBom(mesPartProdGroupDetail.getOrganizeCode(), prodVersion.getAlternativePartList(), partSap.getPartNo());
+//        if (bom != null){
+//            mesWorkOrder.setBomCode(bom.getBomCode())
+//        }
+
+        mesWorkOrder.setQty(sortInfo.getQty());
+        mesWorkOrder.setUnCompleteQty(sortInfo.getQty());
+        mesWorkOrder.setUnit(partSap.getUnit());
+
+        if (partProdGroup.getIsAutoRelease() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+            mesWorkOrder.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.RELEASE.getValue());
+        } else {
+            mesWorkOrder.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.CREATE.getValue());
+        }
+
+        mesWorkOrder.setPartProdGroupCode(partProdGroup.getPartProdGroupCode());
+        // todo 缺少单号 N 单字段
+        // todo 车型
+        // todo 客户零件条码
+        // 打散bom
+        List<MesWorkOrderPart> workOrderPartList = new ArrayList<>();
+        if (partProdGroup.getIsDisassembleBom() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+            workOrderPartList = dismantleBom(partSap.getPartNo(), mesWorkOrder.getQty(), sortInfo.getMatchTime(),bom.getBomCode(),sortInfo.getOrganizeCode(),mesPartProdGroupDetail.getWorkCellCode(), mesWorkOrder.getWorkOrderNo() );
+
+        }
+        //  生成装配件清单
+        List<MesWorkOrderAssembly> assemblyList = getAssemblyList(mesWorkOrder.getWorkCenterCode(), null, workOrderPartList, partProdGroup);
+        ConvertBean.saveOrUpdate(mesWorkOrder,"MES-JOB");
+        mesWorkOrderRao.insert(mesWorkOrder);
+
+        if (!workOrderPartList.isEmpty()) {
+            for (MesWorkOrderPart orderPart : workOrderPartList) {
+                ConvertBean.saveOrUpdate(orderPart,"MES-JOB");
+            }
+            workOrderPartRao.saveAll(workOrderPartList);
+        }
+
+        if (!assemblyList.isEmpty()){
+            for (MesWorkOrderAssembly orderAssembly : assemblyList) {
+                ConvertBean.saveOrUpdate(orderAssembly,"MES-JOB");
+            }
+            workOrderAssemblyRao.saveAll(assemblyList);
+        }
+
+    }
+
+
+    private List<MesWorkOrderAssembly> getAssemblyList(String workCenterCode, String VehicleNo,List<MesWorkOrderPart> workOrderPartList,MesPartProdGroup mesPartProdGroup){
+        //TM_BAS_WORK_ORDER_ASSEMBLY_SETTING 对应  mes_prod_rule_sort_cfg 排序生产规则
+
+        List<MesWorkOrderAssembly> workOrderAssemblyList = new ArrayList<>();
+        List<String> partNoList = workOrderPartList.stream().map(MesWorkOrderPart::getPartNo).collect(Collectors.toList());
+        DdlPackBean prodRuleSortPackBean = DdlPackBean.getDdlPackBean(mesPartProdGroup.getOrganizeCode());
+        DdlPreparedPack.getStringEqualPack(workCenterCode, "workCenterCode", prodRuleSortPackBean);
+        DdlPreparedPack.getInPackList(partNoList,"partNo",prodRuleSortPackBean);
+        List<MesProdRuleSortCfg> sortCfgList = mesProdRuleSortCfgRao.findByHqlWhere(prodRuleSortPackBean);
+        Map<String, MesWorkOrderPart> orderPartMap = workOrderPartList.stream().collect(Collectors.toMap(MesWorkOrderPart::getPartNo, Function.identity()));
+        //遍历排序生产规则
+        for (MesProdRuleSortCfg sortCfg : sortCfgList) {
+            MesWorkOrderPart orderPart = orderPartMap.get(sortCfg.getAssemblyPartNo());
+            //1.逻辑储量程序sortCfg.isLogicNum
+            MesWorkOrderAssembly orderAssembly = new MesWorkOrderAssembly();
+            orderAssembly.setPartNo(orderPart.getPartNo());
+            orderAssembly.setWorkCellCode(sortCfg.getWorkCellCode());
+            orderAssembly.setOrderPartId(orderPart.getId().toString());
+            orderAssembly.setEquipmentCode(sortCfg.getEquipmentCode());
+            orderAssembly.setReportType(sortCfg.getReportType());
+            orderAssembly.setReportPartNo(sortCfg.getReportPartNo());
+            orderAssembly.setImageFileId(sortCfg.getImageFileId());
+            orderAssembly.setCraftCode(sortCfg.getCraftCode());
+            orderAssembly.setCraftName(sortCfg.getCraftName());
+            orderAssembly.setPartTypeCode(sortCfg.getPartTypeCode());
+            orderAssembly.setShowColor(sortCfg.getShowColor());
+            orderAssembly.setProductPartNo(sortCfg.getProductPartNo());
+            workOrderAssemblyList.add(orderAssembly);
+        }
+
+        return workOrderAssemblyList;
+    }
+    private List<MesWorkOrderPart> dismantleBom(String partNo, double qty, String productTime, String bomCode, String organizeCode, String workCellCode, String workOrderNo) {
+        List<MesWorkOrderPart> orderPartList = new ArrayList<>();
+
+        //1.根据bomCode,partNo productTime organizeCode 查询bom清单 bomList
+        List<MesBom> bomList = getPlatBom(partNo, productTime, bomCode, organizeCode);
+        //2.根据bomList中的subPartNo 查询零件清单 partList
+        List<String> partNoList = bomList.stream().map(MesBom::getItemPartNo).distinct().collect(Collectors.toList());
+
+        DdlPackBean partPackBean = DdlPackBean.getDdlPackBean(organizeCode);
+        DdlPreparedPack.getInPackList(partNoList,"partNo", partPackBean);
+        List<MesPartSap> partSapList = mesPartSapRao.findByHqlWhere(partPackBean);
+        Map<String, MesPartSap> partMap = partSapList.stream().collect(Collectors.toMap(MesPartSap::getPartNo, Function.identity()));
+
+
+        for (MesBom bom : bomList) {
+            MesWorkOrderPart orderPart = new MesWorkOrderPart();
+            MesPartSap partSap = partMap.get(bom.getItemPartNo());
+            if (partSap == null) {
+                log.info("工厂:{},零件号:{}未查到零件信息", organizeCode,bom.getItemPartNo());
+                return null;
+            }
+            List<MesWorkOrderPart> orderParts = orderPartList.stream().filter(item -> item.getPartNo().equals(partSap.getPartNo())).collect(Collectors.toList());
+           if (!orderParts.isEmpty()) {
+               MesWorkOrderPart tempPart = orderParts.get(0);
+               tempPart.setItemQty(tempPart.getItemQty() + bom.getItemQty() * qty);
+               continue;
+           }
+            orderPart.setPartName(partSap.getPartName());
+            orderPart.setPartNo(partSap.getPartNo());
+            orderPart.setItemQty(bom.getItemQty() * qty);
+            orderPart.setItemUnit(partSap.getUnit());
+            orderPart.setSourceId(bom.getId());
+            orderPart.setShippingPartNo(partSap.getPartNo());
+            orderPart.setWorkOrderNo(workOrderNo);
+            orderPart.setWorkCellCode(workCellCode);
+            orderPartList.add(orderPart);
+        }
+        //3.遍历bomList
+        return orderPartList;
+    }
+
+
+    private List<MesBom> getPlatBom(String partNo, String effectiveTime, String bomCode, String organizeCode) {
+        if (bomCode == null){
+            //首先根据虚结构的零件号查询出最新的一条bom信息作为bomCode
+            DdlPackBean bomCodePackBean = DdlPackBean.getDdlPackBean(organizeCode);
+            DdlPreparedPack.getStringEqualPack(partNo, "partNo", bomCodePackBean);
+            DdlPreparedPack.getTimeBetweenCol(effectiveTime,"effStartTime","effEndTime",bomCodePackBean,false);
+            DdlPreparedPack.getOrderBy("effStartTime", CommonEnumUtil.ASC_OR_DESC.DESC.getValue(), bomCodePackBean);
+            List<MesBom> bomList = bomRao.findByHqlTopWhere(bomCodePackBean,1);
+            if (bomList == null || bomList.isEmpty()){
+                return new ArrayList<>();
+            }
+            bomCode = bomList.get(0).getBomCode();
+        }
+        List<MesBom> bomResultList = new ArrayList<>();
+        DdlPackBean bomPackBean = DdlPackBean.getDdlPackBean(organizeCode);
+        DdlPreparedPack.getStringEqualPack(bomCode, "bomCode", bomPackBean);
+        DdlPreparedPack.getStringEqualPack(partNo, "partNo", bomPackBean);
+        DdlPreparedPack.getTimeBetweenCol(effectiveTime,"effStartTime","effEndTime",bomPackBean,false);
+        List<MesBom> bomList = bomRao.findByHqlWhere(bomPackBean);
+
+        for (MesBom bom : bomList) {
+          if (bom.getPartType()!=null && bom.getPartType().equalsIgnoreCase("X")){
+              getPlatBom(bom.getItemPartNo(),effectiveTime,null,organizeCode);
+          }else {
+              bom.setBomCode(bom.getBomCode().toLowerCase());
+              bomResultList.add(bom);
+          }
+
+        }
+
+        return bomResultList;
+    }
+
+    private MesPartSap getMesPart(String productPartNo, String organizeCode) {
+        DdlPackBean ddlPackBean = DdlPackBean.getDdlPackBean(organizeCode);
+        DdlPreparedPack.getStringEqualPack(productPartNo, "partNo", ddlPackBean);
+        List<MesPartSap> parts = mesPartSapRao.findByHqlWhere(ddlPackBean);
+        return parts.isEmpty() ? new MesPartSap() : parts.get(0);
+    }
+
+    private MesProductVersion getProdVersion(String organizeCode, String partNo) {
+        DdlPackBean ddlPackBean = DdlPackBean.getDdlPackBean(organizeCode);
+        DdlPreparedPack.getStringEqualPack(partNo, "partNo", ddlPackBean);
+        List<MesProductVersion> mesProductVersionList = mesProductVersionRao.findByHqlWhere(ddlPackBean);
+        return mesProductVersionList.isEmpty() ? null : mesProductVersionList.get(0);
+    }
+
+
+}