jiaxin.lin
/
i3plus-mes-pcn-yfai
forked from I3-YF/i3plus-mes-pcn-yfai
1
0
Fork 0
Code Pull Requests Activity

NC 处理修改字段

Browse Source
tags/yfai-pcn-ext-v1.0
LML丶 12 months ago
parent 2e144c3d16
commit 7007f8d397
8 changed files with 190 additions and 465 deletions
Show Stats Download Patch File Download Diff File

6
modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/busi/IMesShippingLoadingCheckService.java
Unescape Escape View File

@ -1,7 +1,7 @@
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 cn.estsh.i3plus.pojo.mes.bean.MesLoadingList;
import io.swagger.annotations.ApiOperation;
/**
@ -14,10 +14,10 @@ import io.swagger.annotations.ApiOperation;
public interface IMesShippingLoadingCheckService {
@ApiOperation(value = "查询装车单")
public MesShippingLoadingCheckModel queryLoadingOrderNo(MesLoadingVehiclesOrder loadingVehiclesOrder);
public MesShippingLoadingCheckModel queryLoadingOrderNo(MesLoadingList loadingVehiclesOrder);
@ApiOperation(value = "查询装车单-自动推单")
public MesLoadingVehiclesOrder queryLoadingOrderNoByAutoPushOrder(String shippingGroupNo, String org);
public MesLoadingList queryLoadingOrderNoByAutoPushOrder(String shippingGroupNo, String org);
@ApiOperation(value = "扫描发运单")
public MesShippingLoadingCheckModel saveVehiclesOrderAndDetail(MesShippingLoadingCheckModel model, String org);

16
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesShippingLoadingCheckController.java
Unescape Escape View File

@ -5,7 +5,7 @@ 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.i3plus.pojo.mes.bean.MesLoadingList;
import cn.estsh.impp.framework.boot.auth.AuthUtil;
import cn.estsh.impp.framework.boot.exception.ImppBusiException;
import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
@ -31,9 +31,9 @@ public class MesShippingLoadingCheckController {
@GetMapping("/query-loading-order")
@ApiOperation(value = "查询装车单")
public ResultBean queryLoadingOrderNo(MesLoadingVehiclesOrder loadingVehiclesOrder) {
public ResultBean queryLoadingOrderNo(MesLoadingList loadingVehiclesOrder) {
String moduleKey = "shipping:loadingOrderNo:" + loadingVehiclesOrder.getLoadingOrderNo();
String moduleKey = "shipping:loadingOrderNo:" + loadingVehiclesOrder.getOrderCode();
//加锁
boolean lockFlg = false;
@ -43,7 +43,7 @@ public class MesShippingLoadingCheckController {
lockFlg = redisLockUtil.redisLock(moduleKey);
// 数据校验
ValidatorBean.checkNotNull(loadingVehiclesOrder.getLoadingOrderNo(), "装车单不能为空");
ValidatorBean.checkNotNull(loadingVehiclesOrder.getOrderCode(), "装车单不能为空");
loadingVehiclesOrder.setOrganizeCode(AuthUtil.getOrganizeCode());
MesShippingLoadingCheckModel model = shippingLoadingCheckService.queryLoadingOrderNo(loadingVehiclesOrder);
@ -62,7 +62,7 @@ public class MesShippingLoadingCheckController {
@ApiOperation(value = "扫描装车单明细-发运单号")
public ResultBean saveLoadingOrderNoDetail(@RequestBody MesShippingLoadingCheckModel model) {
String moduleKey = "shipping:shippingOrderNo:" + model.getShippingOrderNo();
String moduleKey = "shipping:shippingOrderNo:" + model.getShippingCode();
//加锁
boolean lockFlg = false;
@ -72,8 +72,8 @@ public class MesShippingLoadingCheckController {
lockFlg = redisLockUtil.redisLock(moduleKey);
// 数据校验
ValidatorBean.checkNotNull(model.getShippingOrderNo(), "发运单号不能为空");
ValidatorBean.checkNotNull(model.getVehiclesOrderDetailList(), "装车单明细不能为空");
ValidatorBean.checkNotNull(model.getShippingCode(), "发运单号不能为空");
ValidatorBean.checkNotNull(model.getDetailList(), "装车单明细不能为空");
String org = AuthUtil.getOrganizeCode();
shippingLoadingCheckService.saveVehiclesOrderAndDetail(model, org);
return ResultBean.success("查询成功").setResultObject(model);
@ -93,7 +93,7 @@ public class MesShippingLoadingCheckController {
try {
MesLoadingVehiclesOrder order = shippingLoadingCheckService.queryLoadingOrderNoByAutoPushOrder(shippingGroupNo, AuthUtil.getOrganizeCode());
MesLoadingList order = shippingLoadingCheckService.queryLoadingOrderNoByAutoPushOrder(shippingGroupNo, AuthUtil.getOrganizeCode());
return ResultBean.success("查询成功").setResultObject(order);
} catch (ImppBusiException imppException) {
return ResultBean.fail(imppException);

8
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/controller/busi/MesSortShippingCheckController.java
Unescape Escape View File

@ -33,7 +33,7 @@ public class MesSortShippingCheckController {
@ApiOperation(value = "查询发运单")
public ResultBean queryLoadingOrderNo(MesShippingOrderManagement shippingOrderManagement) {
String moduleKey = "sortShippingCheck:loadingOrderNo:" + shippingOrderManagement.getShippingOrderNo();
String moduleKey = "sortShippingCheck:loadingOrderNo:" + shippingOrderManagement.getShippingCode();
//加锁
boolean lockFlg = false;
@ -43,7 +43,7 @@ public class MesSortShippingCheckController {
lockFlg = redisLockUtil.redisLock(moduleKey);
// 数据校验
ValidatorBean.checkNotNull(shippingOrderManagement.getShippingOrderNo(), "发运单不能为空");
ValidatorBean.checkNotNull(shippingOrderManagement.getShippingCode(), "发运单不能为空");
shippingOrderManagement.setOrganizeCode(AuthUtil.getOrganizeCode());
MesSortShippingCheckModel model = sortShippingCheckService.queryShippingOrderNo(shippingOrderManagement);
@ -72,7 +72,7 @@ public class MesSortShippingCheckController {
lockFlg = redisLockUtil.redisLock(moduleKey);
// 数据校验
ValidatorBean.checkNotNull(model.getShippingOrderNo(), "发运单不能为空");
ValidatorBean.checkNotNull(model.getShippingCode(), "发运单不能为空");
ValidatorBean.checkNotNull(model.getDetailList(), "发运明细不能为空");
ValidatorBean.checkNotNull(model.getSn(), "条码不能为空");
@ -102,7 +102,7 @@ public class MesSortShippingCheckController {
lockFlg = redisLockUtil.redisLock(moduleKey);
// 数据校验
ValidatorBean.checkNotNull(model.getShippingOrderNo(), "发运单不能为空");
ValidatorBean.checkNotNull(model.getShippingCode(), "发运单不能为空");
ValidatorBean.checkNotNull(model.getDetailList(), "发运明细不能为空");
ValidatorBean.checkNotNull(model.getSn(), "条码不能为空");
ValidatorBean.checkNotNull(model.getLocationCode(), "位置码不能为空");

8
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesJisShippingService.java
Unescape Escape View File

@ -39,11 +39,11 @@ public class MesJisShippingService implements IMesJisShippingService {
DdlPackBean packBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(orderManagementDetailList.get(0).getLoadingOrderNo(), "shippingOrderNo", packBean);
DdlPreparedPack.getStringEqualPack(orderManagementDetailList.get(0).getLoadingOrderNo(), "shippingCode", packBean);
MesShippingOrderManagement originBean = shippingOrderManagementRepository.getByProperty(packBean);
DdlPackBean detailPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(originBean.getShippingOrderNo(), "shippingOrderNo", detailPackBean);
DdlPreparedPack.getStringEqualPack(originBean.getShippingCode(), "shippingCode", detailPackBean);
List<MesShippingOrderManagementDetail> detailDeleteList = shippingOrderManagementDetailRepository.findByHqlWhere(detailPackBean);
List<MesJisShipping> jisShippingList = new ArrayList<>();
@ -51,14 +51,14 @@ public class MesJisShippingService implements IMesJisShippingService {
MesJisShipping jisShipping = new MesJisShipping();
BeanUtils.copyProperties(originBean, jisShipping, "id");
BeanUtils.copyProperties(k, jisShipping, "id");
jisShipping.setFactoryCode(originBean.getCustPlantCode());
jisShipping.setFactoryCode(originBean.getCustOrganizeCode());
jisShipping.setShippingTime(TimeTool.getNowTime(true));
jisShipping.setDock(originBean.getSendDockCode());
jisShipping.setCusDock(originBean.getCustDockCode());
jisShipping.setCustOrderNo(k.getCustOrderNo());
jisShipping.setSerialNumber(k.getBarcode());
jisShipping.setQuantityPerCar(detailDeleteList.size());
jisShipping.setShippingOrderCode(originBean.getShippingOrderNo());
jisShipping.setShippingOrderCode(originBean.getShippingCode());
ConvertBean.serviceModelInitialize(jisShipping, AuthUtil.getSessionUser().getUserName());
jisShippingList.add(jisShipping);
});

241
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesShippingLoadingCheckService.java
Unescape Escape View File

@ -9,7 +9,9 @@ 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.bean.MesLoadingList;
import cn.estsh.i3plus.pojo.mes.bean.MesLoadingListDetail;
import cn.estsh.i3plus.pojo.mes.bean.MesShippingOrderManagement;
import cn.estsh.i3plus.pojo.mes.repository.*;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import cn.estsh.impp.framework.boot.auth.AuthUtil;
@ -18,13 +20,11 @@ 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.Collections;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description :
@ -38,9 +38,9 @@ import java.util.stream.Collectors;
public class MesShippingLoadingCheckService implements IMesShippingLoadingCheckService {
@Autowired
private MesLoadingVehiclesOrderRepository vehiclesOrderRepository;
private MesLoadingListRepository vehiclesOrderRepository;
@Autowired
private MesLoadingVehiclesOrderDetailRepository vehiclesOrderDetailRepository;
private MesLoadingListDetailRepository vehiclesOrderDetailRepository;
@Autowired
private MesShippingOrderManagementRepository shippingOrderManagementRepository;
@ -52,241 +52,162 @@ public class MesShippingLoadingCheckService implements IMesShippingLoadingCheckS
private IMesJisShippingService jisShippingService;
@Autowired
private MesJisShippingRepository jisShippingRepository;
@Resource(name = MesPcnConstWords.REDIS_RES_PCN)
private ImppRedis redisMesPcn;
@Override
public MesShippingLoadingCheckModel queryLoadingOrderNo(MesLoadingVehiclesOrder loadingVehiclesOrder) {
public MesShippingLoadingCheckModel queryLoadingOrderNo(MesLoadingList loadingList) {
//校验装车单是否存在
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() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue() && vehiclesOrder.getStatus() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue()) {
throw new ImppBusiException(String.format("【%s】此装车单状态为【%s】,请选择状态为【%s】状态的装车单", loadingVehiclesOrder.getLoadingOrderNo(),
MesExtEnumUtil.SHIPPING_ORDER_STATUS.valueOfDescription(vehiclesOrder.getStatus()), MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getDescription()));
}
//校验装车单
MesLoadingList loadingListResult = checkLoadingList(loadingList.getOrderCode(), loadingList.getOrganizeCode());
DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode);
DdlPreparedPack.getStringEqualPack(loadingVehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", orderDetailPackBean);
DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(loadingList.organizeCode);
DdlPreparedPack.getStringEqualPack(loadingList.getOrderCode(), "orderCode", orderDetailPackBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.ASC.getValue()}, new String[]{"seq"}, orderDetailPackBean);
List<MesLoadingVehiclesOrderDetail> detailList = vehiclesOrderDetailRepository.findByHqlWhere(orderDetailPackBean);
List<MesLoadingListDetail> detailList = vehiclesOrderDetailRepository.findByHqlWhere(orderDetailPackBean);
//是否逆转
if (vehiclesOrder.getIsReverse() == MesCommonConstant.TRUE_INTEGER) {
if (loadingListResult.getIsReverse() == MesCommonConstant.TRUE_INTEGER) {
// 逆转
for (int i = 0; i < detailList.size(); i += vehiclesOrder.getReverseQuantity()) {
if (i + vehiclesOrder.getReverseQuantity() - 1 < detailList.size()) {
Collections.reverse(detailList.subList(i, i + vehiclesOrder.getReverseQuantity()));
for (int i = 0; i < detailList.size(); i += loadingListResult.getReverseQuantity()) {
if (i + loadingListResult.getReverseQuantity() - 1 < detailList.size()) {
Collections.reverse(detailList.subList(i, i + loadingListResult.getReverseQuantity()));
}
}
}
//根据扫描的装车单找到是否先装车配置
//若配置为否，则查询装车单中所有的发运单是否都进行【排序发运校验】完成，若【排序发运校验】没完成，则提示，先进行排序发运校验。
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() != MesExtEnumUtil.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();
Long count = detailList.stream().filter(k -> k.getStatus() == MesExtEnumUtil.LOADING_DETAIL_ORDER_DETAIL_STATUS.SCAN.getValue()).count();
model.setIsScanCount(count.intValue());
model.setOrderCode(loadingList.getOrderCode());
//查询最近扫描完成的装车单号
DdlPackBean recentlyOrderPackBean = DdlPackBean.getDdlPackBean(loadingVehiclesOrder.organizeCode);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue(), "status", recentlyOrderPackBean);
DdlPackBean recentlyOrderPackBean = DdlPackBean.getDdlPackBean(loadingList.organizeCode);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.LOADING_ORDER_STATUS.SHIPPING.getValue(), "status", recentlyOrderPackBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"modifyDatetime"}, recentlyOrderPackBean);
MesLoadingVehiclesOrder recentlyVehiclesOrder = vehiclesOrderRepository.getByProperty(recentlyOrderPackBean);
MesLoadingList recentlyVehiclesOrder = vehiclesOrderRepository.getByProperty(recentlyOrderPackBean);
if (!StringUtils.isEmpty(recentlyVehiclesOrder)) {
model.setRecentlyScanVehiclesOrder(recentlyVehiclesOrder.getLoadingOrderNo());
model.setRecentlyScanVehiclesOrder(recentlyVehiclesOrder.getOrderCode());
}
model.setVehiclesOrderDetailList(detailList);
model.setDetailList(detailList);
return model;
}
@Override
public MesLoadingVehiclesOrder queryLoadingOrderNoByAutoPushOrder(String shippingGroupNo, String org) {
public MesLoadingList queryLoadingOrderNoByAutoPushOrder(String shippingGroupNo, String org) {
//查询最近扫描完成的装车单号
DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue(), "status", orderPackBean);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.LOADING_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);
MesLoadingList loadingList = vehiclesOrderRepository.getByProperty(orderPackBean);
return loadingVehiclesOrder;
return loadingList;
}
@Override
public MesShippingLoadingCheckModel saveVehiclesOrderAndDetail(MesShippingLoadingCheckModel model, String org) {
//校验装车单是否存在
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()));
}
//校验装车单
MesLoadingList loadingList = checkLoadingList(model.getOrderCode(), org);
//校验发运单是否存在
DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderDetailPackBean);
MesLoadingVehiclesOrderDetail vehiclesOrderDetail = vehiclesOrderDetailRepository.getByProperty(orderDetailPackBean);
DdlPreparedPack.getStringEqualPack(model.getShippingCode(), "shippingCode", orderDetailPackBean);
MesLoadingListDetail vehiclesOrderDetail = vehiclesOrderDetailRepository.getByProperty(orderDetailPackBean);
if (StringUtils.isEmpty(vehiclesOrderDetail)) {
throw new ImppBusiException(String.format("【%s】此发运单不存在或还未生成装车单明细，请检查数据！", model.getShippingOrderNo()));
throw new ImppBusiException(String.format("【%s】此发运单不存在或还未生成装车单明细，请检查数据！", model.getShippingCode()));
}
//根据扫描的发运单以及前端传的发运单明细，进行匹配，若没有找到扫描的发运单，则提示扫描的发运单号不在此装车单中，请检查数据！。
Boolean scanflg = false;
for (MesLoadingVehiclesOrderDetail mesLoadingVehiclesOrderDetail : model.getVehiclesOrderDetailList()) {
if (mesLoadingVehiclesOrderDetail.getShippingOrderNo().equals(model.getShippingOrderNo())) {
for (MesLoadingListDetail loadingListDetail : model.getDetailList()) {
if (loadingListDetail.getShippingCode().equals(model.getShippingCode())) {
if (mesLoadingVehiclesOrderDetail.getTempStatus() == MesCommonConstant.TRUE_INTEGER) {
throw new ImppBusiException(String.format("【%s】此发运单已经扫描过，请检查数据！", model.getShippingOrderNo()));
if (loadingListDetail.getTempStatus() == MesCommonConstant.TRUE_INTEGER) {
throw new ImppBusiException(String.format("【%s】此发运单已经扫描过，请检查数据！", model.getShippingCode()));
}
mesLoadingVehiclesOrderDetail.setTempStatus(MesCommonConstant.TRUE_INTEGER);
mesLoadingVehiclesOrderDetail.setTempStatusVal("扫描完成");
loadingListDetail.setTempStatus(MesCommonConstant.TRUE_INTEGER);
loadingListDetail.setTempStatusVal("扫描完成");
//根据是否启动记忆判断 若启用记忆，则根据保存数据库
if (vehiclesOrder.getIsEnableMemory() == MesCommonConstant.TRUE_INTEGER) {
if (loadingList.getIsEnableMemory() == MesCommonConstant.TRUE_INTEGER) {
vehiclesOrder.setStatus(MesExtEnumUtil.LOADING_ORDER_STATUS.LOADING.getValue());
ConvertBean.serviceModelUpdate(vehiclesOrder, AuthUtil.getSessionUser().getUserName());
vehiclesOrderRepository.save(vehiclesOrder);
loadingList.setStatus(MesExtEnumUtil.LOADING_ORDER_STATUS.LOADING.getValue());
ConvertBean.serviceModelUpdate(loadingList, AuthUtil.getSessionUser().getUserName());
vehiclesOrderRepository.save(loadingList);
mesLoadingVehiclesOrderDetail.setStatus(MesExtEnumUtil.LOADING_DETAIL_ORDER_DETAIL_STATUS.SCAN.getValue());
ConvertBean.serviceModelUpdate(mesLoadingVehiclesOrderDetail, AuthUtil.getSessionUser().getUserName());
vehiclesOrderDetailRepository.save(mesLoadingVehiclesOrderDetail);
loadingListDetail.setStatus(MesExtEnumUtil.LOADING_DETAIL_ORDER_DETAIL_STATUS.SCAN.getValue());
ConvertBean.serviceModelUpdate(loadingListDetail, AuthUtil.getSessionUser().getUserName());
vehiclesOrderDetailRepository.save(loadingListDetail);
}
//根据扫描的装车单找到是否先装车配置
//若配置为否，则查询装车单中所有的发运单是否都进行【排序发运校验】完成，若【排序发运校验】没完成，则提示，先进行排序发运校验。
if (loadingList.getIsFirstInstall() == MesCommonConstant.FALSE_INTEGER) {
MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getById(loadingListDetail.getShippingId());
if (!StringUtils.isEmpty(orderManagement)) {
throw new ImppBusiException(String.format("【%s】此装车单中发运单为【%s】，还未做完【排序发运校验】，请检查数据", model.getShippingCode(), loadingListDetail.getShippingCode()));
}
}
scanflg = true;
break;
}
}
if (!scanflg) {
throw new ImppBusiException(String.format("【%s】扫描的发运单号不在【%s】此装车单中，请检查数据！", model.getShippingOrderNo(), model.getLoadingOrderNo()));
throw new ImppBusiException(String.format("【%s】扫描的发运单号不在【%s】此装车单中，请检查数据！", model.getShippingCode(), model.getOrderCode()));
}
Long count = model.getVehiclesOrderDetailList().stream().filter(k -> k.getTempStatus() == MesCommonConstant.TRUE_INTEGER).count();
Long count = model.getDetailList().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) {
//判断是先装车
//修改装车单 装车单明细数据状态。
if (count.intValue() == model.getDetailList().size()) {
//装车单主表
vehiclesOrder.setStatus(MesExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getValue());
ConvertBean.serviceModelUpdate(vehiclesOrder, AuthUtil.getSessionUser().getUserName());
loadingList.setStatus(MesExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getValue());
ConvertBean.serviceModelUpdate(loadingList, AuthUtil.getSessionUser().getUserName());
//装车单明细
DdlPackBean vehiclesOrderDetailPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(vehiclesOrder.getLoadingOrderNo(), "loadingOrderNo", vehiclesOrderDetailPackBean);
List<MesLoadingVehiclesOrderDetail> vehiclesOrderDetailList = vehiclesOrderDetailRepository.findByHqlWhere(vehiclesOrderDetailPackBean);
DdlPreparedPack.getNumEqualPack(loadingList.getId(), "pid", vehiclesOrderDetailPackBean);
List<MesLoadingListDetail> vehiclesOrderDetailList = vehiclesOrderDetailRepository.findByHqlWhere(vehiclesOrderDetailPackBean);
vehiclesOrderDetailList.forEach(k -> {
k.setStatus(MesExtEnumUtil.LOADING_DETAIL_ORDER_STATUS.LOADED.getValue());
ConvertBean.serviceModelUpdate(k, AuthUtil.getSessionUser().getUserName());
});
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.getBarcode()).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(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
ConvertBean.serviceModelUpdate(k, AuthUtil.getSessionUser().getUserName());
});
//发运单明细
orderManagementDetailList.forEach(k -> {
k.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
ConvertBean.serviceModelUpdate(k, AuthUtil.getSessionUser().getUserName());
});
//条码
produceSnList.forEach(k -> {
k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue());
ConvertBean.serviceModelUpdate(k, AuthUtil.getSessionUser().getUserName());
});
//装车单
vehiclesOrder.setStatus(MesExtEnumUtil.LOADING_ORDER_STATUS.SHIPPING.getValue());
ConvertBean.serviceModelUpdate(vehiclesOrder, AuthUtil.getSessionUser().getUserName());
//装车单明细
vehiclesOrderDetailList.forEach(k -> {
k.setStatus(MesExtEnumUtil.LOADING_DETAIL_ORDER_DETAIL_STATUS.SHIPPING.getValue());
k.setShippingStatus(MesExtEnumUtil.LOADING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
ConvertBean.serviceModelUpdate(k, AuthUtil.getSessionUser().getUserName());
});
//报工数据
List<MesJisShipping> jisShippingList = jisShippingService.getJisShipping(orderManagementDetailList, org);
//保存当前发运单明细报工
jisShippingRepository.saveAll(jisShippingList);
shippingOrderManagementRepository.saveAll(orderManagementList);
shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
produceSnRepository.saveAll(produceSnList);
vehiclesOrderDetailRepository.saveAll(vehiclesOrderDetailList);
vehiclesOrderRepository.save(vehiclesOrder);
vehiclesOrderRepository.save(loadingList);
}
return model;
}
/**
* 校验装车单
*
* @param orderCode
* @param org
*/
public MesLoadingList checkLoadingList(String orderCode, String org) {
//校验装车单是否存在
DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(orderCode, "loadingOrderNo", orderPackBean);
MesLoadingList loadingList = vehiclesOrderRepository.getByProperty(orderPackBean);
if (StringUtils.isEmpty(loadingList)) {
throw new ImppBusiException(String.format("【%s】此装车单不存在，请检查数据！", orderCode));
}
return model;
//校验装车单状态 必须是未装车条码
if (loadingList.getStatus() != MesExtEnumUtil.LOADING_ORDER_STATUS.CREATE.getValue()) {
throw new ImppBusiException(String.format("【%s】此装车单状态为【%s】,请选择状态为【%s】状态的装车单", loadingList.getOrderCode(),
MesExtEnumUtil.LOADING_ORDER_STATUS.valueOfDescription(loadingList.getStatus()), MesExtEnumUtil.LOADING_ORDER_STATUS.CREATE.getDescription()));
}
return loadingList;
}
}

310
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/MesSortShippingCheckService.java
Unescape Escape View File

@ -4,25 +4,23 @@ import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesJisShippingService;
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.platform.common.util.MesPcnConstWords;
import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
import cn.estsh.i3plus.pojo.mes.bean.*;
import cn.estsh.i3plus.pojo.mes.repository.*;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import cn.estsh.impp.framework.boot.auth.AuthUtil;
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 :
@ -45,10 +43,10 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
@Autowired
private MesPartShippingGroupRepository partShippingGroupRepository;
@Autowired
private MesLoadingVehiclesOrderRepository vehiclesOrderRepository;
private MesLoadingListRepository ListRepository;
@Autowired
private MesLoadingVehiclesOrderDetailRepository vehiclesOrderDetailRepository;
private MesLoadingListDetailRepository listDetailRepository;
@Autowired
private MesJisShippingRepository jisShippingRepository;
@ -56,25 +54,21 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
@Autowired
private IMesJisShippingService jisShippingService;
@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);
DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingCode(), "shippingCode", orderManagementPackBean);
MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
if (StringUtils.isEmpty(orderManagement)) {
throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", shippingOrderManagement.getShippingOrderNo()));
throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", shippingOrderManagement.getShippingCode()));
}
//校验装车单状态 必须是未装车条码
if (orderManagement.getStatus() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue()) {
throw new ImppBusiException(String.format("【%s】此发运单状态为【%s】,请选择状态为【%s】状态的发运单", shippingOrderManagement.getShippingOrderNo(), orderManagement.getStatus(),
//校验发运单状态 必须是未装车条码
if (orderManagement.getStatus() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue() && orderManagement.getStatus() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue()) {
throw new ImppBusiException(String.format("【%s】此发运单状态为【%s】,请选择状态为【%s】状态的发运单", shippingOrderManagement.getShippingCode(), orderManagement.getStatus(),
MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue()));
}
@ -82,28 +76,24 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
//根据扫描的发运单找到是否装车配置，若是，则根据发运单查询是否生成装车单，若没生成装车单则提示此发运单配置是否装车为是,但没生成装车单，请检查数据！
if (orderManagement.getIsLoading() == MesCommonConstant.TRUE_INTEGER) {
if (StringUtils.isEmpty(orderManagement.getLoadingOrderNo())) {
throw new ImppBusiException(String.format("【%s】此发运单配置是否装车为是,但没绑定装车单号，请检查数据！", shippingOrderManagement.getShippingOrderNo()));
if (StringUtils.isEmpty(orderManagement.getOrderCode())) {
throw new ImppBusiException(String.format("【%s】此发运单配置是否装车为是,但没绑定装车单号，请检查数据！", shippingOrderManagement.getShippingCode()));
}
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()));
DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getOrderCode(), "orderCode", orderDetailPackBean);
MesLoadingList loadingList = ListRepository.getByProperty(orderDetailPackBean);
if (StringUtils.isEmpty(loadingList)) {
throw new ImppBusiException(String.format("【%s】此发运单配置是否装车为是,但没生成装车单，请检查数据！", shippingOrderManagement.getShippingCode()));
}
//判断是否先装车
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() != MesExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getValue()) {
throw new ImppBusiException(String.format("【%s】此发运单对应的【%s】此装车单状态为【%s】，请选择状态为【%s】的数据！", shippingOrderManagement.getShippingOrderNo(),
vehiclesOrder.getLoadingOrderNo(), vehiclesOrder.getStatus(), MesExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getDescription()));
if (loadingList.getStatus() != MesExtEnumUtil.LOADING_DETAIL_ORDER_STATUS.LOADED.getValue()) {
throw new ImppBusiException(String.format("【%s】此发运单对应的【%s】此装车单状态为【%s】，请选择状态为【%s】的数据！", shippingOrderManagement.getShippingCode(),
loadingList.getOrderCode(), MesExtEnumUtil.LOADING_ORDER_STATUS.valueOfDescription(loadingList.getStatus()), MesExtEnumUtil.LOADING_ORDER_STATUS.LOADED.getDescription()));
}
}
}
@ -115,7 +105,7 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.organizeCode);
DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingOrderNo(), "shippingOrderNo", orderDetailPackBean);
DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingCode(), "shippingCode", orderDetailPackBean);
List<MesShippingOrderManagementDetail> detailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderDetailPackBean);
@ -126,10 +116,10 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
MesShippingOrderManagement recentlyVehiclesOrder = shippingOrderManagementRepository.getByProperty(recentlyOrderPackBean);
model.setDetailList(detailList);
model.setShippingOrderNo(orderManagement.getShippingOrderNo());
model.setShippingCode(orderManagement.getShippingCode());
if (!StringUtils.isEmpty(recentlyVehiclesOrder)) {
model.setRecentlyScanShippingOrderNo(recentlyVehiclesOrder.getShippingOrderNo());
model.setRecentlyScanShippingCode(recentlyVehiclesOrder.getShippingCode());
}
return model;
@ -152,6 +142,22 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
detail.setBarcode(produceSn.getSerialNumber());
if (StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
//根据是否启动记忆判断 若启用记忆，则根据保存数据库
if (orderManagement.getIsEnableMemory() == MesCommonConstant.TRUE_INTEGER) {
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
ConvertBean.serviceModelUpdate(orderManagement, AuthUtil.getSessionUser().getUserName());
shippingOrderManagementRepository.save(orderManagement);
detail.setStatus(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
ConvertBean.serviceModelUpdate(detail, AuthUtil.getSessionUser().getUserName());
shippingOrderManagementDetailRepository.save(detail);
produceSn.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue());
ConvertBean.serviceModelUpdate(detail, AuthUtil.getSessionUser().getUserName());
produceSnRepository.save(produceSn);
}
}
break;
}
@ -227,9 +233,11 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
private MesProduceSn checkMesProduceSn(MesSortShippingCheckModel model, String org) {
DdlPackBean productPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(model.getSn(), "serialNumber", productPackBean);
MesProduceSn produceSn = produceSnRepository.getByProperty(productPackBean);
DdlPackBean packBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(model.getSn(), "productSn", packBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"createDatetime"}, packBean);
MesProduceSn produceSn = produceSnRepository.getByProperty(packBean);
if (StringUtils.isEmpty(produceSn)) {
throw new ImppBusiException(String.format("【%s】此产品条码不存在，请检查数据！", model.getSn()));
@ -255,10 +263,10 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
private MesShippingOrderManagement checkMesShippingOrderManagement(MesSortShippingCheckModel model, String org) {
//校验发运单是否存在
DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderManagementPackBean);
DdlPreparedPack.getStringEqualPack(model.getShippingCode(), "shippingCode", orderManagementPackBean);
MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
if (StringUtils.isEmpty(orderManagement)) {
throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", model.getShippingOrderNo()));
throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", model.getShippingCode()));
}
return orderManagement;
}
@ -266,217 +274,31 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
public 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()));
}
//判断是否先装车
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() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue()).count();
//若剩余的发运单号都校验完成
if (completed.intValue() + 1 == orderManagementAllList.size()) {
//修改对应装车单 装车单明细 发运单 发运明细 条码数据 报工给wms。
//发运单状态修改为校验完成
orderManagement.setStatus(MesExtEnumUtil.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(MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
Optional<MesShippingOrderManagementDetail> optional1 =
model.getDetailList().stream().filter(k -> k.getShippingOrderNo().equals(detail.getShippingOrderNo())).findFirst();
detail.setBarcode(optional1.get().getBarcode());
snList.add(optional1.get().getBarcode());
}
DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
//条码校验完成
produceSnList.forEach(k -> k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.CHECKED.getValue()));
//修改当前发运单状态
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
//修改当前发运单明细状态
orderManagementDetailList.forEach(k -> k.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
//当前发运单明细 需要报工的数据
List<MesJisShipping> jisShippingList = jisShippingService.getJisShipping(orderManagementDetailList, org);
//修改当前发运单明细条码状态
produceSnList.forEach(k -> k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
//装车单
DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(orderManagement.getLoadingOrderNo(), "loadingOrderNo", orderPackBean);
MesLoadingVehiclesOrder vehiclesOrder = vehiclesOrderRepository.getByProperty(orderPackBean);
vehiclesOrder.setStatus(MesExtEnumUtil.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(MesExtEnumUtil.LOADING_DETAIL_ORDER_STATUS.SHIPPING.getValue());
k.setShippingStatus(MesExtEnumUtil.LOADING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
});
//此发运单所在装车单对应剩余发运单
DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringNoEqualPack(model.getShippingOrderNo(), "shippingOrderNo", orderManagementPackBean);
DdlPreparedPack.getStringEqualPack(orderManagement.getLoadingOrderNo(), "loadingOrderNo", orderManagementPackBean);
List<MesShippingOrderManagement> orderManagementtSurplusList = shippingOrderManagementRepository.findByHqlWhere(orderManagementPackBean);
orderManagementtSurplusList.forEach(k -> k.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
//此发运单所在装车单对应剩余发运单明细
List<MesShippingOrderManagementDetail> orderManagementDetailSurplusList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementPackBean);
orderManagementDetailSurplusList.forEach(k -> k.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue()));
//剩余发运单明细的条码
List<String> snSurplusList = orderManagementDetailSurplusList.stream().map(k -> k.getBarcode()).collect(Collectors.toList());
producePackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getInPackList(snSurplusList, "serialNumber", producePackBean);
List<MesProduceSn> produceSnSurplusList = produceSnRepository.findByHqlWhere(producePackBean);
produceSnSurplusList.forEach(k -> k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
//剩余发运单明细 需要报工的数据
List<MesJisShipping> jisShippingSurplusList = jisShippingService.getJisShipping(orderManagementDetailSurplusList, org);
//保存当前发运单明细报工
jisShippingRepository.saveAll(jisShippingList);
//保存剩余发运单明细报工
jisShippingRepository.saveAll(jisShippingSurplusList);
//保存剩余发运单
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 {
//发运单状态修改为校验完成
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
//发运单明细状态修改为校验完成
DdlPackBean orderManagementDetailPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(orderManagement.getShippingOrderNo(), "shippingOrderNo", orderManagementDetailPackBean);
DdlPreparedPack.getStringEqualPack(orderManagement.getShippingCode(), "shippingCode", orderManagementDetailPackBean);
List<MesShippingOrderManagementDetail> orderManagementDetailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderManagementDetailPackBean);
List<String> snList = new ArrayList<>();
List<MesProduceSn> produceSnList = new ArrayList<>();
for (MesShippingOrderManagementDetail detail : orderManagementDetailList) {
detail.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
Optional<MesShippingOrderManagementDetail> optional1 =
model.getDetailList().stream().filter(k -> k.getShippingOrderNo().equals(detail.getShippingOrderNo())).findFirst();
detail.setBarcode(optional1.get().getBarcode());
snList.add(optional1.get().getBarcode());
}
detail.setStatus(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
ConvertBean.serviceModelUpdate(detail, AuthUtil.getSessionUser().getUserName());
DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
//条码校验完成
produceSnList.forEach(k -> k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.CHECKED.getValue()));
//根据扫描的条码查询条码是否存在
DdlPackBean packBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(detail.getBarcode(), "productSn", packBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"createDatetime"}, packBean);
MesProduceSn produceSn = produceSnRepository.getByProperty(packBean);
produceSnRepository.saveAll(produceSnList);
shippingOrderManagementRepository.save(orderManagement);
shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
}
} else {
//发运单状态修改为校验完成
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
produceSn.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue());
ConvertBean.serviceModelUpdate(detail, AuthUtil.getSessionUser().getUserName());
produceSnList.add(produceSn);
//发运单明细状态修改为校验完成
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(MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
Optional<MesShippingOrderManagementDetail> optional1 =
model.getDetailList().stream().filter(k -> k.getShippingOrderNo().equals(detail.getShippingOrderNo())).findFirst();
detail.setBarcode(optional1.get().getBarcode());
snList.add(optional1.get().getBarcode());
}
DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
//条码校验完成
produceSnList.forEach(k -> k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.CHECKED.getValue()));
produceSnRepository.saveAll(produceSnList);
shippingOrderManagementRepository.save(orderManagement);
shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
}
} else {
//否装车
//发运单状态修改为校验完成
orderManagement.setStatus(MesExtEnumUtil.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(MesExtEnumUtil.SHIPPING_ORDER_STATUS.VERIFICATION_COMPLETED.getValue());
Optional<MesShippingOrderManagementDetail> optional1 =
model.getDetailList().stream().filter(k -> k.getShippingOrderNo().equals(detail.getShippingOrderNo())).findFirst();
detail.setBarcode(optional1.get().getBarcode());
snList.add(optional1.get().getBarcode());
}
DdlPackBean producePackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getInPackList(snList, "serialNumber", producePackBean);
List<MesProduceSn> produceSnList = produceSnRepository.findByHqlWhere(producePackBean);
produceSnList.forEach(k -> k.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue()));
//当前发运单明细 需要报工的数据
List<MesJisShipping> jisShippingList = jisShippingService.getJisShipping(orderManagementDetailList, org);
@ -484,26 +306,8 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
shippingOrderManagementRepository.save(orderManagement);
shippingOrderManagementDetailRepository.saveAll(orderManagementDetailList);
//保存当前发运单明细报工
jisShippingRepository.saveAll(jisShippingList);
}
}
// private List<MesJisShipping> getJisShipping(List<MesShippingOrderManagementDetail> orderManagementDetailList, String org) {
//
// List<MesJisShipping> shippingList = new ArrayList<>();
// for (MesShippingOrderManagementDetail detail : orderManagementDetailList) {
// MesJisShipping jisShipping = new MesJisShipping();
// jisShipping.setOrganizeCode(org);
// jisShipping.setSerialNumber(detail.getSn());
// jisShipping.setPartNo(detail.getPartNo());
// ConvertBean.serviceModelInitialize(jisShipping, AuthUtil.getSessionUser().getUserName());
// shippingList.add(jisShipping);
// }
//
// return shippingList;
// }
}

8
modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesShippingLoadingCheckModel.java
Unescape Escape View File

@ -1,6 +1,6 @@
package cn.estsh.i3plus.ext.mes.pcn.pojo.model;
import cn.estsh.i3plus.pojo.mes.bean.MesLoadingVehiclesOrderDetail;
import cn.estsh.i3plus.pojo.mes.bean.MesLoadingListDetail;
import io.swagger.annotations.ApiParam;
import lombok.Data;
@ -18,18 +18,18 @@ public class MesShippingLoadingCheckModel {
@ApiParam("装车单")
private String loadingOrderNo;
private String orderCode;
@ApiParam("最近扫描完成的装车单号")
private String recentlyScanVehiclesOrder;
@ApiParam("发运单号")
private String shippingOrderNo;
private String shippingCode;
@ApiParam("已扫描数量")
private Integer isScanCount = 0;
@ApiParam("装车单明细")
private List<MesLoadingVehiclesOrderDetail> vehiclesOrderDetailList;
private List<MesLoadingListDetail> detailList;
}

4
modules/i3plus-ext-mes-pcn-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pcn/pojo/model/MesSortShippingCheckModel.java
Unescape Escape View File

@ -18,9 +18,9 @@ public class MesSortShippingCheckModel {
@ApiParam("发运单号")
private String shippingOrderNo;
private String shippingCode;
@ApiParam("最近扫描完成的装车单号")
private String recentlyScanShippingOrderNo;
private String recentlyScanShippingCode;
@ApiParam("条码")
private String sn;
@ApiParam("位置码")

Write Preview
Loading…
Cancel
Save