Public/cf_imes_server
6
0
Fork 0
mirror of http://192.168.1.205:9980/cf_devdept2/cf_imes_server.git synced 2026-08-12 21:02:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

生产单异步导入：1、xml导入优化；2、excel/xml接入自定义版编号生成；

Browse Source
This commit is contained in:
gaoqr
2025-03-01 17:10:01 +08:00
parent 1a9a1bc503
commit 434a8bc8b7
33 changed files with 2617 additions and 787 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cf-module-prod-executor/cf-module-prod-executor-biz/src/main/java/com/cf/imes/module/executor/service/customplatenorule/BodyNoGenerateRuleServiceImpl.java
+5 -1
View File
@@ -95,6 +95,11 @@ public class BodyNoGenerateRuleServiceImpl implements CustomPlateNoGenerateRuleS
ResetModeEnum resetModeEnum = ResetModeEnum.getByMode(ruleDTO.getResetMode());
// 根据复位模式更新生产单的序号
for (OrderDO orderDO : orderDOS) {
resetOrder(orderDO, resetModeEnum);
}
}
private void resetOrder(OrderDO orderDO, ResetModeEnum resetModeEnum) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = JSON.parseObject(orderDO.getCustomPlatenoSeq(), OrderCustomPlateNoSeqVO.class);
if (ObjectUtil.isNotNull(orderCustomPlateNoSeqVO)) {
if (ObjectUtil.equal(ResetModeEnum.ORDER, resetModeEnum)) {
@@ -110,7 +115,6 @@ public class BodyNoGenerateRuleServiceImpl implements CustomPlateNoGenerateRuleS
orderMapper.update(new LambdaUpdateWrapper<OrderDO>().eq(OrderDO::getId, orderDO.getId()).set(OrderDO::getCustomPlatenoSeq, JsonUtils.zipString(JSON.toJSONString(orderCustomPlateNoSeqVO))));
}
}
}
/**
* 按生产单复位模式下的板编号生成
cf-module-prod-executor/cf-module-prod-executor-biz/src/main/java/com/cf/imes/module/executor/util/fileConversion/admin/files/xml/DefaultOrderImportXmlParserHandler.java
+162 -228
View File
@@ -1,13 +1,13 @@
package com.cf.imes.module.executor.util.fileConversion.admin.files.xml;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.util.ListUtils;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.cf.imes.framework.common.exception.util.ServiceExceptionUtil;
import com.cf.imes.framework.common.util.json.JsonUtils;
import com.cf.imes.framework.dict.core.util.DictFrameworkUtils;
@@ -27,6 +27,7 @@ import com.cf.imes.module.executor.util.fileConversion.admin.ToolUtil;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.AssemblyXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.BlockXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.CorrelationXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.CorrelationXmlVOS;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.CuttingOutlineXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.EdgingXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.GrooveXmlVO;
@@ -36,7 +37,9 @@ import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.Hardwa
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.HoleXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.HoleXmlVOS;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.IsletXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.IsletXmlVOS;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.OffsetLineXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.OffsetLineXmlVOS;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.OrderXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.OutlineXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.PlateXmlVO;
@@ -44,6 +47,7 @@ import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.PointX
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.PointXmlVOS;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.RawOutlineXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.RemarkXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.RemarkXmlVOS;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.RoomBoxXmlVO;
import com.cf.imes.module.executor.util.fileConversion.admin.files.xml.VO.RoomXmlVO;
import jodd.util.StringUtil;
@@ -64,6 +68,7 @@ import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
@@ -133,19 +138,26 @@ public class DefaultOrderImportXmlParserHandler {
// 全局对象，一般用于下级获取属性或者信息提示
private RoomXmlVO roomXmlVO;
private RawOutlineXmlVO rawOutlineXmlVO;
private BlockXmlVO blockXmlVO;
private PointXmlVOS pointXmlVOS;
private OutlineXmlVO outlineXmlVO;
private CuttingOutlineXmlVO cuttingOutlineXmlVO;
private RawOutlineXmlVO rawOutlineXmlVO;
private HoleXmlVOS holeXmlVOS;
private GrooveXmlVOS grooveXmlVOS;
private GrooveXmlVO grooveXmlVO;
private IsletXmlVOS isletXmlVOS;
private IsletXmlVO isletXmlVO;
private CorrelationXmlVOS correlationXmlVOS;
private RemarkXmlVOS remarkXmlVOS;
private OffsetLineXmlVOS offsetLineXmlVOS;
private StartElement se;
// 全局编码标记，如进入plate时设置plateItemCode，结束时设为null
private String plateItemCode;
private String blockProductionCode;
private String partItemCode;
private String outerId;
// 全局标签标记，如进入block时inBlock设为true，结束block时设为false
private boolean inBlock;
// 全局标签标记，如进入outLine时inOutline设为true，结束时设为false
private boolean inOutline;
private boolean inCuttingOutline;
private boolean inRawOutline;
@@ -153,8 +165,6 @@ public class DefaultOrderImportXmlParserHandler {
private boolean inPoints;
private boolean inIslet;
private int pointNum;
private OrderImportTempDataMapper orderImportTempDataMapper;
private OrderService orderService;
@@ -273,20 +283,32 @@ public class DefaultOrderImportXmlParserHandler {
analyzeGroove(attributes);
break;
case "Points":
analyzeGroovePoints(attributes);
analyzePoints(attributes);
break;
case "offsetLines":
analyzeOffsetLines(attributes);
break;
case "offsetLine":
analyzeOffsetLine(attributes);
break;
case "Islets":
analyzeIslets(attributes);
break;
case "Islet":
analyzeIslet(attributes);
break;
case "Correlations":
analyzeCorrelations(attributes);
break;
case "Correlation":
analyzeCorrelation(attributes);
break;
case "Point":
analyzePoint(attributes);
break;
case "Remarks":
analyzeRemarks(attributes);
break;
case "Remark":
analyzeRemark(attributes);
break;
@@ -296,7 +318,7 @@ public class DefaultOrderImportXmlParserHandler {
if (cachedDataList.size() >= BATCH_COUNT) {
saveData();
// 存储完成清理 list
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
cachedDataList.clear();
}
} else if (en.isEndElement()) {
// 根据标签tag选择对应的解析方式
@@ -334,7 +356,7 @@ public class DefaultOrderImportXmlParserHandler {
endGroove();
break;
case "Points":
endGroovePoints();
endPoints();
break;
case "Islet":
endIslet();
@@ -657,19 +679,13 @@ public class DefaultOrderImportXmlParserHandler {
*/
private void analyzeBlockXml(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成block对象
BlockXmlVO blockXmlVO = getJavaBeanFromXmlAttr(BlockXmlVO.class, attributes);
blockXmlVO = getJavaBeanFromXmlAttr(BlockXmlVO.class, attributes);
if (ObjectUtil.isNull(blockXmlVO)) {
blockXmlVO = new BlockXmlVO();
}
// 校验板件
checkBlock(blockXmlVO);
// 全局参数
inBlock = true;
String productionCode = blockXmlVO.getProductionCode();
blockProductionCode = StringUtils.isNotEmpty(productionCode) ? productionCode : String.valueOf(snowFlakeGenerator.nextId(null));
blockXmlVO.setProductionCode(blockProductionCode);
// 如果有未命名的房间编号、柜体编号，直接在临时表创建这个柜体
String roomCode = blockXmlVO.getRoomCode();
String boxCode = blockXmlVO.getBoxCode();
@@ -677,20 +693,9 @@ public class DefaultOrderImportXmlParserHandler {
// 校验检查房间、柜体、加工组编号
checkRoomBoxGroup(se, roomCode, blockXmlVO.getRoomName(), boxCode, blockXmlVO.getBoxName(), groupCodes);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.PLATE.getType())
.innerGoodsId(plateItemCode)
.roomCode(roomCode)
.bodyCode(boxCode)
.groupCode(groupCodes)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(blockXmlVO)))
.sort(sort++)
.build());
blockXmlVO.setRoomCode(roomCode);
blockXmlVO.setBoxCode(boxCode);
blockXmlVO.setGroupCodes(groupCodes);
}
@@ -739,8 +744,32 @@ public class DefaultOrderImportXmlParserHandler {
* block标签结束
*/
private void endBlockXml() {
// 全局inBlock结束
inBlock = false;
blockXmlVO.setOutlineXmlVO(outlineXmlVO);
blockXmlVO.setCuttingOutlineXmlVO(cuttingOutlineXmlVO);
blockXmlVO.setRawOutlineXmlVO(rawOutlineXmlVO);
blockXmlVO.setHoleXmlVOS(holeXmlVOS);
blockXmlVO.setGrooveXmlVOS(grooveXmlVOS);
blockXmlVO.setIsletXmlVOS(isletXmlVOS);
blockXmlVO.setCorrelationXmlVOS(correlationXmlVOS);
blockXmlVO.setRemarkXmlVOS(remarkXmlVOS);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.PLATE.getType())
.innerGoodsId(plateItemCode)
.roomCode(blockXmlVO.getRoomCode())
.bodyCode(blockXmlVO.getBoxCode())
.groupCode(blockXmlVO.getGroupCodes())
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(blockXmlVO)))
.sort(sort++)
.build());
// 清空全局参数
points.clear();
}
/**
@@ -968,24 +997,23 @@ public class DefaultOrderImportXmlParserHandler {
private void analyzeOutline(Iterator<Attribute> attributes) throws Exception {
// 设置全局参数
inOutline = true;
if (inGroove) {
outlineXmlVO = getJavaBeanFromXmlAttr(OutlineXmlVO.class, attributes);
}
}
/**
* Outline标签结束
*/
private void endOutline() {
// 校验count和point数量
// 校验point数量
if (inGroove) {
if (ObjectUtils.isNotNull(outlineXmlVO) && pointNum == 0) {
if (CollUtil.isEmpty(points)) {
throw ServiceExceptionUtil.exception(ORDER_IMPORT_DETAIL_VALID_ERROR, "原始造型(外)轮廓点阵列表不能为空");
}
}
outlineXmlVO.setPointXmlVOList(ListUtil.toList(points));
// 重置全局参数
points.clear();
inOutline = false;
pointNum = 0;
}
/**
@@ -998,31 +1026,20 @@ public class DefaultOrderImportXmlParserHandler {
// 设置全局参数
inCuttingOutline = true;
// 从标签属性生成cuttingoutline对象
CuttingOutlineXmlVO cuttingOutlineXmlVO = getJavaBeanFromXmlAttr(CuttingOutlineXmlVO.class, attributes);
cuttingOutlineXmlVO = getJavaBeanFromXmlAttr(CuttingOutlineXmlVO.class, attributes);
// 校验
isEmptyBackAndNumber(cuttingOutlineXmlVO::getReferenceOffsetX, Double.class, "referenceOffsetX");
isEmptyBackAndNumber(cuttingOutlineXmlVO::getReferenceOffsetY, Double.class, "referenceOffsetY");
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_CUTTINGOUTLINE.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(cuttingOutlineXmlVO)))
.sort(sort++)
.build());
}
/**
* CuttingOutline标签结束
*/
private void endCuttingOutline() {
cuttingOutlineXmlVO.setPointXmlVOList(ListUtil.toList(points));
// 重置全局参数
points.clear();
inCuttingOutline = false;
pointNum = 0;
}
/**
@@ -1042,13 +1059,16 @@ public class DefaultOrderImportXmlParserHandler {
* RawOutline标签结束
*/
private void endRawOutline() {
if (pointNum > 0 && ObjectUtil.isNotNull(rawOutlineXmlVO)) {
if (CollUtil.isNotEmpty(points) && ObjectUtil.isNotNull(rawOutlineXmlVO)) {
isEmptyBackAndNumber(rawOutlineXmlVO::getReferenceOffsetX, Double.class, "referenceOffsetX" + rawOutlineXmlVO.getReferenceOffsetX());
isEmptyBackAndNumber(rawOutlineXmlVO::getReferenceOffsetY, Double.class, "referenceOffsetY" + rawOutlineXmlVO.getReferenceOffsetY());
}
if (ObjectUtil.isNotNull(rawOutlineXmlVO)) {
rawOutlineXmlVO.setPointXmlVOList(ListUtil.toList(points));
}
// 重置全局参数
inRawOutline = false;
pointNum = 0;
points.clear();
}
/**
@@ -1059,23 +1079,13 @@ public class DefaultOrderImportXmlParserHandler {
*/
private void analyzeHoles(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成hole对象
HoleXmlVOS holeXmlVOS = getJavaBeanFromXmlAttr(HoleXmlVOS.class, attributes);
holeXmlVOS = getJavaBeanFromXmlAttr(HoleXmlVOS.class, attributes);
if (ObjectUtil.isNull(holeXmlVOS)) {
return;
}
// 校验holes
checkHoles(holeXmlVOS);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_HOLES.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(holeXmlVOS)))
.sort(sort++)
.build());
holeXmlVOS.setHoleXmlVOList(new ArrayList<>());
}
/**
@@ -1113,17 +1123,7 @@ public class DefaultOrderImportXmlParserHandler {
}
// 校验holes
checkHole(holeXmlVO);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_HOLE.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(holeXmlVO)))
.sort(sort++)
.build());
holeXmlVOS.getHoleXmlVOList().add(holeXmlVO);
}
/**
@@ -1165,21 +1165,11 @@ public class DefaultOrderImportXmlParserHandler {
*/
private void analyzeGrooves(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成grooves对象
GrooveXmlVOS grooveXmlVOS = getJavaBeanFromXmlAttr(GrooveXmlVOS.class, attributes);
grooveXmlVOS = getJavaBeanFromXmlAttr(GrooveXmlVOS.class, attributes);
if (ObjectUtil.isNotNull(grooveXmlVOS)) {
// 校验grooves
checkGooves(grooveXmlVOS);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVES.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(grooveXmlVOS)))
.sort(sort++)
.build());
grooveXmlVOS.setGrooveXmlVOList(new ArrayList<>());
}
}
@@ -1213,26 +1203,11 @@ public class DefaultOrderImportXmlParserHandler {
private void analyzeGroove(Iterator<Attribute> attributes) throws Exception {
// 设置全局参数
inGroove = true;
// 从标签属性生成grooves对象
GrooveXmlVO grooveXmlVO = getJavaBeanFromXmlAttr(GrooveXmlVO.class, attributes);
// 从标签属性生成groove对象
grooveXmlVO = getJavaBeanFromXmlAttr(GrooveXmlVO.class, attributes);
if (ObjectUtil.isNotNull(grooveXmlVO)) {
// 校验grooves
// 校验groove
checkGroove(grooveXmlVO);
// 设计端id
String grooveOuterId = grooveXmlVO.getId();
outerId = grooveOuterId;
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVE.getType())
.outerId(grooveOuterId)
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(grooveXmlVO)))
.sort(sort++)
.build());
}
}
@@ -1240,9 +1215,11 @@ public class DefaultOrderImportXmlParserHandler {
* Groove标签结束
*/
private void endGroove() {
grooveXmlVO.setOutlineXmlVO(outlineXmlVO);
grooveXmlVO.setPointXmlVOS(pointXmlVOS);
grooveXmlVOS.getGrooveXmlVOList().add(grooveXmlVO);
// 重置全局参数
inGroove = false;
outerId = null;
}
/**
@@ -1287,7 +1264,7 @@ public class DefaultOrderImportXmlParserHandler {
* @param attributes
* @throws Exception
*/
private void analyzeGroovePoints(Iterator<Attribute> attributes) throws Exception {
private void analyzePoints(Iterator<Attribute> attributes) throws Exception {
// 设置全局参数
inPoints = true;
// 从标签属性生成points对象
@@ -1297,14 +1274,29 @@ public class DefaultOrderImportXmlParserHandler {
/**
* Points标签结束
*/
private void endGroovePoints() {
private void endPoints() {
// 校验point数量
if (ObjectUtil.isNotNull(pointXmlVOS) && pointNum == 0) {
if (ObjectUtil.isNotNull(pointXmlVOS) && CollUtil.isEmpty(points)) {
throw ServiceExceptionUtil.exception(ORDER_IMPORT_DETAIL_VALID_ERROR, inIslet ? "孤岛点阵列表不可为空" : "槽点坐标列表不可为空");
}
pointXmlVOS.setPointXmlVOList(ListUtil.toList(points));
// 重置全局参数
points.clear();
inPoints = false;
pointNum = 0;
}
/**
* 解析偏移刀路
*
* @param attributes
* @throws Exception
*/
private void analyzeOffsetLines(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成offsetLines对象
offsetLineXmlVOS = getJavaBeanFromXmlAttr(OffsetLineXmlVOS.class, attributes);
if (ObjectUtil.isNotNull(offsetLineXmlVOS)) {
offsetLineXmlVOS.setOffsetLineXmlVOList(new ArrayList<>());
}
}
/**
@@ -1314,24 +1306,12 @@ public class DefaultOrderImportXmlParserHandler {
* @throws Exception
*/
private void analyzeOffsetLine(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成grooves对象
// 从标签属性生成OffsetLine对象
OffsetLineXmlVO offsetLineXmlVO = getJavaBeanFromXmlAttr(OffsetLineXmlVO.class, attributes);
if (ObjectUtil.isNotNull(offsetLineXmlVO)) {
// 校验grooves
// 校验OffsetLine
checkOffsetLine(offsetLineXmlVO);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVE_OFFSETLINE.getType())
.outerGoodsId(blockProductionCode)
.outerSubId(outerId)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(offsetLineXmlVO)))
.sort(sort++)
.build());
offsetLineXmlVOS.getOffsetLineXmlVOList().add(offsetLineXmlVO);
}
}
@@ -1347,6 +1327,22 @@ public class DefaultOrderImportXmlParserHandler {
isEmptyAddAndPositiveNumber(offsetLineXmlVO::getTangentAngle, offsetLineXmlVO::setTangentAngle, "0", Double.class, "tangentAngle");
}
/**
* 解析孤岛
*
* @param attributes
* @throws Exception
*/
private void analyzeIslets(Iterator<Attribute> attributes) throws Exception {
// 设置全局参数
inIslet = true;
// 从标签属性生成grooves对象
isletXmlVOS = getJavaBeanFromXmlAttr(IsletXmlVOS.class, attributes);
if (ObjectUtil.isNotNull(isletXmlVOS)) {
isletXmlVOS.setIsletXmlVOList(new ArrayList<>());
}
}
/**
* 解析孤岛
*
@@ -1357,22 +1353,9 @@ public class DefaultOrderImportXmlParserHandler {
// 设置全局参数
inIslet = true;
// 从标签属性生成grooves对象
IsletXmlVO isletXmlVO = getJavaBeanFromXmlAttr(IsletXmlVO.class, attributes);
isletXmlVO = getJavaBeanFromXmlAttr(IsletXmlVO.class, attributes);
if (ObjectUtil.isNotNull(isletXmlVO)) {
isEmptyAndBack(isletXmlVO::getId, "孤岛ID");
outerId = isletXmlVO.getId();
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVE_ISLET.getType())
.outerGoodsId(blockProductionCode)
.outerId(outerId)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(isletXmlVO)))
.sort(sort++)
.build());
}
}
@@ -1380,10 +1363,28 @@ public class DefaultOrderImportXmlParserHandler {
* Islet标签结束
*/
private void endIslet() {
if (ObjectUtil.isNotNull(isletXmlVO)) {
isletXmlVO.setPointXmlVOS(pointXmlVOS);
isletXmlVOS.getIsletXmlVOList().add(isletXmlVO);
}
// 重置全局参数
points.clear();
inIslet = false;
pointNum = 0;
outerId = null;
}
/**
* 解析关联配件
*
* @param attributes
* @throws Exception
*/
private void analyzeCorrelations(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成correlation对象
correlationXmlVOS = getJavaBeanFromXmlAttr(CorrelationXmlVOS.class, attributes);
if (ObjectUtil.isNotNull(correlationXmlVOS)) {
correlationXmlVOS.setCorrelationXmlVOList(new ArrayList<>());
}
}
/**
@@ -1400,9 +1401,11 @@ public class DefaultOrderImportXmlParserHandler {
isEmptyAndBack(correlationXmlVO::getName, "name");
}
isEmptyBackAndPositiveNumber(correlationXmlVO::getCount, FIELD_COUNT, Integer.class);
correlationXmlVOS.getCorrelationXmlVOList().add(correlationXmlVO);
}
}
}
List<PointXmlVO> points = new ArrayList<>();
/**
* 解析点明细
@@ -1420,93 +1423,24 @@ public class DefaultOrderImportXmlParserHandler {
if (inOutline) {
if (inGroove) {
checkPoint(pointXmlVO, "原始造型(外)轮廓");
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVE_OUTLINE_POINT.getType())
.outerGoodsId(blockProductionCode)
.outerSubId(outerId)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(pointXmlVO)))
.sort(sort++)
.build());
} else {
checkOutlinePoint(pointXmlVO);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_OUTLINE_POINT.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(pointXmlVO)))
.sort(sort++)
.build());
}
}
if (inCuttingOutline) {
checkPointRemoveZ(pointXmlVO, "开料成型轮廓信息");
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_CUTTINGOUTLINE_POINT.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(pointXmlVO)))
.sort(sort++)
.build());
}
if (inRawOutline) {
checkPointRemoveZ(pointXmlVO, "坯料轮廓信息");
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_RAWOUTLINE_POINT.getType())
.outerGoodsId(blockProductionCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(pointXmlVO)))
.sort(sort++)
.build());
}
if (inPoints) {
if (inIslet) {
checkPointRemoveZ(pointXmlVO, "孤岛");
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVE_ISLET_POINTS_POINT.getType())
.outerGoodsId(blockProductionCode)
.outerSubId(outerId)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(pointXmlVO)))
.sort(sort++)
.build());
} else {
checkPoint(pointXmlVO, "刀路点阵");
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(OrderImportTmpDataTypeEnum.BLOCK_GROOVE_POINTS_POINT.getType())
.outerGoodsId(blockProductionCode)
.outerSubId(outerId)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(pointXmlVO)))
.sort(sort++)
.build());
}
}
// 列表数量累加
pointNum++;
points.add(pointXmlVO);
}
/**
@@ -1520,6 +1454,18 @@ public class DefaultOrderImportXmlParserHandler {
isEmptyBackAndNumber(pointXmlVO::getPointZ, Double.class, name + "pointZ");
}
/**
* 解析备注
*
* @param attributes
* @throws Exception
*/
private void analyzeRemarks(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成correlation对象
remarkXmlVOS = new RemarkXmlVOS();
remarkXmlVOS.setRemarkXmlVOList(new ArrayList<>());
}
/**
* 解析备注
*
@@ -1529,18 +1475,7 @@ public class DefaultOrderImportXmlParserHandler {
private void analyzeRemark(Iterator<Attribute> attributes) throws Exception {
// 从标签属性生成correlation对象
RemarkXmlVO remarkXmlVO = getJavaBeanFromXmlAttr(RemarkXmlVO.class, attributes);
// 添加到临时表
cachedDataList.add(OrderImportTempDataDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
.taskId(taskId)
.type(inBlock ? OrderImportTmpDataTypeEnum.BLOCK_REMKAR.getType() : OrderImportTmpDataTypeEnum.PART_REMARK.getType())
.outerSubId(inBlock ? blockProductionCode : partItemCode)
.createTime(LocalDateTime.now())
.detail(JsonUtils.zipString(JSON.toJSONString(remarkXmlVO)))
.sort(sort++)
.build());
remarkXmlVOS.getRemarkXmlVOList().add(remarkXmlVO);
}
/**
@@ -1809,7 +1744,6 @@ public class DefaultOrderImportXmlParserHandler {
* 非空判断+数据类型+数据正数
*
* @param getter:
* @param setter:
* @param name: 字段错误名称
* @param targetType: 数字类型
*/
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/BlockXmlVO.java
+24
View File
@@ -135,4 +135,28 @@ public class BlockXmlVO implements Serializable {
// 绕Z轴旋转角度
private String axisZrotate;
// 成品(设计成型/已封边/贴皮或涂装的板件)轮廓信息
private OutlineXmlVO outlineXmlVO ;
// 坯料(还需进行精修/铣削/打磨的板材)轮廓信息
private RawOutlineXmlVO rawOutlineXmlVO ;
// 开料成型(精修/铣削/打磨完成，未封边/贴皮或涂装的板材)轮廓信息
private CuttingOutlineXmlVO cuttingOutlineXmlVO ;
// 孔信息
private HoleXmlVOS holeXmlVOS;
// 凹槽信息 / 造型
private GrooveXmlVOS grooveXmlVOS ;
// 孤岛列表
private IsletXmlVOS isletXmlVOS ;
// 关联配件/组件列表
private CorrelationXmlVOS correlationXmlVOS;
// 备注
private RemarkXmlVOS remarkXmlVOS;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/CorrelationXmlVOS.java
+20
View File
@@ -0,0 +1,20 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CorrelationXmlVOS implements Serializable {
// 关联配件数量
private String count;
// 房间
private List<CorrelationXmlVO> correlationXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/CuttingOutlineXmlVO.java
+3
View File
@@ -5,6 +5,7 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@@ -17,4 +18,6 @@ public class CuttingOutlineXmlVO implements Serializable {
// 相对于成品轮廓，基准点的Y坐标偏移量
private String referenceOffsetY;
private List<PointXmlVO> pointXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/GrooveXmlVO.java
+9
View File
@@ -70,4 +70,13 @@ public class GrooveXmlVO implements Serializable {
private String isletCount;
private String result;
// 凹槽点信息
private PointXmlVOS pointXmlVOS;
// 偏移刀路列表
private OffsetLineXmlVOS offsetLineXmlVOS;
// 原始造型(外)轮廓信息
private OutlineXmlVO outlineXmlVO;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/GrooveXmlVOS.java
+3
View File
@@ -5,6 +5,7 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@@ -50,4 +51,6 @@ public class GrooveXmlVOS implements Serializable {
// 三维造型刀路(浮雕)数量
private String count3D;
private List<GrooveXmlVO> grooveXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/HoleXmlVOS.java
+3
View File
@@ -5,6 +5,7 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@@ -50,4 +51,6 @@ public class HoleXmlVOS implements Serializable {
// 挖穿孔数量（通孔/对成孔）
private String countThrough;
private List<HoleXmlVO> holeXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/IsletXmlVO.java
+2
View File
@@ -20,4 +20,6 @@ public class IsletXmlVO implements Serializable {
// 内层(不含内嵌孤岛内的凹槽)凹槽数量
private String grooveCount;
private PointXmlVOS pointXmlVOS;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/IsletXmlVOS.java
+22
View File
@@ -0,0 +1,22 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
// 孤岛列表
public class IsletXmlVOS implements Serializable {
// 孤岛数量
private String count;
// 房间
private List<IsletXmlVO> isletXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/OffsetLineXmlVOS.java
+20
View File
@@ -0,0 +1,20 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
// 偏移刀路列表
public class OffsetLineXmlVOS implements Serializable {
// 偏移刀路数量
private String count;
private List<OffsetLineXmlVO> offsetLineXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/OutlineXmlVO.java
+20
View File
@@ -0,0 +1,20 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OutlineXmlVO implements Serializable {
// 点阵数量
private String count;
private List<PointXmlVO> pointXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/PointXmlVOS.java
+19
View File
@@ -0,0 +1,19 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PointXmlVOS implements Serializable {
// 刀路点阵数量
private String count;
private List<PointXmlVO> pointXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/RawOutlineXmlVO.java
+26
View File
@@ -0,0 +1,26 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
// 坯料(还需进行精修/铣削/打磨的板材)轮廓信息
public class RawOutlineXmlVO implements Serializable {
// 相对于成品轮廓，基准点的X坐标偏移量
private String referenceOffsetX;
// 相对于成品轮廓，基准点的Y坐标偏移量
private String referenceOffsetY;
// 点阵数量
private String count;
private List<PointXmlVO> pointXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/controller/orderImport/xml/vo/RemarkXmlVOS.java
+18
View File
@@ -0,0 +1,18 @@
package com.cf.imes.module.plan.controller.orderImport.xml.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RemarkXmlVOS implements Serializable {
private static final long serialVersionUID = 720894888203768497L;
private List<RemarkXmlVO> remarkXmlVOList;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/framework/rpc/config/RpcConfiguration.java
+3 -1
View File
@@ -1,6 +1,8 @@
package com.cf.imes.module.plan.framework.rpc.config;
import com.cf.imes.module.system.api.customplateno.CustomPlateNoSeqApi;
import com.cf.imes.module.system.api.dict.DictDataApi;
import com.cf.imes.module.system.api.systemconfig.SystemConfigApi;
import com.cf.imes.module.system.api.user.AdminUserApi;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Configuration;
@@ -9,6 +11,6 @@ import org.springframework.context.annotation.Configuration;
* @author there
*/
@Configuration(proxyBeanMethods = false)
@EnableFeignClients(clients = {AdminUserApi.class, DictDataApi.class})
@EnableFeignClients(clients = {AdminUserApi.class, DictDataApi.class, SystemConfigApi.class, CustomPlateNoSeqApi.class,})
public class RpcConfiguration {
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/CustomPlateNoGenerateService.java
+40
View File
@@ -0,0 +1,40 @@
package com.cf.imes.module.plan.service.customplateno;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
/**
* 自定义板编号生成服务
*
* @author Gqr
* @since 2024/11/15 10:18
*/
public interface CustomPlateNoGenerateService {
/**
* 获取自定义板编号生成配置
*
* @param orderId
* @return
*/
CustomPlateNoGenerateConfigVO getPlateNoGenerateConfig(Long orderId);
/**
* 生成自定义板编号
*
* @param orderId 生产单号
* @param plateDO 板件
* @param generateConfig 板编号生成配置
* @param isFirstPlate 是否导入的第一块
* @return 生成过程中的配置
*/
void generateCustomPlateNo(Long orderId, PlateDO plateDO, CustomPlateNoGenerateConfigVO generateConfig, boolean isFirstPlate);
/**
* 生成结束后，更新板编号配置到对应生产单
*
* @param generateConfig
* @param orderDO
*/
void updateCustomPlateNoGenerateConfig(CustomPlateNoGenerateConfigVO generateConfig, OrderDO orderDO);
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/CustomPlateNoGenerateServiceImpl.java
+196
View File
@@ -0,0 +1,196 @@
package com.cf.imes.module.plan.service.customplateno;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.cf.imes.framework.common.exception.ServiceException;
import com.cf.imes.framework.common.pojo.CommonResult;
import com.cf.imes.framework.common.util.json.JsonUtils;
import com.cf.imes.module.executor.enums.ErrorCodeConstants;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.dal.mysql.order.OrderMapper;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoRuleVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqVO;
import com.cf.imes.module.plan.service.customplatenorule.CustomPlateNoGenerateRuleService;
import com.cf.imes.module.system.api.customplateno.CustomPlateNoSeqApi;
import com.cf.imes.module.system.api.customplateno.dto.CustomPlateNoSeqDTO;
import com.cf.imes.module.system.api.systemconfig.SystemConfigApi;
import com.cf.imes.module.system.api.systemconfig.dto.SystemConfigRespDTO;
import com.cf.imes.module.system.enums.customplateno.CustomPlateNoRuleCodeEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Optional;
/**
* @author Gqr
* @since 2024/11/14 11:41
*/
@Service
@Slf4j
public class CustomPlateNoGenerateServiceImpl implements CustomPlateNoGenerateService {
@Resource
private SystemConfigApi systemConfigApi;
@Resource
private CustomPlateNoSeqApi customPlateNoSeqApi;
@Resource
private List<CustomPlateNoGenerateRuleService> ruleServices;
@Resource
private OrderMapper orderMapper;
private static final DateTimeFormatter YEAR_FORMATTER = DateTimeFormatter.ofPattern("yyyy");
private static final DateTimeFormatter MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyyMM");
private static final DateTimeFormatter DAY_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
@Override
public CustomPlateNoGenerateConfigVO getPlateNoGenerateConfig(Long orderId) {
// 1、获取生产配置
CustomPlateNoGenerateConfigVO generateConfig = getGenerateConfig(orderId);
// 如果没有查到配置规则就不做后续生成操作了
List<CustomPlateNoRuleVO> orgCustomPlateNoRuleVOList = generateConfig.getOrgCustomPlateNoRuleVOList();
// 如果没有查到机构下配置就不做后续生成操作了
Long orgCustomPlateNoConfigId = generateConfig.getOrgCustomPlateNoConfigId();
if (ObjectUtil.isNull(orgCustomPlateNoConfigId) || CollUtil.isEmpty(orgCustomPlateNoRuleVOList)) {
return null;
}
// 开始生成时记录时间，用于后续年月日复位、上次年月日记录等
LocalDateTime now = LocalDateTime.now();
orgCustomPlateNoRuleVOList.forEach(rule -> rule.setNow(now));
return generateConfig;
}
@Override
public void generateCustomPlateNo(Long orderId, PlateDO plateDO, CustomPlateNoGenerateConfigVO generateConfig, boolean isFirstPlate) {
loopGenerateNo(orderId, plateDO, generateConfig, isFirstPlate);
}
@Override
public void updateCustomPlateNoGenerateConfig(CustomPlateNoGenerateConfigVO generateConfig, OrderDO orderDO) {
if (ObjectUtil.isNull(generateConfig)) {
return;
}
Long orderId = orderDO.getId();
Long orgCustomPlateNoConfigId = generateConfig.getOrgCustomPlateNoConfigId();
LocalDateTime now = LocalDateTime.now();
// 3、保存生产单序号json、设置生产单所用配置id
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
// todo 补板延续自定义版编号
// if (newOrder) {
orderDO.setCustomPlatenoSeq(JSON.toJSONString(orderCustomPlateNoSeqVO));
orderDO.setCustomPlatenoConfigId(orgCustomPlateNoConfigId);
// } else {
// // 已有生产单更新序号
// orderMapper.update(new LambdaUpdateWrapper<OrderDO>().eq(OrderDO::getId, orderId).set(OrderDO::getCustomPlatenoSeq, JsonUtils.zipString(JSON.toJSONString(orderCustomPlateNoSeqVO))));
// }
// 机构下序号配置同步
CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO = generateConfig.getOrgCustomPlateNoSeqRespDTO();
orgCustomPlateNoSeqRespDTO.setLastOrderNo(orderId);
orgCustomPlateNoSeqRespDTO.setLastYear(Integer.parseInt(YEAR_FORMATTER.format(now)));
orgCustomPlateNoSeqRespDTO.setLastMonth(Integer.parseInt(MONTH_FORMATTER.format(now)));
orgCustomPlateNoSeqRespDTO.setLastDay(Integer.parseInt(DAY_FORMATTER.format(now)));
// 保存组织下全局序号配置
CommonResult<Boolean> orgCustomPlateNoSeqModifyResult = customPlateNoSeqApi.modifyOrgCustomPlateNoSeq(orgCustomPlateNoSeqRespDTO);
if (orgCustomPlateNoSeqModifyResult.isError() || !orgCustomPlateNoSeqModifyResult.getData().booleanValue()) {
throw new ServiceException(ErrorCodeConstants.CUSTOM_PLATENO_GENERATE_ORG_CUSTOM_PLATENO_SEQ_MODIFY_ERROR);
}
}
/**
* 循环规则和板件列表生成编号
*
* @param orderId
* @param plateDO
* @param generateConfig
* @param
*/
private CustomPlateNoGenerateConfigVO loopGenerateNo(Long orderId, PlateDO plateDO, CustomPlateNoGenerateConfigVO generateConfig, boolean firstPlate) {
List<CustomPlateNoRuleVO> orgCustomPlateNoRuleVOList = generateConfig.getOrgCustomPlateNoRuleVOList();
// 遍历规则列表
for (CustomPlateNoRuleVO plateNoRule : orgCustomPlateNoRuleVOList) {
if (ObjectUtil.equal(CustomPlateNoRuleCodeEnum.CUSTOM.getRuleCode(), plateNoRule.getRuleCode())) {
plateDO.getCustomPlateNoBuilder().append(Optional.ofNullable(plateNoRule.getStrValue()).orElse(""));
}
if (ObjectUtil.equal(CustomPlateNoRuleCodeEnum.DATE.getRuleCode(), plateNoRule.getRuleCode())) {
String dateValue = plateNoRule.getDateValue();
if (StringUtils.isNotEmpty(dateValue)) {
plateDO.getCustomPlateNoBuilder().append(plateNoRule.getNow().format(DateTimeFormatter.ofPattern(dateValue)));
}
}
// 遍历规则生成服务列表，获取对应的规则服务
for (CustomPlateNoGenerateRuleService ruleService : ruleServices) {
if (ruleService.match(plateNoRule.getRuleCode())) {
generateConfig = ruleService.generateNo(orderId, plateNoRule, generateConfig, plateDO, firstPlate);
break;
}
}
}
plateDO.setCustomPlateNo(plateDO.getCustomPlateNoBuilder().toString());
return generateConfig;
}
/**
* 根据生产单id获取生成需要的配置
*
* @param orderId
* @return 1、生产单下的序号
* 2、机构下的序号
* 3、机构下全局配置的规则
*/
private CustomPlateNoGenerateConfigVO getGenerateConfig(Long orderId) {
// 生成自定义版编号所需配置
CustomPlateNoGenerateConfigVO customPlateNoGenerateConfigVO = new CustomPlateNoGenerateConfigVO();
// 机构下自定义板编号配置
SystemConfigRespDTO orgCustomPlateNoConfig = null;
// 生产单下序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = new OrderCustomPlateNoSeqVO();
// 自定义板编号配置规则明细列表
List<CustomPlateNoRuleVO> customPlateNoRuleVOS = List.of();
// 查询机构的自定义版编号配置
CommonResult<SystemConfigRespDTO> orgCustomPlateNoConfigResult = systemConfigApi.getOrgCustomPlateNoConfig();
if (orgCustomPlateNoConfigResult.isSuccess()) {
orgCustomPlateNoConfig = orgCustomPlateNoConfigResult.getData();
customPlateNoRuleVOS = Optional.ofNullable(orgCustomPlateNoConfig)
.map(config -> JSON.parseArray(config.getSetting(), CustomPlateNoRuleVO.class))
.orElse(List.of());
customPlateNoGenerateConfigVO.setOrgCustomPlateNoConfigId(Optional.ofNullable(orgCustomPlateNoConfig).map(SystemConfigRespDTO::getId).orElse(null));
}
OrderDO order = orderMapper.selectOne(new LambdaQueryWrapper<OrderDO>().eq(OrderDO::getId, orderId));
if (ObjectUtil.isNotNull(order) && ObjectUtil.isNotNull(orgCustomPlateNoConfig)) {
// 老单
// 生产单上的自定义板编号配置id和当前最新的对比，不同用生产单号上的
Long orderCustomPlatenoConfigId = order.getCustomPlatenoConfigId();
if (ObjectUtil.isNotNull(orderCustomPlatenoConfigId) && ObjectUtil.notEqual(orgCustomPlateNoConfig.getId(), orderCustomPlatenoConfigId)) {
CommonResult<SystemConfigRespDTO> previousCustomPlateNoConfig = systemConfigApi.getById(orderCustomPlatenoConfigId);
if (previousCustomPlateNoConfig.isSuccess()) {
customPlateNoRuleVOS = JSON.parseArray(previousCustomPlateNoConfig.getData().getSetting(), CustomPlateNoRuleVO.class);
}
}
// 上一次的生产单内 自定义版编号序号
orderCustomPlateNoSeqVO = JSON.parseObject(order.getCustomPlatenoSeq(), OrderCustomPlateNoSeqVO.class);
}
customPlateNoGenerateConfigVO.setOrderCustomPlateNoSeqVO(orderCustomPlateNoSeqVO);
customPlateNoGenerateConfigVO.setOrgCustomPlateNoRuleVOList(customPlateNoRuleVOS);
CommonResult<CustomPlateNoSeqDTO> orgCustomPlateNoSeq = customPlateNoSeqApi.getOrgCustomPlateNoSeq();
if (orgCustomPlateNoSeq.isSuccess()) {
customPlateNoGenerateConfigVO.setOrgCustomPlateNoSeqRespDTO(orgCustomPlateNoSeq.getData());
}
return customPlateNoGenerateConfigVO;
}
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/vo/CustomPlateNoGenerateConfigVO.java
+36
View File
@@ -0,0 +1,36 @@
package com.cf.imes.module.plan.service.customplateno.vo;
import com.cf.imes.module.system.api.customplateno.dto.CustomPlateNoSeqDTO;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* @author Gqr
* @since 2024/11/15 10:40
*/
@Data
public class CustomPlateNoGenerateConfigVO implements Serializable {
private static final long serialVersionUID = -7383861104153624467L;
/**
* 生产单下的之定义板编号序号内容
*/
private OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO;
/**
* 自定义板编号规则
*/
private List<CustomPlateNoRuleVO> orgCustomPlateNoRuleVOList;
/**
* 机构下自定义板编号-系统配置id
*/
private Long orgCustomPlateNoConfigId;
/**
* 机构下的自定义板编号序号
*/
private CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/vo/CustomPlateNoRuleVO.java
+62
View File
@@ -0,0 +1,62 @@
package com.cf.imes.module.plan.service.customplateno.vo;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统配置-自定义板编号setting项 vo
*
* @author Gqr
* @since 2024/11/15 10:33
*/
@Data
public class CustomPlateNoRuleVO implements Serializable {
private static final long serialVersionUID = -5691595836226548840L;
/**
* 规则编码
*/
private String ruleCode;
/**
* 自定义类型字符串规则值
*/
private String strValue;
/**
* 时间类型字符串规则值
*/
private String dateValue;
/**
* 初始值
*/
private Integer initValue;
/**
* 位数
*/
private Integer length;
/**
* 是否左补零
*/
private boolean leftFillZero;
/**
* 步长
*/
private Integer incrementStep;
/**
* 复位/清零模式
*/
private Integer resetMode;
/**
* 开始生成板编号的时间
*/
private LocalDateTime now;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/vo/OrderCustomPlateNoSeqBodyVO.java
+30
View File
@@ -0,0 +1,30 @@
package com.cf.imes.module.plan.service.customplateno.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrderCustomPlateNoSeqBodyVO implements Serializable {
private static final long serialVersionUID = 2686882895438975156L;
/**
* 柜体名
*/
private String bodyName;
/**
* 柜体下板件序号
*/
private Integer plateNoSeq;
/**
* 柜体序号
*/
private Integer bodyNoSeq;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/vo/OrderCustomPlateNoSeqProcessGroupVO.java
+26
View File
@@ -0,0 +1,26 @@
package com.cf.imes.module.plan.service.customplateno.vo;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
@Data
@Builder
public class OrderCustomPlateNoSeqProcessGroupVO implements Serializable {
private static final long serialVersionUID = -6834098282222544638L;
/**
* 加工组名
*/
private String processGroupName;
/**
* 加工组下板件序号
*/
private Integer plateNoSeq;
/**
* 加工组序号
*/
private Integer processGroupNoSeq;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/vo/OrderCustomPlateNoSeqRoomVO.java
+41
View File
@@ -0,0 +1,41 @@
package com.cf.imes.module.plan.service.customplateno.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrderCustomPlateNoSeqRoomVO implements Serializable {
private static final long serialVersionUID = -127388898531267048L;
/**
* 房间名
*/
private String roomName;
/**
* 房间序号
*/
private Integer roomNoSeq;
/**
* 房间下板件序号
*/
private Integer plateNoSeq;
/**
* 房间下柜体序号
*/
private Integer bodyNoSeq;
/**
* 房间下柜体列表
*/
private List<OrderCustomPlateNoSeqBodyVO> bodys;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplateno/vo/OrderCustomPlateNoSeqVO.java
+52
View File
@@ -0,0 +1,52 @@
package com.cf.imes.module.plan.service.customplateno.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 生产单-自定义板编号序号（custom_plateno_seq）vo
*
* @author Gqr
* @since 2024/11/15 10:41
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderCustomPlateNoSeqVO implements Serializable {
private static final long serialVersionUID = 5841977329049878792L;
/**
* 生产单序号
*/
private Integer orderNoSeq;
/**
* 生产单下房间序号
*/
private Integer roomNoSeq;
/**
* 生产单下柜体序号
*/
private Integer bodyNoSeq;
/**
* 生产单下板件序号
*/
private Integer plateNoSeq;
/**
* 生产单下房间列表
*/
private List<OrderCustomPlateNoSeqRoomVO> rooms;
/**
* 生产单下柜体列表
*/
private List<OrderCustomPlateNoSeqBodyVO> bodys;
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplatenorule/BodyNoGenerateRuleServiceImpl.java
+267
View File
@@ -0,0 +1,267 @@
package com.cf.imes.module.plan.service.customplatenorule;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.cf.imes.framework.common.exception.util.ServiceExceptionUtil;
import com.cf.imes.framework.common.util.json.JsonUtils;
import com.cf.imes.framework.organ.core.context.OrganContextHolder;
import com.cf.imes.module.executor.api.customplateno.dto.CustomPlateNoRuleDTO;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.dal.mysql.order.OrderMapper;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoRuleVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqBodyVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqRoomVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqVO;
import com.cf.imes.module.system.api.customplateno.dto.CustomPlateNoSeqDTO;
import com.cf.imes.module.system.enums.customplateno.CustomPlateNoRuleCodeEnum;
import com.cf.imes.module.system.enums.customplateno.ResetModeEnum;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static com.cf.imes.module.executor.enums.ErrorCodeConstants.CUSTOM_PLATENO_GENERATE_BODY_RULE_NOT_SUPPORT_RESETMODE;
/**
* 柜体序号生成规则服务实现类
*
* @author Gqr
* @since 2024/11/19 16:35
*/
@Service("bodyNoGenerateRuleService")
public class BodyNoGenerateRuleServiceImpl implements CustomPlateNoGenerateRuleService {
@Resource
private OrderMapper orderMapper;
@Override
public boolean match(String ruleCode) {
return ObjectUtil.equal(CustomPlateNoRuleCodeEnum.BODYNO.getRuleCode(), ruleCode);
}
/**
* 初始化生成所需配置
*
* @param generateConfigVO
*/
private static void initConfig(CustomPlateNoGenerateConfigVO generateConfigVO) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfigVO.getOrderCustomPlateNoSeqVO();
if (ObjectUtil.isNull(orderCustomPlateNoSeqVO)) {
orderCustomPlateNoSeqVO = new OrderCustomPlateNoSeqVO();
generateConfigVO.setOrderCustomPlateNoSeqVO(orderCustomPlateNoSeqVO);
}
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
if (CollUtil.isEmpty(rooms)) {
rooms = new ArrayList<>();
orderCustomPlateNoSeqVO.setRooms(rooms);
}
List<OrderCustomPlateNoSeqBodyVO> boyds = orderCustomPlateNoSeqVO.getBodys();
if (CollUtil.isEmpty(boyds)) {
boyds = new ArrayList<>();
orderCustomPlateNoSeqVO.setBodys(boyds);
}
}
@Override
public CustomPlateNoGenerateConfigVO generateNo(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate) {
// 初始化配置
initConfig(generateConfig);
// 按复位模式走不同的生成方式
ResetModeEnum resetModeEnum = ResetModeEnum.getByMode(plateNoRule.getResetMode());
if (ObjectUtil.equal(ResetModeEnum.ORDER, resetModeEnum)) {
generateConfig = generateNoByOrderResetMode(orderId, plateNoRule, generateConfig, plateDO, firstPlate);
} else if (ObjectUtil.equal(ResetModeEnum.ROOM, resetModeEnum)) {
generateConfig = generateNoByRoomResetMode(plateNoRule, generateConfig, plateDO);
} else {
throw ServiceExceptionUtil.exception(CUSTOM_PLATENO_GENERATE_BODY_RULE_NOT_SUPPORT_RESETMODE, plateNoRule.getResetMode());
}
return generateConfig;
}
@Override
public void reset(CustomPlateNoRuleDTO ruleDTO) {
// 查询所有使用当前配置id的生产单列表
Long configId = ruleDTO.getConfigId();
List<OrderDO> orderDOS = orderMapper.selectList(
new LambdaQueryWrapper<OrderDO>().eq(OrderDO::getCustomPlatenoConfigId, configId).eq(OrderDO::getOrganId, OrganContextHolder.getOrganId()));
ResetModeEnum resetModeEnum = ResetModeEnum.getByMode(ruleDTO.getResetMode());
// 根据复位模式更新生产单的序号
for (OrderDO orderDO : orderDOS) {
resetOrder(orderDO, resetModeEnum);
}
}
private void resetOrder(OrderDO orderDO, ResetModeEnum resetModeEnum) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = JSON.parseObject(orderDO.getCustomPlatenoSeq(), OrderCustomPlateNoSeqVO.class);
if (ObjectUtil.isNotNull(orderCustomPlateNoSeqVO)) {
if (ObjectUtil.equal(ResetModeEnum.ORDER, resetModeEnum)) {
orderCustomPlateNoSeqVO.setBodyNoSeq(null);
} else if (ObjectUtil.equal(ResetModeEnum.ROOM, resetModeEnum)) {
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
if (CollUtil.isNotEmpty(rooms)) {
for (OrderCustomPlateNoSeqRoomVO roomVO : rooms) {
roomVO.setBodyNoSeq(null);
}
}
}
orderMapper.update(new LambdaUpdateWrapper<OrderDO>().eq(OrderDO::getId, orderDO.getId()).set(OrderDO::getCustomPlatenoSeq, JsonUtils.zipString(JSON.toJSONString(orderCustomPlateNoSeqVO))));
}
}
/**
* 按生产单复位模式下的板编号生成
*
* @param orderId 生产单号
* @param plateNoRule 当前规则配置
* @param generateConfig 生成规则配置
* @param plateDO 板件列表
* @return
*/
private CustomPlateNoGenerateConfigVO generateNoByOrderResetMode(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate) {
Integer incrementStep = plateNoRule.getIncrementStep();
Integer initValue = plateNoRule.getInitValue() - incrementStep;
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
// 机构下的自定义板编号序号
CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO = generateConfig.getOrgCustomPlateNoSeqRespDTO();
// 生产单下柜体序号
Integer orderBodyNoSeq = Optional.ofNullable(orderCustomPlateNoSeqVO.getBodyNoSeq()).orElse(initValue);
// 生产单序号下的房间序号列表
List<OrderCustomPlateNoSeqBodyVO> bodys = orderCustomPlateNoSeqVO.getBodys();
// 上次导入的生产单号
Long lastOrderNo = orgCustomPlateNoSeqRespDTO.getLastOrderNo();
if (firstPlate && (ObjectUtil.isNull(lastOrderNo) || ObjectUtil.notEqual(orderId, lastOrderNo))) {
// 跨单复位到初始值
orderBodyNoSeq = initValue;
}
String bodyName = plateDO.getBodyName();
// 根据柜体名获取生产单下序号json中第一层柜体列表的柜体序号
OrderCustomPlateNoSeqBodyVO bodySeqVo = getBodySeqVOByBodyName(bodyName, bodys);
// 获取当前柜体序号值
Integer bodyNoSeq = Optional.ofNullable(bodySeqVo).map(OrderCustomPlateNoSeqBodyVO::getBodyNoSeq).orElse(null);
if (bodySeqVo == null) {
// 生产单序号下柜体为空，新建柜体，取生产单下柜体序号
bodySeqVo = OrderCustomPlateNoSeqBodyVO.builder()
.bodyName(bodyName)
.build();
bodys.add(bodySeqVo);
// 累加步长
bodyNoSeq = orderBodyNoSeq + incrementStep;
// 累加后的值同步到当前生产单序号中，生产单下柜体序号累加到多少了
orderCustomPlateNoSeqVO.setBodyNoSeq(bodyNoSeq);
} else if (bodyNoSeq == null) {
// 柜体下序号为空，取生产单下房间序号
// 累加步长
bodyNoSeq = orderBodyNoSeq + incrementStep;
// 累加后的值同步到当前生产单序号中，生产单下柜体序号累加到多少了
orderCustomPlateNoSeqVO.setBodyNoSeq(bodyNoSeq);
}
// 补零
String noPartAfterFillZero = fillZero(bodyNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFillZero);
// 累加后同步到json：柜体下累加到多少了
bodySeqVo.setBodyNoSeq(bodyNoSeq);
return generateConfig;
}
/**
* 按房间号复位模式下的板编号生成
*
* @param plateNoRule
* @param generateConfig
* @param plateDO
* @return
*/
private CustomPlateNoGenerateConfigVO generateNoByRoomResetMode(CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO) {
Integer incrementStep = plateNoRule.getIncrementStep();
Integer initValue = plateNoRule.getInitValue() - incrementStep;
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
String roomName = plateDO.getRoomName();
// 根据房间名获取生产单下序号json中的房间下的柜体序号
OrderCustomPlateNoSeqRoomVO roomSeqVo = getRoomSeqVOByRoomName(roomName, rooms);
Integer roomBodyNoRoomSeq = Optional.ofNullable(roomSeqVo)
.map(OrderCustomPlateNoSeqRoomVO::getBodyNoSeq)
.orElse(initValue);
if (roomSeqVo == null) {
// 房间为空，新建对象，设置初始值
roomSeqVo = OrderCustomPlateNoSeqRoomVO.builder()
.roomName(roomName)
.bodyNoSeq(roomBodyNoRoomSeq)
.bodys(new ArrayList<>())
.build();
rooms.add(roomSeqVo);
}
// 如果是新的柜体vo，要把累加的值记录到生产单rooms下的柜体
String bodyName = plateDO.getBodyName();
// 根据柜体名获取生产单下序号中rooms下柜体列表的柜体序号
List<OrderCustomPlateNoSeqBodyVO> roomBodys = roomSeqVo.getBodys();
OrderCustomPlateNoSeqBodyVO roomBodySeqVo = getBodySeqVOByBodyName(bodyName, roomBodys);
// 获取当前房间下柜体的序号值
Integer roomBodyNoSeq = Optional.ofNullable(roomBodySeqVo).map(OrderCustomPlateNoSeqBodyVO::getBodyNoSeq).orElse(null);
if (roomBodySeqVo == null) {
// 房间下柜体为空，新建对象，设置房间下全局柜体序号值
roomBodySeqVo = OrderCustomPlateNoSeqBodyVO.builder()
.bodyName(bodyName)
.build();
roomBodys.add(roomBodySeqVo);
// 累加步长
roomBodyNoSeq = roomBodyNoRoomSeq + incrementStep;
// 累加后的值同步到当前生产单序号中，生产单下房间中柜体累加到多少了
roomSeqVo.setBodyNoSeq(roomBodyNoSeq);
} else if (roomBodyNoSeq == null) {
// 房间下柜体序号为空，设置房间下全局柜体序号值
// 累加步长
roomBodyNoSeq = roomBodyNoRoomSeq + incrementStep;
// 累加后的值同步到当前生产单序号中，生产单下房间中柜体累加到多少了
roomSeqVo.setBodyNoSeq(roomBodyNoSeq);
}
// 补零
String noPartAfterFillZero = fillZero(roomBodyNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFillZero);
// 累加后同步到json中，room下柜体累加到多少了
roomBodySeqVo.setBodyNoSeq(roomBodyNoSeq);
return generateConfig;
}
/**
* 根据房间名从生产单序号json中获取房间序号
*
* @param roomName
* @param roomVOList
* @return
*/
private OrderCustomPlateNoSeqRoomVO getRoomSeqVOByRoomName(String roomName, List<OrderCustomPlateNoSeqRoomVO> roomVOList) {
return roomVOList.stream().filter(roomVO -> ObjectUtil.equal(roomName, roomVO.getRoomName())).findAny().orElse(null);
}
/**
* 根据柜体名从生产单序号json中获取柜体序号
*
* @param bodyName
* @param bodyVOList
* @return
*/
private OrderCustomPlateNoSeqBodyVO getBodySeqVOByBodyName(String bodyName, List<OrderCustomPlateNoSeqBodyVO> bodyVOList) {
if (CollUtil.isEmpty(bodyVOList)) {
return null;
}
return bodyVOList.stream().filter(bodyVO -> ObjectUtil.equal(bodyName, bodyVO.getBodyName())).findAny().orElse(null);
}
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplatenorule/CustomPlateNoGenerateRuleService.java
+57
View File
@@ -0,0 +1,57 @@
package com.cf.imes.module.plan.service.customplatenorule;
import com.cf.imes.module.executor.api.customplateno.dto.CustomPlateNoRuleDTO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoRuleVO;
/**
* 自定义板编号生成规则服务
*
* @author Gqr
* @since 2024/11/18 16:30
*/
public interface CustomPlateNoGenerateRuleService {
/**
* 是否匹配的规则编码
*
* @param ruleCode
* @return
*/
boolean match(String ruleCode);
/**
* 生成编号
*
* @param orderId 生产单号
* @param plateNoRule 生成规则
* @param generateConfig 生成所需要的配置
* @param plateDO 板材列表
* @param firstPlate 是否循环的第一块板，只有第一块板需要做是否跨单判断，后续都是一个单内
* @return 生成后改变的配置
*/
CustomPlateNoGenerateConfigVO generateNo(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate);
/**
* 左补零
*
* @param curr 当前值
* @param plateNoRule 生成规则
* @return
*/
default String fillZero(int curr, CustomPlateNoRuleVO plateNoRule) {
boolean leftFillZero = plateNoRule.isLeftFillZero();
Integer length = plateNoRule.getLength();
if (leftFillZero) {
return String.format("%0" + length + "d", curr);
}
return String.valueOf(curr);
}
/**
* 复位
*
* @param ruleDTO
*/
void reset(CustomPlateNoRuleDTO ruleDTO);
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplatenorule/OrderNoGenerateRuleServiceImpl.java
+229
View File
@@ -0,0 +1,229 @@
package com.cf.imes.module.plan.service.customplatenorule;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.cf.imes.framework.common.exception.util.ServiceExceptionUtil;
import com.cf.imes.framework.common.util.json.JsonUtils;
import com.cf.imes.framework.organ.core.context.OrganContextHolder;
import com.cf.imes.module.executor.api.customplateno.dto.CustomPlateNoRuleDTO;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.dal.mysql.order.OrderMapper;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoRuleVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqVO;
import com.cf.imes.module.system.api.customplateno.dto.CustomPlateNoSeqDTO;
import com.cf.imes.module.system.enums.customplateno.CustomPlateNoRuleCodeEnum;
import com.cf.imes.module.system.enums.customplateno.ResetModeEnum;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Optional;
import static com.cf.imes.module.executor.enums.ErrorCodeConstants.CUSTOM_PLATENO_GENERATE_ORDERNO_RULE_NOT_SUPPORT_RESETMODE;
/**
* 生产单序号生成规则服务实现类
*
* @author Gqr
* @since 2024/11/18 17:18
*/
@Service("orderNoGenerateRuleService")
public class OrderNoGenerateRuleServiceImpl implements CustomPlateNoGenerateRuleService {
private static final DateTimeFormatter YEAR_FORMATTER = DateTimeFormatter.ofPattern("yyyy");
private static final DateTimeFormatter MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyyMM");
private static final DateTimeFormatter DAY_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
@Resource
private OrderMapper orderMapper;
@Override
public boolean match(String ruleCode) {
return ObjectUtil.equal(CustomPlateNoRuleCodeEnum.ORDERNO.getRuleCode(), ruleCode);
}
/**
* 初始化生成所需配置
*
* @param generateConfigVO
*/
private static void initConfig(CustomPlateNoGenerateConfigVO generateConfigVO) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfigVO.getOrderCustomPlateNoSeqVO();
if (ObjectUtil.isNull(orderCustomPlateNoSeqVO)) {
orderCustomPlateNoSeqVO = new OrderCustomPlateNoSeqVO();
generateConfigVO.setOrderCustomPlateNoSeqVO(orderCustomPlateNoSeqVO);
}
}
@Override
public CustomPlateNoGenerateConfigVO generateNo(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate) {
// 初始化配置
initConfig(generateConfig);
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
Integer orderNoSeq = orderCustomPlateNoSeqVO.getOrderNoSeq();
// 当前导入已有序号的，生产单内生产单序号不会再变直接用
if (ObjectUtil.isNotNull(orderNoSeq)) {
// 补零
String noPartAfterFill = this.fillZero(orderNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFill);
return generateConfig;
}
// 机构下的自定义板编号序号
CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO = generateConfig.getOrgCustomPlateNoSeqRespDTO();
// 获取当前序号值
int currOrderNoSeq = Optional.ofNullable(orgCustomPlateNoSeqRespDTO.getOrderNoSeq()).orElse(plateNoRule.getInitValue() - plateNoRule.getIncrementStep());
// 上次导入的生产单号
Long lastOrderNo = orgCustomPlateNoSeqRespDTO.getLastOrderNo();
if (firstPlate && (ObjectUtil.isNull(lastOrderNo) || ObjectUtil.notEqual(orderId, lastOrderNo))) {
// 根据复位模式计算序号
currOrderNoSeq = generateNoByResetMode(currOrderNoSeq, ResetModeEnum.getByMode(plateNoRule.getResetMode()), plateNoRule, orgCustomPlateNoSeqRespDTO);
}
// 补零
String noPartAfterFill = this.fillZero(currOrderNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFill);
// 累加后的值同步到当前生产单序号和机构序号中
orderCustomPlateNoSeqVO.setOrderNoSeq(currOrderNoSeq);
orgCustomPlateNoSeqRespDTO.setOrderNoSeq(currOrderNoSeq);
return generateConfig;
}
@Override
public void reset(CustomPlateNoRuleDTO ruleDTO) {
// 查询所有使用当前配置id的生产单列表
Long configId = ruleDTO.getConfigId();
List<OrderDO> orderDOS = orderMapper.selectList(
new LambdaQueryWrapper<OrderDO>().eq(OrderDO::getCustomPlatenoConfigId, configId).eq(OrderDO::getOrganId, OrganContextHolder.getOrganId()));
// 更新生产单的序号
for (OrderDO orderDO : orderDOS) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = JSON.parseObject(orderDO.getCustomPlatenoSeq(), OrderCustomPlateNoSeqVO.class);
if (ObjectUtil.isNotNull(orderCustomPlateNoSeqVO)) {
orderCustomPlateNoSeqVO.setOrderNoSeq(null);
orderMapper.update(new LambdaUpdateWrapper<OrderDO>().eq(OrderDO::getId, orderDO.getId()).set(OrderDO::getCustomPlatenoSeq, JsonUtils.zipString(JSON.toJSONString(orderCustomPlateNoSeqVO))));
}
}
}
/**
* 基于复位模式的板编号生成
*
* @param orderNoSeq
* @param resetModeEnum
* @param plateNoRule
* @param orgCustomPlateNoSeqRespDTO
* @return 循环累加后的序号
*/
private int generateNoByResetMode(int orderNoSeq, ResetModeEnum resetModeEnum, CustomPlateNoRuleVO plateNoRule, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO) {
// 根据不同复位模式生成序号
if (ObjectUtil.equal(ResetModeEnum.DIGIT, resetModeEnum)) {
orderNoSeq = resetByLength(orderNoSeq, plateNoRule);
} else if (ObjectUtil.equal(ResetModeEnum.YEAR, resetModeEnum)) {
orderNoSeq = resetByYear(orderNoSeq, orgCustomPlateNoSeqRespDTO, plateNoRule);
} else if (ObjectUtil.equal(ResetModeEnum.MONTH, resetModeEnum)) {
orderNoSeq = resetByMonth(orderNoSeq, orgCustomPlateNoSeqRespDTO, plateNoRule);
} else if (ObjectUtil.equal(ResetModeEnum.DAY, resetModeEnum)) {
orderNoSeq = resetByDay(orderNoSeq, orgCustomPlateNoSeqRespDTO, plateNoRule);
} else {
throw ServiceExceptionUtil.exception(CUSTOM_PLATENO_GENERATE_ORDERNO_RULE_NOT_SUPPORT_RESETMODE, plateNoRule.getResetMode());
}
return orderNoSeq;
}
/**
* 按位数复位
*
* @param curr 当前值
* @param plateNoRule 规则配置
*/
private int resetByLength(int curr, CustomPlateNoRuleVO plateNoRule) {
// 位数下的最大值 10的length次方-1
int maxNum = (int) (Math.pow(10, plateNoRule.getLength()) - 1);
// 加上步长后的下一个序号
int nextValue = curr + plateNoRule.getIncrementStep();
// 超过最大值复位到初始值，没超过就继续下一个
if (nextValue > maxNum) {
return plateNoRule.getInitValue();
} else {
return nextValue;
}
}
/**
* 按年复位
*
* @param curr
* @param orgCustomPlateNoSeqRespDTO
* @param plateNoRule
* @return
*/
private int resetByYear(int curr, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO, CustomPlateNoRuleVO plateNoRule) {
// 上一次的年
Integer lastYear = orgCustomPlateNoSeqRespDTO.getLastYear();
// 初始值
Integer initValue = plateNoRule.getInitValue();
String nowYearFormat = plateNoRule.getNow().format(YEAR_FORMATTER);
if (ObjectUtil.notEqual(String.valueOf(lastYear), nowYearFormat)) {
int nowDayNum = Integer.parseInt(nowYearFormat);
// 跨年，把上一次的年设成当前年，后续不再跨年
orgCustomPlateNoSeqRespDTO.setLastYear(nowDayNum);
// 复位
return initValue;
}
return curr + plateNoRule.getIncrementStep();
}
/**
* 按月复位
*
* @param curr
* @param orgCustomPlateNoSeqRespDTO
* @param plateNoRule
* @return
*/
private int resetByMonth(int curr, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO, CustomPlateNoRuleVO plateNoRule) {
// 上一次的月
Integer lastMonth = orgCustomPlateNoSeqRespDTO.getLastMonth();
// 初始值
Integer initValue = plateNoRule.getInitValue();
String nowMonthFormat = plateNoRule.getNow().format(MONTH_FORMATTER);
if (ObjectUtil.notEqual(String.valueOf(lastMonth), nowMonthFormat)) {
int nowDayNum = Integer.parseInt(nowMonthFormat);
// 跨月，把上一次的月设成当前月，后续不再跨月
orgCustomPlateNoSeqRespDTO.setLastMonth(nowDayNum);
// 复位
return initValue;
}
return curr + plateNoRule.getIncrementStep();
}
/**
* 按天复位
*
* @param curr
* @param orgCustomPlateNoSeqRespDTO
* @param plateNoRule
* @return
*/
private int resetByDay(int curr, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO, CustomPlateNoRuleVO plateNoRule) {
// 上一次的天
Integer lastDay = orgCustomPlateNoSeqRespDTO.getLastDay();
// 初始值
Integer initValue = plateNoRule.getInitValue();
String nowDayFormat = plateNoRule.getNow().format(DAY_FORMATTER);
if (ObjectUtil.notEqual(String.valueOf(lastDay), nowDayFormat)) {
int nowDayNum = Integer.parseInt(nowDayFormat);
// 跨月，把上一次的月设成当前月，后续不再跨月
orgCustomPlateNoSeqRespDTO.setLastDay(nowDayNum);
// 复位
return initValue;
}
return curr + plateNoRule.getIncrementStep();
}
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplatenorule/PlateNoGenerateRuleServiceImpl.java
+387
View File
@@ -0,0 +1,387 @@
package com.cf.imes.module.plan.service.customplatenorule;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.cf.imes.framework.common.exception.util.ServiceExceptionUtil;
import com.cf.imes.framework.common.util.json.JsonUtils;
import com.cf.imes.framework.organ.core.context.OrganContextHolder;
import com.cf.imes.module.executor.api.customplateno.dto.CustomPlateNoRuleDTO;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.dal.mysql.order.OrderMapper;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoRuleVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqBodyVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqRoomVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqVO;
import com.cf.imes.module.system.api.customplateno.dto.CustomPlateNoSeqDTO;
import com.cf.imes.module.system.enums.customplateno.CustomPlateNoRuleCodeEnum;
import com.cf.imes.module.system.enums.customplateno.ResetModeEnum;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static com.cf.imes.module.executor.enums.ErrorCodeConstants.CUSTOM_PLATENO_GENERATE_PLATE_RULE_NOT_SUPPORT_RESETMODE;
/**
* @author Gqr
* @since 2024/11/20 15:28
*/
@Service("plateNoGenerateRuleService")
public class PlateNoGenerateRuleServiceImpl implements CustomPlateNoGenerateRuleService {
private static final DateTimeFormatter YEAR_FORMATTER = DateTimeFormatter.ofPattern("yyyy");
private static final DateTimeFormatter MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyyMM");
private static final DateTimeFormatter DAY_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
@Resource
private OrderMapper orderMapper;
@Override
public boolean match(String ruleCode) {
return ObjectUtil.equal(CustomPlateNoRuleCodeEnum.PLATENO.getRuleCode(), ruleCode);
}
/**
* 初始化生成所需配置
*
* @param generateConfigVO
*/
private void initConfig(CustomPlateNoGenerateConfigVO generateConfigVO) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfigVO.getOrderCustomPlateNoSeqVO();
if (ObjectUtil.isNull(orderCustomPlateNoSeqVO)) {
orderCustomPlateNoSeqVO = new OrderCustomPlateNoSeqVO();
generateConfigVO.setOrderCustomPlateNoSeqVO(orderCustomPlateNoSeqVO);
}
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
if (CollUtil.isEmpty(rooms)) {
rooms = new ArrayList<>();
orderCustomPlateNoSeqVO.setRooms(rooms);
}
}
@Override
public CustomPlateNoGenerateConfigVO generateNo(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate) {
// 初始化配置
initConfig(generateConfig);
// 按复位模式走不同的生成方式
ResetModeEnum resetModeEnum = ResetModeEnum.getByMode(plateNoRule.getResetMode());
if (ObjectUtil.equal(ResetModeEnum.ORDER, resetModeEnum)) {
return generateNoByOrderResetMode(orderId, plateNoRule, generateConfig, plateDO, firstPlate);
} else if (ObjectUtil.equal(ResetModeEnum.ROOM, resetModeEnum)) {
return generateNoByRoomResetMode(plateNoRule, generateConfig, plateDO);
} else if (ObjectUtil.equal(ResetModeEnum.BODY, resetModeEnum)) {
return generateNoByBodyResetMode(plateNoRule, generateConfig, plateDO);
} else if (ObjectUtil.equal(ResetModeEnum.YEAR, resetModeEnum) || ObjectUtil.equal(ResetModeEnum.MONTH, resetModeEnum) || ObjectUtil.equal(ResetModeEnum.DAY, resetModeEnum)) {
return generateNoByDateResetMode(resetModeEnum, plateNoRule, generateConfig, plateDO);
} else {
throw ServiceExceptionUtil.exception(CUSTOM_PLATENO_GENERATE_PLATE_RULE_NOT_SUPPORT_RESETMODE, plateNoRule.getResetMode());
}
}
@Override
public void reset(CustomPlateNoRuleDTO ruleDTO) {
// 查询所有使用当前配置id的生产单列表
Long configId = ruleDTO.getConfigId();
List<OrderDO> orderDOS = orderMapper.selectList(
new LambdaQueryWrapper<OrderDO>().eq(OrderDO::getCustomPlatenoConfigId, configId).eq(OrderDO::getOrganId, OrganContextHolder.getOrganId()));
ResetModeEnum resetModeEnum = ResetModeEnum.getByMode(ruleDTO.getResetMode());
// 根据复位模式更新生产单的序号
for (OrderDO orderDO : orderDOS) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = JSON.parseObject(orderDO.getCustomPlatenoSeq(), OrderCustomPlateNoSeqVO.class);
if (ObjectUtil.isNotNull(orderCustomPlateNoSeqVO)) {
if (ObjectUtil.equal(ResetModeEnum.ORDER, resetModeEnum)) {
orderCustomPlateNoSeqVO.setPlateNoSeq(null);
} else if (ObjectUtil.equal(ResetModeEnum.ROOM, resetModeEnum)) {
resetRoomPlateSeq(orderCustomPlateNoSeqVO.getRooms());
} else if (ObjectUtil.equal(ResetModeEnum.BODY, resetModeEnum)) {
resetBodyPlateSeq(orderCustomPlateNoSeqVO.getRooms());
}
orderMapper.update(new LambdaUpdateWrapper<OrderDO>().eq(OrderDO::getId, orderDO.getId()).set(OrderDO::getCustomPlatenoSeq, JsonUtils.zipString(JSON.toJSONString(orderCustomPlateNoSeqVO))));
}
}
}
/**
* 复位生产单下房间中的板件序号
*
* @param rooms
*/
private void resetRoomPlateSeq(List<OrderCustomPlateNoSeqRoomVO> rooms) {
if (CollUtil.isNotEmpty(rooms)) {
for (OrderCustomPlateNoSeqRoomVO roomVO : rooms) {
roomVO.setPlateNoSeq(null);
}
}
}
/**
* 复位生产单下柜体中的板件序号
*
* @param rooms
*/
private void resetBodyPlateSeq(List<OrderCustomPlateNoSeqRoomVO> rooms) {
if (CollUtil.isNotEmpty(rooms)) {
for (OrderCustomPlateNoSeqRoomVO roomVO : rooms) {
List<OrderCustomPlateNoSeqBodyVO> bodys = roomVO.getBodys();
if (CollUtil.isNotEmpty(bodys)) {
for (OrderCustomPlateNoSeqBodyVO bodyVO : bodys) {
bodyVO.setPlateNoSeq(null);
}
}
}
}
}
/**
* 按年/月/日复位模式下的板编号生成
*/
private CustomPlateNoGenerateConfigVO generateNoByDateResetMode(ResetModeEnum resetModeEnum, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO) {
// 机构下的自定义板编号序号
CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO = generateConfig.getOrgCustomPlateNoSeqRespDTO();
// 从全局配置获取当前序号，取不到用初始值
Integer orderNoSeq = orgCustomPlateNoSeqRespDTO.getPlateNoSeq();
if (ObjectUtil.isNull(orderNoSeq)) {
orderNoSeq = plateNoRule.getInitValue() - plateNoRule.getIncrementStep();
}
if (ObjectUtil.equal(ResetModeEnum.YEAR, resetModeEnum)) {
orderNoSeq = resetByYear(orderNoSeq, orgCustomPlateNoSeqRespDTO, plateNoRule);
} else if (ObjectUtil.equal(ResetModeEnum.MONTH, resetModeEnum)) {
orderNoSeq = resetByMonth(orderNoSeq, orgCustomPlateNoSeqRespDTO, plateNoRule);
} else if (ObjectUtil.equal(ResetModeEnum.DAY, resetModeEnum)) {
orderNoSeq = resetByDay(orderNoSeq, orgCustomPlateNoSeqRespDTO, plateNoRule);
}
// 补零
String noPartAfterFillZero = fillZero(orderNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFillZero);
orgCustomPlateNoSeqRespDTO.setPlateNoSeq(orderNoSeq);
return generateConfig;
}
/**
* 按生产单复位模式下的板编号生成
*
* @param orderId
* @param plateNoRule
* @param generateConfig
* @param plateDO
*/
private CustomPlateNoGenerateConfigVO generateNoByOrderResetMode(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate) {
Integer incrementStep = plateNoRule.getIncrementStep();
Integer initValue = plateNoRule.getInitValue() - incrementStep;
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
// 机构下的自定义板编号序号
CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO = generateConfig.getOrgCustomPlateNoSeqRespDTO();
// 获取当前生产单下板件序号
Integer orderPlateNoSeq = Optional.ofNullable(orderCustomPlateNoSeqVO.getPlateNoSeq()).orElse(initValue);
// 上次导入的生产单号
Long lastOrderNo = orgCustomPlateNoSeqRespDTO.getLastOrderNo();
if (firstPlate && (ObjectUtil.isNull(lastOrderNo) || ObjectUtil.notEqual(orderId, lastOrderNo))) {
// 跨单复位到初始值
orderPlateNoSeq = initValue;
}
// 跨板件累加步长，补零
orderPlateNoSeq += incrementStep;
plateDO.getCustomPlateNoBuilder().append(fillZero(orderPlateNoSeq, plateNoRule));
// 累加后的值同步到当前生产单序号中
orderCustomPlateNoSeqVO.setPlateNoSeq(orderPlateNoSeq);
return generateConfig;
}
/**
* 按房间复位模式下的板编号生成
*
* @param plateNoRule
* @param generateConfig
* @param plateDO
* @return
*/
private CustomPlateNoGenerateConfigVO generateNoByRoomResetMode(CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO) {
Integer incrementStep = plateNoRule.getIncrementStep();
Integer initValue = plateNoRule.getInitValue() - incrementStep;
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
String roomName = plateDO.getRoomName();
// 根据房间名获取生产单下序号json中的房间下的加工组序号
OrderCustomPlateNoSeqRoomVO roomSeqVo = getSeqRoomByRoomName(roomName, rooms);
// 为空初始化，加入列表
if (roomSeqVo == null) {
roomSeqVo = OrderCustomPlateNoSeqRoomVO.builder()
.roomName(roomName)
.bodys(new ArrayList<>())
.build();
rooms.add(roomSeqVo);
}
// 获取当前房间下板件序号
// 累加步长
Integer roomPlateNoSeq = Optional.ofNullable(roomSeqVo.getPlateNoSeq())
.orElse(initValue) + incrementStep;
// 累加后的值同步到当前生产单序号中
roomSeqVo.setPlateNoSeq(roomPlateNoSeq);
// 补零
plateDO.getCustomPlateNoBuilder().append(fillZero(roomPlateNoSeq, plateNoRule));
return generateConfig;
}
/**
* 根据房间名从生产单序号json中获取房间序号列表
*
* @param roomName
* @param roomVOList
* @return
*/
private OrderCustomPlateNoSeqRoomVO getSeqRoomByRoomName(String roomName, List<OrderCustomPlateNoSeqRoomVO> roomVOList) {
return roomVOList.stream().filter(roomVO -> ObjectUtil.equal(roomName, roomVO.getRoomName())).findAny().orElse(null);
}
/**
* 按柜体复位模式下的板编号生成
*
* @param plateNoRule
* @param generateConfig
* @param plateDO
* @return
*/
private CustomPlateNoGenerateConfigVO generateNoByBodyResetMode(CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO) {
Integer incrementStep = plateNoRule.getIncrementStep();
Integer initValue = plateNoRule.getInitValue() - incrementStep;
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
String roomName = plateDO.getRoomName();
// 根据房间名获取生产单下序号json中的房间下的加工组序号
OrderCustomPlateNoSeqRoomVO roomSeqVo = getSeqRoomByRoomName(roomName, rooms);
if (ObjectUtil.isNull(roomSeqVo)) {
// 房间为空，new房间
roomSeqVo = OrderCustomPlateNoSeqRoomVO.
builder()
.roomName(roomName)
.bodys(new ArrayList<>())
.build();
rooms.add(roomSeqVo);
}
String bodyName = plateDO.getBodyName();
// 根据柜体名获取生产单下序号json中的房间下的加工组序号
OrderCustomPlateNoSeqBodyVO bodySeqVO = getBodySeqByBodyName(bodyName, roomSeqVo);
if (bodySeqVO == null) {
// 柜体为空，new柜体
bodySeqVO = OrderCustomPlateNoSeqBodyVO.builder()
.bodyName(bodyName)
.build();
roomSeqVo.getBodys().add(bodySeqVO);
}
// 累加步长
// 获取柜体下的板件序号
Integer bodyPlateNoSeq = Optional.ofNullable(bodySeqVO.getPlateNoSeq()).orElse(initValue) + incrementStep;
// 累加后的值同步到当前生产单序号中
bodySeqVO.setPlateNoSeq(bodyPlateNoSeq);
// 补零
String noPartAfterFillZero = fillZero(bodyPlateNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFillZero);
return generateConfig;
}
/**
* 根据房间名从生产单序号json中获取房间序号列表
*
* @param bodyName
* @param roomVO
* @return
*/
private OrderCustomPlateNoSeqBodyVO getBodySeqByBodyName(String bodyName, OrderCustomPlateNoSeqRoomVO roomVO) {
List<OrderCustomPlateNoSeqBodyVO> bodys = roomVO.getBodys();
if (ObjectUtil.isNotNull(bodys)) {
for (OrderCustomPlateNoSeqBodyVO bodyVO : bodys) {
if (ObjectUtil.equal(bodyVO.getBodyName(), bodyName)) {
return bodyVO;
}
}
} else {
bodys = new ArrayList<>();
roomVO.setBodys(bodys);
}
return null;
}
/**
* 按年复位
*
* @param curr
* @param orgCustomPlateNoSeqRespDTO
* @param plateNoRule
* @return
*/
private int resetByYear(int curr, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO, CustomPlateNoRuleVO plateNoRule) {
// 上一次的年
Integer lastYear = orgCustomPlateNoSeqRespDTO.getLastYear();
Integer initValue = plateNoRule.getInitValue();
String nowYearFormat = plateNoRule.getNow().format(YEAR_FORMATTER);
if (ObjectUtil.notEqual(String.valueOf(lastYear), nowYearFormat)) {
// 跨年，把上一次的年设成当前年，后续不再跨年
orgCustomPlateNoSeqRespDTO.setLastYear(Integer.parseInt(nowYearFormat));
// 复位
return initValue;
}
return curr + plateNoRule.getIncrementStep();
}
/**
* 按月复位
*
* @param curr
* @param orgCustomPlateNoSeqRespDTO
* @param plateNoRule
* @return
*/
private int resetByMonth(int curr, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO, CustomPlateNoRuleVO plateNoRule) {
// 上一次的月
Integer lastMonth = orgCustomPlateNoSeqRespDTO.getLastMonth();
Integer initValue = plateNoRule.getInitValue();
String nowMonthFormat = plateNoRule.getNow().format(MONTH_FORMATTER);
if (ObjectUtil.notEqual(String.valueOf(lastMonth), nowMonthFormat)) {
// 跨月，把上一次的月设成当前月，后续不再跨月
orgCustomPlateNoSeqRespDTO.setLastMonth(Integer.parseInt(nowMonthFormat));
// 复位
return initValue;
}
return curr + plateNoRule.getIncrementStep();
}
/**
* 按天复位
*
* @param curr
* @param orgCustomPlateNoSeqRespDTO
* @param plateNoRule
* @return
*/
private int resetByDay(int curr, CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO, CustomPlateNoRuleVO plateNoRule) {
// 上一次的天
Integer lastDay = orgCustomPlateNoSeqRespDTO.getLastDay();
Integer initValue = plateNoRule.getInitValue();
String nowDayFormat = plateNoRule.getNow().format(DAY_FORMATTER);
if (ObjectUtil.notEqual(String.valueOf(lastDay), nowDayFormat)) {
// 跨月，把上一次的月设成当前月，后续不再跨月
orgCustomPlateNoSeqRespDTO.setLastDay(Integer.parseInt(nowDayFormat));
// 复位
return initValue;
}
return curr + plateNoRule.getIncrementStep();
}
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/customplatenorule/RoomNoGenerateRuleServiceImpl.java
+142
View File
@@ -0,0 +1,142 @@
package com.cf.imes.module.plan.service.customplatenorule;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.cf.imes.framework.common.util.json.JsonUtils;
import com.cf.imes.framework.organ.core.context.OrganContextHolder;
import com.cf.imes.module.executor.api.customplateno.dto.CustomPlateNoRuleDTO;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.plate.PlateDO;
import com.cf.imes.module.plan.dal.mysql.order.OrderMapper;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoRuleVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqRoomVO;
import com.cf.imes.module.plan.service.customplateno.vo.OrderCustomPlateNoSeqVO;
import com.cf.imes.module.system.api.customplateno.dto.CustomPlateNoSeqDTO;
import com.cf.imes.module.system.enums.customplateno.CustomPlateNoRuleCodeEnum;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
/**
* 房间序号生成规则服务实现类
*
* @author Gqr
* @since 2024/11/19 13:41
*/
@Service("roomNoGenerateRuleService")
public class RoomNoGenerateRuleServiceImpl implements CustomPlateNoGenerateRuleService {
@Resource
private OrderMapper orderMapper;
@Override
public boolean match(String ruleCode) {
return ObjectUtil.equal(CustomPlateNoRuleCodeEnum.ROOMNO.getRuleCode(), ruleCode);
}
/**
* 初始化生成所需配置
*
* @param generateConfigVO
*/
private static void initConfig(CustomPlateNoGenerateConfigVO generateConfigVO) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfigVO.getOrderCustomPlateNoSeqVO();
if (ObjectUtil.isNull(orderCustomPlateNoSeqVO)) {
orderCustomPlateNoSeqVO = new OrderCustomPlateNoSeqVO();
generateConfigVO.setOrderCustomPlateNoSeqVO(orderCustomPlateNoSeqVO);
}
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
if (CollUtil.isEmpty(rooms)) {
rooms = new ArrayList<>();
orderCustomPlateNoSeqVO.setRooms(rooms);
}
}
@Override
public CustomPlateNoGenerateConfigVO generateNo(Long orderId, CustomPlateNoRuleVO plateNoRule, CustomPlateNoGenerateConfigVO generateConfig, PlateDO plateDO, boolean firstPlate) {
Integer incrementStep = plateNoRule.getIncrementStep();
Integer initValue = plateNoRule.getInitValue() - incrementStep;
// 初始化配置
initConfig(generateConfig);
// 生产单下的序号
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = generateConfig.getOrderCustomPlateNoSeqVO();
// 机构下的自定义板编号序号
CustomPlateNoSeqDTO orgCustomPlateNoSeqRespDTO = generateConfig.getOrgCustomPlateNoSeqRespDTO();
// 生产单下房间序号
Integer orderRoomNoSeq = Optional.ofNullable(orderCustomPlateNoSeqVO.getRoomNoSeq()).orElse(initValue);
// 生产单序号下的的房间序号列表
List<OrderCustomPlateNoSeqRoomVO> rooms = orderCustomPlateNoSeqVO.getRooms();
// 上次导入的生产单号
Long lastOrderNo = orgCustomPlateNoSeqRespDTO.getLastOrderNo();
if (firstPlate && (ObjectUtil.isNull(lastOrderNo) || ObjectUtil.notEqual(orderId, lastOrderNo))) {
// 跨单复位到初始值
orderRoomNoSeq = initValue;
}
String roomName = plateDO.getRoomName();
// 根据房间名获取生产单下序号json中的房间下的柜体序号
OrderCustomPlateNoSeqRoomVO roomSeqVo = getRoomSeqVOByRoomName(roomName, rooms);
// 获取当前房间序号值
Integer roomNoSeq = Optional.ofNullable(roomSeqVo).map(OrderCustomPlateNoSeqRoomVO::getRoomNoSeq).orElse(null);
if (roomSeqVo == null) {
// 房间为空，新建房间，取生产单下房间序号
roomSeqVo = OrderCustomPlateNoSeqRoomVO.builder()
.roomName(roomName)
.bodys(new ArrayList<>())
.build();
rooms.add(roomSeqVo);
// 累加步长
roomNoSeq = orderRoomNoSeq + incrementStep;
// 累加后的值同步到当前生产单序号中，生产单下房间序号累加到多少了
orderCustomPlateNoSeqVO.setRoomNoSeq(roomNoSeq);
} else if (roomNoSeq == null) {
// 房间下序号为空，取生产单下房间序号
// 累加步长
roomNoSeq = orderRoomNoSeq + incrementStep;
// 累加后的值同步到当前生产单序号中，生产单下房间序号累加到多少了
orderCustomPlateNoSeqVO.setRoomNoSeq(roomNoSeq);
}
// 补零
String noPartAfterFillZero = fillZero(roomNoSeq, plateNoRule);
plateDO.getCustomPlateNoBuilder().append(noPartAfterFillZero);
// 累加后同步到json：房间下累加到多少了
roomSeqVo.setRoomNoSeq(roomNoSeq);
return generateConfig;
}
@Override
public void reset(CustomPlateNoRuleDTO ruleDTO) {
// 查询所有使用当前配置id的生产单列表
Long configId = ruleDTO.getConfigId();
List<OrderDO> orderDOS = orderMapper.selectList(
new LambdaQueryWrapper<OrderDO>().eq(OrderDO::getCustomPlatenoConfigId, configId).eq(OrderDO::getOrganId, OrganContextHolder.getOrganId()));
// 更新生产单的序号
for (OrderDO orderDO : orderDOS) {
OrderCustomPlateNoSeqVO orderCustomPlateNoSeqVO = JSON.parseObject(orderDO.getCustomPlatenoSeq(), OrderCustomPlateNoSeqVO.class);
if (ObjectUtil.isNotNull(orderCustomPlateNoSeqVO)) {
orderCustomPlateNoSeqVO.setRoomNoSeq(null);
orderMapper.update(new LambdaUpdateWrapper<OrderDO>().eq(OrderDO::getId, orderDO.getId()).set(OrderDO::getCustomPlatenoSeq, JsonUtils.zipString(JSON.toJSONString(orderCustomPlateNoSeqVO))));
}
}
}
/**
* 根据房间名从生产单序号json中获取房间序号列表
*
* @param roomName
* @param roomVOList
* @return
*/
private OrderCustomPlateNoSeqRoomVO getRoomSeqVOByRoomName(String roomName, List<OrderCustomPlateNoSeqRoomVO> roomVOList) {
return roomVOList.stream().filter(roomVO -> ObjectUtil.equal(roomName, roomVO.getRoomName())).findAny().orElse(null);
}
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/orderImport/consumer/DefaultExcelOrderImportConsumer.java
+10 -6
View File
@@ -12,6 +12,7 @@ import com.cf.imes.framework.id.core.util.SnowflakeIdWorker3rd;
import com.cf.imes.module.executor.enums.OrderStatusEnum;
import com.cf.imes.module.plan.dal.mysql.orderParts.PartsMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateGoodMapper;
import com.cf.imes.module.plan.service.customplateno.CustomPlateNoGenerateService;
import com.cf.imes.module.plan.service.order.OrderInputProcessor;
import com.cf.imes.module.plan.service.orderImport.factory.DefaultExcelOrderImportFactory;
import com.cf.imes.framework.mq.rabbitmq.constant.RabbitMqConstants;
@@ -114,6 +115,9 @@ public class DefaultExcelOrderImportConsumer {
@Resource
private PartsMapper partsMapper;
@Resource
private CustomPlateNoGenerateService customPlateNoGenerateService;
@RabbitListener(queues = RabbitMqConstants.ORDER_IMPORT_DEFAULT_EXCEL_QUEUE)
@DS("imes_prod")
@Transactional(rollbackFor = Exception.class)
@@ -132,12 +136,12 @@ public class DefaultExcelOrderImportConsumer {
return;
}
// 创建生产单
Long orderId = createOrder(taskId);
OrderDO orderDO = createOrder(taskId);
// 创建工厂
log.info("====================【生产单默认excel导入处理临时数据开始】====================");
DefaultExcelOrderImportFactory defaultExcelOrderImportFactory = new DefaultExcelOrderImportFactory(taskId, orderId, organId, orderImportTaskDO.getCreator(),
DefaultExcelOrderImportFactory defaultExcelOrderImportFactory = new DefaultExcelOrderImportFactory(taskId, orderDO, organId, orderImportTaskDO.getCreator(),
snowFlakeGenerator, idWorker, orderImportTaskMapper, orderImportTempDataMapper, dictDataApi, goodsMapper, rawGoodsMapper, orderPartsMapper,
orderBodyMapper, orderGroupMapper, plateMapper, orderItemMapper, plateGoodMapper, orderInputProcessor, partsMapper);
orderBodyMapper, orderGroupMapper, plateMapper, orderItemMapper, plateGoodMapper, orderInputProcessor, partsMapper, customPlateNoGenerateService);
// 解析临时表数据
defaultExcelOrderImportFactory.analyzeTempData();
log.info("====================【生产单默认excel导入处理临时数据结束】====================");
@@ -206,7 +210,7 @@ public class DefaultExcelOrderImportConsumer {
* @param taskId
* @return
*/
private Long createOrder(Long taskId) {
private OrderDO createOrder(Long taskId) {
// 查询临时表中的order
LambdaQueryWrapper<OrderImportTempDataDO> orderTempData = new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
@@ -221,7 +225,7 @@ public class DefaultExcelOrderImportConsumer {
Optional.ofNullable(orderDO).orElseThrow(() -> ServiceExceptionUtil.exception(ORDER_IMPORT_ORDER_NOT_EXISTS, existOrderId));
// 更新补板生产单属性
updateOrder(orderDO);
return existOrderId;
return orderDO;
}
// 取临时order数据，detail转orderDO，插入新增orderDO
String orderTempDetail = JsonUtils.unzipString(orderImportTempDataDO.getDetail());
@@ -233,7 +237,7 @@ public class DefaultExcelOrderImportConsumer {
orderImportTaskMapper.update(new LambdaUpdateWrapper<OrderImportTaskDO>()
.eq(OrderImportTaskDO::getId, taskId)
.set(OrderImportTaskDO::getOrderId, orderId));
return orderId;
return newOrder;
}
/**
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/orderImport/consumer/DefaultXmlOrderImportConsumer.java
+10 -6
View File
@@ -33,6 +33,7 @@ import com.cf.imes.module.plan.dal.mysql.orderParts.PartsMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateGoodMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateMapper;
import com.cf.imes.module.plan.dal.mysql.rawgoods.RawGoodsMapper;
import com.cf.imes.module.plan.service.customplateno.CustomPlateNoGenerateService;
import com.cf.imes.module.plan.service.order.OrderInputProcessor;
import com.cf.imes.module.plan.service.orderImport.factory.DefaultXmlOrderImportFactory;
import com.rabbitmq.client.Channel;
@@ -110,6 +111,9 @@ public class DefaultXmlOrderImportConsumer {
@Resource
private PartsMapper partsMapper;
@Resource
private CustomPlateNoGenerateService customPlateNoGenerateService;
@RabbitListener(queues = RabbitMqConstants.ORDER_IMPORT_DEFAULT_XML_QUEUE)
@DS("imes_prod")
@Transactional(rollbackFor = Exception.class)
@@ -128,12 +132,12 @@ public class DefaultXmlOrderImportConsumer {
return;
}
// 创建生产单
Long orderId = createOrder(taskId);
OrderDO orderDO = createOrder(taskId);
log.info("====================【生产单默认xml导入处理临时数据开始】====================");
// 创建工厂
DefaultXmlOrderImportFactory defaultExcelOrderImportFactory = new DefaultXmlOrderImportFactory(taskId, orderId, organId, orderImportTaskDO.getCreator(),
DefaultXmlOrderImportFactory defaultExcelOrderImportFactory = new DefaultXmlOrderImportFactory(taskId, orderDO, organId, orderImportTaskDO.getCreator(),
snowFlakeGenerator, idWorker, orderImportTaskMapper, orderImportTempDataMapper, goodsMapper, rawGoodsMapper, orderPartsMapper,
orderBodyMapper, orderGroupMapper, plateMapper, orderItemMapper, plateGoodMapper, orderInputProcessor, partsMapper);
orderBodyMapper, orderGroupMapper, plateMapper, orderItemMapper, plateGoodMapper, orderInputProcessor, partsMapper, customPlateNoGenerateService);
// 解析临时表数据
defaultExcelOrderImportFactory.analyzeTempData();
log.info("====================【生产单默认xml导入处理临时数据结束】====================");
@@ -202,7 +206,7 @@ public class DefaultXmlOrderImportConsumer {
* @param taskId
* @return
*/
private Long createOrder(Long taskId) {
private OrderDO createOrder(Long taskId) {
// 查询临时表中的order
LambdaQueryWrapper<OrderImportTempDataDO> orderTempData = new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
@@ -217,7 +221,7 @@ public class DefaultXmlOrderImportConsumer {
Optional.ofNullable(orderDO).orElseThrow(() -> ServiceExceptionUtil.exception(ORDER_IMPORT_ORDER_NOT_EXISTS, existOrderId));
// 更新补板生产单属性
updateOrder(orderDO);
return existOrderId;
return orderDO;
}
// 取临时order数据，detail转orderDO，插入新增orderDO
String orderTempDetail = JsonUtils.unzipString(orderImportTempDataDO.getDetail());
@@ -229,7 +233,7 @@ public class DefaultXmlOrderImportConsumer {
orderImportTaskMapper.update(new LambdaUpdateWrapper<OrderImportTaskDO>()
.eq(OrderImportTaskDO::getId, taskId)
.set(OrderImportTaskDO::getOrderId, orderId));
return orderId;
return newOrder;
}
/**
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/orderImport/factory/DefaultExcelOrderImportFactory.java
+200 -13
View File
@@ -10,6 +10,7 @@ import com.alibaba.fastjson.JSON;
import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cf.imes.framework.common.enums.OrderPlateTypeEnum;
import com.cf.imes.framework.common.exception.util.ServiceExceptionUtil;
import com.cf.imes.framework.common.util.json.JsonUtils;
@@ -28,6 +29,7 @@ import com.cf.imes.module.executor.enums.OrderItemTypeEnum;
import com.cf.imes.module.plan.controller.orderImport.vo.OrderImportTempDataReqVO;
import com.cf.imes.module.plan.controller.orderImport.vo.OrderPlateImportExcelVO;
import com.cf.imes.module.plan.dal.dataobject.goods.GoodsDO;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.orderBody.OrderBodyDO;
import com.cf.imes.module.plan.dal.dataobject.orderGroup.OrderGroupDO;
import com.cf.imes.module.plan.dal.dataobject.orderImport.OrderImportTaskDO;
@@ -53,10 +55,14 @@ import com.cf.imes.module.plan.dal.mysql.orderParts.PartsMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateGoodMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateMapper;
import com.cf.imes.module.plan.dal.mysql.rawgoods.RawGoodsMapper;
import com.cf.imes.module.plan.service.customplateno.CustomPlateNoGenerateService;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.order.OrderInputProcessor;
import com.cf.imes.module.system.api.dict.DictDataApi;
import com.cf.imes.module.system.api.dict.dto.DictDataRespDTO;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.ResultContext;
import org.apache.ibatis.session.ResultHandler;
import java.math.BigDecimal;
import java.math.RoundingMode;
@@ -87,6 +93,13 @@ public class DefaultExcelOrderImportFactory {
private Long taskId;
private OrderDO orderDO;
private CustomPlateNoGenerateConfigVO plateNoGenerateConfigVO;
// 是否入库的第一块板件
private boolean isFirstPlate;
private List<RawGoodsDO> rawGoodsDOS = ListUtils.newArrayListWithExpectedSize(BATCH_THRESHOLD_NUMBER);
private List<GoodsDO> goodsDOS = ListUtils.newArrayListWithExpectedSize(BATCH_THRESHOLD_NUMBER);
private List<OrderPartsDO> orderPartsDOS = ListUtils.newArrayListWithExpectedSize(BATCH_THRESHOLD_NUMBER);
@@ -137,8 +150,10 @@ public class DefaultExcelOrderImportFactory {
private String operatorName;
private CustomPlateNoGenerateService customPlateNoGenerateService;
public DefaultExcelOrderImportFactory(Long taskId,
Long orderId,
OrderDO orderDO,
Long organId,
String operatorName,
SnowFlakeGenerator snowFlakeGenerator,
@@ -155,9 +170,11 @@ public class DefaultExcelOrderImportFactory {
OrderItemMapper orderItemMapper,
PlateGoodMapper plateGoodMapper,
OrderInputProcessor orderInputProcessor,
PartsMapper partsMapper) {
PartsMapper partsMapper,
CustomPlateNoGenerateService customPlateNoGenerateService) {
this.taskId = taskId;
this.orderId = orderId;
this.orderDO = orderDO;
this.orderId = orderDO.getId();
this.organId = organId;
this.operatorName = operatorName;
this.snowFlakeGenerator = snowFlakeGenerator;
@@ -175,6 +192,7 @@ public class DefaultExcelOrderImportFactory {
this.plateGoodMapper = plateGoodMapper;
this.orderInputProcessor = orderInputProcessor;
this.partsMapper = partsMapper;
this.customPlateNoGenerateService = customPlateNoGenerateService;
}
/**
@@ -182,6 +200,9 @@ public class DefaultExcelOrderImportFactory {
*/
public void analyzeTempData() {
try {
// 获取自定义板编号配置
plateNoGenerateConfigVO = customPlateNoGenerateService.getPlateNoGenerateConfig(orderId);
log.info("====================【生产单默认xml导入处理商品开始】====================");
// 解析商品数据
analyzeGoods();
@@ -196,6 +217,8 @@ public class DefaultExcelOrderImportFactory {
// 解析小板/配件项
analyzeRooms();
log.info("====================【生产单默认xml导入处理小板/配件结束】====================");
// 所有自定义板编号生成完成后更新配置到生产单
customPlateNoGenerateService.updateCustomPlateNoGenerateConfig(plateNoGenerateConfigVO, orderDO);
// 删除临时数据
deleteTempData();
@@ -643,16 +666,22 @@ public class DefaultExcelOrderImportFactory {
private void analyzeItem(OrderBodyDO orderBodyDO, String groupTypeName, String groupName, Long groupId) {
String roomName = orderBodyDO.getRoomName();
String bodyName = orderBodyDO.getName();
OrderImportTempDataReqVO groupNameListReqVO = OrderImportTempDataReqVO.builder().type(PLATE_TYPE).taskId(taskId).roomName(roomName).bodyName(orderBodyDO.getName()).groupTypeName(groupTypeName).groupName(groupName).build();
// 查询房间、柜体、加工组类型名称、加工组名称下的数量
int countGroupName = orderImportTempDataMapper.selectCountGroupName(groupNameListReqVO);
// 计算页码
int pageNum = PageUtil.totalPage(countGroupName, BATCH_THRESHOLD_NUMBER);
// 分页查询临时表
for (int page = 1; page <= pageNum; page++) {
OrderImportTempDataReqVO groupNamePageReqVO = groupNameListReqVO.setDoPaging(true).setOffset((page - 1) * BATCH_THRESHOLD_NUMBER).setSize(BATCH_THRESHOLD_NUMBER);
List<OrderImportTempDataDO> groupNameList = orderImportTempDataMapper.selectGroupNameList(groupNamePageReqVO);
for (OrderImportTempDataDO tempDataDO : groupNameList) {
Page<OrderImportTempDataDO> page = new Page<>(1, BATCH_THRESHOLD_NUMBER);
orderImportTempDataMapper.selectList(page, new LambdaQueryWrapperX<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, PLATE_TYPE)
.eq(OrderImportTempDataDO::getRoomName, roomName)
.eq(OrderImportTempDataDO::getBodyName, bodyName)
.eqIfPresent(OrderImportTempDataDO::getGroupTypeName, groupTypeName)
.eqIfPresent(OrderImportTempDataDO::getGroupName, groupName)
.eq(OrderImportTempDataDO::getOrganId, organId), new ResultHandler<>() {
int count = 0;
@Override
public void handleResult(ResultContext<? extends OrderImportTempDataDO> resultContext) {
OrderImportTempDataDO tempDataDO = resultContext.getResultObject();
int num = tempDataDO.getNum().intValue();
String detail = JsonUtils.unzipString(tempDataDO.getDetail());
OrderPlateImportExcelVO combination = JSON.parseObject(detail, OrderPlateImportExcelVO.class);
@@ -730,6 +759,10 @@ public class DefaultExcelOrderImportFactory {
LocalDateTime now = LocalDateTime.now();
plateDO.setCreateTime(now);
plateDO.setUpdateTime(now);
// 生成自定义板编号
generateCustomPlateNo(plateDO);
// 批量插入order_plate
plateDOS.add(plateDO);
orderInfoBatchInsertWithinThreshold(plateMapper, plateDOS, false);
@@ -775,6 +808,160 @@ public class DefaultExcelOrderImportFactory {
orderModelsBatchInsertWithinThreshold(false);
}
}
});
// OrderImportTempDataReqVO groupNameListReqVO = OrderImportTempDataReqVO.builder().type(PLATE_TYPE).taskId(taskId).roomName(roomName).bodyName(orderBodyDO.getName()).groupTypeName(groupTypeName).groupName(groupName).build();
// // 查询房间、柜体、加工组类型名称、加工组名称下的数量
// int countGroupName = orderImportTempDataMapper.selectCountGroupName(groupNameListReqVO);
// // 计算页码
// int pageNum = PageUtil.totalPage(countGroupName, BATCH_THRESHOLD_NUMBER);
// // 分页查询临时表
// for (int page = 1; page <= pageNum; page++) {
// OrderImportTempDataReqVO groupNamePageReqVO = groupNameListReqVO.setDoPaging(true).setOffset((page - 1) * BATCH_THRESHOLD_NUMBER).setSize(BATCH_THRESHOLD_NUMBER);
// List<OrderImportTempDataDO> groupNameList = orderImportTempDataMapper.selectGroupNameList(groupNamePageReqVO);
// for (OrderImportTempDataDO tempDataDO : groupNameList) {
// int num = tempDataDO.getNum().intValue();
// String detail = JsonUtils.unzipString(tempDataDO.getDetail());
// OrderPlateImportExcelVO combination = JSON.parseObject(detail, OrderPlateImportExcelVO.class);
// // 根据数量生成num个小板数据
// for (int i = 0; i < num; i++) {
// long plateNo = idWorker.nextId();
// long obtainingTime = idWorker.obtainingTime();
// long goodsId = Long.parseLong(tempDataDO.getInnerGoodsId());
// // 成品宽
// String width = combination.getWidth();
// // 成品长
// String height = combination.getHeight();
// // 计算面积
// BigDecimal area = BigDecimal.valueOf(Double.parseDouble(width))
// .multiply(BigDecimal.valueOf(Double.parseDouble(height)))
// .movePointLeft(6)
// .setScale(2, RoundingMode.HALF_UP);
// Long plateId = (Long) snowFlakeGenerator.nextId(null);
// // 排版面 纹路 开门方向转换
// DictDataRespDTO typographyDTO = dictDataApi.parseDictData(DictTypeConstants.TYPOGRAPHY_TYPE, combination.getTypographicFace()).getData();// 排版面
// DictDataRespDTO grainDTO = dictDataApi.parseDictData(DictTypeConstants.GRAIN_TYPE, combination.getTexture()).getData();// 纹路
// DictDataRespDTO doorDTO = dictDataApi.parseDictData(DictTypeConstants.DOOR_OPENING_DIRECTIONS, combination.getOpenDoorType()).getData();
//
// PlateDO plateDO = PlateDO.builder()
// .id(plateId)
// .orderId(orderId)
// .name(combination.getName())
// .plateNo(combination.getPlateNo())
// .type(OrderPlateTypeEnum.LAYERBOARD.getType())
// .goodsId(goodsId)
// .width(BigDecimal.valueOf(Double.parseDouble(width)))
// .plateNo(((obtainingTime) + Long.toString(plateNo).substring(2)))
// .height(BigDecimal.valueOf(Double.parseDouble(height)))
// .thickness(BigDecimal.valueOf(Double.parseDouble(combination.getThickness())))
// .splitWidth(BigDecimal.valueOf(NumberUtil.parseDouble(combination.getSplitWidth())))
// .splitHeight(BigDecimal.valueOf(NumberUtil.parseDouble(combination.getSplitHeight())))
// .splitThickness(BigDecimal.valueOf(Double.parseDouble(tempDataDO.getThickness())))
// .sealLeft(BigDecimal.valueOf(Double.parseDouble(combination.getSealLeft())))
// .sealRight(BigDecimal.valueOf(Double.parseDouble(combination.getSealRight())))
// .sealUp(BigDecimal.valueOf(Double.parseDouble(combination.getSealUp())))
// .sealDown(BigDecimal.valueOf(Double.parseDouble(combination.getSealDown())))
// .holeFace(Integer.valueOf(typographyDTO.getValue()))
// .texture(Integer.valueOf(grainDTO.getValue()))
// .area(area)
// .openDoorType(Integer.valueOf(doorDTO.getValue()))
// .isSpecialShaped(false)
// .isSculpt(false)
// .remark(remarkExtract(combination.remarkJSON()))
// .roomName(roomName)
// .bodyName(bodyName)
// .customPlateNoBuilder(new StringBuilder())
// .organId(organId)
// .holeArrange(0)
// .holeFace(0)
// .unregularPointCount(0)
// .frontHoleCount(0)
// .backHoleCount(0)
// .sideHoleCount(0)
// .frontModelCount(0)
// .backModelCount(0)
// .isDoor(false)
// .offsetX(BIG_ZERO)
// .offsetY(BIG_ZERO)
// .isArcAcross(false)
// .moduleTypeId(0L)
// .isRowHole(false)
// .isOptimized(false)
// .isCutted(0)
// .isCancel(false)
// .filterType(EMPTY_STRING)
// .deleted(false)
// .build();
// plateDO.setCreator(operatorName);
// plateDO.setUpdater(operatorName);
// LocalDateTime now = LocalDateTime.now();
// plateDO.setCreateTime(now);
// plateDO.setUpdateTime(now);
//
// // 生成自定义板编号
// generateCustomPlateNo(plateDO);
//
// // 批量插入order_plate
// plateDOS.add(plateDO);
// orderInfoBatchInsertWithinThreshold(plateMapper, plateDOS, false);
//
// OrderItemDO orderItemDO = OrderItemDO.builder()
// .orderId(orderId)
// .type(OrderItemTypeEnum.PLATE_ITEM.getStatus())
// .roomId(orderBodyDO.getRoomId())
// .bodyId(orderBodyDO.getId())
// .plateId(plateId)
// .num(1.0)
// .groupId(StringUtils.isNotEmpty(groupTypeName) ? groupId : 0L)
// .organId(organId)
// .packageId(0L)
// .partsId(0L)
// .build();
// // 批量插入order_item
// orderItemDOS.add(orderItemDO);
// orderInfoBatchInsertWithinThreshold(orderItemMapper, orderItemDOS, false);
//
// // 批量插入CAD板件信息
// OrderModelDO orderModelDO = OrderModelDO.builder()
// .orderId(orderId)
// .plateId(plateId)
// .typographicFace(Integer.valueOf(typographyDTO.getValue()))
// .texture(plateDO.getTexture())
// .openDoorType(plateDO.getOpenDoorType())
// .build();
//
// // 查询大板id用于小板轮廓goodsId
// GoodsDO goodsDO = goodsMapper.selectById(goodsId);
// if (ObjectUtil.isNull(goodsDO)) {
// throw ServiceExceptionUtil.exception(ORDER_IMPORT_PLATE_GOODS_NOT_EXISTS, orderId, goodsId);
// }
// orderModelDO.setGoodsId(goodsDO.getGoodsId());
// orderModelDO.setPlateGoodsId(goodsId);
// orderModelDO.setOrganId(organId);
// orderModelDO.setCreator(operatorName);
// orderModelDO.setUpdater(operatorName);
// orderModelDOS.add(orderModelDO);
//
// // 批量插入造型数据
// orderModelsBatchInsertWithinThreshold(false);
// }
// }
// }
}
/**
* 生成自定义板编号
*
* @param plateDO
*/
private void generateCustomPlateNo(PlateDO plateDO) {
if (!isFirstPlate) {
isFirstPlate = true;
}
// 配置不为空时，生成自定义板编号
if (ObjectUtil.isNotNull(plateNoGenerateConfigVO)) {
customPlateNoGenerateService.generateCustomPlateNo(orderId, plateDO, plateNoGenerateConfigVO, isFirstPlate);
}
}
cf-module-prod-plan/cf-module-prod-plan-biz/src/main/java/com/cf/imes/module/plan/service/orderImport/factory/DefaultXmlOrderImportFactory.java
+262 -321
View File
@@ -2,7 +2,6 @@ package com.cf.imes.module.plan.service.orderImport.factory;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.util.ListUtils;
@@ -30,6 +29,7 @@ import com.cf.imes.module.plan.controller.orderImport.vo.OrderImportTempDataReqV
import com.cf.imes.module.plan.controller.orderImport.xml.vo.AssemblyXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.BlockXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.CorrelationXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.CorrelationXmlVOS;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.CuttingOutlineXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.EdgingXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.ExtraVO;
@@ -39,13 +39,20 @@ import com.cf.imes.module.plan.controller.orderImport.xml.vo.GroupXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.HardwareXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.HoleXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.HoleXmlVOS;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.IsletXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.IsletXmlVOS;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.OffsetLineXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.OffsetLineXmlVOS;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.OutlineXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.PlateXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.PointXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.PointXmlVOS;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.RawOutlineXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.RectSealVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.RemarkXmlVO;
import com.cf.imes.module.plan.controller.orderImport.xml.vo.RoomBoxXmlVO;
import com.cf.imes.module.plan.dal.dataobject.goods.GoodsDO;
import com.cf.imes.module.plan.dal.dataobject.order.OrderDO;
import com.cf.imes.module.plan.dal.dataobject.orderBody.OrderBodyDO;
import com.cf.imes.module.plan.dal.dataobject.orderGroup.OrderGroupDO;
import com.cf.imes.module.plan.dal.dataobject.orderImport.OrderImportTaskDO;
@@ -81,6 +88,8 @@ import com.cf.imes.module.plan.dal.mysql.orderParts.PartsMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateGoodMapper;
import com.cf.imes.module.plan.dal.mysql.plate.PlateMapper;
import com.cf.imes.module.plan.dal.mysql.rawgoods.RawGoodsMapper;
import com.cf.imes.module.plan.service.customplateno.CustomPlateNoGenerateService;
import com.cf.imes.module.plan.service.customplateno.vo.CustomPlateNoGenerateConfigVO;
import com.cf.imes.module.plan.service.order.OrderInputProcessor;
import org.apache.ibatis.session.ResultContext;
import org.apache.ibatis.session.ResultHandler;
@@ -95,6 +104,8 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import static com.cf.imes.module.executor.enums.OrderImportConstants.NOT_ASSIGNED;
import static com.cf.imes.module.plan.enums.ErrorCodeConstants.ORDER_IMPORT_PLATE_GOODS_NOT_EXISTS;
@@ -118,8 +129,15 @@ public class DefaultXmlOrderImportFactory {
private Long orderId;
private OrderDO orderDO;
private Long taskId;
private CustomPlateNoGenerateConfigVO plateNoGenerateConfigVO;
// 是否入库的第一块板件
private boolean isFirstPlate;
private List<RawGoodsDO> rawGoodsDOS = ListUtils.newArrayListWithExpectedSize(BATCH_THRESHOLD_NUMBER);
private List<GoodsDO> goodsDOS = ListUtils.newArrayListWithExpectedSize(BATCH_THRESHOLD_NUMBER);
private List<OrderPartsDO> orderPartsDOS = ListUtils.newArrayListWithExpectedSize(BATCH_THRESHOLD_NUMBER);
@@ -173,8 +191,10 @@ public class DefaultXmlOrderImportFactory {
private String operatorName;
private CustomPlateNoGenerateService customPlateNoGenerateService;
public DefaultXmlOrderImportFactory(Long taskId,
Long orderId,
OrderDO orderDO,
Long organId,
String operatorName,
SnowFlakeGenerator snowFlakeGenerator,
@@ -190,9 +210,11 @@ public class DefaultXmlOrderImportFactory {
OrderItemMapper orderItemMapper,
PlateGoodMapper plateGoodMapper,
OrderInputProcessor orderInputProcessor,
PartsMapper partsMapper) {
PartsMapper partsMapper,
CustomPlateNoGenerateService customPlateNoGenerateService) {
this.taskId = taskId;
this.orderId = orderId;
this.orderDO = orderDO;
this.orderId = orderDO.getId();
this.organId = organId;
this.operatorName = operatorName;
this.snowFlakeGenerator = snowFlakeGenerator;
@@ -209,6 +231,7 @@ public class DefaultXmlOrderImportFactory {
this.plateGoodMapper = plateGoodMapper;
this.orderInputProcessor = orderInputProcessor;
this.partsMapper = partsMapper;
this.customPlateNoGenerateService = customPlateNoGenerateService;
}
private Map<String, Map<String, OrderImportTempDataDO>> roomBodyMap = new HashMap<>(); // 房间code: （柜体code：柜体数据）
@@ -222,6 +245,9 @@ public class DefaultXmlOrderImportFactory {
*/
public void analyzeTempData() {
try {
// 获取自定义板编号配置
plateNoGenerateConfigVO = customPlateNoGenerateService.getPlateNoGenerateConfig(orderId);
log.info("====================【生产单默认xml导入处理柜体开始】====================");
// 解析柜体数据
analyzeBodyNoPaging();
@@ -534,6 +560,9 @@ public class DefaultXmlOrderImportFactory {
plateDO.setCreateTime(now);
plateDO.setUpdateTime(now);
// 生成自定义板编号
generateCustomPlateNo(plateDO);
OrderItemDO orderItemDO = OrderItemDO.builder()
.id((Long) snowFlakeGenerator.nextId(null))
.orderId(orderId)
@@ -589,20 +618,20 @@ public class DefaultXmlOrderImportFactory {
.plateExtraRemark(new JSONObject())
.build();
String blockProductionCode = blockXmlVO.getProductionCode();
// 处理es封边值
addSealEdge(blockProductionCode, plateDO, orderItemDO, orderModelDO);
// 小板、es 封边值
addSealEdge(plateDO, orderModelDO, blockXmlVO.getOutlineXmlVO(), orderItemDO);
// 偏移量 不含封边
addCuttingOutlinePointDetail(blockProductionCode, plateDO, orderModelDO);
addRawOutlinePointDetail(blockProductionCode, orderModelDO);
addPointDetail(plateDO, orderModelDO, blockXmlVO.getCuttingOutlineXmlVO());
addPointDetail(orderModelDO, blockXmlVO.getRawOutlineXmlVO()); // 坯料
// 孔数据
addHole(blockProductionCode, plateDO, orderModelDO);
// 造型数据 (槽）, 孤岛信息
addContourDetail(blockProductionCode, plateDO, orderModelDO);
addHole(plateDO, orderModelDO, blockXmlVO.getHoleXmlVOS());
// 造型数据 (槽）, 加孤岛信息
addContourDetail(plateDO, orderModelDO, blockXmlVO.getGrooveXmlVOS(), blockXmlVO.getIsletXmlVOS());
// 小板关联配件
addParts(blockProductionCode, orderModelDO);
addParts(orderModelDO, blockXmlVO.getCorrelationXmlVOS());
// 小板备注信息
addRemark(blockProductionCode, plateDO, orderModelDO);
addRemark(plateDO, orderModelDO, blockXmlVO);
// 查询大板id用于小板轮廓goodsId
GoodsDO goodsDO = goodsMapper.selectById(goodsId);
Optional.ofNullable(goodsDO).orElseThrow(() -> ServiceExceptionUtil.exception(ORDER_IMPORT_PLATE_GOODS_NOT_EXISTS, orderId, goodsId));
@@ -625,34 +654,46 @@ public class DefaultXmlOrderImportFactory {
orderInfoBatchInsertWithinThreshold(plateMapper, plateDOS, true);
// 批量插入造型数据
orderModelsBatchInsertWithinThreshold(true);
// 所有自定义板编号生成完成后更新配置到生产单
customPlateNoGenerateService.updateCustomPlateNoGenerateConfig(plateNoGenerateConfigVO, orderDO);
}
/**
* 处理es封边值
* 生成自定义板编号
*
* @param blockProductionCode
* @param plateDO
* @param orderModelDO
*/
private void addSealEdge(String blockProductionCode, PlateDO plateDO, OrderItemDO orderItemDO, OrderModelDO orderModelDO) {
List<OrderImportTempDataDO> outlinePointTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_OUTLINE_POINT.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
private void generateCustomPlateNo(PlateDO plateDO) {
if (!isFirstPlate) {
isFirstPlate = true;
}
// 配置不为空时，生成自定义板编号
if (ObjectUtil.isNotNull(plateNoGenerateConfigVO)) {
customPlateNoGenerateService.generateCustomPlateNo(orderId, plateDO, plateNoGenerateConfigVO, isFirstPlate);
}
}
/**
* 封边值相关信息添加 (原始点明细)
*
* @param plateDO
* @param plateDetail
* @param outlineXmlVO
* @param orderItemDO
*/
private void addSealEdge(PlateDO plateDO, OrderModelDO plateDetail, OutlineXmlVO outlineXmlVO, OrderItemDO orderItemDO) {
BigDecimal[] sealPositions = new BigDecimal[4];
Arrays.fill(sealPositions, BigDecimal.ZERO);
if (outlineXmlVO != null && outlineXmlVO.getPointXmlVOList() != null && !outlineXmlVO.getPointXmlVOList().isEmpty()) {
ExtraVO extraVO = ExtraVO.builder()
.edgeRemarks(new ArrayList<>())
.rectSealDetail(new ArrayList<>())
.build();
int indexId = 0;
for (OrderImportTempDataDO pointTempData : outlinePointTempDataList) {
String detail = pointTempData.getDetail();
if (StringUtils.isNotEmpty(detail)) {
PointXmlVO pointXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), PointXmlVO.class);
for (PointXmlVO pointXmlVO : outlineXmlVO.getPointXmlVOList()) {
if (!(pointXmlVO.getItemCode() == null && pointXmlVO.getEdgingName() == null && pointXmlVO.getEdgingColor() == null
&& pointXmlVO.getEdgingMaterial() == null && (pointXmlVO.getEdgingThickness() == null || pointXmlVO.getEdgingThickness().trim().equals("0")))) {
double x = Double.parseDouble(pointXmlVO.getPointX());
double y = Double.parseDouble(pointXmlVO.getPointY());
BigDecimal size = new BigDecimal(pointXmlVO.getEdgingThickness());
@@ -666,7 +707,7 @@ public class DefaultXmlOrderImportFactory {
// 计算封边条厚度
calculateSealPositions(plateDO, pointXmlVO, sealPositions);
orderModelDO.getRawPointDetail().add(PointDetail.builder()
plateDetail.getRawPointDetail().add(PointDetail.builder()
.pointX(x)
.pointY(y)
.curve(Double.parseDouble(pointXmlVO.getCurvature()))
@@ -682,14 +723,15 @@ public class DefaultXmlOrderImportFactory {
.build());
indexId++;
}
}
String jsonString = JSON.toJSONString(extraVO);
JSONObject jsonObject = JSON.parseObject(jsonString);
orderModelDO.setPlateExtraRemark(jsonObject);
plateDetail.setPlateExtraRemark(jsonObject);
}
plateDO.setSealLeft(sealPositions[0]).setSealRight(sealPositions[1]).setSealUp(sealPositions[2]).setSealDown(sealPositions[3]);
}
/**
* 计算封边条上下左右厚度
*
@@ -715,11 +757,9 @@ public class DefaultXmlOrderImportFactory {
if (x == 0 && y == 0) {
sealPositions[3] = size; // sealDown
}
}
}
/**
* 新增封边条配件
*
@@ -778,39 +818,20 @@ public class DefaultXmlOrderImportFactory {
}
/**
* 处理es开料点明细
* 点明细（不含封边）
*
* @param blockProductionCode
* @param plateDO
* @param orderModelDO
* @param plateDetail
* @param cuttingOutlineXmlVO
*/
private void addCuttingOutlinePointDetail(String blockProductionCode, PlateDO plateDO, OrderModelDO orderModelDO) {
// 查询CuttingOutline
List<OrderImportTempDataDO> cuttingOutlineXmlVOS = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_CUTTINGOUTLINE.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
if (CollUtil.isNotEmpty(cuttingOutlineXmlVOS)) {
String cuttingOutlineTempDataDetail = cuttingOutlineXmlVOS.get(0).getDetail();
if (StringUtils.isNotEmpty(cuttingOutlineTempDataDetail)) {
CuttingOutlineXmlVO cuttingOutlineXmlVO = JSON.parseObject(JsonUtils.unzipString(cuttingOutlineTempDataDetail), CuttingOutlineXmlVO.class);
private void addPointDetail(PlateDO plateDO, OrderModelDO plateDetail, CuttingOutlineXmlVO cuttingOutlineXmlVO) {
if (cuttingOutlineXmlVO != null) {
plateDO.setOffsetX(BigDecimal.valueOf(Double.parseDouble(cuttingOutlineXmlVO.getReferenceOffsetX()))).
setOffsetY(BigDecimal.valueOf(Double.parseDouble(cuttingOutlineXmlVO.getReferenceOffsetY())));
orderModelDO.setOffsetX(plateDO.getOffsetX()).setOffsetY(plateDO.getOffsetY());
// 查询CuttingOutline.Point
List<OrderImportTempDataDO> cuttingOutlineXmlPointVOS = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_CUTTINGOUTLINE_POINT.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO cuttingOutlineXmlPointVO : cuttingOutlineXmlPointVOS) {
String detail = cuttingOutlineXmlPointVO.getDetail();
if (StringUtils.isNotEmpty(detail)) {
PointXmlVO pointXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), PointXmlVO.class);
orderModelDO.getPointDetail().add(PointDetail.builder()
plateDetail.setOffsetX(plateDO.getOffsetX()).setOffsetY(plateDO.getOffsetY());
if (cuttingOutlineXmlVO.getPointXmlVOList() != null && cuttingOutlineXmlVO.getPointXmlVOList().size() > 0) {
for (PointXmlVO pointXmlVO : cuttingOutlineXmlVO.getPointXmlVOList()) {
plateDetail.getPointDetail().add(PointDetail.builder()
.pointX(Double.parseDouble(pointXmlVO.getPointX()))
.pointY(Double.parseDouble(pointXmlVO.getPointY()))
.curve(Double.parseDouble(pointXmlVO.getCurvature()))
@@ -821,27 +842,18 @@ public class DefaultXmlOrderImportFactory {
}
}
}
}
/**
* 处理es胚料点明细
* 坯料
*
* @param blockProductionCode
* @param orderModelDO
* @param plateDetail
* @param rawOutlineXmlVO
*/
private void addRawOutlinePointDetail(String blockProductionCode, OrderModelDO orderModelDO) {
// 查询RawOutline.Point
List<OrderImportTempDataDO> cuttingOutlineXmlPointVOS = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_RAWOUTLINE_POINT.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO cuttingOutlineXmlPointVO : cuttingOutlineXmlPointVOS) {
String detail = cuttingOutlineXmlPointVO.getDetail();
if (StringUtils.isNotEmpty(detail)) {
PointXmlVO pointXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), PointXmlVO.class);
orderModelDO.getBasePointDetail().add(PointDetail.builder()
private void addPointDetail(OrderModelDO plateDetail, RawOutlineXmlVO rawOutlineXmlVO) {
if (rawOutlineXmlVO != null) {
if (rawOutlineXmlVO.getPointXmlVOList() != null && rawOutlineXmlVO.getPointXmlVOList().size() > 0) {
for (PointXmlVO pointXmlVO : rawOutlineXmlVO.getPointXmlVOList()) {
plateDetail.getBasePointDetail().add(PointDetail.builder()
.pointX(Double.parseDouble(pointXmlVO.getPointX()))
.pointY(Double.parseDouble(pointXmlVO.getPointY()))
.curve(Double.parseDouble(pointXmlVO.getCurvature()))
@@ -851,26 +863,34 @@ public class DefaultXmlOrderImportFactory {
}
}
}
}
/**
* 处理es孔数据
* 孔
*
* @param blockProductionCode
* @param plateDO
* @param orderModelDO
* @param plateDetail
* @param holeXmlVOS
*/
private void addHole(String blockProductionCode, PlateDO plateDO, OrderModelDO orderModelDO) {
// 查holes对象
List<OrderImportTempDataDO> holeXmlVOSTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_HOLES.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
if (CollUtil.isNotEmpty(holeXmlVOSTempDataList)) {
String holeXmlVOSTempDataDetail = holeXmlVOSTempDataList.get(0).getDetail();
if (StringUtils.isNotEmpty(holeXmlVOSTempDataDetail)) {
HoleXmlVOS holeXmlVOS = JSON.parseObject(JsonUtils.unzipString(holeXmlVOSTempDataDetail), HoleXmlVOS.class);
private void addHole(PlateDO plateDO, OrderModelDO plateDetail, HoleXmlVOS holeXmlVOS) {
if (holeXmlVOS == null || holeXmlVOS.getHoleXmlVOList() == null || holeXmlVOS.getHoleXmlVOList().isEmpty()) {
return;
}
Map<String, Integer> holeCountMap = extractHoleCount(holeXmlVOS);
updatePlateDetailHoleCount(plateDetail, holeCountMap);
updatePlateDOHoleCount(plateDO, holeXmlVOS);
updatePlateDOFilterTypeIfThroughHolesExist(plateDO, holeXmlVOS);
addHoleDetailsToPlateDetail(plateDetail, holeXmlVOS.getHoleXmlVOList());
}
/**
* 孔数量
*
* @param holeXmlVOS
* @return
*/
private Map<String, Integer> extractHoleCount(HoleXmlVOS holeXmlVOS) {
Map<String, Integer> holeCountMap = new HashMap<>();
holeCountMap.put("count", Integer.valueOf(holeXmlVOS.getCount()));
holeCountMap.put("countFaceA", Integer.valueOf(holeXmlVOS.getCountFaceA()));
@@ -885,40 +905,32 @@ public class DefaultXmlOrderImportFactory {
holeCountMap.put("countBuildIn", Integer.valueOf(holeXmlVOS.getCountBuildIn()));
holeCountMap.put("countHinge", Integer.valueOf(holeXmlVOS.getCountHinge()));
holeCountMap.put("countThrough", Integer.valueOf(holeXmlVOS.getCountThrough()));
return holeCountMap;
}
orderModelDO.getHoleCount().putAll(holeCountMap);
private void updatePlateDetailHoleCount(OrderModelDO plateDetail, Map<String, Integer> holeCountMap) {
plateDetail.getHoleCount().putAll(holeCountMap);
}
private void updatePlateDOHoleCount(PlateDO plateDO, HoleXmlVOS holeXmlVOS) {
plateDO.setFrontHoleCount(Integer.valueOf(holeXmlVOS.getCountFaceA()));
plateDO.setBackHoleCount(Integer.valueOf(holeXmlVOS.getCountFaceB()));
plateDO.setSideHoleCount(Integer.valueOf(holeXmlVOS.getCountSide()));
}
private void updatePlateDOFilterTypeIfThroughHolesExist(PlateDO plateDO, HoleXmlVOS holeXmlVOS) {
if (holeXmlVOS.getCountThrough() != null && Integer.parseInt(holeXmlVOS.getCountThrough()) > 0) {
plateDO.setFilterType(plateDO.getFilterType() + ",2");
}
// 查hole列表
List<OrderImportTempDataDO> holeXmlVOTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_HOLE.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO holeXmlVOTempData : holeXmlVOTempDataList) {
String detail = holeXmlVOTempData.getDetail();
if (StringUtils.isNotEmpty(detail)) {
HoleXmlVO holeXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), HoleXmlVO.class);
}
private void addHoleDetailsToPlateDetail(OrderModelDO plateDetail, List<HoleXmlVO> holeXmlVOList) {
for (HoleXmlVO holeXmlVO : holeXmlVOList) {
HoleDetail holeDetail = createHoleDetail(holeXmlVO);
orderModelDO.getHoleDetail().add(holeDetail);
}
}
}
plateDetail.getHoleDetail().add(holeDetail);
}
}
/**
* 创建孔明细对象
*
* @param holeXmlVO
* @return
*/
private HoleDetail createHoleDetail(HoleXmlVO holeXmlVO) {
String faceType = DictFrameworkUtils.parseDictDataValue(DictTypeConstants.HOLE_FACE, holeXmlVO.getFace());
Integer faceTypeValue = StringUtils.isNotEmpty(faceType) ? Integer.parseInt(faceType) : 2;
@@ -943,25 +955,35 @@ public class DefaultXmlOrderImportFactory {
}
/**
* 处理es造型、孤岛数据
* 造型
*
* @param blockProductionCode
* @param plateDO
* @param orderModelDO
* @param plateDetail
* @param grooveXmlVOS
* @param isletXmlVOS
*/
private void addContourDetail(String blockProductionCode, PlateDO plateDO, OrderModelDO orderModelDO) {
// 查grooves
List<OrderImportTempDataDO> groovesXmlVOTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVES.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
if (CollUtil.isNotEmpty(groovesXmlVOTempDataList)) {
String groovesXMLVOSTempDataDetail = groovesXmlVOTempDataList.get(0).getDetail();
if (StringUtils.isNotEmpty(groovesXMLVOSTempDataDetail)) {
GrooveXmlVOS grooveXmlVOS = JSON.parseObject(JsonUtils.unzipString(groovesXMLVOSTempDataDetail), GrooveXmlVOS.class);
private void addContourDetail(PlateDO plateDO, OrderModelDO plateDetail, GrooveXmlVOS grooveXmlVOS, IsletXmlVOS isletXmlVOS) {
if (grooveXmlVOS == null || org.apache.commons.lang3.ObjectUtils.allNull(grooveXmlVOS)) {
return;
}
Map<String, Integer> contourCount = extractContourCount(grooveXmlVOS);
updatePlateDetailWithContourCount(plateDetail, contourCount);
updatePlateDOWithContourCount(plateDO, grooveXmlVOS);
updatePlateDOFilterTypeIfThroughGroovesExist(plateDO, grooveXmlVOS);
if (grooveXmlVOS.getGrooveXmlVOList() != null && !grooveXmlVOS.getGrooveXmlVOList().isEmpty()) {
addGrooveDetailsToPlateDetail(plateDetail, grooveXmlVOS.getGrooveXmlVOList(), isletXmlVOS);
}
}
/**
* 轮廓数量
*
* @param grooveXmlVOS
* @return
*/
private Map<String, Integer> extractContourCount(GrooveXmlVOS grooveXmlVOS) {
Map<String, Integer> contourCount = new HashMap<>();
contourCount.put("count", Integer.valueOf(grooveXmlVOS.getCount()));
contourCount.put("countFaceA", Integer.valueOf(grooveXmlVOS.getCountFaceA()));
@@ -976,121 +998,39 @@ public class DefaultXmlOrderImportFactory {
contourCount.put("count2V", Integer.valueOf(grooveXmlVOS.getCount2V()));
contourCount.put("count3D", Integer.valueOf(grooveXmlVOS.getCount3D()));
contourCount.put("countThrough", Integer.valueOf(grooveXmlVOS.getCountThrough()));
return contourCount;
}
orderModelDO.getContourCount().putAll(contourCount);
orderModelDO.setHas2DModel(contourCount.getOrDefault("count2V", 0) > 0);
orderModelDO.setHas3DModel(contourCount.getOrDefault("count3D", 0) > 0);
private void updatePlateDetailWithContourCount(OrderModelDO plateDetail, Map<String, Integer> contourCount) {
plateDetail.getContourCount().putAll(contourCount);
plateDetail.setHas2DModel(contourCount.getOrDefault("count2V", 0) > 0);
plateDetail.setHas3DModel(contourCount.getOrDefault("count3D", 0) > 0);
}
private void updatePlateDOWithContourCount(PlateDO plateDO, GrooveXmlVOS grooveXmlVOS) {
plateDO.setFrontModelCount(Integer.valueOf(grooveXmlVOS.getCountFaceA()));
plateDO.setBackModelCount(Integer.valueOf(grooveXmlVOS.getCountFaceB()));
}
private void updatePlateDOFilterTypeIfThroughGroovesExist(PlateDO plateDO, GrooveXmlVOS grooveXmlVOS) {
if (grooveXmlVOS.getCountThrough() != null && Integer.parseInt(grooveXmlVOS.getCountThrough()) > 0) {
plateDO.setFilterType(plateDO.getFilterType() + ",1");
}
addGrooveDetailsToPlateDetail(blockProductionCode, orderModelDO);
}
private void addGrooveDetailsToPlateDetail(OrderModelDO plateDetail, List<GrooveXmlVO> grooveXmlVOList, IsletXmlVOS isletXmlVOS) {
for (GrooveXmlVO grooveXmlVO : grooveXmlVOList) {
ModelDetail modelDetail = createModelDetail(grooveXmlVO, isletXmlVOS);
plateDetail.getContourDetail().add(modelDetail);
}
}
/**
* 处理es关联配件
*
* @param blockProductionCode
* @param orderModelDO
*/
private void addParts(String blockProductionCode, OrderModelDO orderModelDO) {
List<PartsInfo> partsInfos = new ArrayList<>();
List<OrderImportTempDataDO> correlationTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE_CORRELATIONS.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO correlationTempData : correlationTempDataList) {
String correlationTempDataDetail = correlationTempData.getDetail();
if (StringUtils.isNotEmpty(correlationTempDataDetail)) {
CorrelationXmlVO correlationXmlVO = JSON.parseObject(JsonUtils.unzipString(correlationTempDataDetail), CorrelationXmlVO.class);
String partCode = StringUtils.isNotEmpty(correlationXmlVO.getItemCode()) ? correlationXmlVO.getItemCode() : correlationXmlVO.getName() + correlationXmlVO.getColor() + correlationXmlVO.getMaterial() + correlationXmlVO.getSpecs()
+ correlationXmlVO.getMaterial() + correlationXmlVO.getBrand() + correlationXmlVO.getType();
// 获取配件信息
OrderPartsDO orderPartsDO = orderPartsDOMap.get(partCode);
// 板件上面添加配件信息
if (ObjectUtil.isNotNull(orderPartsDO)) {
partsInfos.add(PartsInfo.builder()
.id(orderPartsDO.getId())
.name(orderPartsDO.getName())
.partNum(Double.valueOf(correlationXmlVO.getCount()))
.unit(orderPartsDO.getUnit())
.build());
}
}
}
orderModelDO.setPartsInfos(partsInfos);
}
/**
* 处理es小板备注信息
*
* @param blockProductionCode
* @param plateDO
* @param orderModelDO
*/
private void addRemark(String blockProductionCode, PlateDO plateDO, OrderModelDO orderModelDO) {
// 查grooves
List<OrderImportTempDataDO> blockRemarkTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_REMKAR.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO blockRemarkTempData : blockRemarkTempDataList) {
String blockRemarkTempDataDetail = blockRemarkTempData.getDetail();
if (StringUtils.isNotEmpty(blockRemarkTempDataDetail)) {
RemarkXmlVO remarkXmlVO = JSON.parseObject(JsonUtils.unzipString(blockRemarkTempDataDetail), RemarkXmlVO.class);
orderModelDO.getSideRemark().put(remarkXmlVO.getName(), remarkXmlVO.getInfo());
}
}
plateDO.setRemark(JSON.toJSONString(orderModelDO.getSideRemark()));
}
/**
* 添加造型数据明细
*
* @param blockProductionCode
* @param orderModelDO
*/
private void addGrooveDetailsToPlateDetail(String blockProductionCode, OrderModelDO orderModelDO) {
// 查询GrooveXml
List<OrderImportTempDataDO> grooveXmlVOList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE.getType())
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO grooveXmlVOTempData : grooveXmlVOList) {
String detail = grooveXmlVOTempData.getDetail();
if (StringUtils.isNotEmpty(detail)) {
GrooveXmlVO grooveXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), GrooveXmlVO.class);
ModelDetail modelDetail = createModelDetail(blockProductionCode, grooveXmlVO);
orderModelDO.getContourDetail().add(modelDetail);
}
}
}
/**
* 创建造型明细对象
*
* @param grooveXmlVO
* @return
*/
private ModelDetail createModelDetail(String blockProductionCode, GrooveXmlVO grooveXmlVO) {
private ModelDetail createModelDetail(GrooveXmlVO grooveXmlVO, IsletXmlVOS isletXmlVOS) {
// 槽内孤岛id转换
String[] subIDs = null;
if (grooveXmlVO.getSubIDs() != null) {
subIDs = Arrays.stream(grooveXmlVO.getSubIDs().split(",")).map(String::valueOf).toArray(String[]::new);
}
String grooveId = grooveXmlVO.getId();
return ModelDetail.builder()
.id(Integer.valueOf(grooveXmlVO.getId()))
.subIDs(subIDs)
@@ -1105,50 +1045,40 @@ public class DefaultXmlOrderImportFactory {
.round(Double.parseDouble(grooveXmlVO.getRound()))
.redundance(Double.parseDouble(grooveXmlVO.getRedundance()))
.tangentAngle(Double.parseDouble(grooveXmlVO.getTangentAngle()))
.originModeling(getOriginModelingData(blockProductionCode, grooveXmlVO, subIDs))
.pointList(addPointDetail(blockProductionCode, grooveId))
.offSetList(addOffSetDetail(blockProductionCode, grooveId))
.originModeling(getOriginModelingData(grooveXmlVO, subIDs, isletXmlVOS))
.pointList(addPointDetail(grooveXmlVO.getPointXmlVOS()))
.offSetList(addOffSetDetail(grooveXmlVO.getOffsetLineXmlVOS()))
.mode(grooveXmlVO.getMode())
.build();
}
// 造像轮廓数据
/**
* 造型轮廓数据
*
* @param grooveXmlVO
* @param subIDs
* @param isletXmlVOS
* @return
*/
private IOriginModelingData getOriginModelingData(String blockProductionCode, GrooveXmlVO grooveXmlVO, String[] subIDs) {
private IOriginModelingData getOriginModelingData(GrooveXmlVO grooveXmlVO, String[] subIDs, IsletXmlVOS isletXmlVOS) {
// 孤岛信息
List<List<IContourData>> holes = null;
if (ArrayUtil.isNotEmpty(subIDs)) {
if (subIDs != null && isletXmlVOS != null && isletXmlVOS.getIsletXmlVOList() != null) {
holes = new ArrayList<>();
// 孤岛信息整合
Map<String, IsletXmlVO> isletMap = isletXmlVOS.getIsletXmlVOList().stream().collect(Collectors.toMap(IsletXmlVO::getId, Function.identity()));
// 遍历subIDs
for (String subID : subIDs) {
// 获取孤岛信息
// id查询Islet
List<OrderImportTempDataDO> IsletVOTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE_ISLET.getType())
.eq(OrderImportTempDataDO::getOuterId, subID)
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
if (CollUtil.isNotEmpty(IsletVOTempDataList)) {
List<IContourData> hole = getHole(blockProductionCode, subID);
List<IContourData> hole = getHole(subID, isletMap);
holes.add(hole);
}
}
}
return IOriginModelingData.builder()
.knifeRadius(Double.parseDouble(grooveXmlVO.getToolDiameter()) / 2)
.direction(grooveXmlVO.getDirection())
.outline(addOutlineDetail(blockProductionCode, grooveXmlVO.getId()))
.outline(addOutlineDetail(grooveXmlVO.getOutlineXmlVO()))
.holes(holes)
.addLen(Double.valueOf(grooveXmlVO.getLengthExtend()))
.addDepth(Double.valueOf(grooveXmlVO.getDepthExtend()))
@@ -1157,79 +1087,45 @@ public class DefaultXmlOrderImportFactory {
}
/**
* 原始造型(外)轮廓信息
* 孤岛信息
*
* @param blockProductionCode
* @param subId
* @param subID
* @param isletMap
* @return
*/
private List<IContourData> addOutlineDetail(String blockProductionCode, String subId) {
List<IContourData> iContourDataList = new ArrayList<>();
List<OrderImportTempDataDO> grooveOutLinePointXmlVOList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE_OUTLINE_POINT.getType())
.eq(OrderImportTempDataDO::getOuterSubId, subId)
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO tempDataDO : grooveOutLinePointXmlVOList) {
String detail = tempDataDO.getDetail();
if (StringUtils.isNotEmpty(detail)) {
PointXmlVO pointXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), PointXmlVO.class);
iContourDataList.add(IContourData.builder()
private List<IContourData> getHole(String subID, Map<String, IsletXmlVO> isletMap) {
return isletMap.get(subID).getPointXmlVOS().getPointXmlVOList().stream().map(pointXmlVO -> IContourData.builder()
.pts(new Point(Double.parseDouble(pointXmlVO.getPointX()), Double.parseDouble(pointXmlVO.getPointY()), Double.parseDouble(pointXmlVO.getPointZ())))
.buls(Double.parseDouble(pointXmlVO.getCurvature()))
.radius(Double.parseDouble(pointXmlVO.getRadius()))
.build());
}
}
return iContourDataList;
.buls(Double.parseDouble(pointXmlVO.getCurvature())).radius(Double.parseDouble(pointXmlVO.getRadius())).build()).collect(Collectors.toList());
}
/**
* 孤岛点信息
* 原始造型(外)轮廓信息
*
* @param blockProductionCode
* @param subID
* @param outlineXmlVO
* @return
*/
private List<IContourData> getHole(String blockProductionCode, String subID) {
List<IContourData> iContourDataList = new ArrayList<>();
List<OrderImportTempDataDO> IsletPointVOTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE_ISLET_POINTS_POINT.getType())
.eq(OrderImportTempDataDO::getOuterSubId, subID)
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO tempDataDO : IsletPointVOTempDataList) {
String detail = tempDataDO.getDetail();
if (StringUtils.isNotEmpty(detail)) {
PointXmlVO pointXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), PointXmlVO.class);
iContourDataList.add(IContourData.builder()
private List<IContourData> addOutlineDetail(OutlineXmlVO outlineXmlVO) {
if (outlineXmlVO == null || outlineXmlVO.getPointXmlVOList() == null) {
return null;
}
return outlineXmlVO.getPointXmlVOList().stream().map(pointXmlVO -> IContourData.builder()
.pts(new Point(Double.parseDouble(pointXmlVO.getPointX()), Double.parseDouble(pointXmlVO.getPointY()), Double.parseDouble(pointXmlVO.getPointZ())))
.buls(Double.parseDouble(pointXmlVO.getCurvature()))
.radius(Double.parseDouble(pointXmlVO.getRadius()))
.build());
}
}
return iContourDataList;
.build()).collect(Collectors.toList());
}
private List<PointList> addPointDetail(String blockProductionCode, String subId) {
/**
* 赋值点列表
*
* @param pointXmlVOS
* @return
*/
private List<PointList> addPointDetail(PointXmlVOS pointXmlVOS) {
List<PointList> pointLists = new ArrayList<>();
// 查询GrooveXml
List<OrderImportTempDataDO> grooveXmlPointVOList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE_POINTS_POINT.getType())
.eq(OrderImportTempDataDO::getOuterSubId, subId)
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO grooveXmlPointVOTempData : grooveXmlPointVOList) {
String detail = grooveXmlPointVOTempData.getDetail();
if (StringUtils.isNotEmpty(detail)) {
PointXmlVO pointXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), PointXmlVO.class);
if (pointXmlVOS != null && pointXmlVOS.getPointXmlVOList() != null && !pointXmlVOS.getPointXmlVOList().isEmpty()) {
for (PointXmlVO pointXmlVO : pointXmlVOS.getPointXmlVOList()) {
pointLists.add(PointList.builder()
.pointX(Double.parseDouble(pointXmlVO.getPointX()))
.pointY(Double.parseDouble(pointXmlVO.getPointY()))
@@ -1242,21 +1138,16 @@ public class DefaultXmlOrderImportFactory {
return pointLists;
}
// 偏移量列表
private List<OffSetList> addOffSetDetail(String blockProductionCode, String subId) {
/**
* 偏移量列表
*
* @param offsetLineXmlVOS
* @return
*/
private List<OffSetList> addOffSetDetail(OffsetLineXmlVOS offsetLineXmlVOS) {
List<OffSetList> offSetList = new ArrayList<>();
// 查询GrooveXml
List<OrderImportTempDataDO> offsetLineXmlTempDataList = orderImportTempDataMapper.selectList(new LambdaQueryWrapper<OrderImportTempDataDO>()
.eq(OrderImportTempDataDO::getTaskId, taskId)
.eq(OrderImportTempDataDO::getType, OrderImportTmpDataTypeEnum.BLOCK_GROOVE_OFFSETLINE.getType())
.eq(OrderImportTempDataDO::getOuterSubId, subId)
.eq(OrderImportTempDataDO::getOuterGoodsId, blockProductionCode)
.eq(OrderImportTempDataDO::getOrganId, organId)
);
for (OrderImportTempDataDO offsetLineXmlTempData : offsetLineXmlTempDataList) {
String detail = offsetLineXmlTempData.getDetail();
if (StringUtils.isNotEmpty(detail)) {
OffsetLineXmlVO offsetLineXmlVO = JSON.parseObject(JsonUtils.unzipString(detail), OffsetLineXmlVO.class);
if (offsetLineXmlVOS != null && offsetLineXmlVOS.getOffsetLineXmlVOList() != null && offsetLineXmlVOS.getOffsetLineXmlVOList().size() > 0) {
for (OffsetLineXmlVO offsetLineXmlVO : offsetLineXmlVOS.getOffsetLineXmlVOList()) {
offSetList.add(OffSetList.builder()
.value(Double.parseDouble(offsetLineXmlVO.getOffset()))
.depth(Double.parseDouble(offsetLineXmlVO.getDepth()))
@@ -1269,6 +1160,56 @@ public class DefaultXmlOrderImportFactory {
return offSetList;
}
/**
* 小板关联配件添加
*
* @param plateDetail
* @param correlationXmlVOS
*/
private void addParts(OrderModelDO plateDetail, CorrelationXmlVOS correlationXmlVOS) {
List<PartsInfo> partsInfos = new ArrayList<>();
if (correlationXmlVOS != null && correlationXmlVOS.getCorrelationXmlVOList() != null && correlationXmlVOS.getCorrelationXmlVOList().size() > 0) {
for (CorrelationXmlVO correlationXmlVO : correlationXmlVOS.getCorrelationXmlVOList()) {
String partCode;
if (correlationXmlVO.getItemCode() == null) {
partCode = correlationXmlVO.getName() + correlationXmlVO.getColor() + correlationXmlVO.getMaterial() + correlationXmlVO.getSpecs()
+ correlationXmlVO.getMaterial() + correlationXmlVO.getBrand() + correlationXmlVO.getType();
} else {
partCode = correlationXmlVO.getItemCode();
}
// 获取配件信息
OrderPartsDO orderPartsDO = orderPartsDOMap.get(partCode);
// 板件上面添加配件信息
if (ObjectUtil.isNotNull(orderPartsDO)) {
partsInfos.add(PartsInfo.builder()
.id(orderPartsDO.getId())
.name(orderPartsDO.getName())
.partNum(Double.valueOf(correlationXmlVO.getCount()))
.unit(orderPartsDO.getUnit())
.build());
}
}
plateDetail.setPartsInfos(partsInfos);
}
}
/**
* 小板备注
*
* @param plateDO
* @param plateDetail
* @param blockXmlVO
*/
private void addRemark(PlateDO plateDO, OrderModelDO plateDetail, BlockXmlVO blockXmlVO) {
if (blockXmlVO.getRemarkXmlVOS() != null && blockXmlVO.getRemarkXmlVOS().getRemarkXmlVOList() != null
&& !blockXmlVO.getRemarkXmlVOS().getRemarkXmlVOList().isEmpty()) {
for (RemarkXmlVO remarkXmlVO : blockXmlVO.getRemarkXmlVOS().getRemarkXmlVOList()) {
plateDetail.getSideRemark().put(remarkXmlVO.getName(), remarkXmlVO.getInfo());
}
plateDO.setRemark(JSON.toJSONString(plateDetail.getSideRemark()));
}
}
/**
* 解析配件列表
*/