From 599a4456fd665521b7901d7444843039e80593f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?LML=E4=B8=B6?= Date: Wed, 8 May 2024 12:02:49 +0800 Subject: [PATCH] =?UTF-8?q?=E5=8F=91=E8=BF=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../pcn/api/busi/IMesPartShippingGroupService.java | 20 + .../api/busi/IMesShippingLoadingCheckService.java | 26 ++ .../pcn/api/busi/IMesSortShippingCheckService.java | 28 ++ .../busi/MesPartShippingGroupController.java | 53 +++ .../busi/MesShippingLoadingCheckController.java | 105 ++++++ .../busi/MesSortShippingCheckController.java | 138 +++++++ .../busi/MesPartShippingGroupService.java | 27 ++ .../busi/MesShippingLoadingCheckService.java | 267 +++++++++++++ .../busi/MesSortShippingCheckService.java | 420 +++++++++++++++++++++ .../mes/pcn/apiservice/util/MesRedisLockUtil.java | 40 ++ .../mes/pcn/pojo/constant/MesCommonConstant.java | 22 ++ .../pojo/model/MesShippingLoadingCheckModel.java | 35 ++ .../pcn/pojo/model/MesSortShippingCheckModel.java | 36 ++ .../ext/mes/pcn/pojo/util/MesPcnExtEnumUtil.java | 254 +++++++++++++ 14 files changed, 1471 insertions(+) create mode 100644 modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesPartShippingGroupService.java create mode 100644 modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesShippingLoadingCheckService.java create mode 100644 modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesSortShippingCheckService.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesPartShippingGroupController.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesShippingLoadingCheckController.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesSortShippingCheckController.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesPartShippingGroupService.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesShippingLoadingCheckService.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesSortShippingCheckService.java create mode 100644 modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/util/MesRedisLockUtil.java create mode 100644 modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/constant/MesCommonConstant.java create mode 100644 modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesShippingLoadingCheckModel.java create mode 100644 modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesSortShippingCheckModel.java diff --git a/modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesPartShippingGroupService.java b/modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesPartShippingGroupService.java new file mode 100644 index 0000000..c1575f8 --- /dev/null +++ b/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 findAll(DdlPackBean packBean); + +} diff --git a/modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesShippingLoadingCheckService.java b/modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesShippingLoadingCheckService.java new file mode 100644 index 0000000..d769008 --- /dev/null +++ b/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); + + +} diff --git a/modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesSortShippingCheckService.java b/modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesSortShippingCheckService.java new file mode 100644 index 0000000..794ea32 --- /dev/null +++ b/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); + +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesPartShippingGroupController.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesPartShippingGroupController.java new file mode 100644 index 0000000..929a29c --- /dev/null +++ b/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); + } + } + +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesShippingLoadingCheckController.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesShippingLoadingCheckController.java new file mode 100644 index 0000000..a5584d1 --- /dev/null +++ b/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); + } + } + +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesSortShippingCheckController.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesSortShippingCheckController.java new file mode 100644 index 0000000..9f7f756 --- /dev/null +++ b/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); + } + } + +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesPartShippingGroupService.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesPartShippingGroupService.java new file mode 100644 index 0000000..31dbae5 --- /dev/null +++ b/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 findAll( DdlPackBean packBean) { + List detailDeleteList = shippingGroupRepository.findByHqlWhere(packBean); + return detailDeleteList; + } + +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesShippingLoadingCheckService.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesShippingLoadingCheckService.java new file mode 100644 index 0000000..1363a61 --- /dev/null +++ b/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 detailList = vehiclesOrderDetailRepository.findByHqlWhere(orderDetailPackBean); + + //根据扫描的装车单找到是否先装车配置 + //若配置为否，则查询装车单中所有的发运单是否都进行【排序发运校验】完成，若【排序发运校验】没完成，则提示，先进行排序发运校验。 + if (vehiclesOrder.getIsFirstInstall() == MesCommonConstant.FALSE_INTEGER) { + + //排序发运校验 + List shippingOrderNoList = detailList.stream().map(k -> k.getShippingOrderNo()).collect(Collectors.toList()); + + DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode); + DdlPreparedPack.getInPackList(shippingOrderNoList, "shippingOrderNo", orderManagementPackBean); + List orderManagementList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean); + //未校验完成的发运单 + List 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 isScanDetailList = (List) redisMesPcn.getObject(stringBuilder.toString()); + + AtomicReference 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 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 shippingOrderNoList = model.getVehiclesOrderDetailList().stream().map(k -> k.getShippingOrderNo()).collect(Collectors.toList()); + + //发运单 + DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org); + DdlPreparedPack.getInPackList(shippingOrderNoList, "shippingOrderNo", orderManagementPackBean); + List orderManagementList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean); + + //发运单明细 + List orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementPackBean); + + //条码 + List snList = orderManagementDetailList.stream().map(k -> k.getSn()).collect(Collectors.toList()); + DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org); + DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean); + List produceSnList = produceSnRepository.findByHqlWhere(producePackBean); + + //装车单明细 + DdlPackBean vehiclesOrderDetailPackBean = DdlPackBean.getDdlPackBean(org); + DdlPreparedPack.getStringEqualPack(vehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", vehiclesOrderDetailPackBean); + List 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; + } +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesSortShippingCheckService.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesSortShippingCheckService.java new file mode 100644 index 0000000..805fed2 --- /dev/null +++ b/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 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 orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementDetailPackBean); + + List snList = new ArrayList<>(); + for (MesShippingOrderManagementDetail detail : orderManagementDetailList) { + detail.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue()); + Optional 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 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 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 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 orderManagementtSurplusList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean); + orderManagementtSurplusList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue())); + + //此发运单所在装车单对应剩余发运单明细 + List orderManagementDetailSurplusList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementPackBean); + orderManagementDetailSurplusList.forEach(k -> k.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue())); + + //剩余发运单明细的条码 + List snSurplusList = orderManagementDetailSurplusList.stream().map(k -> k.getSn()).collect(Collectors.toList()); + producePackBean = DdlPackBean.getDdlPackBean(org); + DdlPreparedPack.getInPackList(snSurplusList, "serialNumber", producePackBean); + List 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 orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementDetailPackBean); + + List snList = new ArrayList<>(); + for (MesShippingOrderManagementDetail detail : orderManagementDetailList) { + detail.setStatus(MesPcnExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue()); + Optional 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 produceSnList = produceSnRepository.findByHqlWhere(producePackBean); + produceSnList.forEach(k -> k.setSnStatus(MesPcnExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue())); + + produceSnRepository.saveAll(produceSnList); + shippingOrderManagementRepository.save(orderManagement); + shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList); + } + + } + +} diff --git a/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/util/MesRedisLockUtil.java b/modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/util/MesRedisLockUtil.java new file mode 100644 index 0000000..8a152a1 --- /dev/null +++ b/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); + } + } + +} diff --git a/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/constant/MesCommonConstant.java b/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/constant/MesCommonConstant.java new file mode 100644 index 0000000..ac2c351 --- /dev/null +++ b/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; + + +} diff --git a/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesShippingLoadingCheckModel.java b/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesShippingLoadingCheckModel.java new file mode 100644 index 0000000..ff84953 --- /dev/null +++ b/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 vehiclesOrderDetailList; + +} diff --git a/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesSortShippingCheckModel.java b/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesSortShippingCheckModel.java new file mode 100644 index 0000000..45b32a5 --- /dev/null +++ b/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 detailList; + + +} diff --git a/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/util/MesPcnExtEnumUtil.java b/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/util/MesPcnExtEnumUtil.java index b816391..dc9bd72 100644 --- a/modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/util/MesPcnExtEnumUtil.java +++ b/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; + } + } + + }