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

2026-08-12 21:02:08 +08:00 · 2025-03-01 17:10:01 +08:00
parent 1a9a1bc503
commit 434a8bc8b7
33 changed files with 2617 additions and 787 deletions
@@ -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;
 }
@@ -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;
+}
@@ -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;
 }
@@ -70,4 +70,13 @@ public class GrooveXmlVO implements Serializable {
    private String isletCount;

    private String result;
+
+    // 凹槽点信息
+    private PointXmlVOS pointXmlVOS;
+
+    // 偏移刀路列表
+    private OffsetLineXmlVOS offsetLineXmlVOS;
+
+    // 原始造型(外)轮廓信息
+    private OutlineXmlVO outlineXmlVO;
 }
@@ -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;
 }
@@ -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;
 }
@@ -20,4 +20,6 @@ public class IsletXmlVO implements Serializable {

    // 内层(不含内嵌孤岛内的凹槽)凹槽数量
    private String grooveCount;
+
+    private PointXmlVOS pointXmlVOS;
 }
@@ -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;
+
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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 {
 }
@@ -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);
+}
@@ -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;
+    }
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
+
@@ -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);
+    }
+}
@@ -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);
+}
@@ -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();
+    }
+}
@@ -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();
+    }
+}
@@ -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);
+    }
+}
@@ -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;
    }

    /**
@@ -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;
    }

    /**
@@ -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,138 +666,302 @@ 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) {
-                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);
-                    // 批量插入order_plate
-                    plateDOS.add(plateDO);
-                    orderInfoBatchInsertWithinThreshold(plateMapper, plateDOS, false);
+        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;

-                    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);
+                    @Override
+                    public void handleResult(ResultContext<? extends OrderImportTempDataDO> resultContext) {
+                        OrderImportTempDataDO tempDataDO = resultContext.getResultObject();

-                    // 批量插入CAD板件信息
-                    OrderModelDO orderModelDO = OrderModelDO.builder()
-                            .orderId(orderId)
-                            .plateId(plateId)
-                            .typographicFace(Integer.valueOf(typographyDTO.getValue()))
-                            .texture(plateDO.getTexture())
-                            .openDoorType(plateDO.getOpenDoorType())
-                            .build();
+                        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();

-                    // 查询大板id用于小板轮廓goodsId
-                    GoodsDO goodsDO = goodsMapper.selectById(goodsId);
-                    if (ObjectUtil.isNull(goodsDO)) {
-                        throw ServiceExceptionUtil.exception(ORDER_IMPORT_PLATE_GOODS_NOT_EXISTS, orderId, goodsId);
+                            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);
+                        }
                    }
-                    orderModelDO.setGoodsId(goodsDO.getGoodsId());
-                    orderModelDO.setPlateGoodsId(goodsId);
-                    orderModelDO.setOrganId(organId);
-                    orderModelDO.setCreator(operatorName);
-                    orderModelDO.setUpdater(operatorName);
-                    orderModelDOS.add(orderModelDO);
+        });

-                    // 批量插入造型数据
-                    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);
        }
    }

@@ -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,71 +654,84 @@ 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);

-        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);
-                double x = Double.parseDouble(pointXmlVO.getPointX());
-                double y = Double.parseDouble(pointXmlVO.getPointY());
-                BigDecimal size = new BigDecimal(pointXmlVO.getEdgingThickness());
+        if (outlineXmlVO != null && outlineXmlVO.getPointXmlVOList() != null && !outlineXmlVO.getPointXmlVOList().isEmpty()) {
+            ExtraVO extraVO = ExtraVO.builder()
+                    .edgeRemarks(new ArrayList<>())
+                    .rectSealDetail(new ArrayList<>())
+                    .build();
+            int indexId = 0;
+            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());

-                String itemCode = pointXmlVO.getItemCode();
-                if (StringUtils.isNotEmpty(itemCode)) {
-                    // 配件编码匹配，不存在需要新增
-                    addSealEdgePart(orderItemDO, pointXmlVO);
+                    String itemCode = pointXmlVO.getItemCode();
+                    if (StringUtils.isNotEmpty(itemCode)) {
+                        // 配件编码匹配，不存在需要新增
+                        addSealEdgePart(orderItemDO, pointXmlVO);
+                    }
+
+                    // 计算封边条厚度
+                    calculateSealPositions(plateDO, pointXmlVO, sealPositions);
+
+                    plateDetail.getRawPointDetail().add(PointDetail.builder()
+                            .pointX(x)
+                            .pointY(y)
+                            .curve(Double.parseDouble(pointXmlVO.getCurvature()))
+                            .radius(Double.parseDouble(pointXmlVO.getRadius()))
+                            .sealSize(size)
+                            .build());
+                    extraVO.getEdgeRemarks().add(pointXmlVO.getRemark());
+                    extraVO.getRectSealDetail().add(RectSealVO.builder()
+                            .pointID(String.valueOf(indexId))
+                            .reservedEdge(pointXmlVO.getScale())
+                            .sealColor(pointXmlVO.getEdgingColor())
+                            .sealSize(pointXmlVO.getEdgingThickness())
+                            .build());
+                    indexId++;
                }

-                // 计算封边条厚度
-                calculateSealPositions(plateDO, pointXmlVO, sealPositions);
-
-                orderModelDO.getRawPointDetail().add(PointDetail.builder()
-                        .pointX(x)
-                        .pointY(y)
-                        .curve(Double.parseDouble(pointXmlVO.getCurvature()))
-                        .radius(Double.parseDouble(pointXmlVO.getRadius()))
-                        .sealSize(size)
-                        .build());
-                extraVO.getEdgeRemarks().add(pointXmlVO.getRemark());
-                extraVO.getRectSealDetail().add(RectSealVO.builder()
-                        .pointID(String.valueOf(indexId))
-                        .reservedEdge(pointXmlVO.getScale())
-                        .sealColor(pointXmlVO.getEdgingColor())
-                        .sealSize(pointXmlVO.getEdgingThickness())
-                        .build());
-                indexId++;
            }
+            String jsonString = JSON.toJSONString(extraVO);
+            JSONObject jsonObject = JSON.parseObject(jsonString);
+            plateDetail.setPlateExtraRemark(jsonObject);
        }
-        String jsonString = JSON.toJSONString(extraVO);
-        JSONObject jsonObject = JSON.parseObject(jsonString);
-        orderModelDO.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,147 +818,119 @@ 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);
-                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()
-                                .pointX(Double.parseDouble(pointXmlVO.getPointX()))
-                                .pointY(Double.parseDouble(pointXmlVO.getPointY()))
-                                .curve(Double.parseDouble(pointXmlVO.getCurvature()))
-                                .radius(Double.parseDouble(pointXmlVO.getRadius()))
-                                .process(pointXmlVO.getProcess())
-                                .build());
-                    }
+    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())));
+            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()))
+                            .radius(Double.parseDouble(pointXmlVO.getRadius()))
+                            .process(pointXmlVO.getProcess())
+                            .build());
                }
            }
        }
    }

    /**
-     * 处理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()
-                        .pointX(Double.parseDouble(pointXmlVO.getPointX()))
-                        .pointY(Double.parseDouble(pointXmlVO.getPointY()))
-                        .curve(Double.parseDouble(pointXmlVO.getCurvature()))
-                        .radius(Double.parseDouble(pointXmlVO.getRadius()))
-                        .process(pointXmlVO.getProcess())
-                        .build());
+    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()))
+                            .radius(Double.parseDouble(pointXmlVO.getRadius()))
+                            .process(pointXmlVO.getProcess())
+                            .build());
+                }
            }
        }
    }

    /**
-     * 处理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);
-                Map<String, Integer> holeCountMap = new HashMap<>();
-                holeCountMap.put("count", Integer.valueOf(holeXmlVOS.getCount()));
-                holeCountMap.put("countFaceA", Integer.valueOf(holeXmlVOS.getCountFaceA()));
-                holeCountMap.put("countFaceB", Integer.valueOf(holeXmlVOS.getCountFaceB()));
-                holeCountMap.put("countSide", Integer.valueOf(holeXmlVOS.getCountSide()));
-                holeCountMap.put("countSideL", Integer.valueOf(holeXmlVOS.getCountSideL()));
-                holeCountMap.put("countSideD", Integer.valueOf(holeXmlVOS.getCountSideD()));
-                holeCountMap.put("countSideR", Integer.valueOf(holeXmlVOS.getCountSideR()));
-                holeCountMap.put("countSideU", Integer.valueOf(holeXmlVOS.getCountSideU()));
-                holeCountMap.put("countBevelled", Integer.valueOf(holeXmlVOS.getCountBevelled()));
-                holeCountMap.put("countLocking", Integer.valueOf(holeXmlVOS.getCountLocking()));
-                holeCountMap.put("countBuildIn", Integer.valueOf(holeXmlVOS.getCountBuildIn()));
-                holeCountMap.put("countHinge", Integer.valueOf(holeXmlVOS.getCountHinge()));
-                holeCountMap.put("countThrough", Integer.valueOf(holeXmlVOS.getCountThrough()));
-
-                orderModelDO.getHoleCount().putAll(holeCountMap);
-                plateDO.setFrontHoleCount(Integer.valueOf(holeXmlVOS.getCountFaceA()));
-                plateDO.setBackHoleCount(Integer.valueOf(holeXmlVOS.getCountFaceB()));
-                plateDO.setSideHoleCount(Integer.valueOf(holeXmlVOS.getCountSide()));
-
-                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);
-                        HoleDetail holeDetail = createHoleDetail(holeXmlVO);
-                        orderModelDO.getHoleDetail().add(holeDetail);
-                    }
-                }
-            }
+    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 holeXmlVO
+     * @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()));
+        holeCountMap.put("countFaceB", Integer.valueOf(holeXmlVOS.getCountFaceB()));
+        holeCountMap.put("countSide", Integer.valueOf(holeXmlVOS.getCountSide()));
+        holeCountMap.put("countSideL", Integer.valueOf(holeXmlVOS.getCountSideL()));
+        holeCountMap.put("countSideD", Integer.valueOf(holeXmlVOS.getCountSideD()));
+        holeCountMap.put("countSideR", Integer.valueOf(holeXmlVOS.getCountSideR()));
+        holeCountMap.put("countSideU", Integer.valueOf(holeXmlVOS.getCountSideU()));
+        holeCountMap.put("countBevelled", Integer.valueOf(holeXmlVOS.getCountBevelled()));
+        holeCountMap.put("countLocking", Integer.valueOf(holeXmlVOS.getCountLocking()));
+        holeCountMap.put("countBuildIn", Integer.valueOf(holeXmlVOS.getCountBuildIn()));
+        holeCountMap.put("countHinge", Integer.valueOf(holeXmlVOS.getCountHinge()));
+        holeCountMap.put("countThrough", Integer.valueOf(holeXmlVOS.getCountThrough()));
+        return 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");
+        }
+    }
+
+    private void addHoleDetailsToPlateDetail(OrderModelDO plateDetail, List<HoleXmlVO> holeXmlVOList) {
+        for (HoleXmlVO holeXmlVO : holeXmlVOList) {
+            HoleDetail holeDetail = createHoleDetail(holeXmlVO);
+            plateDetail.getHoleDetail().add(holeDetail);
+        }
+    }
+
    private HoleDetail createHoleDetail(HoleXmlVO holeXmlVO) {
        String faceType = DictFrameworkUtils.parseDictDataValue(DictTypeConstants.HOLE_FACE, holeXmlVO.getFace());
        Integer faceTypeValue = StringUtils.isNotEmpty(faceType) ? Integer.parseInt(faceType) : 2;
@@ -943,154 +955,82 @@ 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 = new HashMap<>();
-                contourCount.put("count", Integer.valueOf(grooveXmlVOS.getCount()));
-                contourCount.put("countFaceA", Integer.valueOf(grooveXmlVOS.getCountFaceA()));
-                contourCount.put("countFaceB", Integer.valueOf(grooveXmlVOS.getCountFaceB()));
-                contourCount.put("countSide", Integer.valueOf(grooveXmlVOS.getCountSide()));
-                contourCount.put("countSideL", Integer.valueOf(grooveXmlVOS.getCountSideL()));
-                contourCount.put("countSideD", Integer.valueOf(grooveXmlVOS.getCountSideD()));
-                contourCount.put("countSideR", Integer.valueOf(grooveXmlVOS.getCountSideR()));
-                contourCount.put("countSideU", Integer.valueOf(grooveXmlVOS.getCountSideU()));
-                contourCount.put("countBevelled", Integer.valueOf(grooveXmlVOS.getCountBevelled()));
-                contourCount.put("countRectangle", Integer.valueOf(grooveXmlVOS.getCountRectangle()));
-                contourCount.put("count2V", Integer.valueOf(grooveXmlVOS.getCount2V()));
-                contourCount.put("count3D", Integer.valueOf(grooveXmlVOS.getCount3D()));
-                contourCount.put("countThrough", Integer.valueOf(grooveXmlVOS.getCountThrough()));
+        Map<String, Integer> contourCount = extractContourCount(grooveXmlVOS);
+        updatePlateDetailWithContourCount(plateDetail, contourCount);
+        updatePlateDOWithContourCount(plateDO, grooveXmlVOS);
+        updatePlateDOFilterTypeIfThroughGroovesExist(plateDO, grooveXmlVOS);

-                orderModelDO.getContourCount().putAll(contourCount);
-                orderModelDO.setHas2DModel(contourCount.getOrDefault("count2V", 0) > 0);
-                orderModelDO.setHas3DModel(contourCount.getOrDefault("count3D", 0) > 0);
-                plateDO.setFrontModelCount(Integer.valueOf(grooveXmlVOS.getCountFaceA()));
-                plateDO.setBackModelCount(Integer.valueOf(grooveXmlVOS.getCountFaceB()));
-                if (grooveXmlVOS.getCountThrough() != null && Integer.parseInt(grooveXmlVOS.getCountThrough()) > 0) {
-                    plateDO.setFilterType(plateDO.getFilterType() + ",1");
-                }
-
-                addGrooveDetailsToPlateDetail(blockProductionCode, orderModelDO);
-            }
+        if (grooveXmlVOS.getGrooveXmlVOList() != null && !grooveXmlVOS.getGrooveXmlVOList().isEmpty()) {
+            addGrooveDetailsToPlateDetail(plateDetail, grooveXmlVOS.getGrooveXmlVOList(), isletXmlVOS);
        }
    }

    /**
-     * 处理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
+     * @param grooveXmlVOS
     * @return
     */
-    private ModelDetail createModelDetail(String blockProductionCode, GrooveXmlVO grooveXmlVO) {
+    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()));
+        contourCount.put("countFaceB", Integer.valueOf(grooveXmlVOS.getCountFaceB()));
+        contourCount.put("countSide", Integer.valueOf(grooveXmlVOS.getCountSide()));
+        contourCount.put("countSideL", Integer.valueOf(grooveXmlVOS.getCountSideL()));
+        contourCount.put("countSideD", Integer.valueOf(grooveXmlVOS.getCountSideD()));
+        contourCount.put("countSideR", Integer.valueOf(grooveXmlVOS.getCountSideR()));
+        contourCount.put("countSideU", Integer.valueOf(grooveXmlVOS.getCountSideU()));
+        contourCount.put("countBevelled", Integer.valueOf(grooveXmlVOS.getCountBevelled()));
+        contourCount.put("countRectangle", Integer.valueOf(grooveXmlVOS.getCountRectangle()));
+        contourCount.put("count2V", Integer.valueOf(grooveXmlVOS.getCount2V()));
+        contourCount.put("count3D", Integer.valueOf(grooveXmlVOS.getCount3D()));
+        contourCount.put("countThrough", Integer.valueOf(grooveXmlVOS.getCountThrough()));
+        return contourCount;
+    }
+
+    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");
+        }
+    }
+
+    private void addGrooveDetailsToPlateDetail(OrderModelDO plateDetail, List<GrooveXmlVO> grooveXmlVOList, IsletXmlVOS isletXmlVOS) {
+        for (GrooveXmlVO grooveXmlVO : grooveXmlVOList) {
+            ModelDetail modelDetail = createModelDetail(grooveXmlVO, isletXmlVOS);
+            plateDetail.getContourDetail().add(modelDetail);
+        }
+    }
+
+    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);
-                    holes.add(hole);
-                }
+                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()
-                        .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;
+    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()).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()
-                        .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());
-            }
+    private List<IContourData> addOutlineDetail(OutlineXmlVO outlineXmlVO) {
+        if (outlineXmlVO == null || outlineXmlVO.getPointXmlVOList() == null) {
+            return null;
        }
-        return iContourDataList;
+        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()).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()));
+        }
+    }
+
    /**
     * 解析配件列表
     */