//package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.base.ep;
//
//import cn.estsh.i3plus.ext.mes.pcn.api.base.INumberRuleExtService;
//import cn.estsh.i3plus.ext.mes.pcn.api.base.IPartExtService;
//import cn.estsh.i3plus.ext.mes.pcn.api.base.ep.IEpModulePackageTaskService;
//import cn.estsh.i3plus.ext.mes.pcn.api.busi.IPackageExtService;
//import cn.estsh.i3plus.ext.mes.pcn.api.busi.IProductEncodeCfgExtService;
//import cn.estsh.i3plus.ext.mes.pcn.api.busi.ISxNumberRuleCheckAttributeService;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.bean.*;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.model.ContainerModel;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.repository.*;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.util.ConvertBeanExt;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtConstWords;
//import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtEnumUtil;
//import cn.estsh.i3plus.mes.pcn.api.iservice.busi.ISyncFuncService;
//import cn.estsh.i3plus.platform.common.convert.ConvertBean;
//import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum;
//import cn.estsh.i3plus.platform.common.tool.MathOperation;
//import cn.estsh.i3plus.platform.common.tool.TimeTool;
//import cn.estsh.i3plus.pojo.base.bean.BaseResultBean;
//import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
//import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
//import cn.estsh.i3plus.pojo.base.enumutil.MesPcnEnumUtil;
//import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
//import cn.estsh.i3plus.pojo.mes.bean.MesContainer;
//import cn.estsh.i3plus.pojo.mes.bean.MesPartContainerCapacity;
//import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
//import cn.estsh.i3plus.pojo.mes.model.GenSerialNoModel;
//import cn.estsh.i3plus.pojo.mes.repository.MesContainerRepository;
//import cn.estsh.i3plus.pojo.mes.repository.MesPartContainerCapacityRepository;
//import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
//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.transaction.annotation.Transactional;
//import org.springframework.util.CollectionUtils;
//import org.springframework.util.StringUtils;
//
//import java.math.BigDecimal;
//import java.math.RoundingMode;
//import java.util.*;
//import java.util.stream.Collectors;
//
///**
// * 文件描述
// *
// * @author xiangming.liao
// * @date 2021年03月23日 11:23
// */
//@Slf4j
//@Service
//@Transactional(readOnly = false)
//public class EpModulePackageTaskServiceBak implements IEpModulePackageTaskService {
//
//    @Autowired
//    private MesWorkOrderExtRepository workOrderExtRepository;
//
//    @Autowired
//    private MesContainerRepository containerRepository;
//
//    @Autowired
//    private MesPartContainerCapacityRepository partContainerCapacityRepository;
//
//    @Autowired
//    private MesPackageRecordRepository packageRecordRepository;
//
//    @Autowired
//    private MesPackageExtRepository packageExtRepository;
//
//    @Autowired
//    private ISyncFuncService syncFuncService;
//
//    @Autowired
//    private SxProductOffLineRepository productOffLineRepository;
//
//    @Autowired
//    private SxProductOffLineExtRepository productOffLineExtRepository;
//
//    @Autowired
//    private IPartExtService partExtService;
//
//    @Autowired
//    private MesOutPutStatisticsRepository outPutStatisticsRepository;
//
//    @Autowired
//    private MesWorkCenterExtRepository workCenterExtRepository;
//
//    @Autowired
//    private IProductEncodeCfgExtService productEncodeCfgExtService;
//
//    @Autowired
//    private ISxNumberRuleCheckAttributeService iSxNumberRuleCheckAttributeService;
//
//    @Autowired
//    private INumberRuleExtService numberRuleExtService;
//
//    @Autowired
//    private IPackageExtService packageExtService;
//
//    @Override
//    public MesWorkOrderExt queryWorkOrderByCenter(String workCenterCode, String organizeCode) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(workCenterCode, MesPcnExtConstWords.WORK_CENTER_CODE, packBean);
//        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.WORK_ORDER_STATUS.OPEN.getValue(), MesPcnExtConstWords.WORK_ORDER_STATUS, packBean);
//        packBean.setOrderByStr(" order by seq desc ");
//        List<MesWorkOrderExt> workOrderExts = workOrderExtRepository.findByHqlWhere(packBean);
//        //获取工单集合中顺序最小的工单
//        MesWorkOrderExt workOrderExt = new MesWorkOrderExt();
//        if (!CollectionUtils.isEmpty(workOrderExts)) {
//            workOrderExt = workOrderExts.stream().min(Comparator.comparing(MesWorkOrder::getSeq)).get();
//        }
//        return workOrderExt;
//    }
//
//    @Transactional(readOnly = false)
//    @Override
//    public ContainerModel queryContainerByScanBarcode(String workOrderNo, String barcode, String organizeCode, String userName, String workCellCode) {
//
//        //查询工单信息
//        MesWorkOrderExt workOrderExt = getWorkOrderExtByWorkOrderNo(workOrderNo, organizeCode);
//        String partNo = workOrderExt.getPartNo();
//        String workCenterCode = workOrderExt.getWorkCenterCode();
//        //1、根据条码查询容器是否存在
//        MesContainer containerByDb = getContainerByBarCode(barcode, organizeCode);
//
//        MesWorkCenterExt workCenterExt = getWorkCenterExtByWorkCenterCode(organizeCode, workOrderExt.getWorkCenterCode());
//
//        if (null != containerByDb) {
//            //判断工单物料是否匹配容器物料
//            String ctCode = containerByDb.getCtCode();
//            MesPartContainerCapacity partContainerCapacity = getPartContainerCapacity(organizeCode, ctCode, partNo);
//            if (null == partContainerCapacity) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("该容器未配置装此物料，请重新扫描")
//                        .build();
//            }
//
//            //判断容器状态是否为占用
//            if (MesPcnExtEnumUtil.CONTAINER_USE_STATUS.OCCUPY.getValue().equals(containerByDb.getUseStatus())) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("该容器已被占用，请重新扫描")
//                        .build();
//            }
//            //查询是否有工单包装操作记录
//            List<MesPackageRecord> packageRecords = getPackageRecordsByBarcode(barcode, null, organizeCode);
//            //判断操作记录中是否有其他工单输入的数量
//            List<MesPackageRecord> recordsByWorkOrderNo = packageRecords.stream().filter(p -> !p.getWorkOrderNo().equals(workOrderNo)).collect(Collectors.toList());
//            if (!CollectionUtils.isEmpty(recordsByWorkOrderNo)) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("该容器已被其他工单占用，请重新扫描")
//                        .build();
//            }
//            //判断操作记录中是否有其他产线输入的数量
//            List<MesPackageRecord> recordsByWorkCenterCode = packageRecords.stream().filter(p -> !p.getWorkCenterCode().equals(workCenterCode)).collect(Collectors.toList());
//            if (!CollectionUtils.isEmpty(recordsByWorkCenterCode)) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("该容器已被其他产线占用，请重新扫描")
//                        .build();
//            }
//
//
//            if(Double.valueOf(partContainerCapacity.getCtQty()) == 1.0){
//                MesPackageRecord packageRecord = new MesPackageRecord();
//                ConvertBean.serviceModelInitialize(packageRecord,userName);
//                packageRecord.setCtNo(barcode);
//                packageRecord.setPartNo(partNo);
//                packageRecord.setQty(1.0);
//                packageRecord.setOrganizeCode(organizeCode);
//                packageRecord.setWorkCenterCode(workCenterCode);
//                packageRecord.setWorkCellCode(workCellCode);
//                packageRecord.setWorkOrderNo(workOrderNo);
//                ContainerModel containerModel = new ContainerModel();
//                containerModel.setPackFlag(insertCompleteQty(packageRecord));
//            }else {
//                //汇总已装数量
//                Double totalQty = packageRecords.stream().map(MesPackageRecord::getQty).reduce(0.0, Double::sum);
//                ContainerModel containerModel = new ContainerModel();
//                containerModel.setUsedCtQty(totalQty);
//                containerModel.setCtQty(Double.valueOf(partContainerCapacity.getCtQty()));
//                containerModel.setPartNo(partNo);
//                containerModel.setPackageRecordList(packageRecords);
//                containerModel.setPackageType(MesPcnExtEnumUtil.PACKAGE_RECORD_TYPE.CONTAINER.getValue());
//                containerModel.setPackFlag(false);
//                return containerModel;
//            }
//        }
//        // 不存在则根据条码查询包装表
//        MesPackageExt mesPackageExtDb = getMesPackageByBarCode(barcode, organizeCode);
//
//        // 设置编码类型为物料类型
//        Integer codeType = MesPcnExtEnumUtil.ENCODE_CODE_TYPE.PACK_SN.getValue();
//
//        MesPartExt partDb = partExtService.getPartExt(organizeCode, partNo);
//
//        // 当前标包数量
//        Double curPackSpecQty;
//        if(partDb == null){
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("工单关联的物料不存在")
//                    .build();
//        }
//
//        // 根据组织代码、编码类型、物料、产线代码 获取编码规则代码
//        String ruleCode;
//        try {
//            ruleCode = productEncodeCfgExtService.getRuleCodeByMatchType(organizeCode, codeType, partDb, workCenterCode);
//        } catch (Exception e) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("当前执行工单号[%s]关联的物料[%s]:[%s]", workOrderNo, partNo, e.getMessage())
//                    .build();
//        }
//
//        // 根据编码规则代码获取编码规则
//        MesNumberRuleExt numberRuleDb = numberRuleExtService.getNumberRuleExtByRuleCode(organizeCode, ruleCode);
//
//        if(numberRuleDb == null || StringUtils.isEmpty(numberRuleDb.getRuleLengthSpilt()) || StringUtils.isEmpty(numberRuleDb.getMethodName())){
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("当前执行工单号[%s]关联的物料[%s]配置的编码规则代码[%s]无效", workOrderNo, partNo, ruleCode)
//                    .build();
//        }
//
//        Map<String,Object> map = new LinkedHashMap<>();
//
//        map.put(MesPcnExtConstWords.SERIAL_NUMBER, barcode);
//        map.put(MesPcnExtConstWords.NUMBER_RULE_EXT, numberRuleDb);
//        map.put(MesPcnExtConstWords.PART_EXT, partDb);
//
//        Map<String,Object> resultMap = iSxNumberRuleCheckAttributeService.doCheckNumberRule(map);
//        if((Boolean)resultMap.get(MesPcnExtConstWords.RESULT) == false){
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("当前执行工单号[%s]关联的物料[%s]配置的编码规则代码[%s]无效", workOrderNo, partNo, ruleCode)
//                    .build();
//        }
//
//        if(mesPackageExtDb != null){
//            if (!mesPackageExtDb.getPartNo().equals(partNo)) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("该容器未配置装此物料，请重新扫描")
//                        .build();
//            }
//
//            if (MesPcnExtEnumUtil.PACKAGE_IS_SEALED.SEALED.getValue() == mesPackageExtDb.getIsSealed()) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("【%s】包装已封箱", barcode)
//                        .build();
//            }
//
//            if(workOrderExt.getWorkOrderType() == MesPcnExtEnumUtil.WORK_ORDER_TYPE.REWORK_ORDER.getValue()){
//                if(mesPackageExtDb.getLastWorkOrderNo() == mesPackageExtDb.getWorkOrderNo()){
//                    throw ImppExceptionBuilder.newInstance()
//                            .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                            .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                            .setErrorDetail("条码[%s]不为返工条码", barcode)
//                            .build();
//                }
//            }
//            curPackSpecQty = mesPackageExtDb.getPackSpecQty();
//        }else {
//            //校验物料信息维护包装数量
//
//            if (partDb.getQty2() == null || partDb.getQty2() <= 0) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("请在物料信息中维护包装数量", workOrderNo, partNo)
//                        .build();
//            }
//
//            List<MesPackageExt> packageExtList =  packageExtService.getPackageListByWorkOrderNo(organizeCode, workOrderNo);
//
//            log.info("packageExtList ：{}",packageExtList);
//            Double assignedQty = 0.0;
//            if(!CollectionUtils.isEmpty(packageExtList)){
//                assignedQty = packageExtList.stream().map(MesPackageExt::getPackSpecQtyVal).reduce(0.00, Double::sum);
//            }
//
//            //剩余未分配的工单计划数量
//            double residuePlanQty = MathOperation.sub(workOrderExt.getQty(), assignedQty);
//            //包装条码包装数量
//            double packSpecQty;
//            if(residuePlanQty > 0 && MathOperation.compareTo(partDb.getQty2(), residuePlanQty) >= 0){
//                packSpecQty = residuePlanQty;
//            }else if(residuePlanQty > 0){
//                packSpecQty = partDb.getQty2();
//            }else {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("工单[%s]的包装数量已达到要求",workOrderNo)
//                        .build();
//            }
//            if(mesPackageExtDb == null){
//                log.info("mesPackageExtDb 不为空:{}",mesPackageExtDb);
//                MesPackageExt pack = new MesPackageExt();
//                pack.setPackageNo(barcode);
//                pack.setWorkOrderNo(workOrderNo);
//                pack.setLastWorkOrderNo(workOrderNo);
//                pack.setPartNo(partDb.getPartNo());
//                pack.setPartNameRdd(partDb.getPartName());
//                pack.setQty(0.0);
////                pack.setPackSpec(prodPackDb.getPackSpec());
//                pack.setPackSpecQty(packSpecQty);
////                pack.setPackageLabelTemplate(prodPackDb.getPackLabelTemplate());
//                pack.setUnit(partDb.getUnit());
//                pack.setIsSealed(MesPcnEnumUtil.PACKAGE_IS_SEALED.UNSEALED.getValue());
//                pack.setPrintStatus(MesPcnEnumUtil.PACKAGE_PRINT_STATUS.UNPRINTED.getValue());
//                pack.setPackLevel(MesPcnEnumUtil.PACKAGE_PACKLEVEL.FIRST.getValue());
//                pack.setWorkCenterCode(workOrderExt.getWorkCenterCode());
//                pack.setOrganizeCode(workOrderExt.getOrganizeCode());
//                ConvertBean.serviceModelInitialize(pack, userName);
//                pack.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//                pack.setPartLotNo(String.valueOf(resultMap.get(MesPcnExtConstWords.L)));
//                pack.setWorkTime(workCenterExt.getWorkTime());
//                pack.setShiftCode(workCenterExt.getShiftCode());
//                new ConvertBeanExt(pack).convertBean(pack);
//                packageExtRepository.insert(pack);
//            }
//            curPackSpecQty = packSpecQty;
//        }
//
//        List<MesPackageRecord> packageRecords = getPackageRecordsByBarcode(null, barcode, organizeCode);
//        //判断操作记录中是否有其他工单输入的数量
//        List<MesPackageRecord> recordsByWorkOrderNo = packageRecords.stream().filter(p -> !p.getWorkOrderNo().equals(workOrderNo)).collect(Collectors.toList());
//        log.info("recordsByWorkOrderNo ：{}",recordsByWorkOrderNo);
//        if (!CollectionUtils.isEmpty(recordsByWorkOrderNo)) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("该容器已被其他工单占用，请重新扫描")
//                    .build();
//        }
//        //判断操作记录中是否有其他产线输入的数量
//        List<MesPackageRecord> recordsByWorkCenterCode = packageRecords.stream().filter(p -> !p.getWorkCenterCode().equals(workCenterCode)).collect(Collectors.toList());
//        if (!CollectionUtils.isEmpty(recordsByWorkCenterCode)) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("该容器已被其他产线占用，请重新扫描")
//                    .build();
//        }
//
//        if(curPackSpecQty == 1.0){
//            MesPackageRecord packageRecord = new MesPackageRecord();
//            ConvertBean.serviceModelInitialize(packageRecord, userName);
//            packageRecord.setCtNo(barcode);
//            packageRecord.setPartNo(partNo);
//            packageRecord.setQty(1.0);
//            packageRecord.setOrganizeCode(organizeCode);
//            packageRecord.setWorkCenterCode(workCenterCode);
//            packageRecord.setWorkCellCode(workCellCode);
//            packageRecord.setWorkOrderNo(workOrderNo);
//            ContainerModel containerModel = new ContainerModel();
//            containerModel.setPackFlag(insertCompleteQty(packageRecord));
//            return containerModel;
//        }
//        //汇总已装数量
//        Double totalQty = packageRecords.stream().map(MesPackageRecord::getQty).reduce(0.0, Double::sum);
//        ContainerModel containerModel = new ContainerModel();
//        containerModel.setUsedCtQty(totalQty);
//        containerModel.setCtQty(curPackSpecQty);
//        containerModel.setPartNo(partNo);
//        containerModel.setPackageRecordList(packageRecords);
//        containerModel.setPackageType(MesPcnExtEnumUtil.PACKAGE_RECORD_TYPE.PACKAGE.getValue());
//        containerModel.setPackFlag(false);
//        return containerModel;
//    }
//
//    @Override
//    public Boolean insertCompleteQty(MesPackageRecord packageRecord) {
//        String organizeCode = packageRecord.getOrganizeCode();
//        String workOrderNo = packageRecord.getWorkOrderNo();
//        String modifyUser = packageRecord.getModifyUser();
//        MesWorkOrderExt workOrderExt = getWorkOrderExtByWorkOrderNo(workOrderNo, organizeCode);
//        String workCenterCode = workOrderExt.getWorkCenterCode();
//        //产线信息
//        MesWorkCenterExt workCenterExt = getWorkCenterExtByWorkCenterCode(organizeCode, workCenterCode);
//        if (null == workCenterExt) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("产线【%s】不存在，请重新扫描！", workCenterCode)
//                    .build();
//        }
//
//        if (StringUtils.isEmpty(workCenterExt.getWorkTime())) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("产线【%s】启动时间为空，请重新扫描！", workCenterCode)
//                    .build();
//        }
//
//        packageRecord.setLotNo(workCenterExt.getWorkTime());
//        MesContainer containerByDb = getContainerByBarCode(packageRecord.getCtNo(), organizeCode);
//        //判断扫描的是否是容器
//        if (null != containerByDb) {
//            //扫描容器的情况
//            return scanContainerConfirm(packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterExt);
//
//        } else {
//            //扫描包装的情况
//            return scanPackageConfirm(packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterExt);
//        }
//    }
//
//    @Override
//    public void deletePackageRecord(Long[] ids, String organizeCode, String modifyUser) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getInPackArray(ids, MesPcnExtConstWords.ID, packBean);
//        List<MesPackageRecord> packageRecordsByDb = packageRecordRepository.findByHqlWhere(packBean);
//        List<MesPackageRecord> packageRecords = new ArrayList<>();
//        for (MesPackageRecord packageRecord : packageRecordsByDb) {
//            packageRecord.setIsDeleted(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
//            ConvertBean.saveOrUpdate(packageRecord, modifyUser);
//            packageRecords.add(packageRecord);
//        }
//        packageRecordRepository.saveAll(packageRecords);
//    }
//
//    @Override
//    public void  doCompletePackage(String workOrderNo, String partNo, String barcode, String organizeCode, String modifyUser) {
//        //工单信息
//        MesWorkOrderExt workOrderExt = getWorkOrderExtByWorkOrderNo(workOrderNo, organizeCode);
//        String workCenterCode = workOrderExt.getWorkCenterCode();
//        //产线信息
//        MesWorkCenterExt workCenterExt = getWorkCenterExtByWorkCenterCode(organizeCode, workCenterCode);
//        //容器信息
//        MesContainer containerByBarCode = getContainerByBarCode(barcode, organizeCode);
//        //物料信息
//        MesPartExt partExt = partExtService.getPartExt(organizeCode, partNo);
//        String unit = partExt.getUnit();
//        String partName = partExt.getPartName();
//        //类型
//        String categoryCode1 = partExt.getCategoryCode1();
//        //判断扫描的是否是容器
//        if (null != containerByBarCode) {
//
//            //扫描容器的情况
//            String ctNo = containerByBarCode.getCtNo();
//            String ctCode = containerByBarCode.getCtCode();
//            List<MesPackageRecord> packageRecordList = getPackageRecordsByCtNo(ctNo, workOrderNo, organizeCode, false);
//            //已装数量
//            Double installQty = packageRecordList.stream().map(MesPackageRecord::getQty).reduce(0.0, Double::sum);
//            //产品容器容量信息
//            MesPartContainerCapacity partContainerCapacity = getPartContainerCapacity(organizeCode, ctCode, partNo);
//
//            //所有包装记录  包装编号字段赋值
//            String packageNo = getPackage(organizeCode);
//            List<MesPackageRecord> packageRecordsByCtNo = getPackageRecordsByCtNo(ctNo, workOrderNo, organizeCode, false);
//            for (MesPackageRecord mesPackageRecord : packageRecordsByCtNo) {
//                mesPackageRecord.setPackageNo(packageNo);
//                ConvertBean.serviceModelUpdate(mesPackageRecord, modifyUser);
//            }
//            packageRecordRepository.saveAll(packageRecordsByCtNo);
//
//            //将包装记录中 容器使用状态改为占用
//            updateContainerUseStatus(organizeCode, workOrderNo, modifyUser, barcode, false);
//
//            //生成包装编号,汇总包装数量，存入包装记录表
//            MesPackageRecord packageRecord = new MesPackageRecord();
//            packageRecord.setWorkOrderNo(workOrderNo);
//            packageRecord.setCtNo(ctNo);
//            packageRecord.setPartNo(partNo);
//            packageRecord.setPackageNo(getPackage(organizeCode));
//            packageRecord.setQty(installQty);
//            packageRecord.setUnit(unit);
//            packageRecord.setPartName(partName);
//            packageRecord.setPartType(Integer.parseInt(categoryCode1));
//            packageRecord.setLotNo(workCenterExt.getWorkTime());
//            packageRecord.setOrganizeCode(organizeCode);
//            ConvertBean.serviceModelInitialize(packageRecord, modifyUser);
//
//            //packageRecordRepository.save(packageRecord);
//
//            //存入包装表
//            MesPackageExt mesPackageExt = new MesPackageExt();
//            BeanUtils.copyProperties(packageRecord, mesPackageExt, MesPcnExtConstWords.ID);
//            mesPackageExt.setLastWorkOrderNo(mesPackageExt.getWorkOrderNo());
//            mesPackageExt.setPartNameRdd(packageRecord.getPartName());
//            mesPackageExt.setWorkCellCode(packageRecordList.get(0).getWorkCellCode());
//            mesPackageExt.setPackSpecQty(Double.valueOf(partContainerCapacity.getCtQty()));
//            mesPackageExt.setIsSealed(MesPcnExtEnumUtil.PACKAGE_IS_SEALED.SEALED.getValue());
//            mesPackageExt.setPrintStatus(MesPcnExtEnumUtil.PRODUCE_SN_PRINT_STATUS.UNPRINT.getValue());
//            mesPackageExt.setWorkCenterCode(workCenterCode);
//            mesPackageExt.setOrganizeCode(organizeCode);
//            ConvertBean.serviceModelInitialize(mesPackageExt, modifyUser);
//            mesPackageExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//            mesPackageExt.setWorkTime(workCenterExt.getWorkTime());
//            mesPackageExt.setShiftCode(workCenterExt.getShiftCode());
//            new ConvertBeanExt(mesPackageExt).convertBean(mesPackageExt);
//            packageExtRepository.insert(mesPackageExt);
//
//            //工单完工数量累加
//            //已装数量+工单完工数量
//            Double completeInstallQty = doubleSum(installQty, workOrderExt.getCompleteQty());
//            updateWorkOrderCompleteQty(workOrderExt, completeInstallQty, modifyUser);
//
//            //修改容器状态为占用
//            updateContainerUseStatus(ctNo, MesPcnExtEnumUtil.CONTAINER_USE_STATUS.OCCUPY.getValue(), modifyUser);
//
//            //存入报工接口表
//            SxProductOffLine productOffLine = saveOffLine(packageRecord, mesPackageExt.getPartLotNo(), workOrderExt, organizeCode, modifyUser);
//
//            //存入包装关系接口表
//            saveOffLineExt(productOffLine, ctNo, modifyUser);
//
//            //进行产量统计
//            doOutPutStatistics(organizeCode, workOrderExt, modifyUser, installQty, partExt, workCenterExt);
//
//            //包装记录状态解绑
//            updatePackageNoIsNull(organizeCode, ctNo, modifyUser);
//
//            //已装数量+工单完工数量是否等于工单计划数量
//            Boolean isEqualToWorkOrderPlanQty = completeInstallQty.compareTo(workOrderExt.getQty()) == 0;
//            if (isEqualToWorkOrderPlanQty) {
//                //如果达到工单计划数量，关闭工单。
//                workOrderExt.setWorkOrderStatus(MesPcnExtEnumUtil.WORK_ORDER_STATUS.CLOSE.getValue());
//                ConvertBean.serviceModelUpdate(workOrderExt, modifyUser);
//                workOrderExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//                new ConvertBeanExt(workOrderExt).convertBean(workOrderExt);
//                workOrderExtRepository.save(workOrderExt);
//            }
//
//
//        } else {
//            //扫描包装的情况
//
//            List<MesPackageRecord> packageRecordList = getPackageRecordsByCtPackageNo(barcode, workOrderNo, organizeCode, false);
//            //已装数量
//            Double installQty = packageRecordList.stream().map(MesPackageRecord::getQty).reduce(0.0, Double::sum);
//            //包装信息
//            MesPackageExt mesPackageExt = getMesPackageByBarCode(barcode, organizeCode, workCenterCode, workOrderNo);
//
//            if(workOrderExt.getWorkOrderType() == MesPcnExtEnumUtil.WORK_ORDER_TYPE.REWORK_ORDER.getValue()){
//                if(mesPackageExt.getLastWorkOrderNo().equals(mesPackageExt.getWorkOrderNo())){
//                    throw ImppExceptionBuilder.newInstance()
//                            .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                            .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                            .setErrorDetail("条码[%s]不为返工条码", barcode)
//                            .build();
//                }
//            }
//
//            //将包装记录中 容器使用状态改为占用
//            updateContainerUseStatus(organizeCode, workOrderNo, modifyUser, barcode, true);
//
//            //生成包装编号,汇总包装数量，存入包装记录表
//            MesPackageRecord packageRecord = new MesPackageRecord();
//            packageRecord.setWorkOrderNo(workOrderNo);
//            packageRecord.setPackageNo(barcode);
//            packageRecord.setPartNo(partNo);
//            //packageRecord.setPackageNo(getPackage(organizeCode));
//            packageRecord.setQty(installQty);
//            packageRecord.setUnit(unit);
//            packageRecord.setPartName(partName);
//            packageRecord.setPartType(Integer.parseInt(categoryCode1));
//            packageRecord.setLotNo(workCenterExt.getWorkTime());
//            packageRecord.setWorkCellCode(packageRecordList.get(0).getWorkCellCode());
//            packageRecord.setOrganizeCode(organizeCode);
//            ConvertBean.serviceModelInitialize(packageRecord, modifyUser);
//            packageRecordRepository.insert(packageRecord);
//
//            //修改包装是否封箱状态为封箱
//            mesPackageExt.setQty(installQty);
//            mesPackageExt.setIsSealed(MesPcnExtEnumUtil.PACKAGE_IS_SEALED.SEALED.getValue());
//            mesPackageExt.setLotNo(packageRecord.getLotNo());
//            mesPackageExt.setWorkCellCode(packageRecord.getWorkCellCode());
//            ConvertBean.serviceModelUpdate(mesPackageExt, modifyUser);
//            mesPackageExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//            mesPackageExt.setWorkTime(workCenterExt.getWorkTime());
//            mesPackageExt.setShiftCode(workCenterExt.getShiftCode());
//            new ConvertBeanExt(mesPackageExt).convertBean(mesPackageExt);
//            packageExtRepository.save(mesPackageExt);
//
//            //工单完工数量累加
//            //已装数量+工单完工数量
//            Double completeInstallQty = doubleSum(installQty, workOrderExt.getCompleteQty());
//            updateWorkOrderCompleteQty(workOrderExt, completeInstallQty, modifyUser);
//
//            //存入报工接口表
//            saveOffLine(packageRecord, mesPackageExt.getPartLotNo(),workOrderExt, organizeCode, modifyUser);
//
//            //包装记录状态解绑
//            updatePackageNoIsNull(organizeCode, barcode, modifyUser);
//
//            //进行产量统计
//            doOutPutStatistics(organizeCode, workOrderExt, modifyUser, installQty, partExt, workCenterExt);
//
//            //已装数量+工单完工数量是否等于工单计划数量
//            Boolean isEqualToWorkOrderPlanQty = completeInstallQty.compareTo(workOrderExt.getQty()) == 0;
//            if (isEqualToWorkOrderPlanQty) {
//                //如果达到工单计划数量，关闭工单。
//                workOrderExt.setWorkOrderStatus(MesPcnExtEnumUtil.WORK_ORDER_STATUS.CLOSE.getValue());
//                ConvertBean.serviceModelUpdate(workOrderExt, modifyUser);
//                workOrderExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//                new ConvertBeanExt(workOrderExt).convertBean(workOrderExt);
//                workOrderExtRepository.save(workOrderExt);
//            }
//        }
//    }
//
//    /**
//     * @return void
//     * @Description: 包装记录状态解绑
//     * @Param [organizeCode, ctNo]
//     * @Date 2021/9/7 20:22
//     **/
//    private void updatePackageNoIsNull(String organizeCode, String ctNo, String userName) {
//        packageRecordRepository.updateByProperties(
//                new String[]{MesPcnExtConstWords.CT_NO, MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID},
//                new Object[]{ctNo, organizeCode, CommonEnumUtil.IS_DEAL.NO.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue()},
//                new String[]{MesPcnExtConstWords.CT_NO, "containerUseStatus", "modifyUser", "modifyDatetime"},
//                new Object[]{null, MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue(), userName, TimeTool.getNowTime(true)});
//    }
//
//
//    /**
//     * @return java.lang.Boolean
//     * @Description: 扫描容器点击确定
//     * @Param [packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterCode]
//     * @Date 2021/3/26 17:37
//     **/
//    private Boolean scanContainerConfirm(MesPackageRecord packageRecord, String organizeCode, String workOrderNo, String modifyUser, MesWorkOrderExt workOrderExt, MesWorkCenterExt workCenterExt) {
//        String partNo = packageRecord.getPartNo();
//        String ctNo = packageRecord.getCtNo();
//
//        //1、根据条码查询容器是否存在
//        MesContainer containerByDb = getContainerByBarCode(ctNo, organizeCode);
//        if (null == containerByDb) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("容器【%s】不存在，请重新扫描！", ctNo)
//                    .build();
//        }
//        //判断工单物料是否匹配容器物料
//        String ctCode = containerByDb.getCtCode();
//        MesPartContainerCapacity partContainerCapacity = getPartContainerCapacity(organizeCode, ctCode, partNo);
//        if (null == partContainerCapacity) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("该容器未配置装此物料，请重新扫描")
//                    .build();
//        }
//
//        //判断容器状态是否为占用
//        if (MesPcnExtEnumUtil.CONTAINER_USE_STATUS.OCCUPY.getValue().equals(containerByDb.getUseStatus())) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("该容器已被占用，请重新扫描")
//                    .build();
//        }
//
//        //1、判断是否存在其他工单的包装操作记录
//        List<MesPackageRecord> notPresentWorkOrderRecords = getPackageRecordsByCtNo(ctNo, workOrderNo, organizeCode, true);
//        isNotPresentWorkOrderRecords(notPresentWorkOrderRecords);
//
//        //2、是否同批次
//        List<MesPackageRecord> packageRecords = getPackageRecordsByCtNo(ctNo, workOrderNo, organizeCode, false);
//        for (MesPackageRecord record : packageRecords) {
//            if (!record.getLotNo().equals(packageRecord.getLotNo())) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("不允许多批次混装")
//                        .build();
//            }
//        }
//
//        //已装数量
//        Double installQty = packageRecords.stream().map(MesPackageRecord::getQty).reduce(0.0, Double::sum);
//        installQty = doubleSum(installQty, packageRecord.getQty());
//        //产品容器容量信息
//        //MesContainer container = getContainerByBarCode(ctNo, organizeCode);
//        //MesPartContainerCapacity partContainerCapacity = getPartContainerCapacity(organizeCode, container.getCtCode(), partNo);
//
//        //是否大于标准包装
//        Boolean isGreaterThanToCtQty = installQty.compareTo(Double.valueOf(partContainerCapacity.getCtQty())) == 1;
//        if (isGreaterThanToCtQty) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("已超出容器容量，请重新输入数量")
//                    .build();
//        }
//
//        //已装数量+工单完工数量是否大于工单计划数量
//        Double completeInstallQty = doubleSum(installQty, workOrderExt.getCompleteQty());
//        Boolean isGreaterThanWorkOrderPlanQty = completeInstallQty.compareTo(workOrderExt.getQty()) == 1;
//        if (isGreaterThanWorkOrderPlanQty) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("已超出工单计划数量，请重新输入数量")
//                    .build();
//        }
//
//
//        //是否小于标准包装
//        Boolean isLessThanCtQty = installQty.compareTo(Double.valueOf(partContainerCapacity.getCtQty())) == -1;
//        //是否等于标准包装
//        Boolean isEqualToCtQty = installQty.compareTo(Double.valueOf(partContainerCapacity.getCtQty())) == 0;
//
//        //是否小于或者等于包装数量
//        if (isEqualToCtQty || isLessThanCtQty) {
//            MesPartExt partExt = partExtService.getPartExt(organizeCode, partNo);
//            if (null == partExt) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("物料[s%],不存在物料扩展信息", partNo)
//                        .build();
//            }
//            packageRecord.setUnit(partExt.getUnit());
//            packageRecord.setPartName(partExt.getPartName());
//            //物料类型1，用于判断半成品/成品
//            packageRecord.setPartType(Integer.parseInt(partExt.getCategoryCode1()));
//            packageRecord.setContainerUseStatus(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue());
//            ConvertBean.serviceModelInitialize(packageRecord, modifyUser);
//            packageRecordRepository.save(packageRecord);
//        }
//
//        //如果等于包装数量，则完成包装
//        if (isEqualToCtQty) {
//            return scanContainerCompletePackage(packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterExt, ctNo, installQty, partContainerCapacity, completeInstallQty);
//        }
//        return false;
//    }
//
//    /**
//     * @return boolean
//     * @Description: 扫描容器，点击完成包装
//     * @Param [packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterCode, ctNo, installQty, partContainerCapacity, completeInstallQty]
//     * @Date 2021/3/29 20:17
//     **/
//    private boolean scanContainerCompletePackage(MesPackageRecord packageRecord, String organizeCode, String workOrderNo, String modifyUser, MesWorkOrderExt workOrderExt, MesWorkCenterExt workCenterExt, String ctNo, Double installQty, MesPartContainerCapacity partContainerCapacity, Double completeInstallQty) {
//        //所有包装记录  包装编号字段赋值
//        String packageNo = getPackage(organizeCode);
//        List<MesPackageRecord> packageRecordsByCtNo = getPackageRecordsByCtNo(ctNo, workOrderNo, organizeCode, false);
//        for (MesPackageRecord mesPackageRecord : packageRecordsByCtNo) {
//            mesPackageRecord.setPackageNo(packageNo);
//            ConvertBean.serviceModelUpdate(mesPackageRecord, modifyUser);
//        }
//        packageRecordRepository.saveAll(packageRecordsByCtNo);
//
//        //将包装记录中 容器使用状态改为占用
//        updateContainerUseStatus(organizeCode, workOrderNo, modifyUser, ctNo, false);
//
//        //生成包装编号,汇总包装数量
//        MesPackageRecord packageRecord1 = new MesPackageRecord();
//        BeanUtils.copyProperties(packageRecord, packageRecord1, "id");
//        packageRecord1.setPackageNo(packageNo);
//        packageRecord1.setQty(installQty);
//        packageRecord1.setOrganizeCode(organizeCode);
//        //packageRecordRepository.save(packageRecord1);
//
//        //存入包装表
//        MesPackageExt mesPackageExt = new MesPackageExt();
//        BeanUtils.copyProperties(packageRecord1, mesPackageExt, "id");
//        mesPackageExt.setLastWorkOrderNo(mesPackageExt.getWorkOrderNo());
//        mesPackageExt.setPartNameRdd(packageRecord1.getPartName());
//        mesPackageExt.setPackSpecQty(Double.valueOf(partContainerCapacity.getCtQty()));
//        mesPackageExt.setLotNo(packageRecord1.getLotNo());
//        mesPackageExt.setWorkCellCode(packageRecord1.getWorkCellCode());
//        mesPackageExt.setIsSealed(MesPcnExtEnumUtil.PACKAGE_IS_SEALED.SEALED.getValue());
//        mesPackageExt.setPrintStatus(MesPcnExtEnumUtil.PRODUCE_SN_PRINT_STATUS.UNPRINT.getValue());
//        mesPackageExt.setWorkCenterCode(workCenterExt.getWorkCenterCode());
//        mesPackageExt.setOrganizeCode(organizeCode);
//        ConvertBean.serviceModelInitialize(mesPackageExt, modifyUser);
//        mesPackageExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//        mesPackageExt.setWorkTime(workCenterExt.getWorkTime());
//        mesPackageExt.setShiftCode(workCenterExt.getShiftCode());
//        new ConvertBeanExt(mesPackageExt).convertBean(mesPackageExt);
//        packageExtRepository.insert(mesPackageExt);
//
//        //工单完工数量累加
//        updateWorkOrderCompleteQty(workOrderExt, completeInstallQty, modifyUser);
//
//        //修改容器状态为占用
//        updateContainerUseStatus(ctNo, MesPcnExtEnumUtil.CONTAINER_USE_STATUS.OCCUPY.getValue(), modifyUser);
//
//        //存入报工接口表
//        SxProductOffLine productOffLine = saveOffLine(packageRecord1, mesPackageExt.getPartLotNo(), workOrderExt, organizeCode, modifyUser);
//
//        //存入包装关系接口表
//        saveOffLineExt(productOffLine, ctNo, modifyUser);
//
//        //包装记录状态解绑
//        updatePackageNoIsNull(organizeCode, ctNo, modifyUser);
//
//        //进行产量统计
//        MesPartExt partExt = partExtService.getPartExt(organizeCode, packageRecord1.getPartNo());
//        doOutPutStatistics(organizeCode, workOrderExt, modifyUser, installQty, partExt, workCenterExt);
//
//        //已装数量+工单完工数量是否等于工单计划数量
//        Boolean isEqualToWorkOrderPlanQty = completeInstallQty.compareTo(workOrderExt.getQty()) == 0;
//        if (isEqualToWorkOrderPlanQty) {
//            //如果达到工单计划数量，关闭工单。
//            workOrderExt.setWorkOrderStatus(MesPcnExtEnumUtil.WORK_ORDER_STATUS.CLOSE.getValue());
//            ConvertBean.serviceModelUpdate(workOrderExt, modifyUser);
//            workOrderExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//            new ConvertBeanExt(workOrderExt).convertBean(workOrderExt);
//            workOrderExtRepository.save(workOrderExt);
//        }
//        return true;
//    }
//
//    /**
//     * @return void
//     * @Description: 修改包装记录表  容器使用状态
//     * @Param [organizeCode, workOrderNo, modifyUser, ctNo]
//     * @Date 2021/3/31 14:58
//     **/
//    private void updateContainerUseStatus(String organizeCode, String workOrderNo, String modifyUser, String barCode, Boolean isPackage) {
//        List<MesPackageRecord> packageRecords = new ArrayList<>();
//        if (isPackage) {
//            DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//            DdlPreparedPack.getStringEqualPack(barCode, MesPcnExtConstWords.PACKAGENO, packBean);
//            DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue(), MesPcnExtConstWords.CONTAINER_USE_STATUS, packBean);
//            packageRecords = packageRecordRepository.findByHqlWhere(packBean);
//        } else {
//            packageRecords = getPackageRecordsByCtNo(barCode, workOrderNo, organizeCode, false);
//        }
//
//        for (MesPackageRecord record : packageRecords) {
//            record.setContainerUseStatus(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.OCCUPY.getValue());
//            ConvertBean.serviceModelUpdate(record, modifyUser);
//        }
//        packageRecordRepository.saveAll(packageRecords);
//    }
//
//    /**
//     * @return void
//     * @Description: 进行产量统计
//     * @Param [organizeCode, workOrderNo, planQty, modifyUser, installQty, partExt, workCenterExt]
//     * @Date 2021/4/13 13:31
//     **/
//    private void doOutPutStatistics(String organizeCode, MesWorkOrderExt workOrderExt, String modifyUser, Double installQty, MesPartExt partExt, MesWorkCenterExt workCenterExt) {
//
//        MesOutPutStatistics outPutStatistics = outPutStatisticsRepository.getByProperty(
//                new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID,
//                        MesPcnExtConstWords.WORK_ORDER_NO, MesPcnExtConstWords.WORK_TIME, MesPcnExtConstWords.SHIFT_CODE},
//                new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(),
//                        workOrderExt.getOrderNo(), workCenterExt.getWorkTime(), workCenterExt.getShiftCode()});
//        if (null == outPutStatistics) {
//            outPutStatistics = new MesOutPutStatistics();
//            outPutStatistics.setWorkCenterCode(workCenterExt.getWorkCenterCode());
//            outPutStatistics.setShiftCode(workCenterExt.getShiftCode());
//            outPutStatistics.setWorkTime(workCenterExt.getWorkTime());
//            outPutStatistics.setPartNo(partExt.getPartNo());
//            outPutStatistics.setPartNameRdd(partExt.getPartName());
//            outPutStatistics.setWorkOrderNo(workOrderExt.getOrderNo());
//            outPutStatistics.setPlanQty(workOrderExt.getQty());
//            outPutStatistics.setOrganizeCode(organizeCode);
//            outPutStatistics.setStartTime(TimeTool.getNowTime(true));
//            outPutStatistics.setEndTime(outPutStatistics.getStartTime());
//            outPutStatistics.setOrderStartTime(workOrderExt.getStartTime());
//            outPutStatistics.setQty(installQty);
//            outPutStatistics.setRemakeQty(new Double(0));
//            outPutStatistics.setWorkOrderType(workOrderExt.getWorkOrderType());
//            outPutStatistics.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//            ConvertBean.serviceModelInitialize(outPutStatistics, modifyUser);
//            outPutStatisticsRepository.insert(outPutStatistics);
//        } else {
//            outPutStatistics.setQty(doubleSum(outPutStatistics.getQty(), installQty));
//            outPutStatistics.setEndTime(TimeTool.getNowTime(true));
//            ConvertBean.serviceModelUpdate(outPutStatistics, modifyUser);
//            outPutStatistics.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//            outPutStatisticsRepository.save(outPutStatistics);
//        }
//    }
//
//    /**
//     * @return cn.estsh.i3plus.ext.mes.pcn.pojo.bean.MesWorkCenterExt
//     * @Description: 通过产线代码查询产线信息
//     * @Param [organizeCode, workCenterCode]
//     * @Date 2021/3/29 18:37
//     **/
//    private MesWorkCenterExt getWorkCenterExtByWorkCenterCode(String organizeCode, String workCenterCode) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(workCenterCode, MesPcnExtConstWords.WORK_CENTER_CODE, packBean);
//        MesWorkCenterExt workCenterExt = workCenterExtRepository.getByProperty(packBean);
//        if (null == workCenterExt) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_NOT_EXIT.getCode())
//                    .setErrorDetail("生产线[%s]不存在", workCenterExt.getWorkCenterCode())
//                    .build();
//        }
//        if (StringUtils.isEmpty(workCenterExt.getShiftCode()) || StringUtils.isEmpty(workCenterExt.getWorkTime())) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("生产线[%s]未启动班次", workCenterExt.getWorkCenterCode())
//                    .build();
//        }
//        return workCenterExt;
//    }
//
//    /**
//     * @return java.lang.Boolean
//     * @Description: 扫描包装点击确定
//     * @Param [packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterCode]
//     * @Date 2021/3/26 17:35
//     **/
//    private Boolean scanPackageConfirm(MesPackageRecord packageRecord, String organizeCode, String workOrderNo, String modifyUser, MesWorkOrderExt workOrderExt, MesWorkCenterExt workCenterExt) {
//        String partNo = packageRecord.getPartNo();
//        String ctNo = packageRecord.getCtNo();
//        //不存在则根据条码查询包装表
//        MesPackageExt mesPackageExtByDb = getMesPackageByBarCode(ctNo, organizeCode, workCenterExt.getWorkCenterCode(), workOrderNo);
//        if (null == mesPackageExtByDb) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("扫描的条码【%s】,不存在于当前工单", ctNo)
//                    .build();
//        }
//        if (!mesPackageExtByDb.getPartNo().equals(partNo)) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("该容器未配置装此物料，请重新扫描")
//                    .build();
//        }
//        if (MesPcnExtEnumUtil.PACKAGE_IS_SEALED.SEALED.getValue() == mesPackageExtByDb.getIsSealed()) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("【%s】包装已封箱", ctNo)
//                    .build();
//        }
//
//        MesWorkOrderExt workOrderExtDb = getWorkOrderExtByWorkOrderNo(workOrderNo, organizeCode);
//
//        if(workOrderExtDb.getWorkOrderType() == MesPcnExtEnumUtil.WORK_ORDER_TYPE.REWORK_ORDER.getValue()){
//            if(mesPackageExtByDb.getLastWorkOrderNo() == mesPackageExtByDb.getWorkOrderNo()){
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("条码[%s]不是返工条码", ctNo)
//                        .build();
//            }
//
//            if(!mesPackageExtByDb.getLastWorkOrderNo().equals(workOrderNo)){
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("条码[%s]不为返工条码", ctNo)
//                        .build();
//            }
//        }
//
//        packageRecord.setPackageNo(ctNo);
//        packageRecord.setCtNo(null);
//        String packageNo = packageRecord.getPackageNo();
//        //1、判断是否存在其他工单的包装操作记录
//        List<MesPackageRecord> notPresentWorkOrderRecords = getPackageRecordsByCtPackageNo(packageNo, workOrderNo, organizeCode, true);
//        isNotPresentWorkOrderRecords(notPresentWorkOrderRecords);
//
//        //2、是否同批次
//        List<MesPackageRecord> packageRecords = getPackageRecordsByCtPackageNo(packageNo, workOrderNo, organizeCode, false);
//        for (MesPackageRecord record : packageRecords) {
//            if (!record.getLotNo().equals(packageRecord.getLotNo())) {
//                throw ImppExceptionBuilder.newInstance()
//                        .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                        .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                        .setErrorDetail("不允许多批次混装")
//                        .build();
//            }
//        }
//
//        //已装数量
//        Double installQty = packageRecords.stream().map(MesPackageRecord::getQty).reduce(0.0, Double::sum);
//        installQty = doubleSum(installQty, packageRecord.getQty());
//        //包装信息
//        MesPackageExt mesPackageExt = getMesPackageByBarCode(packageNo, organizeCode, workCenterExt.getWorkCenterCode(), workOrderNo);
//        Double packSpecQty = mesPackageExt.getPackSpecQty();
//        //是否大于标准包装
//        Boolean isGreaterThanToCtQty = installQty.compareTo(packSpecQty) == 1;
//        if (isGreaterThanToCtQty) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("已超出包装容量，请重新输入数量")
//                    .build();
//        }
//
//        //已装数量+工单完工数量是否大于工单计划数量
//        Double completeInstallQty = doubleSum(installQty, workOrderExt.getCompleteQty());
//        Boolean isGreaterThanWorkOrderPlanQty = completeInstallQty.compareTo(workOrderExt.getQty()) == 1;
//        if (isGreaterThanWorkOrderPlanQty) {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("已超出工单计划数量，请重新输入数量")
//                    .build();
//        }
//
//        //是否小于标准包装
//        Boolean isLessThanCtQty = installQty.compareTo(packSpecQty) == -1;
//        //是否等于标准包装
//        Boolean isEqualToCtQty = installQty.compareTo(packSpecQty) == 0;
//
//        //是否小于或者等于包装数量
//        if (isEqualToCtQty || isLessThanCtQty) {
//            MesPartExt partExt = partExtService.getPartExt(organizeCode, partNo);
//            packageRecord.setPartName(partExt.getPartName());
//            packageRecord.setUnit(partExt.getUnit());
//            packageRecord.setPartType(Integer.parseInt(partExt.getCategoryCode1()));
//            packageRecord.setContainerUseStatus(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue());
//            ConvertBean.serviceModelInitialize(packageRecord, modifyUser);
//            packageRecordRepository.save(packageRecord);
//        }
//
//        //如果等于包装数量，则完成包装
//        if (isEqualToCtQty) {
//            return scanPackageCompletePackage(packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterExt, installQty, mesPackageExt, completeInstallQty);
//        }
//        return false;
//    }
//
//    /**
//     * @return java.lang.Boolean
//     * @Description: 扫描包装 点击完成包装
//     * @Param [packageRecord, organizeCode, workOrderNo, modifyUser, workOrderExt, workCenterCode, installQty, mesPackageExt, completeInstallQty]
//     * @Date 2021/3/31 15:03
//     **/
//    private Boolean scanPackageCompletePackage(MesPackageRecord packageRecord, String organizeCode, String workOrderNo, String modifyUser, MesWorkOrderExt workOrderExt, MesWorkCenterExt workCenterExt, Double installQty, MesPackageExt mesPackageExt, Double completeInstallQty) {
//        //将包装记录中 容器使用状态改为占用
//        updateContainerUseStatus(organizeCode, workOrderNo, modifyUser, packageRecord.getPackageNo(), true);
//
//        //汇总包装数量，存入包装记录表
//        MesPackageRecord packageRecord1 = new MesPackageRecord();
//        BeanUtils.copyProperties(packageRecord, packageRecord1, MesPcnExtConstWords.ID);
//        packageRecord1.setQty(installQty);
//        ConvertBean.serviceModelUpdate(packageRecord1, modifyUser);
//        packageRecordRepository.insert(packageRecord1);
//
//        //修改包装是否封箱状态为封箱
//        mesPackageExt.setIsSealed(MesPcnExtEnumUtil.PACKAGE_IS_SEALED.SEALED.getValue());
//        mesPackageExt.setWorkCellCode(packageRecord.getWorkCellCode());
//        mesPackageExt.setLotNo(packageRecord.getLotNo());
//        ConvertBean.serviceModelUpdate(mesPackageExt, modifyUser);
//        mesPackageExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//        mesPackageExt.setWorkTime(workCenterExt.getWorkTime());
//        mesPackageExt.setShiftCode(workCenterExt.getShiftCode());
//        new ConvertBeanExt(mesPackageExt).convertBean(mesPackageExt);
//        packageExtRepository.save(mesPackageExt);
//
//        //工单完工数量累加
//        updateWorkOrderCompleteQty(workOrderExt, completeInstallQty, modifyUser);
//
//        //存入报工接口表
//        saveOffLine(packageRecord1, mesPackageExt.getPartLotNo(), workOrderExt, organizeCode, modifyUser);
//
//        //包装记录状态解绑
//        updatePackageNoIsNull(organizeCode, packageRecord.getCtNo(), modifyUser);
//
//        //进行产量统计
//        MesPartExt partExt = partExtService.getPartExt(organizeCode, packageRecord1.getPartNo());
//        doOutPutStatistics(organizeCode, workOrderExt, modifyUser, installQty, partExt, workCenterExt);
//
//        //已装数量+工单完工数量是否等于工单计划数量
//        Boolean isEqualToWorkOrderPlanQty = completeInstallQty.compareTo(workOrderExt.getQty()) == 0;
//        if (isEqualToWorkOrderPlanQty) {
//            //如果达到工单计划数量，关闭工单。
//            workOrderExt.setWorkOrderStatus(MesPcnExtEnumUtil.WORK_ORDER_STATUS.CLOSE.getValue());
//            ConvertBean.serviceModelUpdate(workOrderExt, modifyUser);
//            workOrderExt.setSystemSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//            new ConvertBeanExt(workOrderExt).convertBean(workOrderExt);
//            workOrderExtRepository.save(workOrderExt);
//        }
//        return true;
//    }
//
//    private List<MesPackageRecord> getPackageRecordsByCtPackageNo(String packageNo, String workOrderNo, String organizeCode, Boolean isNotInWorkOrderNo) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(packageNo, "packageNo", packBean);
//        if (isNotInWorkOrderNo) {
//            DdlPreparedPack.getNotInPack(workOrderNo, MesPcnExtConstWords.WORK_ORDER_NO, packBean);
//        }
//        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue(), MesPcnExtConstWords.CONTAINER_USE_STATUS, packBean);
//        List<MesPackageRecord> packageRecords = packageRecordRepository.findByHqlWhere(packBean);
//        return packageRecords;
//    }
//
//    /**
//     * @return void
//     * @Description: 修改容器使用状态
//     * @Param [ctNo, useStatus, modifyUser]
//     * @Date 2021/3/26 10:58
//     **/
//    private void updateContainerUseStatus(String ctNo, String useStatus, String modifyUser) {
//        containerRepository.updateByProperties(new String[]{MesPcnExtConstWords.CT_NO}, new Object[]{ctNo},
//                new String[]{MesPcnExtConstWords.USE_STATUS, MesPcnExtConstWords.MODIFY_USER, MesPcnExtConstWords.MODIFY_DATE_TIME},
//                new Object[]{useStatus, modifyUser, TimeTool.getNowTime(true)});
//    }
//
//    /**
//     * @return void
//     * @Description: 累加工单完工数量
//     * @Param [workOrderExt, completeQty, modifyUser]
//     * @Date 2021/3/26 14:29
//     **/
//    private void updateWorkOrderCompleteQty(MesWorkOrderExt workOrderExt, Double completeQty, String modifyUser) {
//        workOrderExt.setCompleteQty(completeQty);
//        ConvertBean.serviceModelUpdate(workOrderExt, modifyUser);
//        new ConvertBeanExt(workOrderExt).convertBean(workOrderExt);
//        workOrderExtRepository.save(workOrderExt);
//    }
//
//    /**
//     * @return cn.estsh.i3plus.ext.mes.pcn.pojo.bean.SxProductOffLine
//     * @Description: 存入报工接口表
//     * @Param [packageRecord, workOrderExt]
//     * @Date 2021/3/26 10:48
//     **/
//    private SxProductOffLine saveOffLine(MesPackageRecord packageRecord, String partLotNo, MesWorkOrderExt workOrderExt, String organizeCode, String userName) {
//        MesPartExt partExt = partExtService.getPartExt(organizeCode, packageRecord.getPartNo());
//
//        SxProductOffLine productOffLine = new SxProductOffLine();
//        BeanUtils.copyProperties(packageRecord, productOffLine, MesPcnExtConstWords.ID);
//        productOffLine.setWorkCenterCode(workOrderExt.getWorkCenterCode());
//        productOffLine.setErpWarehouse(workOrderExt.getErpWarehouse());
//        //取物料信息中的类型
//        productOffLine.setProdType(Integer.parseInt(partExt.getCategoryCode1()));
//        productOffLine.setSnType(MesPcnExtEnumUtil.PRODUCE_SN_TYPE.STANDARD_SN.getValue());
//        productOffLine.setSyncStatus(MesPcnExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());
//        MesWorkCenterExt workCenterExt = getWorkCenterExtByWorkCenterCode(organizeCode, workOrderExt.getWorkCenterCode());
//        productOffLine.setShiftCode(workCenterExt.getShiftCode());
//        productOffLine.setOrganizeCode(organizeCode);
//        ConvertBean.serviceModelUpdate(productOffLine, userName);
//        //新增成品批次号
//        productOffLine.setPartLotNo(partLotNo);
//        return productOffLineRepository.insert(productOffLine);
//    }
//
//    /**
//     * @return void
//     * @Description: 存入包装关系表
//     * @Param [productOffLine]
//     * @Date 2021/3/26 10:47
//     **/
//    private void saveOffLineExt(SxProductOffLine productOffLine, String ctNo, String userName) {
//        SxProductOffLineExt productOffLineExt = new SxProductOffLineExt();
//        BeanUtils.copyProperties(productOffLine, productOffLineExt, "id");
//        productOffLineExt.setCtNo(ctNo);
//        productOffLineExt.setIsAGVCarry(MesPcnExtEnumUtil.IS_AGV_CARRY.NO.getValue());
//        ConvertBean.serviceModelInitialize(productOffLineExt, userName);
//        productOffLineExtRepository.insert(productOffLineExt);
//    }
//
//    private String getPackage(String organizeCode) {
//        String orderNo = "";
//        BaseResultBean oneCodeResult = syncFuncService.syncSerialNo(new GenSerialNoModel(MesPcnExtConstWords.MODULE_PACKAGE_NO), null, organizeCode, 1);
//        if (oneCodeResult != null && oneCodeResult.isSuccess()) {
//            orderNo = oneCodeResult.getResultList().get(0).toString();
//        } else {
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.CLOUD_CALL_EXCEPTION.getCode())
//                    .setErrorDetail("生成包装编号失败")
//                    .build();
//        }
//        return orderNo;
//    }
//
//    /**
//     * @return void
//     * @Description: 判断是否存在其他工单的包装操作记录
//     * @Param [notPresentWorkOrderRecords]
//     * @Date 2021/3/25 16:57
//     **/
//    private void isNotPresentWorkOrderRecords(List<MesPackageRecord> notPresentWorkOrderRecords) {
//        if (!CollectionUtils.isEmpty(notPresentWorkOrderRecords)) {
//            List<String> workOrderNoByDistinct = notPresentWorkOrderRecords.stream().map(MesPackageRecord::getWorkOrderNo).distinct().collect(Collectors.toList());
//            StringBuffer workStr = new StringBuffer();
//            workOrderNoByDistinct.forEach(e -> {
//                workStr.append("【");
//                workStr.append(e);
//                workStr.append("】");
//            });
//            throw ImppExceptionBuilder.newInstance()
//                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES_PCN.getCode())
//                    .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION.getCode())
//                    .setErrorDetail("该容器已被%s工单占用", workStr)
//                    .build();
//        }
//    }
//
//    /**
//     * @return double
//     * @Description: 两double类型相加
//     * @Param [d1, d2]
//     * @Date 2021/3/25 16:12
//     **/
//    public static double doubleSum(double d1, double d2) {
//        BigDecimal b1 = new BigDecimal(Double.toString(d1));
//        BigDecimal b2 = new BigDecimal(Double.toString(d2));
//        return b1.add(b2).setScale(2, RoundingMode.HALF_UP).doubleValue();
//    }
//
//    /**
//     * @return java.util.List<cn.estsh.i3plus.ext.mes.pcn.pojo.bean.MesPackageRecord>
//     * @Description: 通过容器编号查询包装条码为空的工单包装记录
//     * @Param [ctNo, workOrderNo, organizeCode, isNotInWorkOrderNo]
//     * @Date 2021/3/26 10:53
//     **/
//    private List<MesPackageRecord> getPackageRecordsByCtNo(String ctNo, String workOrderNo, String organizeCode, Boolean isNotInWorkOrderNo) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(ctNo, MesPcnExtConstWords.CT_NO, packBean);
//        DdlPreparedPack.getIsNull("packageNo", packBean);
//        if (isNotInWorkOrderNo) {
//            DdlPreparedPack.getNotInPack(workOrderNo, MesPcnExtConstWords.WORK_ORDER_NO, packBean);
//        }
//        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue(), MesPcnExtConstWords.CONTAINER_USE_STATUS, packBean);
//        List<MesPackageRecord> packageRecords = packageRecordRepository.findByHqlWhere(packBean);
//        return packageRecords;
//    }
//
//    /**
//     * @return cn.estsh.i3plus.pojo.mes.bean.MesPackage
//     * @Description: 通过条码查询包装表
//     * @Param [barcode, organizeCode]
//     * @Date 2021/3/24 9:33
//     **/
//    private MesPackageExt getMesPackageByBarCode(String barcode, String organizeCode, String workCenterCode, String workOrderNo) {
//        MesPackageExt mesPackageExt = packageExtRepository.getByProperty(
//                new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.PACKAGENO, MesPcnExtConstWords.WORK_CENTER_CODE, MesPcnExtConstWords.WORK_ORDER_NO},
//                new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), barcode, workCenterCode, workOrderNo});
//
//        return mesPackageExt;
//    }
//
//    /**
//     * @return cn.estsh.i3plus.pojo.mes.bean.MesPackage
//     * @Description: 通过条码查询包装表
//     * @Param [barcode, organizeCode]
//     * @Date 2021/3/24 9:33
//     **/
//    private MesPackageExt getMesPackageByBarCode(String barcode, String organizeCode) {
//        MesPackageExt mesPackageExt = packageExtRepository.getByProperty(
//                new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.PACKAGENO},
//                new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), barcode});
//
//        return mesPackageExt;
//    }
//
//    /**
//     * @return java.util.List<cn.estsh.i3plus.ext.mes.pcn.pojo.bean.MesPackageRecord>
//     * @Description: 通过容器编号查询包装记录
//     * @Param [barcode, organizeCode]
//     * @Date 2021/3/23 19:20
//     **/
//    private List<MesPackageRecord> getPackageRecordsByBarcode(String barcode, String packageNo, String organizeCode) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        if (!StringUtils.isEmpty(barcode)) {
//            DdlPreparedPack.getStringEqualPack(barcode, MesPcnExtConstWords.CT_NO, packBean);
//            DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.CONTAINER_USE_STATUS.LEISURE.getValue(), MesPcnExtConstWords.CONTAINER_USE_STATUS, packBean);
//            DdlPreparedPack.getIsNull("packageNo", packBean);
//        } else {
//            DdlPreparedPack.getStringEqualPack(packageNo, "packageNo", packBean);
//        }
//        List<MesPackageRecord> packageRecords = packageRecordRepository.findByHqlWhere(packBean);
////        redisMesPcn.putHash("MesPackageRecord", "MesPackageRecord", packageRecords);
////        boolean mesPackageRecord = redisMesPcn.hasKey("MesPackageRecord");
////        List<MesPackageRecord> packageRecordsByRedis= (List<MesPackageRecord>) redisMesPcn.getHash("MesPackageRecord", "MesPackageRecord");
//
//        return packageRecords;
//    }
//
//    /**
//     * @return cn.estsh.i3plus.pojo.mes.bean.MesPartContainerCapacity
//     * @Description: 根据容器的容器类型和工单的物料号查询产品容器容量
//     * @Param [organizeCode, ctCode, partNo]
//     * @Date 2021/3/23 15:20
//     **/
//    private MesPartContainerCapacity getPartContainerCapacity(String organizeCode, String ctCode, String partNo) {
//        DdlPackBean packBean1 = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(ctCode, MesPcnExtConstWords.CT_CODE, packBean1);
//        DdlPreparedPack.getStringEqualPack(partNo, MesPcnExtConstWords.PART_NO, packBean1);
//        MesPartContainerCapacity partContainerCapacity = partContainerCapacityRepository.getByProperty(packBean1);
//        return partContainerCapacity;
//    }
//
//    /**
//     * @return cn.estsh.i3plus.ext.mes.pcn.pojo.bean.MesWorkOrderExt
//     * @Description: 通过工单号查询工单信息
//     * @Param [workOrderNo, organizeCode]
//     * @Date 2021/3/23 14:54
//     **/
//    private MesWorkOrderExt getWorkOrderExtByWorkOrderNo(String workOrderNo, String organizeCode) {
//        DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(workOrderNo, MesPcnExtConstWords.ORDER_NO, packBean);
//        MesWorkOrderExt workOrderExt = workOrderExtRepository.getByProperty(packBean);
//        return workOrderExt;
//    }
//
//    /**
//     * @Description: 根据条码查询容器
//     * @Param: [barcode, organizeCode]
//     * @return: cn.estsh.i3plus.pojo.mes.bean.MesContainer
//     * @Date: 2021/3/23
//     */
//    private MesContainer getContainerByBarCode(String barcode, String organizeCode) {
//        /*DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
//        DdlPreparedPack.getStringEqualPack(barcode, MesPcnExtConstWords.CT_NO, packBean);
//        MesContainer containerByDb = containerRepository.getByProperty(packBean);
//        */
//        MesContainer containerByDb = containerRepository.getByProperty(
//                new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.CT_NO},
//                new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), barcode});
//        return containerByDb;
//    }
//}
