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

Merge branch 'dev-wuhan' of http://git.estsh.com/I3-YF/i3plus-mes-pcn-yfai into dev-wuhan

Browse Source
tags/yfai-pcn-ext-v2.3
gsz 8 months ago
parent 5fb9601736 78f398a7fb
commit 007256524b
11 changed files with 787 additions and 285 deletions
Show Stats Download Patch File Download Diff File

7
modules/i3plus-ext-mes-pcn-api/src/main/java/cn/estsh/i3plus/ext/mes/pcn/api/base/IMesEquipmentExtService.java
Unescape Escape View File

@ -28,4 +28,11 @@ public interface IMesEquipmentExtService {
@ApiOperation(value = "根据设备数据变量ID集合查询设备数据变量信息")
List<MesEquipmentVariable> getEquipmentVariableList(String organizeCode, List<Long> equipVariableIdList);
@ApiOperation(value = "根据设备代码和设备变量ID查询设备变量")
MesEquipmentVariable getMesEquipmentVariable(String organizeCode, String equipmentCode,long equipmentVariableId);
@ApiOperation(value = "根据设备代码和通道查询设备通道信息")
MesEquipmentChannel getMesEquipmentChannel(String organizeCode, String equipmentCode,String channel);
}

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

@ -2,7 +2,6 @@ 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.MesJisShipping;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesLoadingList;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagement;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagementDetail;
import io.swagger.annotations.ApiOperation;
@ -22,7 +21,7 @@ public interface IMesSortShippingCheckService {
MesSortShippingCheckModel doShippingOrderNoQuery(MesShippingOrderManagement shippingOrderManagement);
@ApiOperation(value = "保存条码")
MesSortShippingCheckModel saveSn(MesSortShippingCheckModel model, String organizeCode, String userInfo);
MesSortShippingCheckModel saveSn(MesSortShippingCheckModel model);
@ApiOperation(value = "保存条码和位置码")
MesSortShippingCheckModel saveSnAndLocationCode(MesSortShippingCheckModel model, String organizeCode, String userInfo);

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

@ -32,6 +32,9 @@ public interface IMesWorkOrderExtService {
void update(MesWorkOrder item);
@ApiOperation(value = "保存工单信息")
void saveAll(List<MesWorkOrder> workOrderList);
@ApiOperation(value = "根据生产工单ID查询生产工单信息")
List<MesWorkOrder> getWorkOrderListByShiftCode(String organizeCode, String workCenterCode, String shiftCode);

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

@ -107,9 +107,10 @@ public class MesSortShippingCheckController {
ValidatorBean.checkNotNull(model.getShippingCode(), "发运单不能为空");
ValidatorBean.checkNotNull(model.getDetailList(), "发运明细不能为空");
ValidatorBean.checkNotNull(model.getSn(), "条码不能为空");
sortShippingCheckService.saveSn(model, organizeCode, userInfo);
return ResultBean.success("查询成功").setResultObject(model);
model.setOrganizeCode(organizeCode);
model.setUserInfo(userInfo);
sortShippingCheckService.saveSn(model);
return ResultBean.success("扫描成功").setResultObject(model);
} catch (ImppBusiException imppException) {
return ResultBean.fail(imppException);
} catch (Exception e) {

17
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/base/MesEquipmentExtService.java
Unescape Escape View File

@ -117,4 +117,21 @@ public class MesEquipmentExtService implements IMesEquipmentExtService {
else DdlPreparedPack.getInPackList(equipVariableIdList, MesPcnExtConstWords.ID, packBean);
return equipmentVariableRepository.findByHqlWhere(packBean);
}
@Override
public MesEquipmentVariable getMesEquipmentVariable(String organizeCode, String equipmentCode, long equipmentVariableId) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(equipmentCode) || equipmentVariableId == 0) return null;
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(equipmentCode, MesPcnExtConstWords.EQUIPMENT_CODE, packBean);
DdlPreparedPack.getNumEqualPack(equipmentVariableId, MesPcnExtConstWords.ID, packBean);
return equipmentVariableRepository.getByProperty(packBean);
}
@Override
public MesEquipmentChannel getMesEquipmentChannel(String organizeCode, String equipmentCode, String channel) {
if (StringUtils.isEmpty(organizeCode) || StringUtils.isEmpty(equipmentCode) || StringUtils.isEmpty(channel)) return null;
return equipmentChannelRepository.getByProperty(
new String[]{MesPcnExtConstWords.ORGANIZE_CODE, MesPcnExtConstWords.IS_DELETED, MesPcnExtConstWords.IS_VALID, MesPcnExtConstWords.EQUIPMENT_CODE, MesPcnExtConstWords.CHANNEL},
new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(), equipmentCode, channel});
}
}

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

@ -1,7 +1,9 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi;
import cn.estsh.i3plus.ext.mes.pcn.api.base.IMesEquipmentExtService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.*;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.aspect.MonitorLog;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi.shippingscan.IMesShippingScanStrategyService;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.util.MesPcnException;
import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesSortShippingCheckModel;
@ -12,16 +14,17 @@ 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.base.util.StringUtil;
import cn.estsh.i3plus.pojo.mes.bean.MesJisShipping;
import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.*;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesLoadingList;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesLoadingListDetail;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagement;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagementDetail;
import cn.estsh.i3plus.pojo.mes.model.MesEquipVariableRwResult;
import cn.estsh.i3plus.pojo.mes.repository.*;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import cn.estsh.impp.framework.boot.exception.ImppBusiException;
import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@ -30,6 +33,7 @@ import org.springframework.util.StringUtils;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @Description :
@ -44,17 +48,14 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
@Autowired
private MesShippingOrderManagementRepository shippingOrderManagementRepository;
@Autowired
private MesShippingOrderManagementDetailRepository shippingOrderManagementDetailRepository;
@Autowired
private MesProduceSnRepository produceSnRepository;
@Autowired
private IMesProduceSnExtService produceSnExtService;
private MesProduceSnRepository produceSnRepository;
@Autowired
private MesPartShippingGroupRepository partShippingGroupRepository;
@Autowired
private MesLoadingListRepository listRepository;
@Autowired
@ -70,30 +71,141 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
private IMesJisShippingService jisShippingService;
@Autowired
private MesLoadingListDetailRepository vehiclesOrderDetailRepository;
@Autowired
private MesLoadingListRepository vehiclesOrderRepository;
@Autowired
private MesCustomerPartRepository mesCustomerPartRepository;
private MesPartShippingGroupService mesPartShippingGroupService;
@Autowired
private MesPartShippingGroupService mesPartShippingGroupService;
private MesBallTrackRuleRepository mesBallTrackRuleRepository;
@Autowired
private IMesConfigService mesConfigService;
private IMesWorkOrderExtService mesWorkOrderExtService;
@Autowired
private IMesEquipmentExtService mesEquipmentExtService;
@Autowired
private IMesEquipVariableRwExtService equipVariableRwExtService;
@Override
public MesSortShippingCheckModel doShippingOrderNoQuery(MesShippingOrderManagement shippingOrderManagement) {
//校验发运单
MesShippingOrderManagement orderManagement = getMesShippingOrderManagement(shippingOrderManagement);
if(Objects.isNull(orderManagement)){
return null;
}
//校验发运单扫描顺序
checkShippingOrderSeq(shippingOrderManagement, orderManagement);
//根据扫描的发运单找到是否装车配置，若是，则根据发运单查询是否生成装车单，若没生成装车单则提示此发运单配置是否装车为是,但没生成装车单，请检查数据！
checkLoadingList(shippingOrderManagement, orderManagement);
//返回数据组装
MesSortShippingCheckModel model = new MesSortShippingCheckModel();
if (!StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
model.setIsScanLocationCode(true);
}
//发运单号
model.setShippingCode(orderManagement.getShippingCode());
//零件发运组
model.setMesPartShippingGroup(getMesPartShippingGroup(orderManagement.getOrganizeCode(),orderManagement.getShippingGroupCode()));
//发运单明细
model.setDetailList(getMesShippingOrderManagementDetails(orderManagement));
//最近扫描完成的发运单号
MesShippingOrderManagement lastShippingOrder = getLastShippingOrder(orderManagement.getOrganizeCode());
if (!Objects.isNull(lastShippingOrder)) {
model.setRecentlyScanShippingCode(lastShippingOrder.getShippingCode());
}
return model;
}
@Override
public MesSortShippingCheckModel saveSn(MesSortShippingCheckModel model) {
//校验发运单是否存在
MesShippingOrderManagement orderManagement = checkMesShippingOrderManagement(model);
//零件发运组
MesPartShippingGroup shippingGroup = Objects.isNull(model.getMesPartShippingGroup()) ? getMesPartShippingGroup(orderManagement.getOrganizeCode(), orderManagement.getShippingGroupCode()) : model.getMesPartShippingGroup();
//扫描跳过码
if (!Objects.isNull(model.getIsPass()) && Objects.equals(MesPcnExtConstWords.ONE, model.getIsPass())) {
skipShippingDetails(model, model.getUserInfo(), orderManagement);
//扫描条码
} else{
model = ((IMesShippingScanStrategyService) SpringContextsUtil.getBean(MesExtEnumUtil.SHIPPING_GROUP_CONFIRM_PART_TYPE.valueOfServiceImpl(Integer.parseInt(shippingGroup.getConfirmPartType())))).doScan(model,orderManagement,shippingGroup);
}
model.setDetailList(model.getDetailList());
//当前发运单全部扫描完成 并且不需要扫位置码
if (model.getIsScanCount() == model.getDetailList().size() && StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
//保存数据库
saveDate(orderManagement, model, model.getOrganizeCode(), model.getUserInfo());
}
return model;
}
@Override
public MesSortShippingCheckModel saveSnAndLocationCode(MesSortShippingCheckModel model, String organizeCode, String userInfo) {
//校验条码
MesProduceSn produceSn = checkMesProduceSn(model, organizeCode);
//校验发运单是否存在
MesShippingOrderManagement orderManagement = checkMesShippingOrderManagement(model);
//根据条码找到对应的物料号，若物料号一致，则修改扫描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.setBarcode(produceSn.getSerialNumber());
break;
}
}
if (!scanFlg) {
throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
}
Long count = model.getDetailList().stream().filter(k -> Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).count();
//当前发运单全部扫描完成
if (count.intValue() == model.getDetailList().size()) {
//保存数据库
saveDate(orderManagement, model, organizeCode, userInfo);
}
return model;
}
@Override
public MesShippingOrderManagement queryShippingOrderNoByAutoPushOrder(String shippingGroupNo, String org) {
//查询最近扫描完成的装车单号
DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue(), "status", orderPackBean);
DdlPreparedPack.getStringEqualPack(shippingGroupNo, "shippingGroupCode", orderPackBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"seq"}, orderPackBean);
return shippingOrderManagementRepository.getByProperty(orderPackBean);
}
private MesPartShippingGroup getMesPartShippingGroup(String org, String partShippingGroupCode) {
if(StringUtil.isEmpty(org) ||StringUtil.isEmpty(partShippingGroupCode)){
return null;
}
MesPartShippingGroup shippingGroup = mesPartShippingGroupService.getMesPartShippingGroup(org, partShippingGroupCode);
if(Objects.isNull(shippingGroup)){
throw new ImppBusiException(String.format("零件发运组【%s】信息不存在，请检查数据！", partShippingGroupCode));
}
return shippingGroup;
}
private MesShippingOrderManagement getMesShippingOrderManagement(MesShippingOrderManagement shippingOrderManagement) {
//查询发运单信息 发运跳过
DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(shippingOrderManagement.getShippingCode(), "shippingCode", orderManagementPackBean);
DdlPreparedPack.getNumberSmallerPack(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue(), "status", orderManagementPackBean);
MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
if (StringUtils.isEmpty(orderManagement)) {
throw new ImppBusiException(String.format("【%s】此发运单不存在，请检查数据！", shippingOrderManagement.getShippingCode()));
}
//校验发运单状态 必须是未装车条码
if (orderManagement.getStatus() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue() && orderManagement.getStatus() != MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue()) {
if (!Stream.of(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue(),MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue()).collect(Collectors.toList()).contains(orderManagement.getStatus())) {
throw new ImppBusiException(String.format("【%s】此发运单状态为【%s】,请选择状态为【%s】或【%s】状态的发运单", shippingOrderManagement.getShippingCode(),
MesExtEnumUtil.SHIPPING_ORDER_STATUS.valueOfDescription(orderManagement.getStatus()),
MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getDescription(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getDescription()));
@ -109,47 +221,39 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
updateShippingOrderDetails(orderManagement.getOrganizeCode(), shippingOrderManagement.getModifyUser(), orderManagement.getId());
return null;
}
return orderManagement;
}
//校验发运单扫描顺序
List<Integer> statusForCheckList = new ArrayList<>();
statusForCheckList.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue());
statusForCheckList.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue());
statusForCheckList.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue());
statusForCheckList.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.PRINTED.getValue());
List<Integer> status = new ArrayList<>();
status.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue());
status.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.LOADING.getValue());
status.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.STATISTICSING.getValue());
status.add(MesExtEnumUtil.SHIPPING_ORDER_STATUS.STATISTICS.getValue());
private void checkShippingOrderSeq(MesShippingOrderManagement shippingOrderManagement, MesShippingOrderManagement orderManagement) {
//最后一个扫描完成的发运单信息
orderManagementPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.getOrganizeCode());
DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.getOrganizeCode());
DdlPreparedPack.getNumberSmallerPack(orderManagement.getSeq(), "seq", orderManagementPackBean);
DdlPreparedPack.getStringEqualPack(orderManagement.getShippingGroupCode(),"shippingGroupCode",orderManagementPackBean);
DdlPreparedPack.getInPackList(status, "status", orderManagementPackBean);
DdlPreparedPack.getOrderBy("seq",CommonEnumUtil.ASC_OR_DESC.DESC.getValue(),orderManagementPackBean);
DdlPreparedPack.getStringEqualPack(orderManagement.getShippingGroupCode(), "shippingGroupCode", orderManagementPackBean);
DdlPreparedPack.getInPackList(Stream.of(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPED.getValue(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.LOADING.getValue(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.STATISTICSING.getValue(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.STATISTICS.getValue()).collect(Collectors.toList()), "status", orderManagementPackBean);
DdlPreparedPack.getOrderBy("seq", CommonEnumUtil.ASC_OR_DESC.DESC.getValue(), orderManagementPackBean);
MesShippingOrderManagement management = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
//是否存在
//当前发运组是否存在比当前小的序号，且状态是未发运完成
orderManagementPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.getOrganizeCode());
DdlPreparedPack.getNumberSmallerPack(orderManagement.getSeq(), "seq", orderManagementPackBean);
if(!Objects.isNull(management)){
if (!Objects.isNull(management)) {
DdlPreparedPack.getNumberBiggerPack(management.getSeq(), "seq", orderManagementPackBean);
}
DdlPreparedPack.getStringEqualPack(orderManagement.getShippingGroupCode(),"shippingGroupCode",orderManagementPackBean);
DdlPreparedPack.getInPackList(statusForCheckList, "status", orderManagementPackBean);
boolean exists = shippingOrderManagementRepository.isExitByHql(orderManagementPackBean);
if (exists) {
DdlPreparedPack.getStringEqualPack(orderManagement.getShippingGroupCode(), "shippingGroupCode", orderManagementPackBean);
DdlPreparedPack.getInPackList(Stream.of(MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue(), MesExtEnumUtil.SHIPPING_ORDER_STATUS.PRINTED.getValue()).collect(Collectors.toList()), "status", orderManagementPackBean);
if (shippingOrderManagementRepository.isExitByHql(orderManagementPackBean)) {
//1强过
if((!Objects.isNull(shippingOrderManagement.getIsPass()) && Objects.equals(MesPcnExtConstWords.ONE,shippingOrderManagement.getIsPass()))){
if ((!Objects.isNull(shippingOrderManagement.getIsPass()) && Objects.equals(MesPcnExtConstWords.ONE, shippingOrderManagement.getIsPass()))) {
orderManagement.setRemark(MesPcnExtConstWords.STRONGER_PASS);
ConvertBean.serviceModelUpdate(orderManagement,shippingOrderManagement.getModifyUser());
ConvertBean.serviceModelUpdate(orderManagement, shippingOrderManagement.getModifyUser());
vehiclesOrderRepository.update(orderManagement);
}else{
} else {
throw new ImppBusiException(String.format("【%s】发运单对应排序【%s】前存在未扫描发运的发运单，请检查数据！",
orderManagement.getShippingCode(), orderManagement.getSeq()));
}
}
}
//根据扫描的发运单找到是否装车配置，若是，则根据发运单查询是否生成装车单，若没生成装车单则提示此发运单配置是否装车为是,但没生成装车单，请检查数据！
private void checkLoadingList(MesShippingOrderManagement shippingOrderManagement, MesShippingOrderManagement orderManagement) {
if (Objects.equals(orderManagement.getIsLoading(), MesCommonConstant.TRUE_INTEGER)) {
//查询装车单明细
DdlPackBean packBean = DdlPackBean.getDdlPackBean(orderManagement.getOrganizeCode());
@ -164,10 +268,8 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
if(Objects.isNull(loadingList)){
throw new ImppBusiException(String.format("【%s】此发运单配置是否装车为是,但没生成装车单，请检查数据！", shippingOrderManagement.getShippingCode()));
}
//判断是否先装车
if (Objects.equals(orderManagement.getIsFirstInstall(), MesCommonConstant.TRUE_INTEGER)) {
//若没进行装车校验，则提示【%s】此发运单对应的【%s】此装车单状态为【%s】，请选择状态为【%s】的数据
if (loadingList.getStatus() != MesExtEnumUtil.MES_LOADING_STATUS.SCANNED.getValue()) {
throw new ImppBusiException(String.format("【%s】此发运单对应的【%s】此装车单状态为【%s】，请选择状态为【%s】的数据！",
@ -177,265 +279,67 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
}
}
}
}
MesSortShippingCheckModel model = new MesSortShippingCheckModel();
if (!StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
model.setIsScanLocationCode(true);
}
DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.getOrganizeCode());
private List<MesShippingOrderManagementDetail> getMesShippingOrderManagementDetails(MesShippingOrderManagement orderManagement) {
DdlPackBean orderDetailPackBean = DdlPackBean.getDdlPackBean(orderManagement.getOrganizeCode());
DdlPreparedPack.getNumEqualPack(orderManagement.getId(), "pid", orderDetailPackBean);
DdlPreparedPack.getNumberSmallerPack(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.CLOSE.getValue(),"status",orderDetailPackBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.ASC.getValue()}, new String[]{"custInfoSeq"}, orderDetailPackBean);
List<MesShippingOrderManagementDetail> detailList = shippingOrderManagementDetailRepository.findByHqlWhere(orderDetailPackBean);
if(CollectionUtils.isEmpty(detailList)){
throw new ImppBusiException(String.format("发运单【%s】明细信息不存在，请检查数据！", orderManagement.getShippingCode()));
}
//已扫描数据
detailList.forEach(k -> {
if (k.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue() || k.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SKIP.getValue()){
if (Stream.of(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue(),MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SKIP.getValue()).collect(Collectors.toList()).contains(k.getStatus())){
k.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
}
});
return detailList;
}
Long count = detailList.stream().filter(k -> Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).count();
model.setIsScanCount(count.intValue());
//查询最近扫描完成的装车单号
DdlPackBean recentlyOrderPackBean = DdlPackBean.getDdlPackBean(shippingOrderManagement.getOrganizeCode());
private MesShippingOrderManagement getLastShippingOrder(String organizeCode) {
DdlPackBean recentlyOrderPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.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.setShippingCode(orderManagement.getShippingCode());
if (!StringUtils.isEmpty(recentlyVehiclesOrder)) {
model.setRecentlyScanShippingCode(recentlyVehiclesOrder.getShippingCode());
}
return model;
}
@Override
public MesSortShippingCheckModel saveSn(MesSortShippingCheckModel model, String organizeCode, String userInfo) {
//校验发运单是否存在
MesShippingOrderManagement orderManagement = checkMesShippingOrderManagement(model, organizeCode);
//零件发运组
MesPartShippingGroup shippingGroup = getMesPartShippingGroup(organizeCode, orderManagement.getShippingGroupCode());
//根据条码找到对应的物料号，若物料号一致，则修改扫描flg，将flg改为true.
//根据扫描的发运单以及前端传的发运单明细，进行匹配，若没有找到扫描的发运单，则提示扫描的发运单号不在此装车单中，请检查数据！。
//1 跳过
if(!Objects.isNull(model.getIsPass()) && Objects.equals(MesPcnExtConstWords.ONE,model.getIsPass())){
Optional<MesShippingOrderManagementDetail> shippingOrderManagementDetailOptional = model.getDetailList().stream().filter(t -> !Objects.equals(t.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).findFirst();
if(shippingOrderManagementDetailOptional.isPresent()){
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = shippingOrderManagementDetailOptional.get();
MesProduceSn produceSn = new MesProduceSn();
produceSn.setProductSn(model.getSn());
updateOrderManagementDetails(userInfo, produceSn, orderManagement, mesShippingOrderManagementDetail,MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SKIP.getValue(),MesPcnExtConstWords.SHIP_PASS);
}else{
throw new ImppBusiException(String.format("【%s】明细已全部扫描完成，请检查数据！", orderManagement.getShippingCode()));
}
}else{
//校验条码
MesProduceSn produceSn = checkSn(model, organizeCode);
boolean scanFlg = false;
for (MesShippingOrderManagementDetail detail : model.getDetailList()) {
if (detail.getPartNo().equals(produceSn.getPartNo()) && StringUtils.isEmpty(detail.getBarcode()) && !Objects.equals(detail.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)) {
//校验发运单明细顺序
if(!StringUtils.isEmpty(shippingGroup.getIsEnableShippingFailSafe()) && CommonEnumUtil.VALID == shippingGroup.getIsEnableShippingFailSafe()){
Optional<MesShippingOrderManagementDetail> first = model.getDetailList().stream().filter(k -> k.getCustInfoSeq().compareTo(detail.getCustInfoSeq()) < 0 && !Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).findFirst();
if(first.isPresent()){
throw new ImppBusiException(String.format("发运单【%s】启用明细顺序防错，序号【%s】前还有未扫描的发运单明细，请检查数据！", orderManagement.getShippingCode(), detail.getCustInfoSeq()));
}
}
//判断是否需要排序校验 默认排序则需要校验
if (!StringUtils.isEmpty(orderManagement.getScanSeqWay()) && orderManagement.getScanSeqWay() == MesExtEnumUtil.SHIPPING_GROUP_SCAN_CONFIRM_SEQ_MODE.DEFAULT_SORT.getValue()) {
//获取明细中最小的
Optional<String> minPartNO = model.getDetailList().stream().filter(k -> StringUtils.isEmpty(k.getBarcode()))
.min(Comparator.comparingLong(k -> k.getCustInfoSeq())).map(k -> k.getPartNo());
//若扫描的不是最小顺序 则报错
if (minPartNO.isPresent() && !minPartNO.get().equals(produceSn.getPartNo())) {
throw new ImppBusiException(String.format("【%s】此条码扫描顺序错误，请检查数据！", model.getSn()));
}
}
//校验客户零件信息是否存在
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(detail.getPartNo(), "erpPartNo", packBean);
DdlPreparedPack.getStringEqualPack(detail.getCustPartNo(), "custPartNo", packBean);
if(!mesCustomerPartRepository.isExitByHql(packBean)){
throw new ImppBusiException(String.format("零件号【%s】客户零件号【%s】关系不存在，请检查数据！", detail.getPartNo(),detail.getCustPartNo()));
}
scanFlg = true;
updateOrderManagementDetails(userInfo, produceSn, orderManagement, detail,MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue(),"扫描完成");
break;
}
}
if (!scanFlg) {
throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
}
}
Long count = model.getDetailList().stream().filter(k -> Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).count();
model.setIsScanCount(count.intValue());
//当前发运单全部扫描完成 并且不需要扫位置码
if (count.intValue() == model.getDetailList().size() && StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
//保存数据库
saveDate(orderManagement, model, organizeCode, userInfo);
}
return model;
return shippingOrderManagementRepository.getByProperty(recentlyOrderPackBean);
}
private void updateOrderManagementDetails(String userInfo, MesProduceSn produceSn, MesShippingOrderManagement orderManagement, MesShippingOrderManagementDetail detail,Integer status,String remark) {
if(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue() == status){
detail.setBarcode(produceSn.getProductSn());
}
if (StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
detail.setStatus(status);
detail.setRemark(remark);
//根据是否启动记忆判断 若启用记忆，则根据保存数据库
if (!StringUtils.isEmpty(orderManagement.getIsEnableMemory()) && Objects.equals(orderManagement.getIsEnableMemory(), MesCommonConstant.TRUE_INTEGER)) {
//若发运单状态为创建或发布 则写入开始扫描时间
if (!StringUtils.isEmpty(orderManagement.getStatus()) && (orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue() ||
orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue())) {
orderManagement.setStartScanTime(TimeTool.getNowTime(true));
}
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue());
orderManagement.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(orderManagement, userInfo);
update(orderManagement);
detail.setActualQty(1);
detail.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(detail, userInfo);
updateDetail(detail);
//内部条码更新条码状态
if (!Objects.isNull(produceSn.getId())) {
produceSn.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue());
produceSn.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(detail, userInfo);
produceSnExtService.update(produceSn);
}
private void updateOrderManagementDetails(String userInfo, MesShippingOrderManagement orderManagement, MesShippingOrderManagementDetail detail) {
detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
detail.setStatus(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SKIP.getValue());
detail.setRemark(MesPcnExtConstWords.SHIP_PASS);
//根据是否启动记忆判断 若启用记忆，则根据保存数据库
if (!StringUtils.isEmpty(orderManagement.getIsEnableMemory()) && Objects.equals(orderManagement.getIsEnableMemory(), MesCommonConstant.TRUE_INTEGER)) {
//若发运单状态为创建或发布 则写入开始扫描时间
if (!StringUtils.isEmpty(orderManagement.getStatus()) && (orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue() ||
orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue())) {
orderManagement.setStartScanTime(TimeTool.getNowTime(true));
}
//发运单状态
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue());
orderManagement.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(orderManagement, userInfo);
update(orderManagement);
//发运单明细
detail.setActualQty(1);
detail.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(detail, userInfo);
updateDetail(detail);
}
}
@Override
public MesSortShippingCheckModel saveSnAndLocationCode(MesSortShippingCheckModel model, String organizeCode, String userInfo) {
//校验条码
MesProduceSn produceSn = checkMesProduceSn(model, organizeCode);
//校验发运单是否存在
MesShippingOrderManagement orderManagement = checkMesShippingOrderManagement(model, organizeCode);
//根据条码找到对应的物料号，若物料号一致，则修改扫描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.setBarcode(produceSn.getSerialNumber());
break;
}
}
if (!scanFlg) {
throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
private MesSortShippingCheckModel skipShippingDetails(MesSortShippingCheckModel model, String userInfo, MesShippingOrderManagement orderManagement) {
Optional<MesShippingOrderManagementDetail> shippingOrderManagementDetailOptional = model.getDetailList().stream().filter(t -> !Objects.equals(t.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).findFirst();
if(!shippingOrderManagementDetailOptional.isPresent()){
throw new ImppBusiException(String.format("【%s】明细已全部扫描完成，请检查数据！", orderManagement.getShippingCode()));
}
Long count = model.getDetailList().stream().filter(k -> k.getIsScanFlg() == MesCommonConstant.TRUE_INTEGER).count();
//当前发运单全部扫描完成
if (count.intValue() == model.getDetailList().size()) {
//保存数据库
saveDate(orderManagement, model, organizeCode, userInfo);
}
//更新明细
updateOrderManagementDetails(userInfo, orderManagement, shippingOrderManagementDetailOptional.get());
return model;
}
@Override
public MesShippingOrderManagement queryShippingOrderNoByAutoPushOrder(String shippingGroupNo, String org) {
//查询最近扫描完成的装车单号
DdlPackBean orderPackBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue(), "status", orderPackBean);
// DdlPreparedPack.getStringEqualPack(shippingGroupNo, "shippingGroupCode", orderPackBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"seq"}, orderPackBean);
MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderPackBean);
return orderManagement;
}
private MesPartShippingGroup getMesPartShippingGroup(String org, String partShippingGroupCode) {
MesPartShippingGroup shippingGroup = mesPartShippingGroupService.getMesPartShippingGroup(org, partShippingGroupCode);
if(Objects.isNull(shippingGroup)){
throw new ImppBusiException(String.format("零件发运组【%s】信息不存在，请检查数据！", partShippingGroupCode));
}
return shippingGroup;
}
private MesProduceSn checkSn(MesSortShippingCheckModel model, String org) {
//校验条码是否重复扫描
Optional<MesShippingOrderManagementDetail> optional = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getBarcode()) && k.getBarcode().equals(model.getSn())).findFirst();
if (optional.isPresent()) {
throw new ImppBusiException(String.format("【%s】此条码已经扫描过，请检查数据！", model.getSn()));
}
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)) {
//校验状态
checkStatus(model, produceSn);
}else{
//外部条码解析
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = getMesShippingOrderManagementDetail(model, org);
//封装信息
produceSn = new MesProduceSn();
produceSn.setSerialNumber(model.getSn());
produceSn.setProductSn(model.getSn());
produceSn.setPartNo(mesShippingOrderManagementDetail.getPartNo());
}
return produceSn;
}
private MesShippingOrderManagementDetail getMesShippingOrderManagementDetail(MesSortShippingCheckModel model, String org) {
//外部解析条码长度卡控
String cfgValue = mesConfigService.getCfgValue(org, MesPcnExtConstWords.MAX_SHIPPING_BARCODE_LENGTH);
if(Integer.parseInt(cfgValue) < model.getSn().length()) MesPcnException.throwMesBusiException("【%s】此条码长度超过【%s】位，请检查数据！", model.getSn(),cfgValue);
List<MesShippingOrderManagementDetail> detailList = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getCustPartNo()) && model.getSn().startsWith(k.getCustPartNo()) && StringUtils.isEmpty(k.getBarcode()) && !Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).collect(Collectors.toList());
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = null;
for (MesShippingOrderManagementDetail managementDetail : detailList) {
DdlPackBean packBean = DdlPackBean.getDdlPackBean(org);
DdlPreparedPack.getStringEqualPack(managementDetail.getPartNo(), "erpPartNo", packBean);
DdlPreparedPack.getStringEqualPack(managementDetail.getCustPartNo(), "custPartNo", packBean);
if(mesCustomerPartRepository.isExitByHql(packBean)){
mesShippingOrderManagementDetail = managementDetail;
break;
}
}
if(Objects.isNull(mesShippingOrderManagementDetail)){
throw new ImppBusiException(String.format("【%s】此条码未匹配到数据，请检查数据！", model.getSn()));
}
return mesShippingOrderManagementDetail;
}
private MesProduceSn checkMesProduceSn(MesSortShippingCheckModel model, String org) {
//校验条码是否已经扫描
@ -470,9 +374,9 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
}
}
private MesShippingOrderManagement checkMesShippingOrderManagement(MesSortShippingCheckModel model, String org) {
private MesShippingOrderManagement checkMesShippingOrderManagement(MesSortShippingCheckModel model) {
//校验发运单是否存在
DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(org);
DdlPackBean orderManagementPackBean = DdlPackBean.getDdlPackBean(model.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(model.getShippingCode(), "shippingCode", orderManagementPackBean);
MesShippingOrderManagement orderManagement = shippingOrderManagementRepository.getByProperty(orderManagementPackBean);
if (StringUtils.isEmpty(orderManagement)) {
@ -513,6 +417,7 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
Map<Long, List<MesShippingOrderManagementDetail>> custInfoSeqMap = detailList.stream().collect(Collectors.groupingBy(MesShippingOrderManagementDetail::getCustInfoSeq));
List<MesProduceSn> produceSnList = new ArrayList<>();
List<MesWorkOrder> mesWorkOrderList = new ArrayList<>();
for (MesShippingOrderManagementDetail detail : orderManagementDetailList) {
//根据扫描的条码查询条码是否存在
packBean = DdlPackBean.getDdlPackBean(organizeCode);
@ -538,13 +443,27 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
ConvertBean.serviceModelUpdate(produceSn, userInfo);
produceSnList.add(produceSn);
}
//更新工单
if(!StringUtils.isEmpty(detail.getVisualOrderNo())){
MesWorkOrder workOrder = mesWorkOrderExtService.getWorkOrder(organizeCode, detail.getVisualOrderNo());
if(!Objects.isNull(workOrder)){
workOrder.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.SHIPPING.getValue());
produceSn.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(workOrder, userInfo);
mesWorkOrderList.add(workOrder);
}
}
}
}
//更新条码
if(!CollectionUtils.isEmpty(produceSnList)){
produceSnRepository.saveAll(produceSnList);
}
//更新工单
if(!CollectionUtils.isEmpty(mesWorkOrderList)){
mesWorkOrderExtService.saveAll(mesWorkOrderList);
}
//更新发运单
ConvertBean.serviceModelUpdate(orderManagement,userInfo);
update(orderManagement);
@ -559,6 +478,8 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
vehiclesOrderDetailRepository.save(vehiclesOrderDetail);
}
if(StringUtils.isEmpty(orderManagement.getOrderCode()) || StringUtils.isEmpty(orderManagement.getLoadingListId())){
//发送数据给辊道线
sendShippingFinishedCmd(model, organizeCode);
//保存当前发运单明细报工
jisShippingRepository.saveAll(getMesJisShippings(orderManagement,userInfo));
}else{
@ -596,6 +517,39 @@ public class MesSortShippingCheckService implements IMesSortShippingCheckService
}
private void sendShippingFinishedCmd(MesSortShippingCheckModel model, String organizeCode) {
if (!Objects.isNull(model.getMesPartShippingGroup()) && !StringUtil.isEmpty(model.getMesPartShippingGroup().getEquipmentCode())) {
//辊道设备配置
MesBallTrackRule rule = getMesBallTrackRule(model, organizeCode);
//设备变量
MesEquipmentVariable mesEquipmentVariable = mesEquipmentExtService.getMesEquipmentVariable(organizeCode, rule.getEquipmentCode(), rule.getEquipVariableId());
if (Objects.isNull(mesEquipmentVariable)) {
MesPcnException.throwMesBusiException("设备【%s】设备变量ID【%s】信息不存在，请检查", rule.getEquipmentCode(), rule.getEquipVariableId());
}
//设备通道
MesEquipmentChannel mesEquipmentChannel = mesEquipmentExtService.getMesEquipmentChannel(organizeCode, rule.getEquipmentCode(), mesEquipmentVariable.getChannel());
if (Objects.isNull(mesEquipmentChannel)) {
MesPcnException.throwMesBusiException("设备【%s】设备通道【%s】信息不存在，请检查", rule.getEquipmentCode(), mesEquipmentVariable.getChannel());
}
//写入
MesEquipVariableRwResult equipVariableRwResult = equipVariableRwExtService.writeVariable(rule.getEquipVariableValue(), mesEquipmentVariable, mesEquipmentChannel.getKepwareFlag());
if (!equipVariableRwResult.getIsSuccessed()) {
MesPcnException.throwMesBusiException(String.format("设备【%s】:发运成功指令发送失败!原因:%s", mesEquipmentChannel.getEquipmentName(), JSONObject.toJSONString(equipVariableRwResult)));
}
}
}
private MesBallTrackRule getMesBallTrackRule(MesSortShippingCheckModel model, String organizeCode) {
DdlPackBean bean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(model.getMesPartShippingGroup().getEquipmentCode(), "equipmentCode", bean);
DdlPreparedPack.getNumEqualPack(MesExtEnumUtil.BALL_TRACK_TYPE.BALL_TRACK_TYPE_30.getValue(), "ballTrackType", bean);
MesBallTrackRule rule = mesBallTrackRuleRepository.getByProperty(bean);
if (Objects.isNull(rule) || Objects.isNull(rule.getEquipVariableId())) {
MesPcnException.throwMesBusiException("设备【%s】辊道设备配置信息不存在，请检查", model.getMesPartShippingGroup().getEquipmentCode());
}
return rule;
}
public List<MesJisShipping> getMesJisShippings(MesShippingOrderManagement mesShippingOrderManagement,String userName) {
DdlPackBean detailPackBean = DdlPackBean.getDdlPackBean(mesShippingOrderManagement.getOrganizeCode());
DdlPreparedPack.getNumEqualPack(mesShippingOrderManagement.getId(), "pid", detailPackBean);

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

@ -116,6 +116,11 @@ public class MesWorkOrderExtService implements IMesWorkOrderExtService {
}
@Override
public void saveAll(List<MesWorkOrder> mesWorkOrderList) {
workOrderRepository.saveAll(mesWorkOrderList);
}
@Override
public List<MesWorkOrder> getWorkOrderListByShiftCode(String organizeCode, String workCenterCode, String shiftCode) {
String currentTime = DateUtil.formatDateTime(new Date());
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);

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

@ -0,0 +1,19 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi.shippingscan;
import cn.estsh.i3plus.ext.mes.pcn.pojo.model.MesSortShippingCheckModel;
import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagement;
import io.swagger.annotations.ApiOperation;
/**
* @Description : 发运扫描
* @Reference :
* @Author : junsheng.li
* @CreateDate 2024/9/25 10:49
* @Modify:
**/
public interface IMesShippingScanStrategyService {
@ApiOperation("扫描条码或目视单")
MesSortShippingCheckModel doScan(MesSortShippingCheckModel model, MesShippingOrderManagement orderManagement, MesPartShippingGroup shippingGroup);
}

267
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/shippingscan/strategy/MesShippingScanSnAndOrderStrategyServiceImpl.java
Unescape Escape View File

@ -0,0 +1,267 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi.shippingscan.strategy;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesConfigService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProduceSnExtService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesWorkOrderExtService;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.aspect.MonitorLog;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi.shippingscan.IMesShippingScanStrategyService;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.util.MesPcnException;
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.MesPcnExtConstWords;
import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.platform.common.tool.TimeTool;
import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagement;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagementDetail;
import cn.estsh.i3plus.pojo.mes.repository.MesCustomerPartRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesProduceSnRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesShippingOrderManagementDetailRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesShippingOrderManagementRepository;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import cn.estsh.impp.framework.boot.exception.ImppBusiException;
import groovy.util.logging.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @Description : 扫描条码和目视单
* @Reference :
* @Author : junsheng.li
* @CreateDate 2024/9/25 10:54
* @Modify:
**/
@Service
@Slf4j
public class MesShippingScanSnAndOrderStrategyServiceImpl implements IMesShippingScanStrategyService {
@Autowired
private MesShippingOrderManagementRepository shippingOrderManagementRepository;
@Autowired
private MesShippingOrderManagementDetailRepository shippingOrderManagementDetailRepository;
@Autowired
private MesProduceSnRepository produceSnRepository;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private MesCustomerPartRepository mesCustomerPartRepository;
@Autowired
private IMesConfigService mesConfigService;
@Autowired
private IMesWorkOrderExtService mesWorkOrderExtService;
@Override
public MesSortShippingCheckModel doScan(MesSortShippingCheckModel model, MesShippingOrderManagement orderManagement, MesPartShippingGroup shippingGroup) {
if (!Objects.isNull(model.getLastShippingDetailId())) {
//校验目视单是否已经扫描
if (model.getDetailList().stream().anyMatch(t -> !StringUtils.isEmpty(t.getVisualOrderNo()) && t.getVisualOrderNo().equals(model.getSn()))) {
throw new ImppBusiException(String.format("【%s】此目视单已经扫描过，请检查数据！", model.getSn()));
}
//更新单据信息
model.getDetailList().stream().filter(t -> t.getId().equals(model.getLastShippingDetailId())).forEach(detail -> {
detail.setVisualOrderNo(model.getSn());
updateOrderManagementDetails(orderManagement, detail, getWorkOrder(model, detail), model.getUserInfo());
});
model.setLastShippingDetailId(null);
} else {
//校验条码
MesProduceSn produceSn = checkSn(model);
boolean scanFlg = false;
for (MesShippingOrderManagementDetail detail : model.getDetailList()) {
if (detail.getPartNo().equals(produceSn.getPartNo()) && StringUtils.isEmpty(detail.getBarcode()) && !Objects.equals(detail.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)) {
//校验发运明细
checkShippingDetails(model, orderManagement, shippingGroup, produceSn, detail);
detail.setBarcode(model.getSn());
//校验通过的明细ID
model.setLastShippingDetailId(detail.getId());
scanFlg = true;
break;
}
}
if (!scanFlg) {
throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
}
}
return model;
}
private MesWorkOrder getWorkOrder(MesSortShippingCheckModel model, MesShippingOrderManagementDetail detail) {
MesWorkOrder workOrder = mesWorkOrderExtService.getWorkOrder(model.getOrganizeCode(), model.getSn());
if (Objects.isNull(workOrder)) {
throw new ImppBusiException(String.format("目视单【%s】不存在，请检查数据！", model.getSn()));
}
//校验目视单状态
if (MesExtEnumUtil.ORDER_STATUS.COMPLETE.getValue() != workOrder.getWorkOrderStatus() || MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue() != workOrder.getQcStatus()) {
throw new ImppBusiException(String.format("目视单【%s】状态为【%s】质量状态为【%s】，不允许发运！", model.getSn(), MesExtEnumUtil.ORDER_STATUS.valueOfDescription(workOrder.getWorkOrderStatus()), MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(workOrder.getQcStatus())));
}
//校验条码是否匹配
if (!Objects.equals(detail.getBarcode(), workOrder.getSn())) {
throw new ImppBusiException(String.format("目视单【%s】条码【%s】与扫描条码【%s】，不匹配！", model.getSn(), workOrder.getSn(), detail.getBarcode()));
}
//校验零件是否匹配
if (!Objects.equals(detail.getPartNo(), workOrder.getPartNo())) {
throw new ImppBusiException(String.format("目视单【%s】零件【%s】与发运单零件【%s】，不匹配！", model.getSn(), workOrder.getPartNo(), detail.getPartNo()));
}
return workOrder;
}
private void checkShippingDetails(MesSortShippingCheckModel model, MesShippingOrderManagement orderManagement, MesPartShippingGroup shippingGroup, MesProduceSn produceSn, MesShippingOrderManagementDetail detail) {
//校验发运单明细顺序
if (!Objects.isNull(shippingGroup) && !StringUtils.isEmpty(shippingGroup.getIsEnableShippingFailSafe()) && CommonEnumUtil.VALID == shippingGroup.getIsEnableShippingFailSafe()) {
Optional<MesShippingOrderManagementDetail> first = model.getDetailList().stream().filter(k -> k.getCustInfoSeq().compareTo(detail.getCustInfoSeq()) < 0 && !Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).findFirst();
if (first.isPresent()) {
throw new ImppBusiException(String.format("发运单【%s】启用明细顺序防错，序号【%s】前还有未扫描的发运单明细，请检查数据！", orderManagement.getShippingCode(), detail.getCustInfoSeq()));
}
}
//判断是否需要排序校验 默认排序则需要校验
if (!StringUtils.isEmpty(orderManagement.getScanSeqWay()) && orderManagement.getScanSeqWay() == MesExtEnumUtil.SHIPPING_GROUP_SCAN_CONFIRM_SEQ_MODE.DEFAULT_SORT.getValue()) {
//获取明细中最小的
Optional<String> minPartNo = model.getDetailList().stream().filter(k -> StringUtils.isEmpty(k.getBarcode()))
.min(Comparator.comparingLong(MesShippingOrderManagementDetail::getCustInfoSeq)).map(MesShippingOrderManagementDetail::getPartNo);
//若扫描的不是最小顺序 则报错
if (minPartNo.isPresent() && !minPartNo.get().equals(produceSn.getPartNo())) {
throw new ImppBusiException(String.format("【%s】此条码扫描顺序错误，请检查数据！", model.getSn()));
}
}
//校验客户零件信息是否存在
DdlPackBean packBean = DdlPackBean.getDdlPackBean(model.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(detail.getPartNo(), "erpPartNo", packBean);
DdlPreparedPack.getStringEqualPack(detail.getCustPartNo(), "custPartNo", packBean);
if (!mesCustomerPartRepository.isExitByHql(packBean)) {
throw new ImppBusiException(String.format("零件号【%s】客户零件号【%s】关系不存在，请检查数据！", detail.getPartNo(), detail.getCustPartNo()));
}
}
private MesProduceSn checkSn(MesSortShippingCheckModel model) {
//校验条码是否重复扫描
Optional<MesShippingOrderManagementDetail> optional = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getBarcode()) && k.getBarcode().equals(model.getSn())).findFirst();
if (optional.isPresent()) {
throw new ImppBusiException(String.format("【%s】此条码已经扫描过，请检查数据！", model.getSn()));
}
MesProduceSn produceSn = getMesProduceSn(model.getOrganizeCode(), model.getSn());
if (!StringUtils.isEmpty(produceSn)) {
//校验状态
checkStatus(model, produceSn);
} else {
//外部条码解析
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = getMesShippingOrderManagementDetail(model);
//封装信息
produceSn = new MesProduceSn();
produceSn.setSerialNumber(model.getSn());
produceSn.setProductSn(model.getSn());
produceSn.setPartNo(mesShippingOrderManagementDetail.getPartNo());
}
return produceSn;
}
private MesProduceSn getMesProduceSn(String organizeCode, String productSn) {
DdlPackBean packBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(productSn, "custSn", packBean);
DdlPreparedPack.getOrderByPack(new Object[]{CommonEnumUtil.ASC_OR_DESC.DESC.getValue()}, new String[]{"createDatetime"}, packBean);
return produceSnRepository.getByProperty(packBean);
}
private void checkStatus(MesSortShippingCheckModel model, MesProduceSn produceSn) {
//校验产品条码状态 必须是状态为已下线条码
if (produceSn.getSnStatus() != MesExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getValue() && produceSn.getSnStatus() != MesExtEnumUtil.PRODUCE_SN_STATUS.CREATE.getValue()) {
throw new ImppBusiException(String.format("【%s】此条码状态为【%s】,请选择状态为【%s】或【%s】状态的条码", model.getSn(), MesExtEnumUtil.PRODUCE_SN_STATUS.valueOfDescription(produceSn.getSnStatus()),
MesExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getDescription(), MesExtEnumUtil.PRODUCE_SN_STATUS.CREATE.getDescription()));
}
//校验产品质量状态 必须是状态为合格条码
if (produceSn.getQcStatus() != MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue()) {
throw new ImppBusiException(String.format("【%s】此条码质量状态为【%s】,请选择【%s】状态的条码", model.getSn(), MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(produceSn.getQcStatus()),
MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getDescription()));
}
}
private MesShippingOrderManagementDetail getMesShippingOrderManagementDetail(MesSortShippingCheckModel model) {
//外部解析条码长度卡控
String cfgValue = mesConfigService.getCfgValue(model.getOrganizeCode(), MesPcnExtConstWords.MAX_SHIPPING_BARCODE_LENGTH);
if (Integer.parseInt(cfgValue) < model.getSn().length())
MesPcnException.throwMesBusiException("【%s】此条码长度超过【%s】位，请检查数据！", model.getSn(), cfgValue);
List<MesShippingOrderManagementDetail> detailList = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getCustPartNo()) && model.getSn().startsWith(k.getCustPartNo()) && StringUtils.isEmpty(k.getBarcode()) && !Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).collect(Collectors.toList());
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = null;
for (MesShippingOrderManagementDetail managementDetail : detailList) {
DdlPackBean packBean = DdlPackBean.getDdlPackBean(model.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(managementDetail.getPartNo(), "erpPartNo", packBean);
DdlPreparedPack.getStringEqualPack(managementDetail.getCustPartNo(), "custPartNo", packBean);
if (mesCustomerPartRepository.isExitByHql(packBean)) {
mesShippingOrderManagementDetail = managementDetail;
break;
}
}
if (Objects.isNull(mesShippingOrderManagementDetail)) {
throw new ImppBusiException(String.format("【%s】此条码未匹配到数据，请检查数据！", model.getSn()));
}
return mesShippingOrderManagementDetail;
}
private void updateOrderManagementDetails(MesShippingOrderManagement orderManagement, MesShippingOrderManagementDetail detail, MesWorkOrder workOrder, String userInfo) {
if (StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
detail.setStatus(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
detail.setRemark("扫描完成");
//根据是否启动记忆判断 若启用记忆，则根据保存数据库
if (!StringUtils.isEmpty(orderManagement.getIsEnableMemory()) && Objects.equals(orderManagement.getIsEnableMemory(), MesCommonConstant.TRUE_INTEGER)) {
//若发运单状态为创建或发布 则写入开始扫描时间
if (!StringUtils.isEmpty(orderManagement.getStatus()) && (orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue() ||
orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue())) {
orderManagement.setStartScanTime(TimeTool.getNowTime(true));
}
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue());
orderManagement.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(orderManagement, userInfo);
update(orderManagement);
detail.setActualQty(1);
detail.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(detail, userInfo);
updateDetail(detail);
MesProduceSn produceSn = getMesProduceSn(orderManagement.getOrganizeCode(), detail.getBarcode());
//内部条码更新条码状态
if (!Objects.isNull(produceSn)) {
produceSn.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue());
produceSn.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(produceSn, userInfo);
produceSnExtService.update(produceSn);
}
//更新工单状态为发运
workOrder.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.SHIPPING.getValue());
ConvertBean.serviceModelUpdate(workOrder, userInfo);
mesWorkOrderExtService.update(workOrder);
}
}
}
@MonitorLog
public void update(MesShippingOrderManagement item) {
shippingOrderManagementRepository.update(item);
}
@MonitorLog
public void updateDetail(MesShippingOrderManagementDetail item) {
shippingOrderManagementDetailRepository.update(item);
}
}

217
modules/i3plus-ext-mes-pcn-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/pcn/apiservice/serviceimpl/busi/shippingscan/strategy/MesShippingScanSnStrategyServiceImpl.java
Unescape Escape View File

@ -0,0 +1,217 @@
package cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi.shippingscan.strategy;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesConfigService;
import cn.estsh.i3plus.ext.mes.pcn.api.busi.IMesProduceSnExtService;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.aspect.MonitorLog;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.serviceimpl.busi.shippingscan.IMesShippingScanStrategyService;
import cn.estsh.i3plus.ext.mes.pcn.apiservice.util.MesPcnException;
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.MesPcnExtConstWords;
import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.platform.common.tool.TimeTool;
import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
import cn.estsh.i3plus.pojo.mes.bean.MesProduceSn;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagement;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagementDetail;
import cn.estsh.i3plus.pojo.mes.repository.MesCustomerPartRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesProduceSnRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesShippingOrderManagementDetailRepository;
import cn.estsh.i3plus.pojo.mes.repository.MesShippingOrderManagementRepository;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import cn.estsh.impp.framework.boot.exception.ImppBusiException;
import groovy.util.logging.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @Description : 扫描条码
* @Reference :
* @Author : junsheng.li
* @CreateDate 2024/9/25 10:54
* @Modify:
**/
@Service
@Slf4j
public class MesShippingScanSnStrategyServiceImpl implements IMesShippingScanStrategyService {
@Autowired
private MesShippingOrderManagementRepository shippingOrderManagementRepository;
@Autowired
private MesShippingOrderManagementDetailRepository shippingOrderManagementDetailRepository;
@Autowired
private MesProduceSnRepository produceSnRepository;
@Autowired
private IMesProduceSnExtService produceSnExtService;
@Autowired
private MesCustomerPartRepository mesCustomerPartRepository;
@Autowired
private IMesConfigService mesConfigService;
@Override
public MesSortShippingCheckModel doScan(MesSortShippingCheckModel model, MesShippingOrderManagement orderManagement, MesPartShippingGroup shippingGroup) {
//校验条码
MesProduceSn produceSn = checkSn(model);
boolean scanFlg = false;
for (MesShippingOrderManagementDetail detail : model.getDetailList()) {
if (detail.getPartNo().equals(produceSn.getPartNo()) && StringUtils.isEmpty(detail.getBarcode()) && !Objects.equals(detail.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)) {
//校验发运明细
checkShippingDetails(model, orderManagement, shippingGroup, produceSn, detail);
scanFlg = true;
//明细更新
updateOrderManagementDetails(produceSn, orderManagement, detail, model.getUserInfo());
break;
}
}
if (!scanFlg) {
throw new ImppBusiException(String.format("【%s】此条码对应的【%s】物料号与发运单中物料号不匹配，请检查数据！", model.getSn(), produceSn.getPartNo()));
}
return model;
}
private void checkShippingDetails(MesSortShippingCheckModel model, MesShippingOrderManagement orderManagement, MesPartShippingGroup shippingGroup, MesProduceSn produceSn, MesShippingOrderManagementDetail detail) {
//校验发运单明细顺序
if (!Objects.isNull(shippingGroup) && !StringUtils.isEmpty(shippingGroup.getIsEnableShippingFailSafe()) && CommonEnumUtil.VALID == shippingGroup.getIsEnableShippingFailSafe()) {
Optional<MesShippingOrderManagementDetail> first = model.getDetailList().stream().filter(k -> k.getCustInfoSeq().compareTo(detail.getCustInfoSeq()) < 0 && !Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).findFirst();
if (first.isPresent()) {
throw new ImppBusiException(String.format("发运单【%s】启用明细顺序防错，序号【%s】前还有未扫描的发运单明细，请检查数据！", orderManagement.getShippingCode(), detail.getCustInfoSeq()));
}
}
//判断是否需要排序校验 默认排序则需要校验
if (!StringUtils.isEmpty(orderManagement.getScanSeqWay()) && orderManagement.getScanSeqWay() == MesExtEnumUtil.SHIPPING_GROUP_SCAN_CONFIRM_SEQ_MODE.DEFAULT_SORT.getValue()) {
//获取明细中最小的
Optional<String> minPartNo = model.getDetailList().stream().filter(k -> StringUtils.isEmpty(k.getBarcode()))
.min(Comparator.comparingLong(MesShippingOrderManagementDetail::getCustInfoSeq)).map(MesShippingOrderManagementDetail::getPartNo);
//若扫描的不是最小顺序 则报错
if (minPartNo.isPresent() && !minPartNo.get().equals(produceSn.getPartNo())) {
throw new ImppBusiException(String.format("【%s】此条码扫描顺序错误，请检查数据！", model.getSn()));
}
}
//校验客户零件信息是否存在
DdlPackBean packBean = DdlPackBean.getDdlPackBean(model.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(detail.getPartNo(), "erpPartNo", packBean);
DdlPreparedPack.getStringEqualPack(detail.getCustPartNo(), "custPartNo", packBean);
if (!mesCustomerPartRepository.isExitByHql(packBean)) {
throw new ImppBusiException(String.format("零件号【%s】客户零件号【%s】关系不存在，请检查数据！", detail.getPartNo(), detail.getCustPartNo()));
}
}
private MesProduceSn checkSn(MesSortShippingCheckModel model) {
//校验条码是否重复扫描
Optional<MesShippingOrderManagementDetail> optional = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getBarcode()) && k.getBarcode().equals(model.getSn())).findFirst();
if (optional.isPresent()) {
throw new ImppBusiException(String.format("【%s】此条码已经扫描过，请检查数据！", model.getSn()));
}
DdlPackBean packBean = DdlPackBean.getDdlPackBean(model.getOrganizeCode());
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)) {
//校验状态
checkStatus(model, produceSn);
} else {
//外部条码解析
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = getMesShippingOrderManagementDetail(model);
//封装信息
produceSn = new MesProduceSn();
produceSn.setSerialNumber(model.getSn());
produceSn.setProductSn(model.getSn());
produceSn.setPartNo(mesShippingOrderManagementDetail.getPartNo());
}
return produceSn;
}
private void checkStatus(MesSortShippingCheckModel model, MesProduceSn produceSn) {
//校验产品条码状态 必须是状态为已下线条码
if (produceSn.getSnStatus() != MesExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getValue() && produceSn.getSnStatus() != MesExtEnumUtil.PRODUCE_SN_STATUS.CREATE.getValue()) {
throw new ImppBusiException(String.format("【%s】此条码状态为【%s】,请选择状态为【%s】或【%s】状态的条码", model.getSn(), MesExtEnumUtil.PRODUCE_SN_STATUS.valueOfDescription(produceSn.getSnStatus()),
MesExtEnumUtil.PRODUCE_SN_STATUS.OFFLINE.getDescription(), MesExtEnumUtil.PRODUCE_SN_STATUS.CREATE.getDescription()));
}
//校验产品质量状态 必须是状态为合格条码
if (produceSn.getQcStatus() != MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getValue()) {
throw new ImppBusiException(String.format("【%s】此条码质量状态为【%s】,请选择【%s】状态的条码", model.getSn(), MesExtEnumUtil.PRODUCE_QC_STATUS.valueOfDescription(produceSn.getQcStatus()),
MesExtEnumUtil.PRODUCE_QC_STATUS.QUALIFIED.getDescription()));
}
}
private MesShippingOrderManagementDetail getMesShippingOrderManagementDetail(MesSortShippingCheckModel model) {
//外部解析条码长度卡控
String cfgValue = mesConfigService.getCfgValue(model.getOrganizeCode(), MesPcnExtConstWords.MAX_SHIPPING_BARCODE_LENGTH);
if (Integer.parseInt(cfgValue) < model.getSn().length())
MesPcnException.throwMesBusiException("【%s】此条码长度超过【%s】位，请检查数据！", model.getSn(), cfgValue);
List<MesShippingOrderManagementDetail> detailList = model.getDetailList().stream().filter(k -> !StringUtils.isEmpty(k.getCustPartNo()) && model.getSn().startsWith(k.getCustPartNo()) && StringUtils.isEmpty(k.getBarcode()) && !Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).collect(Collectors.toList());
MesShippingOrderManagementDetail mesShippingOrderManagementDetail = null;
for (MesShippingOrderManagementDetail managementDetail : detailList) {
DdlPackBean packBean = DdlPackBean.getDdlPackBean(model.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(managementDetail.getPartNo(), "erpPartNo", packBean);
DdlPreparedPack.getStringEqualPack(managementDetail.getCustPartNo(), "custPartNo", packBean);
if (mesCustomerPartRepository.isExitByHql(packBean)) {
mesShippingOrderManagementDetail = managementDetail;
break;
}
}
if (Objects.isNull(mesShippingOrderManagementDetail)) {
throw new ImppBusiException(String.format("【%s】此条码未匹配到数据，请检查数据！", model.getSn()));
}
return mesShippingOrderManagementDetail;
}
private void updateOrderManagementDetails(MesProduceSn produceSn, MesShippingOrderManagement orderManagement, MesShippingOrderManagementDetail detail, String userInfo) {
if (StringUtils.isEmpty(orderManagement.getCheckSeqCode())) {
detail.setBarcode(produceSn.getProductSn());
detail.setIsScanFlg(MesCommonConstant.TRUE_INTEGER);
detail.setStatus(MesExtEnumUtil.SHIPPING_ORDER_DETAIL_SHIPPING_STATUS.SHIPPINGED.getValue());
detail.setRemark("扫描完成");
//根据是否启动记忆判断 若启用记忆，则根据保存数据库
if (!StringUtils.isEmpty(orderManagement.getIsEnableMemory()) && Objects.equals(orderManagement.getIsEnableMemory(), MesCommonConstant.TRUE_INTEGER)) {
//若发运单状态为创建或发布 则写入开始扫描时间
if (!StringUtils.isEmpty(orderManagement.getStatus()) && (orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.CREATE.getValue() ||
orderManagement.getStatus() == MesExtEnumUtil.SHIPPING_ORDER_STATUS.PUBLISHED.getValue())) {
orderManagement.setStartScanTime(TimeTool.getNowTime(true));
}
orderManagement.setStatus(MesExtEnumUtil.SHIPPING_ORDER_STATUS.SHIPPING.getValue());
orderManagement.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(orderManagement, userInfo);
update(orderManagement);
detail.setActualQty(1);
detail.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(detail, userInfo);
updateDetail(detail);
//内部条码更新条码状态
if (!Objects.isNull(produceSn.getId())) {
produceSn.setSnStatus(MesExtEnumUtil.PRODUCE_SN_STATUS.SHIPPED.getValue());
produceSn.setSystemSyncStatus(CommonEnumUtil.FALSE);
ConvertBean.serviceModelUpdate(produceSn, userInfo);
produceSnExtService.update(produceSn);
}
}
}
}
@MonitorLog
public void update(MesShippingOrderManagement item) {
shippingOrderManagementRepository.update(item);
}
@MonitorLog
public void updateDetail(MesShippingOrderManagementDetail item) {
shippingOrderManagementDetailRepository.update(item);
}
}

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

@ -1,10 +1,13 @@
package cn.estsh.i3plus.ext.mes.pcn.pojo.model;
import cn.estsh.i3plus.ext.mes.pcn.pojo.constant.MesCommonConstant;
import cn.estsh.i3plus.pojo.mes.bean.MesPartShippingGroup;
import cn.estsh.i3plus.pojo.mes.bean.shipping.MesShippingOrderManagementDetail;
import io.swagger.annotations.ApiParam;
import lombok.Data;
import java.util.List;
import java.util.Objects;
/**
* @Description :
@ -42,5 +45,15 @@ public class MesSortShippingCheckModel {
@ApiParam("发运组明细数据")
private List<MesShippingOrderManagementDetail> detailList;
@ApiParam("发运组")
private MesPartShippingGroup mesPartShippingGroup;
@ApiParam("最后扫描的发运单明细ID")
private Long lastShippingDetailId;
public void setDetailList(List<MesShippingOrderManagementDetail> detailList) {
this.detailList = detailList;
this.isScanCount = (int) detailList.stream().filter(k -> Objects.equals(k.getIsScanFlg(), MesCommonConstant.TRUE_INTEGER)).count();
}
}

Write Preview
Loading…
Cancel
Save