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

武汉客户条码生成

Browse Source
tags/yfai-mes-ext-v2.3
臧学普 8 months ago
parent e9bc105f43
commit 3a7cb17dab
3 changed files with 332 additions and 96 deletions
Show Stats Download Patch File Download Diff File

8
modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/schedulejob/MesWhJisCreateOrderJob.java
Unescape Escape View File

@ -66,16 +66,16 @@ public class MesWhJisCreateOrderJob extends BaseMesScheduleJob {
}
if (CollectionUtils.isEmpty(paramMap)) {
LOGGER.error("BTO生成工单,没有配置参数");
LOGGER.error("武汉JIS生成工单,没有配置参数");
return;
}
String organizeCode = (String) paramMap.get("organizeCode");
List<String> groupCodeList = (List<String>) paramMap.get("groupCode");
btoJobService.doCreateBto(organizeCode, groupCodeList);
LOGGER.info("BTO生成工单job结束 ----- end");
btoJobService.doWhJisWorkOrder(organizeCode, groupCodeList);
LOGGER.info("武汉JIS生成工单 ----- end");
} catch (Exception e) {
LOGGER.error("BTO生成工单e:{}", Arrays.toString(e.getStackTrace()));
LOGGER.error("武汉JIS生成工单e:{}", Arrays.toString(e.getStackTrace()));
}
}

2
modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesBomService.java
Unescape Escape View File

@ -174,7 +174,7 @@ public class MesBomService extends BaseMesService<MesBom> implements IMesBomServ
DdlPackBean bomPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(partNo, "partNo", bomPackBean);
DdlPreparedPack.getStringEqualPack(bomVersion, "bomVersion", bomPackBean);
List<MesBom> bomList = this.baseRDao.findByHqlWhere(bomPackBean);
List<MesBom> bomList = this.baseRDao.findByHqlTopWhere(bomPackBean,1);
return bomList.isEmpty() ? null : bomList.get(0);
}

418
modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/roundness/MesPackageRoundnessService.java
Unescape Escape View File

@ -1,8 +1,9 @@
package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.roundness;
import cn.estsh.i3plus.ext.mes.api.base.IMesCustSoftInfoService;
import cn.estsh.i3plus.ext.mes.api.base.strategy.IRoundnessStrategy;
import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.MesBomService;
import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.MesCustSoftInfoServiceImpl;
import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.MesPartSapService;
import cn.estsh.i3plus.ext.mes.pojo.constant.MesCommonConstant;
import cn.estsh.i3plus.mes.api.iservice.busi.ISyncFuncService;
import cn.estsh.i3plus.platform.common.convert.ConvertBean;
@ -15,12 +16,12 @@ import cn.estsh.i3plus.pojo.mes.bean.shipping.MesCustSortInfo;
import cn.estsh.i3plus.pojo.mes.model.GenSerialNoModel;
import cn.estsh.i3plus.pojo.mes.repository.*;
import cn.estsh.i3plus.pojo.mes.util.MesExtEnumUtil;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
@ -38,8 +39,7 @@ import java.util.stream.Collectors;
public class MesPackageRoundnessService implements IRoundnessStrategy {
private static final Logger log = LoggerFactory.getLogger(MesPackageRoundnessService.class);
@Autowired
private IMesProdGroupPartBtoCountRepository btoCountRao;
@Autowired
private MesPartSapRepository mesPartSapRao;
@ -70,14 +70,37 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
@Autowired
private MesWorkOrderAssemblyRepository workOrderAssemblyRao;
@Autowired
private ISyncFuncService syncFuncService;
@Autowired
private IMesCustSoftInfoService custSoftInfoService;
@Autowired
private MesPartPtrRepository partPtrRao;
@Autowired
private MesPartSapService mesPartSapService;
@Autowired
private MesProduceSnRepository mesProduceSnRao;
@Override
public void execute(MesPartProdGroup partProdGroup, List<MesCustSortInfo> sortInfoList, List<MesPartProdGroupDetail> details) {
try {
//是否是头部零件
Integer isSeqInfoHeadPart = partProdGroup.getIsSeqInfoHeadPart();
if (isSeqInfoHeadPart == null || isSeqInfoHeadPart == CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) {
log.info("非头零件不能按照包装圆整;零件生产组为:{}", partProdGroup.getPartProdGroupCode());
return;
}
Map<String, MesPartProdGroupDetail> prodGroupDetailMap = details.stream().collect(Collectors.toMap(MesPartProdGroupDetail::getCustPartNo, Function.identity()));
//1.生产组中的圆整数量
double roundQty = Double.parseDouble(partProdGroup.getRoundQty());
//2.排序信息中的零件合计数量
double qty = sortInfoList.stream().map(MesCustSortInfo::getQty).reduce(Double::sum).get();
MesCustSortInfo sortInfo;
//3.当数量未达到圆整包装数时
if (qty < roundQty) {
//4.查看客户排序信息钟的最早的一条过点时间 + 生产组最晚生成时间是否已到达当前时间
@ -93,7 +116,7 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
return -1;
}).collect(Collectors.toList());
MesCustSortInfo sortInfo = sortInfoList.get(0);
sortInfo = sortInfoList.get(0);
//最晚延迟的时间
int latestCreationTime = Integer.parseInt(partProdGroup.getLatestCreationTime());
Calendar calendar = Calendar.getInstance();
@ -108,55 +131,46 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
//如果最早来的排序信息的多点时间已经超过最晚生成时间，则圆整数为当前排序信息对应的合计数
roundQty = qty;
}
//是否是头部零件
Integer isSeqInfoHeadPart = partProdGroup.getIsSeqInfoHeadPart();
if (isSeqInfoHeadPart == null || isSeqInfoHeadPart == CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()) {
log.info("非头零件不能按照包装圆整;零件生产组为:{}", partProdGroup.getPartProdGroupCode());
return;
}
}
//扣减qty 生成工单
while (qty > 0) {
//临时客户排序信息中的数量计数器
double custSortRoundnessQty = roundQty;
while (custSortRoundnessQty > 0) {
sortInfo = sortInfoList.get(0);
double custQty = sortInfo.getQty();
//当客户排序信息中的数量大于剩余圆整数量要Break
if (custQty > roundQty) {
log.info("单笔订单数量大于圆整数量01,车号:{}", sortInfo.getVinCode());
return;
}
if (custQty > custSortRoundnessQty) {
log.info("单笔订单数量大于圆整数量02,车号:{}", sortInfo.getVinCode());
return;
}
//查找该零件是否在生产组中
MesPartProdGroupDetail mesPartProdGroupDetail = prodGroupDetailMap.get(sortInfo.getCustPartNo());
if (mesPartProdGroupDetail == null) {
log.info("生产组中未找到该零件:{}", sortInfo.getCustPartNo());
return;
}
//生产零件号
if (mesPartProdGroupDetail.getProductPartNo() == null) {
mesPartProdGroupDetail.setProductPartNo(mesPartProdGroupDetail.getPartNo());
}
MesPartSap mesPart = this.getMesPart(mesPartProdGroupDetail.getProductPartNo(), partProdGroup.getOrganizeCode());
if (mesPart == null) {
log.info("{}工厂没有,零件:{}信息", partProdGroup.getOrganizeCode(), mesPartProdGroupDetail.getProductPartNo());
return;
}
//扣减qty 生成工单
while (qty > 0) {
//临时客户排序信息中的数量计数器
sortInfo = sortInfoList.get(0);
double custQty = sortInfo.getQty();
//当客户排序信息中的数量大于剩余圆整数量要Break
if (custQty > roundQty) {
log.info("单笔订单数量大于圆整数量01,车号:{}", sortInfo.getVinCode());
return;
}
//查找该零件是否在生产组中
MesPartProdGroupDetail mesPartProdGroupDetail = prodGroupDetailMap.get(sortInfo.getCustPartNo());
if (mesPartProdGroupDetail == null) {
log.info("生产组中未找到该零件:{}", sortInfo.getCustPartNo());
return;
}
//生产零件号
if (mesPartProdGroupDetail.getProductPartNo() == null) {
mesPartProdGroupDetail.setProductPartNo(mesPartProdGroupDetail.getPartNo());
}
MesPartSap mesPart = this.getMesPart(mesPartProdGroupDetail.getProductPartNo(), partProdGroup.getOrganizeCode());
doCreateWorkOrder(partProdGroup,mesPartProdGroupDetail,mesPart,sortInfo);
}
if (mesPart == null) {
log.info("{}工厂没有,零件:{}信息", partProdGroup.getOrganizeCode(), mesPartProdGroupDetail.getProductPartNo());
return;
}
doCreateWorkOrder(partProdGroup, mesPartProdGroupDetail, mesPart, sortInfo);
qty -= custQty;
sortInfoList.remove(sortInfo);
// 更新排序信息 已完成
custSoftInfoService.updateCustSortInfo(sortInfo);
}
} catch (Exception e) {
log.error("按包装圆整出错:MesPackageRoundnessService", e);
}
@ -164,6 +178,7 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
private void doCreateWorkOrder(MesPartProdGroup partProdGroup, MesPartProdGroupDetail mesPartProdGroupDetail, MesPartSap partSap, MesCustSortInfo sortInfo) throws ParseException {
String organizeCode = partProdGroup.getOrganizeCode();
MesWorkOrder mesWorkOrder = new MesWorkOrder();
//工单版本号
@ -183,12 +198,11 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
mesWorkOrder.setProductTime(sortInfo.getMatchTime());
mesWorkOrder.setPlanStartTime(sortInfo.getMatchTime());
mesWorkOrder.setPlanEndTime(sortInfo.getInfoPointTime());
//todo ptr信息
//mesWorkOrder.setPtrInfo(sortInfo.getRemark());
mesWorkOrder.setPtrInfo(sortInfo.getRemark());
//客户订单号
mesWorkOrder.setCustOrderNo(sortInfo.getCustOrderCode());
//车型代码 todo
//mesWorkOrder.setCarModelCode(sortInfo.getCarModelCode());
//车型代码
mesWorkOrder.setCarModelCode(sortInfo.getVehicleCategory());
//车型描述 mesWorkOrder.setCarName = vehicleClassCode
//备注取自于车型配置表中
@ -201,7 +215,7 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
// 11. 是否将生成日期减一天
// 班次 根据产线+计划时间匹配班次
DdlPackBean shiftPackBean = DdlPackBean.getDdlPackBean(mesPartProdGroupDetail.getOrganizeCode());
DdlPackBean shiftPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(mesPartProdGroupDetail.getWorkCenterCode(), "workCenterCode", shiftPackBean);
List<MesShift> shiftList = mesShiftRao.findByHqlWhere(shiftPackBean);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@ -230,8 +244,15 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
mesWorkOrder.setPartNo(partSap.getPartNo());
mesWorkOrder.setPartName(partSap.getPartName());
//工单号生成规则 【工厂号+yyyyMMdd+5位流水】
GenSerialNoModel genSerialNoModel = new GenSerialNoModel(MesCommonConstant.MES_WORK_CENTER_ORDER_NO);
genSerialNoModel.setPartNo(mesPartProdGroupDetail.getWorkCenterCode());
List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel.organizeCode(organizeCode), "edi", mesPartProdGroupDetail.getOrganizeCode(), 1).getResultList();
mesWorkOrder.setWorkOrderNo(resultList.get(0));
// 13.生产版本 organizeCode + partNo
MesProductVersion prodVersion = getProdVersion(mesPartProdGroupDetail.getOrganizeCode(), partSap.getPartNo());
MesProductVersion prodVersion = getProdVersion(organizeCode, partSap.getPartNo());
if (prodVersion == null) {
log.info("请配置工厂:{},partNo:{}的生产版本", mesPartProdGroupDetail.organizeCode, partSap.getPartNo());
} else {
@ -239,11 +260,11 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
mesWorkOrder.setProductVersion(productVersion);
}
//todo bom prodVersion.alternativePartList bom版本
MesBom bom = mesBomService.findBom(mesPartProdGroupDetail.getOrganizeCode(), prodVersion.getAlternativePartList(), partSap.getPartNo());
// if (bom != null){
// mesWorkOrder.setBomCode(bom.getBomCode())
// }
// bom prodVersion.alternativePartList bom版本
MesBom bom = mesBomService.findBom(organizeCode, prodVersion == null ? null : prodVersion.getAlternativePartList(), partSap.getPartNo());
if (bom != null){
mesWorkOrder.setBomCode(bom.getBomCode());
}
mesWorkOrder.setQty(sortInfo.getQty());
mesWorkOrder.setUnCompleteQty(sortInfo.getQty());
@ -256,53 +277,219 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
}
mesWorkOrder.setPartProdGroupCode(partProdGroup.getPartProdGroupCode());
// todo 缺少单号 N 单字段
// todo 车型
mesWorkOrder.setCarModelCode(sortInfo.getVehicleNo());
// todo 客户零件条码
/**
* RS 为记录分隔符ASCII:30
* GS 为分组符ASCII:29
* EOT 为传输结束符ASCII:04
* {splitRule} [)>%RS%06%GS%Y
* {splitRule} vpps= 4110000000000X
* {splitRule} %GS%P
* {partNo} 8位客户零件号
* {splitRule} %GS%12V
* {splitRule} duns 545238347
* {splitRule} %GS%T1A
* {yydayofyear}
* {splitRule} A2B4C
* {serialNo} 4位 步长1
* {splitRule}%RS%%EOT%
*{spiltRule}{spiltRule}{spiltRule}{partNo}{spiltRule}{spiltRule}{spiltRule}{year}{day}{spiltRule}{serialNo}{spiltRule}
* [)>%RS%06%GS%Y,4110000000000X,%GS%P,%GS%12V,545238347,%GS%T1A,A2B4C,%RS%%EOT%
* 通用二维码组成部分('RS'为记录分隔符ASCII:30，'GS'为分组符ASCII:29,'EOT'为传输结束符ASCII:04)
* [)>+'RS'+06+'GS'+Y+vpps+'GS'+P+8位客户零件号+'GS'+12V+DUNS+'GS'+T+1位line num+1位班次号+2位年份+3位天数+1位追溯(精确追溯A，批次追溯@)+2工程更改记录+2位自定义+4位流水号+'RS'+'EOT'
* 如：[)>+'RS'+06+'GS'+Y+4110000000000X+'GS'+P+12345678+'GS'+12V+545295227+'GS'+T+1A13304A2B4C0001+'RS'+'EOT'
*
* vpps = Y00000000000000
* 8位客户零件号=最后四位要大写
* Duns是什么？
* 1位lineNumber是什么？ 固定值 1
* 1位班次号是什么？
* 2位年YY 24
* 3位天-~365/366
* 追溯
* A--精确追溯
* @--批次追溯
*
* 2位工程更改记录
* 2位供应商自定义信息
* 4位流水号，当班班次计数，每班班次归零
*
* WH_CUST_SN_RULE
*/
Calendar custCalendar = Calendar.getInstance();
custCalendar.setTime(new Date());
GenSerialNoModel custGenSerialNoModel= new GenSerialNoModel("WH_CUST_SN_RULE");
String partNo = mesWorkOrder.getPartNo();
String prefix = partNo.substring(0, partNo.length() - 4);
String partNo4 = partNo.substring(partNo.length() - 4).toUpperCase();
custGenSerialNoModel.setPartNo(prefix+partNo4);
String year = custCalendar.get(Calendar.YEAR)+"";
custGenSerialNoModel.setYear(year.substring(2));
custGenSerialNoModel.setDay(custCalendar.get(Calendar.DAY_OF_YEAR)+"");
List<String> custNumRuleList = syncFuncService.syncSerialNo(genSerialNoModel, "edi", organizeCode, 1).getResultList();
// [)>%RS%06%GS%Y,4110000000000X,%GS%P,%GS%12V,545238347,%GS%T1A,A2B4C,%RS%%EOT%
//截取替换为ascii码
String snOriginal = custNumRuleList.get(0);
String[] split = snOriginal.split("%RS%");
StringBuilder rsStr = new StringBuilder();
for (int i = 0; i < split.length-1; i++) {
rsStr.append(split[i]).append((char) 30);
}
rsStr.append(split[split.length - 1]);
StringBuilder gsStr = new StringBuilder();
String[] split1 = rsStr.toString().split("%GS%");
for (int i = 0; i < split1.length-1; i++) {
gsStr.append(split1[i]).append((char) 29);
}
gsStr.append(split1[split1.length-1]);
String[] split2 = gsStr.toString().split("%EOT%");
String sn = split2[0]+(char)4;
//保存条码
mesWorkOrder.setSn(sn);
// 打散bom
List<MesWorkOrderPart> workOrderPartList = new ArrayList<>();
if (partProdGroup.getIsDisassembleBom() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
workOrderPartList = dismantleBom(partSap.getPartNo(), mesWorkOrder.getQty(), sortInfo.getMatchTime(),bom.getBomCode(),sortInfo.getOrganizeCode(),mesPartProdGroupDetail.getWorkCellCode(), mesWorkOrder.getWorkOrderNo() );
workOrderPartList = dismantleBom(partSap.getPartNo(), mesWorkOrder.getQty(), sortInfo.getMatchTime(), bom.getBomCode(), sortInfo.getOrganizeCode(), mesPartProdGroupDetail.getWorkCellCode(), mesWorkOrder.getWorkOrderNo());
}
// 生成装配件清单
List<MesWorkOrderAssembly> assemblyList = getAssemblyList(mesWorkOrder.getWorkCenterCode(), null, workOrderPartList, partProdGroup);
ConvertBean.saveOrUpdate(mesWorkOrder,"MES-JOB");
mesWorkOrderRao.insert(mesWorkOrder);
/**
* 总成拆bom,变成子零件
* 替换子零件，通过替换后的零件，去找排序工艺
*/
//是否修改为P单
boolean isModifyPOrder = false;
//查询mes_part_ptr表，根据物料清单查找ptr替换信息
if (!workOrderPartList.isEmpty()){
Map<String, MesWorkOrderPart> orderPartMap = workOrderPartList.stream().collect(Collectors.toMap(MesWorkOrderPart::getPartNo, Function.identity()));
//先替换客户的ptr信息
String ptrInfo = mesWorkOrder.getPtrInfo();
if (StringUtils.isNotBlank(ptrInfo)) {
List<String> ptrInfoList = Arrays.asList(ptrInfo.replace("_", "").split("\\|"));
if (!ptrInfoList.isEmpty()){
List<MesPartPtr> custPartPtrList = getCustPartPtrList(ptrInfoList, organizeCode);
for (MesPartPtr mesPartPtr : custPartPtrList) {
//根据mesPartPtr的目标零件号，找到零件信息
String destPartNo = mesPartPtr.getDestPartNo();
MesPartSap mesPartSap = mesPartSapService.getMesPartSapByPartNo(destPartNo, organizeCode);
//更新物料清单
MesWorkOrderPart orderPart = orderPartMap.get(destPartNo);
if (orderPart != null) {
orderPart.setPartNo(mesPartSap.getPartNo());
orderPart.setPartName(mesPartSap.getPartName());
orderPart.setShippingPartNo(mesPartSap.getPartNo());
if (!isModifyPOrder){
isModifyPOrder = true;
}
}
}
}
}
List<String> partNoList = workOrderPartList.stream().map(MesWorkOrderPart::getPartNo).collect(Collectors.toList());
List<MesPartPtr> partPtrList = getPartPtrList(organizeCode, mesWorkOrder.getWorkCenterCode(), partNoList);
for (MesPartPtr mesPartPtr : partPtrList) {
//根据mesPartPtr的目标零件号，找到零件信息
String destPartNo = mesPartPtr.getDestPartNo();
String srcPartNo = mesPartPtr.getSrcPartNo();
MesPartSap mesPartSap = mesPartSapService.getMesPartSapByPartNo(destPartNo, organizeCode);
//更新物料清单
MesWorkOrderPart orderPart = orderPartMap.get(srcPartNo);
if (orderPart != null) {
orderPart.setPartNo(mesPartSap.getPartNo());
orderPart.setPartName(mesPartSap.getPartName());
orderPart.setShippingPartNo(mesPartSap.getPartNo());
if (!isModifyPOrder){
isModifyPOrder = true;
}
//更新mes_part_ptr的实际数量 + 1
//更新mes_part_ptr_detail 的workOrder.partNo 数量加 1 ;替换了几次还是什么
}
}
}
if (!workOrderPartList.isEmpty()) {
for (MesWorkOrderPart orderPart : workOrderPartList) {
ConvertBean.saveOrUpdate(orderPart,"MES-JOB");
orderPart.setOrganizeCode(organizeCode);
ConvertBean.saveOrUpdate(orderPart, "MES-JOB");
}
workOrderPartRao.saveAll(workOrderPartList);
}
// 生成装配件清单
List<MesWorkOrderAssembly> assemblyList = getAssemblyList(mesWorkOrder.getWorkCenterCode(), mesWorkOrder.getCarModelCode(), workOrderPartList, partProdGroup);
ConvertBean.saveOrUpdate(mesWorkOrder, "MES-JOB");
if (isModifyPOrder){
mesWorkOrder.setOrderFlag(MesExtEnumUtil.ORDER_TYPE_IDENTIFICATION.P_SORT.getValue());
}else {
mesWorkOrder.setOrderFlag(MesExtEnumUtil.ORDER_TYPE_IDENTIFICATION.N.getValue());
}
mesWorkOrderRao.insert(mesWorkOrder);
if (!assemblyList.isEmpty()){
if (!assemblyList.isEmpty()) {
for (MesWorkOrderAssembly orderAssembly : assemblyList) {
ConvertBean.saveOrUpdate(orderAssembly,"MES-JOB");
orderAssembly.setWorkOrderNo(mesWorkOrder.getWorkOrderNo());
orderAssembly.setOrganizeCode(organizeCode);
ConvertBean.saveOrUpdate(orderAssembly, "MES-JOB");
}
workOrderAssemblyRao.saveAll(assemblyList);
}
//生成条码表
MesProduceSn mesProduceSn = new MesProduceSn();
mesProduceSn.setProductSn(mesWorkOrder.getSn());
mesProduceSn.setWorkOrderNo(mesWorkOrder.getWorkOrderNo());
mesProduceSn.setOrganizeCode(organizeCode);
ConvertBean.saveOrUpdate(mesProduceSn, "MES-JOB");
mesProduceSnRao.insert(mesProduceSn);
}
private List<MesWorkOrderAssembly> getAssemblyList(String workCenterCode, String VehicleNo,List<MesWorkOrderPart> workOrderPartList,MesPartProdGroup mesPartProdGroup){
private List<MesWorkOrderAssembly> getAssemblyList(String workCenterCode, String VehicleNo, List<MesWorkOrderPart> workOrderPartList, MesPartProdGroup mesPartProdGroup) {
//TM_BAS_WORK_ORDER_ASSEMBLY_SETTING 对应 mes_prod_rule_sort_cfg 排序生产规则
List<MesWorkOrderAssembly> workOrderAssemblyList = new ArrayList<>();
List<String> partNoList = workOrderPartList.stream().map(MesWorkOrderPart::getPartNo).collect(Collectors.toList());
DdlPackBean prodRuleSortPackBean = DdlPackBean.getDdlPackBean(mesPartProdGroup.getOrganizeCode());
// DdlPreparedPack.getStringEqualPack(mesPartProdGroup.getPartProdGroupCode(),"productGroupCode",prodRuleSortPackBean);
DdlPreparedPack.getStringEqualPack(workCenterCode, "workCenterCode", prodRuleSortPackBean);
DdlPreparedPack.getInPackList(partNoList,"partNo",prodRuleSortPackBean);
DdlPreparedPack.getInPackList(partNoList, "assemblyPartNo", prodRuleSortPackBean);
//查询当前产线的所有排序生产规则--分为当前工单清单的装配件
List<MesProdRuleSortCfg> sortCfgList = mesProdRuleSortCfgRao.findByHqlWhere(prodRuleSortPackBean);
Map<String, MesWorkOrderPart> orderPartMap = workOrderPartList.stream().collect(Collectors.toMap(MesWorkOrderPart::getPartNo, Function.identity()));
List<MesProdRuleSortCfg> sortCfgListFilter = sortCfgList.stream().filter(item -> partNoList.contains(item.getAssemblyPartNo())).collect(Collectors.toList());
Map<String, List<MesWorkOrderPart>> orderPartMap = workOrderPartList.stream().collect(Collectors.groupingBy(MesWorkOrderPart::getPartNo));
//遍历排序生产规则
for (MesProdRuleSortCfg sortCfg : sortCfgList) {
MesWorkOrderPart orderPart = orderPartMap.get(sortCfg.getAssemblyPartNo());
//1.逻辑储量程序sortCfg.isLogicNum
for (MesProdRuleSortCfg sortCfg : sortCfgListFilter) {
String t = sortCfg.getAssemblyPartNo();
System.out.println(sortCfg.getAssemblyPartNo());
List<MesWorkOrderPart> orderPartList = orderPartMap.get(sortCfg.getAssemblyPartNo());
MesWorkOrderAssembly orderAssembly = new MesWorkOrderAssembly();
MesWorkOrderPart orderPart = orderPartList.get(0);
//1.逻辑储量程序sortCfg.isLogicNum
if ((sortCfg.getIsLogicNum() !=null && sortCfg.getIsLogicNum() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) && (sortCfg.getLogicNum()!=null && sortCfg.getLogicNum() >0 )){
Double total = orderPartList.stream().map(MesWorkOrderPart::getItemQty).reduce(Double::sum).get();
if (!total.equals(sortCfg.getLogicNum())){
log.info("零件号:{}的数量:{}对应排序规则{}的逻辑数量:{}不一致",orderPart.getPartNo(),total,sortCfg.getWorkCenterCode(),sortCfg.getLogicNum());
continue;
}
}
//2.当排序规则的车型不为空时，则需要与参数匹配，如果不符合 则不加这个装配项
if (StringUtils.isNotBlank(sortCfg.getVehicleNo()) && !sortCfg.getVehicleNo().equals(VehicleNo)){
continue;
}
orderAssembly.setCraftName(sortCfg.getCraftName());
orderAssembly.setCraftCode(sortCfg.getCraftCode());
orderAssembly.setRouteSeq(sortCfg.getRouteSeq());
orderAssembly.setPartNo(orderPart.getPartNo());
orderAssembly.setPartName(orderPart.getPartName());
orderAssembly.setWorkCellCode(sortCfg.getWorkCellCode());
orderAssembly.setOrderPartId(orderPart.getId().toString());
orderAssembly.setEquipmentCode(sortCfg.getEquipmentCode());
@ -314,11 +501,41 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
orderAssembly.setPartTypeCode(sortCfg.getPartTypeCode());
orderAssembly.setShowColor(sortCfg.getShowColor());
orderAssembly.setProductPartNo(sortCfg.getProductPartNo());
orderAssembly.setPid(sortCfg.getId());
workOrderAssemblyList.add(orderAssembly);
}
//查询所有共用的零件 且没有零件号，多用于螺钉---查询排序加工规则
DdlPackBean prodRuleSortPublicPackBean = DdlPackBean.getDdlPackBean(mesPartProdGroup.getOrganizeCode());
DdlPreparedPack.getStringEqualPack(workCenterCode, "workCenterCode", prodRuleSortPublicPackBean);
DdlPreparedPack.getIsNull("assemblyPartNo", prodRuleSortPublicPackBean);
List<MesProdRuleSortCfg> ruleSortCfgs = mesProdRuleSortCfgRao.findByHqlWhere(prodRuleSortPublicPackBean);
for (MesProdRuleSortCfg ruleSortCfg : ruleSortCfgs) {
MesWorkOrderAssembly orderAssembly = new MesWorkOrderAssembly();
orderAssembly.setWorkCellCode(ruleSortCfg.getWorkCellCode());
orderAssembly.setProcessCode(ruleSortCfg.getProcessCode());
orderAssembly.setProcessName(ruleSortCfg.getProcessName());
orderAssembly.setCraftCode(ruleSortCfg.getCraftCode());
orderAssembly.setRouteSeq(ruleSortCfg.getRouteSeq());
orderAssembly.setEquipmentCode(ruleSortCfg.getEquipmentCode());
orderAssembly.setReportType(ruleSortCfg.getReportType());
orderAssembly.setReportPartNo(ruleSortCfg.getReportPartNo());
orderAssembly.setProcessSeq(ruleSortCfg.getProcessSeq());
orderAssembly.setPid(ruleSortCfg.getId());
orderAssembly.setImageFileId(ruleSortCfg.getImageFileId());
orderAssembly.setPartTypeCode(ruleSortCfg.getPartTypeCode());
orderAssembly.setMaxValue(ruleSortCfg.getMaxValue());
orderAssembly.setMinValue(ruleSortCfg.getMinValue());
orderAssembly.setProductPartNo(ruleSortCfg.getProductPartNo());
workOrderAssemblyList.add(orderAssembly);
}
return workOrderAssemblyList;
}
private List<MesWorkOrderPart> dismantleBom(String partNo, double qty, String productTime, String bomCode, String organizeCode, String workCellCode, String workOrderNo) {
List<MesWorkOrderPart> orderPartList = new ArrayList<>();
@ -328,7 +545,7 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
List<String> partNoList = bomList.stream().map(MesBom::getItemPartNo).distinct().collect(Collectors.toList());
DdlPackBean partPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getInPackList(partNoList,"partNo", partPackBean);
DdlPreparedPack.getInPackList(partNoList, "partNo", partPackBean);
List<MesPartSap> partSapList = mesPartSapRao.findByHqlWhere(partPackBean);
Map<String, MesPartSap> partMap = partSapList.stream().collect(Collectors.toMap(MesPartSap::getPartNo, Function.identity()));
@ -337,15 +554,15 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
MesWorkOrderPart orderPart = new MesWorkOrderPart();
MesPartSap partSap = partMap.get(bom.getItemPartNo());
if (partSap == null) {
log.info("工厂:{},零件号:{}未查到零件信息", organizeCode,bom.getItemPartNo());
log.info("工厂:{},零件号:{}未查到零件信息", organizeCode, bom.getItemPartNo());
return null;
}
List<MesWorkOrderPart> orderParts = orderPartList.stream().filter(item -> item.getPartNo().equals(partSap.getPartNo())).collect(Collectors.toList());
if (!orderParts.isEmpty()) {
MesWorkOrderPart tempPart = orderParts.get(0);
tempPart.setItemQty(tempPart.getItemQty() + bom.getItemQty() * qty);
continue;
}
if (!orderParts.isEmpty()) {
MesWorkOrderPart tempPart = orderParts.get(0);
tempPart.setItemQty(tempPart.getItemQty() + bom.getItemQty() * qty);
continue;
}
orderPart.setPartName(partSap.getPartName());
orderPart.setPartNo(partSap.getPartNo());
orderPart.setItemQty(bom.getItemQty() * qty);
@ -362,14 +579,14 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
private List<MesBom> getPlatBom(String partNo, String effectiveTime, String bomCode, String organizeCode) {
if (bomCode == null){
if (bomCode == null) {
//首先根据虚结构的零件号查询出最新的一条bom信息作为bomCode
DdlPackBean bomCodePackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(partNo, "partNo", bomCodePackBean);
DdlPreparedPack.getTimeBetweenCol(effectiveTime,"effStartTime","effEndTime",bomCodePackBean,false);
DdlPreparedPack.getTimeBetweenCol(effectiveTime, "effStartTime", "effEndTime", bomCodePackBean, false);
DdlPreparedPack.getOrderBy("effStartTime", CommonEnumUtil.ASC_OR_DESC.DESC.getValue(), bomCodePackBean);
List<MesBom> bomList = bomRao.findByHqlTopWhere(bomCodePackBean,1);
if (bomList == null || bomList.isEmpty()){
List<MesBom> bomList = bomRao.findByHqlTopWhere(bomCodePackBean, 1);
if (bomList == null || bomList.isEmpty()) {
return new ArrayList<>();
}
bomCode = bomList.get(0).getBomCode();
@ -378,16 +595,17 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
DdlPackBean bomPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(bomCode, "bomCode", bomPackBean);
DdlPreparedPack.getStringEqualPack(partNo, "partNo", bomPackBean);
DdlPreparedPack.getTimeBetweenCol(effectiveTime,"effStartTime","effEndTime",bomPackBean,false);
DdlPreparedPack.getStringSmallerPack(effectiveTime, "effStartTime", bomPackBean);
DdlPreparedPack.getStringBiggerPack(effectiveTime, "effEndTime", bomPackBean);
List<MesBom> bomList = bomRao.findByHqlWhere(bomPackBean);
for (MesBom bom : bomList) {
if (bom.getPartType()!=null && bom.getPartType().equalsIgnoreCase("X")){
getPlatBom(bom.getItemPartNo(),effectiveTime,null,organizeCode);
}else {
bom.setBomCode(bom.getBomCode().toLowerCase());
bomResultList.add(bom);
}
if (bom.getPartType() != null && bom.getPartType().equalsIgnoreCase("X")) {
getPlatBom(bom.getItemPartNo(), effectiveTime, null, organizeCode);
} else {
bom.setBomCode(bom.getBomCode().toLowerCase());
bomResultList.add(bom);
}
}
@ -409,4 +627,22 @@ public class MesPackageRoundnessService implements IRoundnessStrategy {
}
private List<MesPartPtr> getPartPtrList(String organizeCode,String workCenterCode, List<String> partNoList) {
DdlPackBean partPtrPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getStringEqualPack(workCenterCode, "workCenterCode", partPtrPackBean);
DdlPreparedPack.getInPackList(partNoList, "srcPartNo", partPtrPackBean);
DdlPreparedPack.getStringSmallerPack(TimeTool.getNowTime("yyyy-MM-dd HH:mm:ss"), "startTime", partPtrPackBean);
DdlPreparedPack.getStringBiggerPack(TimeTool.getNowTime("yyyy-MM-dd HH:mm:ss"), "endTime", partPtrPackBean);
DdlPreparedPack.getIsNotNull("prtVehicleCount", partPtrPackBean);
List<MesPartPtr> partPtrList = partPtrRao.findByHqlWhere(partPtrPackBean);
partPtrList = partPtrList.stream().filter(item -> item.getPrtVehicleCount() != null && item.getPrtVehicleCount() > 0).collect(Collectors.toList());
return partPtrList;
}
//根据排序信息PTR零件号 获取 ptr信息
private List<MesPartPtr> getCustPartPtrList(List<String> ptrInfoList,String organizeCode){
DdlPackBean partPtrPackBean = DdlPackBean.getDdlPackBean(organizeCode);
DdlPreparedPack.getInPackList(ptrInfoList, "seqInfoPrtPart", partPtrPackBean);
return partPtrRao.findByHqlWhere(partPtrPackBean);
}
}

Write Preview
Loading…
Cancel
Save