发运

modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesPartShippingGroupService.java

@@ -0,0 +1,20 @@
+package cn.estsh.i3plus.ext.mes.pcn.api.busi;
+
+import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
+import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
+import io.swagger.annotations.ApiOperation;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @CreateDate 2024/04/16
+ * @Author mingliang.li
+ */
+public interface IMesPartShippingGroupService {
+
+
+    @ApiOperation(value = "查询发运组数据")
+    public List<MesPartShippingGroup> findAll(DdlPackBean packBean);
+
+}

modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesShippingLoadingCheckService.java

@@ -0,0 +1,26 @@
+package cn.estsh.i3plus.ext.mes.pcn.api.busi;
+
+import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesShippingLoadingCheckModel;
+import cn.estsh.i3plus.pojo.mes.bean.MesLoadingVehiclesOrder;
+import io.swagger.annotations.ApiOperation;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-04-26 15:37
+ * @Modify:
+ **/
+public interface IMesShippingLoadingCheckService {
+
+    @ApiOperation(value = "查询装车单")
+    public MesShippingLoadingCheckModel queryLoadingOrderNo(MesLoadingVehiclesOrder loadingVehiclesOrder);
+
+    @ApiOperation(value = "查询装车单-自动推单")
+    public MesLoadingVehiclesOrder queryLoadingOrderNoByAutoPushOrder(String shippingGroupNo, String org);
+
+    @ApiOperation(value = "扫描发运单")
+    public MesShippingLoadingCheckModel saveVehiclesOrderAndDetail(MesShippingLoadingCheckModel model, String org);
+
+
+}

modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesSortShippingCheckService.java

@@ -0,0 +1,28 @@
+package cn.estsh.i3plus.ext.mes.pcn.api.busi;
+
+import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesSortShippingCheckModel;
+import cn.estsh.i3plus.pojo.mes.bean.MesShippingOrderManagement;
+import io.swagger.annotations.ApiOperation;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-04-26 15:37
+ * @Modify:
+ **/
+public interface IMesSortShippingCheckService {
+
+    @ApiOperation(value = "扫描发运单")
+    public MesSortShippingCheckModel queryShippingOrderNo(MesShippingOrderManagement shippingOrderManagement);
+
+    @ApiOperation(value = "保存条码")
+    public MesSortShippingCheckModel saveSn(MesSortShippingCheckModel model, String org);
+
+    @ApiOperation(value = "保存条码和位置码")
+    public MesSortShippingCheckModel saveSnAndLocationCode(MesSortShippingCheckModel model, String org);
+
+    @ApiOperation(value = "查询发运单-自动推单")
+    public MesShippingOrderManagement queryShippingOrderNoByAutoPushOrder(String shippingGroupNo, String org);
+
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesPartShippingGroupController.java

@@ -0,0 +1,53 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.controller.busi;
+
+import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesPartShippingGroupService;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
+import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
+import cn.estsh.impp.framework.boot.auth.AuthUtil;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+import cn.estsh.impp.framework.boot.util.ResultBean;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-05-06 16:25
+ * @Modify:
+ **/
+
+@Api("零件发运组")
+@RestController
+@RequestMapping(MesCommonConstant.MES_YANFEN + "/part-shipping-group")
+public class MesPartShippingGroupController {
+
+    @Autowired
+    private IMesPartShippingGroupService shippingGroupService;
+
+
+    @GetMapping("/list")
+    @ApiOperation(value = "查询所有")
+    public ResultBean list(MesPartShippingGroup partShippingGroup) {
+
+        try {
+
+            //默认查询所有
+//            DdlPackBean listAllPackBean = DdlPackBean.getDdlPackBean("CK01");
+            DdlPackBean listAllPackBean = DdlPackBean.getDdlPackBean(AuthUtil.getOrganizeCode());
+            ;
+            return ResultBean.success("查询成功").setResultList(shippingGroupService.findAll(listAllPackBean));
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        }
+    }
+
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesShippingLoadingCheckController.java

@@ -0,0 +1,105 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.controller.busi;
+
+
+import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesShippingLoadingCheckService;
+import cn.estsh.i3plus.ext.mes.pcn.apiservice.util.MesRedisLockUtil;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesShippingLoadingCheckModel;
+import cn.estsh.i3plus.pojo.mes.bean.MesLoadingVehiclesOrder;
+import cn.estsh.impp.framework.boot.auth.AuthUtil;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+import cn.estsh.impp.framework.boot.util.ResultBean;
+import cn.estsh.impp.framework.boot.util.ValidatorBean;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@Api(tags = "装车校验")
+@RequestMapping(MesCommonConstant.MES_YANFEN + "/shipping-loading-check")
+@Slf4j
+public class MesShippingLoadingCheckController {
+
+    @Autowired
+    private IMesShippingLoadingCheckService shippingLoadingCheckService;
+
+    @Autowired
+    private MesRedisLockUtil redisLockUtil;
+
+    @GetMapping("/query-loading-order")
+    @ApiOperation(value = "查询装车单")
+    public ResultBean queryLoadingOrderNo(MesLoadingVehiclesOrder loadingVehiclesOrder) {
+
+        String moduleKey = "shipping:loadingOrderNo:" + loadingVehiclesOrder.getLoadingOrderNo();
+
+        //加锁
+        boolean lockFlg = false;
+        try {
+
+            //加锁
+            lockFlg = redisLockUtil.redisLock(moduleKey);
+
+            // 数据校验
+            ValidatorBean.checkNotNull(loadingVehiclesOrder.getLoadingOrderNo(), "装车单不能为空");
+            loadingVehiclesOrder.setOrganizeCode(AuthUtil.getOrganizeCode());
+
+            MesShippingLoadingCheckModel model = shippingLoadingCheckService.queryLoadingOrderNo(loadingVehiclesOrder);
+            return ResultBean.success("查询成功").setResultObject(model);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        } finally {
+            //解锁
+            redisLockUtil.redisUnLock(lockFlg, moduleKey);
+        }
+    }
+
+    @PostMapping("/scan-loading-order-detail")
+    @ApiOperation(value = "扫描装车单明细-发运单号")
+    public ResultBean saveLoadingOrderNoDetail(@RequestBody MesShippingLoadingCheckModel model) {
+
+        String moduleKey = "shipping:shippingOrderNo:" + model.getShippingOrderNo();
+
+        //加锁
+        boolean lockFlg = false;
+        try {
+
+            //加锁
+            lockFlg = redisLockUtil.redisLock(moduleKey);
+
+            // 数据校验
+            ValidatorBean.checkNotNull(model.getShippingOrderNo(), "发运单号不能为空");
+            ValidatorBean.checkNotNull(model.getVehiclesOrderDetailList(), "装车单明细不能为空");
+            String org = AuthUtil.getOrganizeCode();
+            shippingLoadingCheckService.saveVehiclesOrderAndDetail(model, org);
+            return ResultBean.success("查询成功").setResultObject(model);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        } finally {
+            //解锁
+            redisLockUtil.redisUnLock(lockFlg, moduleKey);
+        }
+    }
+
+    @GetMapping("/query-auto-push-order")
+    @ApiOperation(value = "自动推单")
+    public ResultBean queryAutoPushOrder(String shippingGroupNo) {
+
+        try {
+
+            MesLoadingVehiclesOrder order = shippingLoadingCheckService.queryLoadingOrderNoByAutoPushOrder(shippingGroupNo, AuthUtil.getOrganizeCode());
+            return ResultBean.success("查询成功").setResultObject(order);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        }
+    }
+
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesSortShippingCheckController.java

@@ -0,0 +1,138 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.controller.busi;
+
+
+import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesSortShippingCheckService;
+import cn.estsh.i3plus.ext.mes.pcn.apiservice.util.MesRedisLockUtil;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesSortShippingCheckModel;
+import cn.estsh.i3plus.pojo.mes.bean.MesShippingOrderManagement;
+import cn.estsh.impp.framework.boot.auth.AuthUtil;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+import cn.estsh.impp.framework.boot.util.ResultBean;
+import cn.estsh.impp.framework.boot.util.ValidatorBean;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@Api(tags = "排序发运校验")
+@RequestMapping(MesCommonConstant.MES_YANFEN + "/sort-shipping-check")
+@Slf4j
+public class MesSortShippingCheckController {
+
+    @Autowired
+    private IMesSortShippingCheckService sortShippingCheckService;
+
+    @Autowired
+    private MesRedisLockUtil redisLockUtil;
+
+    @GetMapping("/query-loading-order")
+    @ApiOperation(value = "查询发运单")
+    public ResultBean queryLoadingOrderNo(MesShippingOrderManagement shippingOrderManagement) {
+
+        String moduleKey = "sortShippingCheck:loadingOrderNo:" + shippingOrderManagement.getShippingOrderNo();
+
+        //加锁
+        boolean lockFlg = false;
+        try {
+
+            //加锁
+            lockFlg = redisLockUtil.redisLock(moduleKey);
+
+            // 数据校验
+            ValidatorBean.checkNotNull(shippingOrderManagement.getShippingOrderNo(), "发运单不能为空");
+            shippingOrderManagement.setOrganizeCode(AuthUtil.getOrganizeCode());
+
+            MesSortShippingCheckModel model = sortShippingCheckService.queryShippingOrderNo(shippingOrderManagement);
+            return ResultBean.success("查询成功").setResultObject(model);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        } finally {
+            //解锁
+            redisLockUtil.redisUnLock(lockFlg, moduleKey);
+        }
+    }
+
+    @PostMapping("/scan-sn")
+    @ApiOperation(value = "扫描条码")
+    public ResultBean saveSn(@RequestBody MesSortShippingCheckModel model) {
+
+        String moduleKey = "sortShippingCheck:sn:" + model.getSn();
+
+        //加锁
+        boolean lockFlg = false;
+        try {
+
+            //加锁
+            lockFlg = redisLockUtil.redisLock(moduleKey);
+
+            // 数据校验
+            ValidatorBean.checkNotNull(model.getShippingOrderNo(), "发运单不能为空");
+            ValidatorBean.checkNotNull(model.getDetailList(), "发运明细不能为空");
+            ValidatorBean.checkNotNull(model.getSn(), "条码不能为空");
+
+            sortShippingCheckService.saveSn(model, AuthUtil.getOrganizeCode());
+            return ResultBean.success("查询成功").setResultObject(model);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        } finally {
+            //解锁
+            redisLockUtil.redisUnLock(lockFlg, moduleKey);
+        }
+    }
+
+    @PostMapping("/scan-location-code")
+    @ApiOperation(value = "扫描位置码")
+    public ResultBean saveLocationCode(@RequestBody MesSortShippingCheckModel model) {
+
+        String moduleKey = "sortShippingCheck:sn:" + model.getSn();
+
+        //加锁
+        boolean lockFlg = false;
+        try {
+
+            //加锁
+            lockFlg = redisLockUtil.redisLock(moduleKey);
+
+            // 数据校验
+            ValidatorBean.checkNotNull(model.getShippingOrderNo(), "发运单不能为空");
+            ValidatorBean.checkNotNull(model.getDetailList(), "发运明细不能为空");
+            ValidatorBean.checkNotNull(model.getSn(), "条码不能为空");
+            ValidatorBean.checkNotNull(model.getLocationCode(), "位置码不能为空");
+
+            sortShippingCheckService.saveSnAndLocationCode(model, AuthUtil.getOrganizeCode());
+            return ResultBean.success("查询成功").setResultObject(model);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        } finally {
+            //解锁
+            redisLockUtil.redisUnLock(lockFlg, moduleKey);
+        }
+    }
+
+
+    @GetMapping("/query-auto-push-order")
+    @ApiOperation(value = "自动推单")
+    public ResultBean queryAutoPushOrder(String shippingGroupNo) {
+
+        try {
+
+            MesShippingOrderManagement order = sortShippingCheckService.queryShippingOrderNoByAutoPushOrder(shippingGroupNo, AuthUtil.getOrganizeCode());
+            return ResultBean.success("查询成功").setResultObject(order);
+        } catch (ImppBusiException imppException) {
+            return ResultBean.fail(imppException);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        }
+    }
+
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesPartShippingGroupService.java

@@ -0,0 +1,27 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi;
+
+import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesPartShippingGroupService;
+import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
+import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
+import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
+import cn.estsh.i3plus.pojo.mes.repository.MesPartShippingGroupRepository;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+@Slf4j
+public class MesPartShippingGroupService implements IMesPartShippingGroupService {
+
+
+    @Autowired
+    private MesPartShippingGroupRepository shippingGroupRepository;
+
+    public List<MesPartShippingGroup> findAll( DdlPackBean packBean) {
+        List<MesPartShippingGroup> detailDeleteList = shippingGroupRepository.findByHqlWhere(packBean);
+        return detailDeleteList;
+    }
+
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesShippingLoadingCheckService.java

@@ -0,0 +1,267 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi;
+
+import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesShippingLoadingCheckService;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesShippingLoadingCheckModel;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtEnumUtil;
+import cn.estsh.i3plus.platform.common.util.MesPcnConstWords;
+import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.i3plus.pojo.base.enumutil.MesEnumUtil;
+import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
+import cn.estsh.i3plus.pojo.mes.bean.*;
+import cn.estsh.i3plus.pojo.mes.repository.*;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.util.ImppRedis;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-04-26 15:38
+ * @Modify:
+ **/
+@Service
+@Slf4j
+public class MesShippingLoadingCheckService implements IMesShippingLoadingCheckService {
+
+    @Autowired
+    private MesLoadingVehiclesOrderRepository vehiclesOrderRepository;
+    @Autowired
+    private MesLoadingVehiclesOrderDetailRepository vehiclesOrderDetailRepository;
+
+    @Autowired
+    private MesShippingOrderManagementRepository shippingOrderManagementRepository;
+    @Autowired
+    private MesShippingOrderManagementDetailRepository shippingOrderManagementDetailRepository;
+    @Autowired
+    private MesProduceSnRepository produceSnRepository;
+    @Resource(name = MesPcnConstWords.REDIS_RES_PCN)
+    private ImppRedis redisMesPcn;
+
+    @Override
+    public MesShippingLoadingCheckModel queryLoadingOrderNo(MesLoadingVehiclesOrder loadingVehiclesOrder) {
+
+        //校验装车单是否存在
+        DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode);
+        DdlPreparedPack.getStringEqualPack(loadingVehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", orderPackBean);
+        MesLoadingVehiclesOrder vehiclesOrder = vehiclesOrderRepository.getByProperty(orderPackBean);
+        if (StringUtils.isEmpty(vehiclesOrder)) {
+            throw new ImppBusiException(String.format("【%s】此装车单不存在，请检查数据！", loadingVehiclesOrder.getLoadingOrderNo()));
+        }
+
+        //校验装车单状态 必须是未装车条码
+        if (vehiclesOrder.getStatus() != MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue()) {
+            throw new ImppBusiException(String.format("【%s】此装车单状态为【%s】,请选择状态为【%s】状态的装车单", loadingVehiclesOrder.getLoadingOrderNo(), vehiclesOrder.getStatus(), MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue()));
+        }
+
+
+        DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode);
+        DdlPreparedPack.getStringEqualPack(loadingVehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", orderDetailPackBean);
+        List<MesLoadingVehiclesOrderDetail> detailList = vehiclesOrderDetailRepository.findByHqlWhere(orderDetailPackBean);
+
+        //根据扫描的装车单找到是否先装车配置
+        //若配置为否，则查询装车单中所有的发运单是否都进行【排序发运校验】完成，若【排序发运校验】没完成，则提示，先进行排序发运校验。
+        if (vehiclesOrder.getIsFirstInstall() == MesCommonConstant.FALSE_INTEGER) {
+
+            //排序发运校验
+            List<String> shippingOrderNoList = detailList.stream().map(k -> k.getShippingOrderNo()).collect(Collectors.toList());
+
+            DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode);
+            DdlPreparedPack.getInPackList(shippingOrderNoList, "shippingOrderNo", orderManagementPackBean);
+            List<MesShippingOrderManagement> orderManagementList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean);
+            //未校验完成的发运单
+            List<String> orderNoList =
+                    orderManagementList.stream().filter(k -> k.getStatus() != MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue()).map(k -> k.getShippingGroupNo()).collect(Collectors.toList());
+
+            if (!CollectionUtils.isEmpty(orderNoList)) {
+                throw new ImppBusiException(String.format("【%s】此装车单中发运单为【%s】，还未做完【排序发运校验】，请检查数据", vehiclesOrder.getLoadingOrderNo(), orderNoList));
+            }
+
+        }
+
+        MesShippingLoadingCheckModel model = new MesShippingLoadingCheckModel();
+        //根据是否启用记忆
+        //若启用，则获取redis数据，redis中数据为空，则获取装车单明细数据 若redis中数据不为空，则根据装车单明细中发运单号，将扫描过的标记。 若不启动则获取装车单明细数据
+        if (vehiclesOrder.getIsEnableMemory() == MesCommonConstant.TRUE_INTEGER) {
+
+            StringBuilder stringBuilder = new StringBuilder();
+            stringBuilder.append(loadingVehiclesOrder.getOrganizeCode()).append(":").append(loadingVehiclesOrder.getLoadingOrderNo()).append(":");
+
+            //获取redis数据
+            if (redisMesPcn.hasKey(stringBuilder.toString())) {
+                //redis中数据不为空
+                List<MesLoadingVehiclesOrderDetail> isScanDetailList = (List<MesLoadingVehiclesOrderDetail>) redisMesPcn.getObject(stringBuilder.toString());
+
+                AtomicReference<Integer> isScanCount = new AtomicReference<>(0);
+                //根据装车单明细中发运单号，将扫描过的标记
+                detailList.forEach(k -> {
+                    Optional optional = isScanDetailList.stream().filter(scanDetail -> scanDetail.getLoadingOrderNo().equals(k.getLoadingOrderNo())).findFirst();
+                    if (optional.isPresent()) {
+                        k.setTempStatus(MesCommonConstant.TRUE_INTEGER);
+                        isScanCount.getAndSet(isScanCount.get() + 1);
+                    }
+                });
+
+                model.setIsScanCount(isScanCount.get());
+            }
+
+        }
+
+        //查询最近扫描完成的装车单号
+        DdlPackBean recentlyOrderPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode);
+        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue(), "status", recentlyOrderPackBean);
+        DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"modifyDatetime"}, recentlyOrderPackBean);
+        MesLoadingVehiclesOrder recentlyVehiclesOrder = vehiclesOrderRepository.getByProperty(recentlyOrderPackBean);
+
+        if (!StringUtils.isEmpty(recentlyVehiclesOrder)) {
+
+            model.setRecentlyScanVehiclesOrder(recentlyVehiclesOrder.getLoadingOrderNo());
+        }
+        model.setVehiclesOrderDetailList(detailList);
+
+        return model;
+    }
+
+    @Override
+    public MesLoadingVehiclesOrder queryLoadingOrderNoByAutoPushOrder(String shippingGroupNo, String org) {
+
+
+        //查询最近扫描完成的装车单号
+        DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
+        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue(), "status", orderPackBean);
+        DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"seq"}, orderPackBean);
+        MesLoadingVehiclesOrder loadingVehiclesOrder = vehiclesOrderRepository.getByProperty(orderPackBean);
+
+        return loadingVehiclesOrder;
+    }
+
+    @Override
+    public MesShippingLoadingCheckModel saveVehiclesOrderAndDetail(MesShippingLoadingCheckModel model, String org) {
+
+
+        //校验发运单是否存在
+        DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(org);
+        DdlPreparedPack.getStringEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderDetailPackBean);
+        MesLoadingVehiclesOrderDetail vehiclesOrderDetail = vehiclesOrderDetailRepository.getByProperty(orderDetailPackBean);
+        if (StringUtils.isEmpty(vehiclesOrderDetail)) {
+            throw new ImppBusiException(String.format("【%s】此发运单不存在或还未生成装车单明细，请检查数据！", model.getShippingOrderNo()));
+        }
+
+        //根据扫描的发运单以及前端传的发运单明细，进行匹配，若没有找到扫描的发运单，则提示扫描的发运单号不在此装车单中，请检查数据！。
+        Boolean scanflg = false;
+        for (MesLoadingVehiclesOrderDetail mesLoadingVehiclesOrderDetail : model.getVehiclesOrderDetailList()) {
+            if (mesLoadingVehiclesOrderDetail.getShippingOrderNo().equals(model.getShippingOrderNo())) {
+
+                if (mesLoadingVehiclesOrderDetail.getTempStatus() == MesCommonConstant.TRUE_INTEGER) {
+                    throw new ImppBusiException(String.format("【%s】此发运单已经扫描过，请检查数据！", model.getShippingOrderNo()));
+                }
+                mesLoadingVehiclesOrderDetail.setTempStatus(MesCommonConstant.TRUE_INTEGER);
+                mesLoadingVehiclesOrderDetail.setTempStatusVal("扫描完成");
+                scanflg = true;
+            }
+        }
+
+        if (!scanflg) {
+            throw new ImppBusiException(String.format("【%s】扫描的发运单号不在【%s】此装车单中，请检查数据！", model.getShippingOrderNo(), model.getLoadingOrderNo()));
+        }
+
+        //校验装车单是否存在
+        DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
+        DdlPreparedPack.getStringEqualPack(model.getLoadingOrderNo(), "loadingOrderNo", orderPackBean);
+        MesLoadingVehiclesOrder vehiclesOrder = vehiclesOrderRepository.getByProperty(orderPackBean);
+        if (StringUtils.isEmpty(vehiclesOrder)) {
+            throw new ImppBusiException(String.format("【%s】此装车单不存在，请检查数据！", model.getLoadingOrderNo()));
+        }
+        if (vehiclesOrder.getIsEnableMemory() == MesCommonConstant.TRUE_INTEGER) {
+
+            StringBuilder stringBuilder = new StringBuilder();
+            stringBuilder.append(org).append(":").append(model.getLoadingOrderNo()).append(":");
+
+            redisMesPcn.putHash(stringBuilder.toString(), MesPcnConstWords.BIND_KEY_PART, model.getVehiclesOrderDetailList(), -1);
+        }
+
+        Long count = model.getVehiclesOrderDetailList().stream().filter(k -> k.getTempStatus() == MesCommonConstant.TRUE_INTEGER).count();
+        model.setIsScanCount(count.intValue());
+
+        //全部扫描完成
+        if (count.intValue() == model.getVehiclesOrderDetailList().size()) {
+
+            //判断是否先装车
+            if (vehiclesOrder.getIsFirstInstall() == MesCommonConstant.TRUE_INTEGER) {
+
+                //判断是先装车
+                //修改装车单 装车单明细数据状态。
+
+                //装车单主表
+                vehiclesOrder.setStatus(MesPcnExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getValue());
+
+                //装车单明细
+                DdlPackBean vehiclesOrderDetailPackBean = DdlPackBean.getDdlPackBean(org);
+                DdlPreparedPack.getStringEqualPack(vehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", vehiclesOrderDetailPackBean);
+                List<MesLoadingVehiclesOrderDetail> vehiclesOrderDetailList = vehiclesOrderDetailRepository.findByHqlWhere(vehiclesOrderDetailPackBean);
+                vehiclesOrderDetailList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.LOADING_DETAIL_ORDER_STATUS.LOADED.getValue()));
+
+                vehiclesOrderDetailRepository.saveAll(vehiclesOrderDetailList);
+                vehiclesOrderRepository.save(vehiclesOrder);
+
+            } else {
+
+                //判断否先装车
+                //修改对应装车单 装车单明细 发运单 发运明细 条码数据 报工给wms。
+
+                //排序发运校验
+                List<String> shippingOrderNoList = model.getVehiclesOrderDetailList().stream().map(k -> k.getShippingOrderNo()).collect(Collectors.toList());
+
+                //发运单
+                DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org);
+                DdlPreparedPack.getInPackList(shippingOrderNoList, "shippingOrderNo", orderManagementPackBean);
+                List<MesShippingOrderManagement> orderManagementList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean);
+
+                //发运单明细
+                List<MesShippingOrderManagementDetail> orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementPackBean);
+
+                //条码
+                List<String> snList = orderManagementDetailList.stream().map(k -> k.getSn()).collect(Collectors.toList());
+                DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
+                DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
+                List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
+
+                //装车单明细
+                DdlPackBean vehiclesOrderDetailPackBean = DdlPackBean.getDdlPackBean(org);
+                DdlPreparedPack.getStringEqualPack(vehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", vehiclesOrderDetailPackBean);
+                List<MesLoadingVehiclesOrderDetail> vehiclesOrderDetailList = vehiclesOrderDetailRepository.findByHqlWhere(vehiclesOrderDetailPackBean);
+
+                orderManagementList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
+                orderManagementDetailList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
+                produceSnList.forEach(k -> k.setSnStatus(MesPcnExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
+                vehiclesOrder.setStatus(MesPcnExtEnumUtil.LOADING_ORDER_STATUS.SHIPPING.getValue());
+                vehiclesOrderDetailList.forEach(k -> {
+                    k.setStatus(MesPcnExtEnumUtil.LOADING_DETAIL_ORDER_STATUS.SHIPPING.getValue());
+                    k.setShippingStatus(MesPcnExtEnumUtil.LOADING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
+                });
+
+                shippingOrderManagementRepository.saveAll(orderManagementList);
+                shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
+                produceSnRepository.saveAll(produceSnList);
+                vehiclesOrderDetailRepository.saveAll(vehiclesOrderDetailList);
+                vehiclesOrderRepository.save(vehiclesOrder);
+
+            }
+
+        }
+
+        return model;
+    }
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesSortShippingCheckService.java

@@ -0,0 +1,420 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi;
+
+import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesSortShippingCheckService;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesSortShippingCheckModel;
+import cn.estsh.i3plus.ext.mes.pcn.pojo.util.MesPcnExtEnumUtil;
+import cn.estsh.i3plus.platform.common.util.MesPcnConstWords;
+import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
+import cn.estsh.i3plus.pojo.mes.bean.*;
+import cn.estsh.i3plus.pojo.mes.repository.*;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.util.ImppRedis;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-04-26 15:38
+ * @Modify:
+ **/
+@Service
+@Slf4j
+public class MesSortShippingCheckService implements IMesSortShippingCheckService {
+
+    @Autowired
+    private MesShippingOrderManagementRepository shippingOrderManagementRepository;
+    @Autowired
+    private MesShippingOrderManagementDetailRepository shippingOrderManagementDetailRepository;
+    @Autowired
+    private MesProduceSnRepository produceSnRepository;
+
+    @Autowired
+    private MesPartShippingGroupRepository partShippingGroupRepository;
+    @Autowired
+    private MesLoadingVehiclesOrderRepository vehiclesOrderRepository;
+
+    @Autowired
+    private MesLoadingVehiclesOrderDetailRepository vehiclesOrderDetailRepository;
+
+    @Resource(name = MesPcnConstWords.REDIS_RES_PCN)
+    private ImppRedis redisMesPcn;
+
+
+    @Override
+    public MesSortShippingCheckModel queryShippingOrderNo(MesShippingOrderManagement shippingOrderManagement) {
+
+
+        //校验装车单是否存在
+        DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.organizeCode);
+        DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingOrderNo(), "shippingOrderNo", orderManagementPackBean);
+        MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
+        if (StringUtils.isEmpty(orderManagement)) {
+            throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", shippingOrderManagement.getShippingOrderNo()));
+        }
+
+        //校验装车单状态 必须是未装车条码
+        if (orderManagement.getStatus() != MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue()) {
+            throw new ImppBusiException(String.format("【%s】此发运单状态为【%s】,请选择状态为【%s】状态的发运单", shippingOrderManagement.getShippingOrderNo(), orderManagement.getStatus(),
+                    MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue()));
+        }
+
+
+        //根据扫描的发运单找到是否装车配置，若是，则根据发运单查询是否生成装车单，若没生成装车单则提示此发运单配置是否装车为是,但没生成装车单，请检查数据！
+        if (orderManagement.getIsLoading() == MesCommonConstant.TRUE_INTEGER) {
+
+            DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.organizeCode);
+            DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingOrderNo(), "shippingOrderNo", orderDetailPackBean);
+            MesLoadingVehiclesOrderDetail vehiclesOrderDetail = vehiclesOrderDetailRepository.getByProperty(orderDetailPackBean);
+            if (StringUtils.isEmpty(vehiclesOrderDetail)) {
+                throw new ImppBusiException(String.format("【%s】此发运单配置是否装车为是,但没生成装车单，请检查数据！", shippingOrderManagement.getShippingOrderNo()));
+            }
+
+            //判断是否先装车
+            if (orderManagement.getIsFirstInstall() == MesCommonConstant.TRUE_INTEGER) {
+
+                //是否进行完装车校验
+                DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.organizeCode);
+                DdlPreparedPack.getStringEqualPack(vehiclesOrderDetail.getLoadingOrderNo(), "loadingOrderNo", orderPackBean);
+                MesLoadingVehiclesOrder vehiclesOrder = vehiclesOrderRepository.getByProperty(orderPackBean);
+                //若没进行装车校验，则提示【%s】此发运单对应的【%s】此装车单状态为【%s】，请选择状态为【%s】的数据
+                if (vehiclesOrder.getStatus() != MesPcnExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getValue()) {
+                    throw new ImppBusiException(String.format("【%s】此发运单对应的【%s】此装车单状态为【%s】，请选择状态为【%s】的数据！", shippingOrderManagement.getShippingOrderNo(),
+                            vehiclesOrder.getLoadingOrderNo(), vehiclesOrder.getStatus(), MesPcnExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getDescription()));
+                }
+
+            }
+        }
+
+        MesSortShippingCheckModel model = new MesSortShippingCheckModel();
+        if (!StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
+            model.setIsScanLocationCode(true);
+        }
+
+
+        DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.organizeCode);
+        DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingOrderNo(), "shippingOrderNo", orderDetailPackBean);
+        List<MesShippingOrderManagementDetail> detailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderDetailPackBean);
+
+
+        //查询最近扫描完成的装车单号
+        DdlPackBean recentlyOrderPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.organizeCode);
+        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue(), "status", recentlyOrderPackBean);
+        DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"modifyDatetime"}, recentlyOrderPackBean);
+        MesShippingOrderManagement recentlyVehiclesOrder = shippingOrderManagementRepository.getByProperty(recentlyOrderPackBean);
+
+        model.setDetailList(detailList);
+        model.setShippingOrderNo(orderManagement.getShippingOrderNo());
+        if (!StringUtils.isEmpty(recentlyVehiclesOrder)) {
+
+            model.setRecentlyScanShippingOrderNo(recentlyVehiclesOrder.getShippingOrderNo());
+        }
+
+        return model;
+    }
+
+    @Override
+    public MesSortShippingCheckModel saveSn(MesSortShippingCheckModel model, String org) {
+
+        //校验条码
+        MesProduceSn produceSn = checkMesProduceSn(model, org);
+
+        //校验发运单是否存在
+        MesShippingOrderManagement orderManagement = checkMesShippingOrderManagement(model, org);
+
+        //根据条码找到对应的物料号，若物料号一致，则修改扫描flg，将flg改为true.
+        boolean scanFlg = false;
+        for (MesShippingOrderManagementDetail detail : model.getDetailList()) {
+            if (detail.getPartNo().equals(produceSn.getPartNo())) {
+                scanFlg = true;
+                if (StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
+                    detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
+                }
+                detail.setSn(produceSn.getSerialNumber());
+                break;
+            }
+        }
+
+        if (!scanFlg) {
+            throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
+        }
+
+        Long count = model.getDetailList().stream().filter(k -> k.getIsScanFlg() == MesCommonConstant.TRUE_INTEGER).count();
+
+
+        //当前发运单全部扫描完成 并且不需要扫位置码
+        if (count.intValue() == model.getDetailList().size() && StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
+
+            //保存数据库
+            saveDate(orderManagement, model, org);
+        }
+
+        return model;
+    }
+
+    @Override
+    public MesSortShippingCheckModel saveSnAndLocationCode(MesSortShippingCheckModel model, String org) {
+
+        //校验条码
+        MesProduceSn produceSn = checkMesProduceSn(model, org);
+
+
+        //校验发运单是否存在
+        MesShippingOrderManagement orderManagement = checkMesShippingOrderManagement(model, org);
+
+        //根据条码找到对应的物料号，若物料号一致，则修改扫描flg，将flg改为true.
+        boolean scanFlg = false;
+        for (MesShippingOrderManagementDetail detail : model.getDetailList()) {
+            if (detail.getPartNo().equals(produceSn.getPartNo())) {
+                scanFlg = true;
+                detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
+                detail.setSn(produceSn.getSerialNumber());
+                break;
+            }
+        }
+
+        if (!scanFlg) {
+            throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
+        }
+
+        Long count = model.getDetailList().stream().filter(k -> k.getIsScanFlg() == MesCommonConstant.TRUE_INTEGER).count();
+
+        //当前发运单全部扫描完成
+        if (count.intValue() == model.getDetailList().size()) {
+
+            //保存数据库
+            saveDate(orderManagement, model, org);
+
+        }
+
+        return model;
+    }
+
+    @Override
+    public MesShippingOrderManagement queryShippingOrderNoByAutoPushOrder(String shippingGroupNo, String org) {
+
+        //查询最近扫描完成的装车单号
+        DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
+        DdlPreparedPack.getNumEqualPack(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue(), "status", orderPackBean);
+        DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"seq"}, orderPackBean);
+        MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderPackBean);
+
+        return orderManagement;
+
+    }
+
+
+    private MesProduceSn checkMesProduceSn(MesSortShippingCheckModel model, String org) {
+        DdlPackBean productPackBean = DdlPackBean.getDdlPackBean(org);
+        DdlPreparedPack.getStringEqualPack(model.getSn(), "serialNumber", productPackBean);
+        MesProduceSn produceSn = produceSnRepository.getByProperty(productPackBean);
+
+        if (StringUtils.isEmpty(produceSn)) {
+            throw new ImppBusiException(String.format("【%s】此产品条码不存在，请检查数据！", model.getSn()));
+        }
+        //校验产品条码状态 必须是状态为已下线条码
+        if (produceSn.getSnStatus() != MesPcnExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getValue()) {
+            throw new ImppBusiException(String.format("【%s】此条码状态为【%s】,请选择状态为【%s】状态的条码", model.getSn(), produceSn.getSnStatus(),
+                    MesPcnExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getValue()));
+        }
+        //校验产品质量状态 必须是状态为合格条码
+        if (produceSn.getQcStatus() != MesPcnExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue()) {
+            throw new ImppBusiException(String.format("【%s】此条码质量状态为【%s】,请选择状态为【%s】状态的条码", model.getSn(), produceSn.getQcStatus(),
+                    MesPcnExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue()));
+        }
+
+        Optional optional = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getSn()) && k.getSn().equals(model.getSn())).findFirst();
+        if (optional.isPresent()) {
+            throw new ImppBusiException(String.format("【%s】此条码已经扫描过，请检查数据！", model.getSn()));
+        }
+        return produceSn;
+    }
+
+    private MesShippingOrderManagement checkMesShippingOrderManagement(MesSortShippingCheckModel model, String org) {
+        //校验发运单是否存在
+        DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org);
+        DdlPreparedPack.getStringEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderManagementPackBean);
+        MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
+        if (StringUtils.isEmpty(orderManagement)) {
+            throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", model.getShippingOrderNo()));
+        }
+        return orderManagement;
+    }
+
+    private void saveDate(MesShippingOrderManagement orderManagement, MesSortShippingCheckModel model, String org) {
+
+
+        //根据扫描的发运单找到是否装车配置，若是，则根据发运单查询是否生成装车单，若没生成装车单则提示此发运单配置是否装车为是,但没生成装车单，请检查数据！
+        if (orderManagement.getIsLoading() == MesCommonConstant.TRUE_INTEGER) {
+
+
+            DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(org);
+            DdlPreparedPack.getStringEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderDetailPackBean);
+            MesLoadingVehiclesOrderDetail vehiclesOrderDetail = vehiclesOrderDetailRepository.getByProperty(orderDetailPackBean);
+            if (StringUtils.isEmpty(vehiclesOrderDetail)) {
+                throw new ImppBusiException(String.format("【%s】此发运单配置是否装车为是,但没生成装车单，请检查数据！", model.getShippingOrderNo()));
+            }
+
+
+            //发运单状态修改为校验完成
+            orderManagement.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
+
+            //发运单明细状态修改为校验完成
+            DdlPackBean orderManagementDetailPackBean = DdlPackBean.getDdlPackBean(org);
+            DdlPreparedPack.getStringEqualPack(orderManagement.getShippingOrderNo(), "shippingOrderNo", orderManagementDetailPackBean);
+            List<MesShippingOrderManagementDetail> orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementDetailPackBean);
+
+            List<String> snList = new ArrayList<>();
+            for (MesShippingOrderManagementDetail detail : orderManagementDetailList) {
+                detail.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
+                Optional<MesShippingOrderManagementDetail> optional1 =
+                        model.getDetailList().stream().filter(k -> k.getShippingOrderNo().equals(detail.getShippingOrderNo())).findFirst();
+                detail.setSn(optional1.get().getSn());
+                snList.add(optional1.get().getSn());
+            }
+
+            DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
+            DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
+            List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
+            //todo
+            //条码校验完成
+            produceSnList.forEach(k -> k.setSnStatus(MesPcnExtEnumUtil.PRODUCE_SN_STATUS.CHECKED.getValue()));
+
+            //判断是否先装车
+            if (orderManagement.getIsFirstInstall() == MesCommonConstant.TRUE_INTEGER) {
+
+                //是先装车
+                //判断此装车单下所有的发运单扫描完成
+                //修改对应装车单 装车单明细 发运单 发运明细 条码数据 报工给wms。
+
+                //剩余的发运单号
+                DdlPackBean orderManagementAllPackBean = DdlPackBean.getDdlPackBean(org);
+                DdlPreparedPack.getStringEqualPack(orderManagement.getLoadingOrderNo(), "loadingOrderNo", orderManagementAllPackBean);
+                List<MesShippingOrderManagement> orderManagementAllList = shippingOrderManagementRepository.findByHqlWhere(orderManagementAllPackBean);
+
+                //排序校验完成的发运单数量
+                Long completed =
+                        orderManagementAllList.stream().filter(k -> k.getStatus() == MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue()).count();
+
+                //若剩余的发运单号都校验完成
+                if (completed.intValue() + 1 == orderManagementAllList.size()) {
+
+//                        //修改对应装车单 装车单明细 发运单 发运明细 条码数据 报工给wms。
+
+                    //修改当前发运单状态
+                    orderManagement.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
+
+                    //修改当前发运单明细状态
+                    orderManagementDetailList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
+
+                    //修改当前发运单明细条码状态
+                    produceSnList.forEach(k -> k.setSnStatus(MesPcnExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
+
+                    //装车单
+                    DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
+                    DdlPreparedPack.getStringEqualPack(orderManagement.getLoadingOrderNo(), "loadingOrderNo", orderPackBean);
+                    MesLoadingVehiclesOrder vehiclesOrder = vehiclesOrderRepository.getByProperty(orderPackBean);
+                    vehiclesOrder.setStatus(MesPcnExtEnumUtil.LOADING_ORDER_STATUS.SHIPPING.getValue());
+
+                    //装车单明细
+                    DdlPackBean vehiclesOrderDetailPackBean = DdlPackBean.getDdlPackBean(org);
+                    DdlPreparedPack.getStringEqualPack(vehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", vehiclesOrderDetailPackBean);
+                    List<MesLoadingVehiclesOrderDetail> vehiclesOrderDetailList = vehiclesOrderDetailRepository.findByHqlWhere(vehiclesOrderDetailPackBean);
+                    vehiclesOrderDetailList.forEach(k -> {
+                        k.setStatus(MesPcnExtEnumUtil.LOADING_DETAIL_ORDER_STATUS.SHIPPING.getValue());
+                        k.setShippingStatus(MesPcnExtEnumUtil.LOADING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
+                    });
+
+                    //此发运单所在装车单对应剩余发运单
+                    DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org);
+                    DdlPreparedPack.getStringNoEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderManagementPackBean);
+                    DdlPreparedPack.getStringEqualPack(orderManagement.getLoadingOrderNo(), "shippingOrderNo", orderManagementPackBean);
+                    List<MesShippingOrderManagement> orderManagementtSurplusList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean);
+                    orderManagementtSurplusList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
+
+                    //此发运单所在装车单对应剩余发运单明细
+                    List<MesShippingOrderManagementDetail> orderManagementDetailSurplusList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementPackBean);
+                    orderManagementDetailSurplusList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
+
+                    //剩余发运单明细的条码
+                    List<String> snSurplusList = orderManagementDetailSurplusList.stream().map(k -> k.getSn()).collect(Collectors.toList());
+                    producePackBean = DdlPackBean.getDdlPackBean(org);
+                    DdlPreparedPack.getInPackList(snSurplusList, "serialNumber", producePackBean);
+                    List<MesProduceSn> produceSnSurplusList = produceSnRepository.findByHqlWhere(producePackBean);
+                    produceSnSurplusList.forEach(k -> k.setSnStatus(MesPcnExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
+
+
+                    //保存剩余发运单
+                    shippingOrderManagementRepository.saveAll(orderManagementtSurplusList);
+                    //保存当前发运单
+                    shippingOrderManagementRepository.save(orderManagement);
+                    //保存剩余发运单明细
+                    shippingOrderManagementDetailRepository.saveAll(orderManagementDetailSurplusList);
+                    //保存当前发运单明细
+                    shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
+                    //保存剩余发运单条码
+                    produceSnRepository.saveAll(produceSnSurplusList);
+                    //保存当前发运单条码
+                    produceSnRepository.saveAll(produceSnList);
+                    //保存装车单明细
+                    vehiclesOrderDetailRepository.saveAll(vehiclesOrderDetailList);
+                    //保存装车单
+                    vehiclesOrderRepository.save(vehiclesOrder);
+
+                } else {
+
+                    produceSnRepository.saveAll(produceSnList);
+                    shippingOrderManagementRepository.save(orderManagement);
+                    shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
+                }
+            } else {
+                produceSnRepository.saveAll(produceSnList);
+                shippingOrderManagementRepository.save(orderManagement);
+                shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
+
+            }
+
+        } else {
+            //否装车
+
+            //发运单状态修改为校验完成
+            orderManagement.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
+
+            //发运单明细状态修改为校验完成
+            DdlPackBean orderManagementDetailPackBean = DdlPackBean.getDdlPackBean(org);
+            DdlPreparedPack.getStringEqualPack(orderManagement.getShippingOrderNo(), "shippingOrderNo", orderManagementDetailPackBean);
+            List<MesShippingOrderManagementDetail> orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementDetailPackBean);
+
+            List<String> snList = new ArrayList<>();
+            for (MesShippingOrderManagementDetail detail : orderManagementDetailList) {
+                detail.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
+                Optional<MesShippingOrderManagementDetail> optional1 =
+                        model.getDetailList().stream().filter(k -> k.getShippingOrderNo().equals(detail.getShippingOrderNo())).findFirst();
+                detail.setSn(optional1.get().getSn());
+                snList.add(optional1.get().getSn());
+            }
+            DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
+            DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
+            List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
+            produceSnList.forEach(k -> k.setSnStatus(MesPcnExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
+
+            produceSnRepository.saveAll(produceSnList);
+            shippingOrderManagementRepository.save(orderManagement);
+            shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
+        }
+
+    }
+
+}

modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/util/MesRedisLockUtil.java

@@ -0,0 +1,40 @@
+package cn.estsh.i3plus.ext.mes.pcn.apiservice.util;
+
+import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.util.ImppRedis;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2023-01-04 17:51
+ * @Modify:
+ **/
+@Service
+public class MesRedisLockUtil {
+    @Resource(name = "redisMesPcn")
+    private ImppRedis redisMes;
+
+    public Boolean redisLock(String moduleKey) {
+        //加锁
+        boolean lockFlg = redisMes.setIfAbsent(moduleKey, MesCommonConstant.EXPIRE_TIME);
+        //成功则返回true 失败则提示消息
+        if (!lockFlg) {
+            throw new ImppBusiException(MesCommonConstant.REDIS_LOCK_MESSAGE);
+        }
+        redisMes.expire(moduleKey, MesCommonConstant.EXPIRE_TIME);
+        return true;
+    }
+
+    public void redisUnLock(boolean lockFlg, String moduleKey) {
+        //解锁
+        if (lockFlg) {
+            redisMes.deleteKey(moduleKey);
+        }
+    }
+
+}

modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/constant/MesCommonConstant.java

@@ -0,0 +1,22 @@
+package cn.estsh.i3plus.ext.mes.pcn.pojo.constant;
+
+
+public class MesCommonConstant {
+
+    //yanfeng
+    public static final String MES_YANFEN = "/mes-pcn/ext";
+
+    public static final Long EXPIRE_TIME = 60L;
+
+    public static final String REDIS_LOCK_MESSAGE = "已有人正在执行，请稍后再试";
+
+    public static final String TRUE_STRING = "1";
+
+    public static final String FALSE_STRING = "2";
+
+    public static final Integer TRUE_INTEGER = 1;
+
+    public static final Integer FALSE_INTEGER = 2;
+
+
+}

modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesShippingLoadingCheckModel.java

@@ -0,0 +1,35 @@
+package cn.estsh.i3plus.ext.mes.pcn.pojo.model;
+
+import cn.estsh.i3plus.pojo.mes.bean.MesLoadingVehiclesOrderDetail;
+import io.swagger.annotations.ApiParam;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-04-26 15:44
+ * @Modify:
+ **/
+@Data
+public class MesShippingLoadingCheckModel {
+
+
+    @ApiParam("装车单")
+    private String loadingOrderNo;
+
+    @ApiParam("最近扫描完成的装车单号")
+    private String recentlyScanVehiclesOrder;
+
+    @ApiParam("发运单号")
+    private String shippingOrderNo;
+
+    @ApiParam("已扫描数量")
+    private Integer isScanCount = 0;
+
+    @ApiParam("装车单明细")
+    private List<MesLoadingVehiclesOrderDetail> vehiclesOrderDetailList;
+
+}

modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesSortShippingCheckModel.java

@@ -0,0 +1,36 @@
+package cn.estsh.i3plus.ext.mes.pcn.pojo.model;
+
+import cn.estsh.i3plus.pojo.mes.bean.MesShippingOrderManagementDetail;
+import io.swagger.annotations.ApiParam;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author :
+ * @CreateDate : 2024-04-26 15:44
+ * @Modify:
+ **/
+@Data
+public class MesSortShippingCheckModel {
+
+
+    @ApiParam("发运单号")
+    private String shippingOrderNo;
+    @ApiParam("最近扫描完成的装车单号")
+    private String recentlyScanShippingOrderNo;
+    @ApiParam("条码")
+    private String sn;
+    @ApiParam("位置码")
+    private String locationCode;
+
+    @ApiParam("是否需要扫描槽位码")
+    private Boolean isScanLocationCode = false;
+
+    @ApiParam("发运组明细数据")
+    private List<MesShippingOrderManagementDetail> detailList;
+
+
+}

modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/util/MesPcnExtEnumUtil.java

@@ -1,5 +1,259 @@
 package cn.estsh.i3plus.ext.mes.pcn.pojo.util;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
+
 public class MesPcnExtEnumUtil {
 
+
+    /**
+     * 装车单-状态
+     */
+    @JsonFormat(
+            shape = JsonFormat.Shape.OBJECT
+    )
+    public static enum LOADING_ORDER_STATUS {
+        CREATE(10, "创建"),
+        LOADING(15, "装车中"),
+        LOADED(20, "已装车"),
+        SHIPPING(30, "已发运"),
+        CLOSE(40, "关闭");
+
+        private int value;
+        private String description;
+
+
+        private LOADING_ORDER_STATUS(int value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public static String valueOfDescription(int val) {
+            String tmp = null;
+
+            for (int i = 0; i < values().length; ++i) {
+                if (values()[i].value == val) {
+                    tmp = values()[i].description;
+                }
+            }
+
+            return tmp;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+
+        public String getDescription() {
+            return this.description;
+        }
+    }
+
+    /**
+     * 装车单明细-状态
+     */
+    @JsonFormat(
+            shape = JsonFormat.Shape.OBJECT
+    )
+    public static enum LOADING_DETAIL_ORDER_STATUS {
+        CREATE(10, "创建"),
+        LOADED(20, "已装车"),
+        SHIPPING(30, "已发运"),
+        CLOSE(40, "关闭");
+
+        private int value;
+        private String description;
+
+
+        private LOADING_DETAIL_ORDER_STATUS(int value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public static String valueOfDescription(int val) {
+            String tmp = null;
+
+            for (int i = 0; i < values().length; ++i) {
+                if (values()[i].value == val) {
+                    tmp = values()[i].description;
+                }
+            }
+
+            return tmp;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+
+        public String getDescription() {
+            return this.description;
+        }
+    }
+
+
+    /**
+     * 发运单状态
+     */
+    @JsonFormat(
+            shape = JsonFormat.Shape.OBJECT
+    )
+    public static enum SHIPPING_ORDER_STATUS {
+        CREATE(10, "创建"),
+        PUBLISHED(20, "已发布"),
+        SHIPPED(30, "已发运"),
+        VERIFYING(35, "校验中"),
+        VERIFICATION_COMPLETED(40, "校验完成");
+
+        private int value;
+        private String description;
+
+        private SHIPPING_ORDER_STATUS(int value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public static String valueOfDescription(int val) {
+            String tmp = null;
+
+            for (int i = 0; i < values().length; ++i) {
+                if (values()[i].value == val) {
+                    tmp = values()[i].description;
+                }
+            }
+
+            return tmp;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+
+        public String getDescription() {
+            return this.description;
+        }
+    }
+
+
+    /**
+     * 装车单明细-发运状态
+     */
+    @JsonFormat(
+            shape = JsonFormat.Shape.OBJECT
+    )
+    public static enum LOADING_ORDER_DETAIL_SHIPPING_STATUS {
+        PUBLISHED(10, "Published"),
+        SHIPPINGED(20, "Shippinged");
+
+        private int value;
+        private String description;
+
+        private LOADING_ORDER_DETAIL_SHIPPING_STATUS(int value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public static String valueOfDescription(int val) {
+            String tmp = null;
+
+            for (int i = 0; i < values().length; ++i) {
+                if (values()[i].value == val) {
+                    tmp = values()[i].description;
+                }
+            }
+
+            return tmp;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+
+        public String getDescription() {
+            return this.description;
+        }
+    }
+
+    /**
+     * 零件发运组-扫描确认零件方式
+     */
+    @JsonFormat(
+            shape = JsonFormat.Shape.OBJECT
+    )
+    public static enum PRODUCE_SN_STATUS {
+        CREATE(10, "创建"),
+        OFFLINE(20, "已完成"),
+        ASSEMBLY(30, "已装配"),
+        CHECKED(40, "已校验"),
+        SHIPPED(50, "发运");
+
+        private int value;
+        private String description;
+
+        private PRODUCE_SN_STATUS(int value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public static String valueOfDescription(int val) {
+            String tmp = null;
+
+            for (int i = 0; i < values().length; ++i) {
+                if (values()[i].value == val) {
+                    tmp = values()[i].description;
+                }
+            }
+
+            return tmp;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+
+        public String getDescription() {
+            return this.description;
+        }
+    }
+
+    /**
+     * 零件发运组-扫描确认零件方式
+     */
+    @JsonFormat(
+            shape = JsonFormat.Shape.OBJECT
+    )
+    public static enum PRODUCE_QC_STATUS {
+        QUALIFIED(10, "合格"),
+        SUSPICIOUS(20, "可疑"),
+        SCRAP(30, "报废");
+
+        private int value;
+        private String description;
+
+        private PRODUCE_QC_STATUS(int value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public static String valueOfDescription(int val) {
+            String tmp = null;
+
+            for (int i = 0; i < values().length; ++i) {
+                if (values()[i].value == val) {
+                    tmp = values()[i].description;
+                }
+            }
+
+            return tmp;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+
+        public String getDescription() {
+            return this.description;
+        }
+    }
+
+
 }