工序设备表数据处理

src/main/java/com/aps/controller/ScheduleController.java

@@ -82,7 +82,7 @@ public class ScheduleController {
             }
             
             // 提取工序ID用于后续查询
-            Set<Integer> operationIds = operations.stream()
+            Set<Long> operationIds = operations.stream()
                     .map(RoutingDetail::getId)
                     .collect(Collectors.toSet());
             
@@ -96,7 +96,7 @@ public class ScheduleController {
             }
             
             // 提取设备ID用于后续查询
-            Set<Integer> equipmentIds = operationEquipments.stream()
+            Set<Long> equipmentIds = operationEquipments.stream()
                     .map(RoutingDetailEquip::getEquipId)
                     .collect(Collectors.toSet());
             

src/main/java/com/aps/controller/ScheduleResultController.java

@@ -90,7 +90,7 @@ public class ScheduleResultController {
             }
 
             // 提取工序ID用于后续查询
-            Set<Integer> operationIds = operations.stream()
+            Set<Long> operationIds = operations.stream()
                     .map(RoutingDetail::getId)
                     .collect(Collectors.toSet());
 
@@ -104,7 +104,7 @@ public class ScheduleResultController {
             }
 
             // 提取设备ID用于后续查询
-            Set<Integer> equipmentIds = operationEquipments.stream()
+            Set<Long> equipmentIds = operationEquipments.stream()
                     .map(RoutingDetailEquip::getEquipId)
                     .collect(Collectors.toSet());
 

src/main/java/com/aps/controller/ScheduleResultController1.java

@@ -105,7 +105,7 @@ public class ScheduleResultController1 {
             }
 
             // 提取工序ID用于后续查询
-            Set<Integer> operationIds = operations.stream()
+            Set<Long> operationIds = operations.stream()
                     .map(RoutingDetail::getId)
                     .collect(Collectors.toSet());
 
@@ -119,7 +119,7 @@ public class ScheduleResultController1 {
             }
 
             // 提取设备ID用于后续查询
-            Set<Integer> equipmentIds = operationEquipments.stream()
+            Set<Long> equipmentIds = operationEquipments.stream()
                     .map(RoutingDetailEquip::getEquipId)
                     .collect(Collectors.toSet());
 

src/main/java/com/aps/entity/ApsOrder.java

@@ -30,10 +30,10 @@ private String mmid;
 private String mmcode;
 private String mmname;
 private String unit;
-private BigDecimal quantity;
-private BigDecimal meetquantity;
-private BigDecimal meetrate;
-private BigDecimal price;
+private double quantity;
+private double meetquantity;
+private double meetrate;
+private double price;
 private LocalDateTime deliverytime;
 private Long stockid;
 private String stock;

src/main/java/com/aps/entity/ProdEquipment.java

+package com.aps.entity;
+
+import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.io.Serializable;
+
+@Data
+@TableName("prod_equipment")
+public class ProdEquipment implements Serializable {
+
+    private String sceneId;
+    private Long equipId;
+    private String equipCode;
+    private String equipName;
+    private Long resourceId;
+    private String execId;
+    private Double speed;
+}
\ No newline at end of file

src/main/java/com/aps/entity/ProdLaunchOrder.java

@@ -26,7 +26,7 @@ public class ProdLaunchOrder {
     private Integer orderPriority;
     private String groupCode;
     private String colorCode;
-    private BigDecimal quantity;
+    private double quantity;
     private String orderStatus;//S未启动E执行中C已完成
     private String materialId;
     private String routingCode;

src/main/java/com/aps/entity/ProdOrderProcess.java

@@ -9,4 +9,6 @@ private String orderId;
 private String taskSeq;
 private String targetOrderId;
 private String targetTaskSeq;
+private String execId;
+private String targetExecId;
 }
\ No newline at end of file

src/main/java/com/aps/entity/ProdProcessExec.java

 package com.aps.entity;
 
 import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 
 @Data
+@TableName("prod_process_exec")
 public class ProdProcessExec {
-private String execId;
-private String sceneId;
-private String orderId;
-private String routingDetailId;
-private String taskSeq;
-private String routingDetailName;
-private Long machineId;
-private String resourceGroup;
-private BigDecimal planQty;
-private BigDecimal actualQty;
-private Long planDuration;
-private Long usedDuration;
-private Long remainDuration;
-private String processStatus;
-private Long standardCapacity;
-private Long minCapacity;
-private Long maxCapacity;
-private Long prepDuration;
-private Long changeDuration;
-private Short logicalOrder;
-private LocalDateTime targetStartDate;
-private LocalDateTime targetEndDate;
+
+    private String execId;
+    private String sceneId;
+    private String orderId;
+    private Long routingDetailId;
+    private Long taskSeq;
+    private String routingDetailName;
+    private Long machineId;
+    private String resourceGroup;
+    private Double planQty;
+    private Double actualQty;
+    private Long planDuration;
+    private Long usedDuration;
+    private Long remainDuration;
+    private String processStatus;
+    private Long standardCapacity;
+    private Long minCapacity;
+    private Long maxCapacity;
+    private Long prepDuration;
+    private Long changeDuration;
+    private Long logicalOrder;
+    private LocalDateTime targetStartDate;
+    private LocalDateTime targetEndDate;
 
     /**
      * 工序准备工时（小时）
@@ -66,5 +70,5 @@ private LocalDateTime targetEndDate;
     private Long postprocessingTime;
 
     //速度
-    private BigDecimal speed;
+    private Double speed;
 }
\ No newline at end of file

src/main/java/com/aps/entity/RoutingDetail.java

@@ -8,7 +8,7 @@ import lombok.Data;
 
 @Data
 public class RoutingDetail {
-private Integer id;
+private Long id;
 private LocalDateTime creationTime;
 private BigDecimal creatorUserId;
 private LocalDateTime lastModificationTime;
@@ -19,7 +19,7 @@ private LocalDateTime deletionTime;
 private Long classId;
 private Long routingHeaderId;
 private String name;
-private Short taskSeq;
+private Long taskSeq;
 private String description;
 private String taskContent;
 private Long resourceId;

src/main/java/com/aps/entity/RoutingDetailConnect.java

@@ -8,13 +8,13 @@ import java.time.LocalDateTime;
 public class RoutingDetailConnect {
 private Long id;
 private LocalDateTime creationtime;
-private Long creatoruserid;
+private Long  creatoruserid;
 private LocalDateTime lastmodificationtime;
-private Long lastmodifieruserid;
-private Long isdeleted;
+private Integer lastmodifieruserid;
+private Integer isdeleted;
 private LocalDateTime deletiontime;
-private Long deleteruserid;
-private Long destoperationid;
+private Long  deleteruserid;
+private Long  destoperationid;
 private Long sourceoperationid;
 private String destoperation;
 private String sourceoperation;

src/main/java/com/aps/entity/RoutingDetailEquip.java

@@ -45,7 +45,7 @@ public class RoutingDetailEquip implements Serializable {
     /**
      * 更新人
      */
-    private Integer lastmodifieruserid;
+    private Long lastmodifieruserid;
 
     /**
      * 删除人
@@ -65,7 +65,7 @@ public class RoutingDetailEquip implements Serializable {
     /**
      * 设备类型
      */
-    private Integer type1;
+    private Long type1;
 
     /**
      * 设备类型名
@@ -111,17 +111,17 @@ public class RoutingDetailEquip implements Serializable {
     /**
      * 工序id
      */
-    private Integer routingDetailId;
+    private Long routingDetailId;
 
     /**
      * 设备id
      */
-    private Integer equipId;
+    private Long equipId;
 
     /**
      * 工艺id
      */
-    private Integer routingHeaderId;
+    private Long routingHeaderId;
 
     /**
      * 单次批量产出

src/main/java/com/aps/entity/ScheduledTask.java

@@ -9,8 +9,8 @@ import java.time.LocalDateTime;
 @Data
 public class ScheduledTask {
     private String orderId;       // 工单ID
-    private Integer operationId;  // 工序ID
-    private Integer equipId;      // 设备ID
+    private Long operationId;  // 工序ID
+    private Long equipId;      // 设备ID
     @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime startTime; // 实际开始时间
     @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")

src/main/java/com/aps/mapper/ProdEquipmentMapper.java

+package com.aps.mapper;
+
+import com.aps.entity.ProdEquipment;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author MyBatis-Plus
+ * @since 2025-11-27
+ */
+public interface ProdEquipmentMapper extends BaseMapper<ProdEquipment> {
+
+}

src/main/java/com/aps/service/ProdEquipmentService.java

+package com.aps.service;
+
+import com.aps.entity.ProdEquipment;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author MyBatis-Plus
+ * @since 2025-11-27
+ */
+public interface ProdEquipmentService extends IService<ProdEquipment> {
+
+}

src/main/java/com/aps/service/impl/LanuchServiceImpl.java

@@ -18,21 +18,20 @@ import java.math.RoundingMode;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.UUID;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
- * 设备日历服务实现类
- * 负责生成设备日历数据、处理订单数据转换等功能
+ • 设备日历服务实现类
+
+ • 负责生成设备日历数据、处理订单数据转换等功能
+
  */
 @Slf4j
 @Service
-@RequiredArgsConstructor  // 使用构造器注入替代@Autowired
+@RequiredArgsConstructor
 public class LanuchServiceImpl implements LanuchService {
-    
+
     @Autowired
     ProdEquipSpecialCalService prodEquipSpecialCalService;
     @Autowired
@@ -56,13 +55,22 @@ public class LanuchServiceImpl implements LanuchService {
     RoutingHeaderMapper routingHeaderMapper;
     @Autowired
     ProdSceneConfigService prodSceneConfigService;
+
+    @Autowired
+    ProdEquipmentService prodEquipmentService;
+    @Autowired
+    RoutingDetailEquipService routingDetailEquipService;
     /**
-     * 生成场景数据
+     ◦ 生成场景数据
+
      *
      *
-     * @param sceneName        场景名称
-     * @param username         操作用户
-     * @return 处理结果
+     ◦ @param sceneName        场景名称
+
+     ◦ @param username         操作用户
+
+     ◦ @return 处理结果
+
      */
     @Override
     @Transactional(rollbackFor = Exception.class)
@@ -72,9 +80,9 @@ public class LanuchServiceImpl implements LanuchService {
             if (sceneName == null || sceneName.trim().isEmpty()) {
                 return R.failed("场景名称不能为空");
             }
-            
 
-            
+
+
             // 1. 创建场景
             String sceneId = createScene(sceneName);
             if (sceneId == null) {
@@ -97,9 +105,10 @@ public class LanuchServiceImpl implements LanuchService {
             // 5. 转换工单于工序执行表
             convertToProcessExecBatch(prodLaunchOrders, sceneId);
 
+
             // 6. 生成工序关联关系
             generateProcessRelationsBatch(prodLaunchOrders, sceneId);
-            
+
             log.info("场景数据生成完成，场景ID：{}", sceneId);
             return R.ok("场景数据生成成功");
         } catch (Exception e) {
@@ -107,15 +116,17 @@ public class LanuchServiceImpl implements LanuchService {
             return R.failed("生成场景数据失败: " + e.getMessage());
         }
     }
-    
+
 
 
 
 
     /**
-     * 处理订单数据：批量转换ProdOrderMain到ProdLaunchOrder
+     ◦ 处理订单数据：批量转换ProdOrderMain到ProdLaunchOrder
+
      *
-     * @param sceneId 场景ID
+     ◦ @param sceneId 场景ID
+
      */
     private List<ProdLaunchOrder> processOrderData(String sceneId, List<ApsOrder> prodOrderMainList) {
 
@@ -126,11 +137,9 @@ public class LanuchServiceImpl implements LanuchService {
                 .filter(Objects::nonNull)
                 .collect(Collectors.toList());
 
-        // 在您的 LanuchServiceImpl 中修改这一行：
-// 原来的问题代码：
-// prodLaunchOrderService.saveBatch(launchOrders);
 
-// 修改为：
+
+        // 批量插入
         if (!launchOrderList .isEmpty()) {
             for (ProdLaunchOrder order : launchOrderList ) {
                 try {
@@ -148,11 +157,15 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 将ProdOrderMain转换为ProdLaunchOrder
+     ◦ 将ProdOrderMain转换为ProdLaunchOrder
+
      *
-     * @param order    源订单
-     * @param sceneId  场景ID
-     * @return 转换后的ProdLaunchOrder
+     ◦ @param order    源订单
+
+     ◦ @param sceneId  场景ID
+
+     ◦ @return 转换后的ProdLaunchOrder
+
      */
     private ProdLaunchOrder convertToLaunchOrder(ApsOrder order, String sceneId) {
         try {
@@ -168,7 +181,7 @@ public class LanuchServiceImpl implements LanuchService {
             launchOrder.setOrderPriority(1);
             launchOrder.setQuantity(order.getQuantity());
             launchOrder.setMaterialId(order.getMmid());
-            
+
             String mmid = order.getMmid();
             // 通过mmid查找对应的工艺
             if (mmid != null && !mmid.isEmpty()) {
@@ -180,7 +193,7 @@ public class LanuchServiceImpl implements LanuchService {
                 if (!CollectionUtils.isEmpty(routingHeaders)) {
                     routingHeader = routingHeaders.get(0);
                 }
-                
+
                 if (routingHeader != null) {
                     launchOrder.setRoutingId(routingHeader.getId().toString());
                     launchOrder.setRoutingCode(defaultIfBlank(routingHeader.getCode(), ""));
@@ -195,10 +208,13 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 创建场景
+     ◦ 创建场景
+
      *
-     * @param sceneName 场景名称
-     * @return 场景ID，如果场景已存在则返回null
+     ◦ @param sceneName 场景名称
+
+     ◦ @return 场景ID，如果场景已存在则返回null
+
      */
     private String createScene(String sceneName) {
         // 检查场景名称是否已存在
@@ -226,26 +242,34 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 生成场景ID
+     ◦ 生成场景ID
+
      *
-     * @return 格式化的场景ID
+     ◦ @return 格式化的场景ID
+
      */
     private String generateSceneId() {
         return UUID.randomUUID().toString().replace("-", "").toUpperCase();
     }
 
     /**
-     * 生成日历数据
+     ◦ 生成日历数据
+
      *
-     * @param sceneId           场景ID
-     * @param planResource      设备信息
-     * @param shiftWorkSchedList 班次信息
-     * @param startTime         开始时间
-     * @param endTime           结束时间
+     ◦ @param sceneId           场景ID
+
+     ◦ @param planResource      设备信息
+
+     ◦ @param shiftWorkSchedList 班次信息
+
+     ◦ @param startTime         开始时间
+
+     ◦ @param endTime           结束时间
+
      */
     private void generateCalendarData(String sceneId, PlanResource planResource,
-                                     List<MesShiftWorkSched> shiftWorkSchedList,
-                                     LocalDateTime startTime, LocalDateTime endTime) {
+                                      List<MesShiftWorkSched> shiftWorkSchedList,
+                                      LocalDateTime startTime, LocalDateTime endTime) {
         LocalDate currentDate = startTime.toLocalDate();
         LocalDate endDate = endTime.toLocalDate();
 
@@ -258,7 +282,7 @@ public class LanuchServiceImpl implements LanuchService {
             for (MesShiftWorkSched shiftWorkSched : shiftWorkSchedList) {
                 if (shiftWorkSched.getStartWeekDay() == dayOfWeekValue) {
                     processSingleShift(sceneId, planResource, shiftWorkSched,
-                                     currentDate, startTime, endTime, calendarList);
+                            currentDate, startTime, endTime, calendarList);
                 }
             }
 
@@ -273,20 +297,28 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 处理单个班次
+     ◦ 处理单个班次
+
      *
-     * @param sceneId         场景ID
-     * @param planResource    设备信息
-     * @param shiftWorkSched  班次信息
-     * @param currentDate     当前日期
-     * @param startTime       开始时间
-     * @param endTime         结束时间
-     * @param calendarList    日历列表
+     ◦ @param sceneId         场景ID
+
+     ◦ @param planResource    设备信息
+
+     ◦ @param shiftWorkSched  班次信息
+
+     ◦ @param currentDate     当前日期
+
+     ◦ @param startTime       开始时间
+
+     ◦ @param endTime         结束时间
+
+     ◦ @param calendarList    日历列表
+
      */
     private void processSingleShift(String sceneId, PlanResource planResource,
-                                   MesShiftWorkSched shiftWorkSched, LocalDate currentDate,
-                                   LocalDateTime startTime, LocalDateTime endTime,
-                                   List<ProdEquipSpecialCal> calendarList) {
+                                    MesShiftWorkSched shiftWorkSched, LocalDate currentDate,
+                                    LocalDateTime startTime, LocalDateTime endTime,
+                                    List<ProdEquipSpecialCal> calendarList) {
         LocalTime shiftStartTimeRaw = shiftWorkSched.getShiftStart().toLocalTime();
         LocalTime shiftEndTimeRaw = shiftWorkSched.getShiftEnd().toLocalTime();
 
@@ -309,24 +341,31 @@ public class LanuchServiceImpl implements LanuchService {
 
         if (actualStartTime.isBefore(actualEndTime)) {
             ProdEquipSpecialCal equipSpecialCal = createCalendarRecord(sceneId, planResource,
-                                                                      shiftWorkSched, actualStartTime, actualEndTime);
+                    shiftWorkSched, actualStartTime, actualEndTime);
             calendarList.add(equipSpecialCal);
         }
     }
 
     /**
-     * 创建日历记录
+     ◦ 创建日历记录
+
      *
-     * @param sceneId         场景ID
-     * @param planResource    设备信息
-     * @param shiftWorkSched  班次信息
-     * @param startTime       开始时间
-     * @param endTime         结束时间
-     * @return 日历记录
+     ◦ @param sceneId         场景ID
+
+     ◦ @param planResource    设备信息
+
+     ◦ @param shiftWorkSched  班次信息
+
+     ◦ @param startTime       开始时间
+
+     ◦ @param endTime         结束时间
+
+     ◦ @return 日历记录
+
      */
     private ProdEquipSpecialCal createCalendarRecord(String sceneId, PlanResource planResource,
-                                                    MesShiftWorkSched shiftWorkSched,
-                                                    LocalDateTime startTime, LocalDateTime endTime) {
+                                                     MesShiftWorkSched shiftWorkSched,
+                                                     LocalDateTime startTime, LocalDateTime endTime) {
         ProdEquipSpecialCal equipSpecialCal = new ProdEquipSpecialCal();
         equipSpecialCal.setSceneId(sceneId);
         equipSpecialCal.setEquipId(planResource.getReferenceId());
@@ -340,10 +379,13 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 批量转换工单于工序执行表
+     ◦ 批量转换工单于工序执行表
+
      *
-     * @param order 工单列表
-     * @param sceneId          场景ID
+     ◦ @param order 工单列表
+
+     ◦ @param sceneId          场景ID
+
      */
     private void convertToProcessExecBatch(List<ProdLaunchOrder> order, String sceneId) {
         if (CollectionUtils.isEmpty(order)) {
@@ -365,11 +407,15 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 转换工单到工序执行表
+     ◦ 转换工单到工序执行表
+
      *
-     * @param prodOrderMain  工单ID
-     * @param sceneId   场景ID
-     * @return 转换结果
+     ◦ @param prodOrderMain  工单ID
+
+     ◦ @param sceneId   场景ID
+
+     ◦ @return 转换结果
+
      */
     public boolean convertToProcessExec(ProdLaunchOrder prodOrderMain, String sceneId) {
 
@@ -381,9 +427,11 @@ public class LanuchServiceImpl implements LanuchService {
 
         List<RoutingDetail> routingDetails = getRoutingDetails(routingHeader.getId());
 
+        List<RoutingDetailEquip> routingDetailEquip = getRoutingDetailEquip(routingHeader.getId());
+
 
         // 批量插入新的工序工单记录
-        batchInsertProcessExec(prodOrderMain, routingDetails, sceneId);
+        batchInsertProcessExec(prodOrderMain, routingDetails, sceneId,routingDetailEquip);
 
 
 
@@ -391,15 +439,18 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 获取工艺信息
+     ◦ 获取工艺信息
+
      *
-     * @param routingId 工艺ID
-     * @return 工艺信息
+     ◦ @param routingId 工艺ID
+
+     ◦ @return 工艺信息
+
      */
     private RoutingHeader getRoutingHeader(String routingId) {
         LambdaQueryWrapper<RoutingHeader> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(RoutingHeader::getId, routingId)
-               .eq(RoutingHeader::getIsDeleted, 0); // 添加 is_deleted=0 过滤条件
+                .eq(RoutingHeader::getIsDeleted, 0); // 添加 is_deleted=0 过滤条件
         RoutingHeader routingHeader = routingHeaderMapper.selectOne(wrapper);
 
         if (routingHeader == null) {
@@ -411,16 +462,19 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 获取工艺工序列表
+     ◦ 获取工艺工序列表
+
      *
-     * @param routingHeaderId 工艺头ID
-     * @return 工序列表
+     ◦ @param routingHeaderId 工艺头ID
+
+     ◦ @return 工序列表
+
      */
     private List<RoutingDetail> getRoutingDetails(Integer routingHeaderId) {
         LambdaQueryWrapper<RoutingDetail> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(RoutingDetail::getRoutingHeaderId, routingHeaderId)
-               .eq(RoutingDetail::getIsDeleted, 0) // 添加 is_deleted=0 过滤条件
-               .orderByAsc(RoutingDetail::getTaskSeq);
+                .eq(RoutingDetail::getIsDeleted, 0) // 添加 is_deleted=0 过滤条件
+                .orderByAsc(RoutingDetail::getTaskSeq);
 
         List<RoutingDetail> routingDetails = routingDetailMapper.selectList(wrapper);
 
@@ -434,41 +488,60 @@ public class LanuchServiceImpl implements LanuchService {
 
 
     /**
-     * 批量插入工序执行记录
+     ◦ 批量插入工序执行记录
+
      *
-     * @param prodOrderMain 工单信息
-     * @param routingDetails 工序列表
-     * @param sceneId       场景ID
+     ◦ @param prodOrderMain 工单信息
+
+     ◦ @param routingDetails 工序列表
+
+     ◦ @param sceneId       场景ID
+
      */
     private void batchInsertProcessExec(ProdLaunchOrder prodOrderMain,
-                                       List<RoutingDetail> routingDetails,
-                                       String sceneId) {
+                                        List<RoutingDetail> routingDetails,
+                                        String sceneId, List<RoutingDetailEquip> routingDetailEquip)  {
         List<ProdProcessExec> processExecList = routingDetails.stream()
                 .map(detail -> createProcessExec(prodOrderMain, detail, sceneId))
                 .collect(Collectors.toList());
 
+        batchInsertEquipMent(routingDetailEquip, sceneId,processExecList);
+
         // 批量插入
         if (!CollectionUtils.isEmpty(processExecList)) {
             prodProcessExecService.saveBatch(processExecList); // 假设MyBatis-Plus支持批量插入
         }
     }
 
+    // 添加一个方法来更新execId映射
+    /*
+    private void updateExecIdMapping(List<ProdProcessExec> processExecList) {
+        // 这里可以将processExecList中的数据添加到一个全局映射中，供其他方法使用
+        // 由于当前设计限制，暂不实现全局映射，但保留此方法以备将来扩展
+    }
+    */
+
     /**
-     * 创建工序执行记录
+     ◦ 创建工序执行记录
+
      *
-     * @param prodOrderMain 工单信息
-     * @param detail        工序详情
-     * @param sceneId       场景ID
-     * @return 工序执行记录
+     ◦ @param prodOrderMain 工单信息
+
+     ◦ @param detail        工序详情
+
+     ◦ @param sceneId       场景ID
+
+     ◦ @return 工序执行记录
+
      */
     private ProdProcessExec createProcessExec(ProdLaunchOrder prodOrderMain,
-                                             RoutingDetail detail,
-                                             String sceneId) {
+                                              RoutingDetail detail,
+                                              String sceneId) {
         ProdProcessExec prodProcessExec = new ProdProcessExec();
         prodProcessExec.setExecId(UUID.randomUUID().toString().replace("-", ""));
         prodProcessExec.setOrderId(prodOrderMain.getOrderId());
-        prodProcessExec.setRoutingDetailId(String.valueOf(detail.getId()));
-        prodProcessExec.setTaskSeq(String.valueOf(detail.getTaskSeq()));
+        prodProcessExec.setRoutingDetailId(detail.getId());
+        prodProcessExec.setTaskSeq(detail.getTaskSeq());
         prodProcessExec.setRoutingDetailName(detail.getName());
         prodProcessExec.setMachineId(detail.getEquipTypeId());
 //        prodProcessExec.setResourceGroup(String.valueOf(detail.getResourceId()));
@@ -487,20 +560,24 @@ public class LanuchServiceImpl implements LanuchService {
                 Optional.ofNullable(detail.getSingleOut())
                         .filter(out -> detail.getRuntime() != null)
                         .filter(out -> detail.getRuntime().compareTo(BigDecimal.ZERO) != 0)
-                        .map(out -> out.divide(detail.getRuntime(), 4, RoundingMode.HALF_UP))
-                        .orElse(BigDecimal.ZERO)
+                        .map(out -> out.divide(detail.getRuntime(), 6, RoundingMode.HALF_UP))
+                        .map(BigDecimal::doubleValue)  // 关键转换
+                        .orElse(0.0)
         );
-        System.out.println(prodProcessExec.getSpeed());
+
         return prodProcessExec;
     }
 
 
 
     /**
-     * 批量生成工序关联关系
+     ◦ 批量生成工序关联关系
+
      *
-     * @param prodOrderMains 工单ID列表
-     * @param sceneId          场景ID
+     ◦ @param prodOrderMains 工单ID列表
+
+     ◦ @param sceneId          场景ID
+
      */
     private void generateProcessRelationsBatch(List<ProdLaunchOrder> prodOrderMains, String sceneId) {
         if (CollectionUtils.isEmpty(prodOrderMains)) {
@@ -508,18 +585,47 @@ public class LanuchServiceImpl implements LanuchService {
             return;
         }
 
-        generateProcessRelations(prodOrderMains, sceneId);
+        // 先批量获取所有需要的ProdProcessExec对象
+        Set<Long> routingDetailIds = new HashSet<>();
+        for (ProdLaunchOrder order : prodOrderMains) {
+            List<RoutingDetailConnect> connections = routingDetailConnectService.lambdaQuery()
+                    .eq(RoutingDetailConnect::getRoutingHeaderId, order.getRoutingId())
+                    .eq(RoutingDetailConnect::getIsdeleted, 0)
+                    .list();
+
+            for (RoutingDetailConnect connection : connections) {
+                routingDetailIds.add(connection.getSourceoperationid());
+                routingDetailIds.add(connection.getDestoperationid());
+            }
+        }
+
+        List<ProdProcessExec> processExecList = prodProcessExecService.lambdaQuery()
+                .eq(ProdProcessExec::getSceneId, sceneId)
+                .in(ProdProcessExec::getRoutingDetailId, new ArrayList<>(routingDetailIds))
+                .list();
+
+        // 构建routingDetailId到execId的映射
+        Map<Long, String> routingDetailIdToExecIdMap = processExecList.stream()
+                .collect(Collectors.toMap(
+                        ProdProcessExec::getRoutingDetailId,
+                        ProdProcessExec::getExecId,
+                        (existing, replacement) -> existing)); // 处理重复key的情况
+
+        generateProcessRelations(prodOrderMains, sceneId, routingDetailIdToExecIdMap);
 
         log.info("完成{}个工单的工序关系生成", prodOrderMains.size());
     }
 
     /**
-     * 生成工序关联关系
+     ◦ 生成工序关联关系
+
      *
-     * @param prodOrderMains 工单列表
-     * @param sceneId        场景ID
+     ◦ @param prodOrderMains 工单列表
+
+     ◦ @param sceneId        场景ID
+
      */
-    public void generateProcessRelations(List<ProdLaunchOrder> prodOrderMains, String sceneId) {
+    public void generateProcessRelations(List<ProdLaunchOrder> prodOrderMains, String sceneId, Map<Long, String> routingDetailIdToExecIdMap) {
         if (CollectionUtils.isEmpty(prodOrderMains)) {
             return;
         }
@@ -528,7 +634,7 @@ public class LanuchServiceImpl implements LanuchService {
 
         for (ProdLaunchOrder prodOrderMain : prodOrderMains) {
             try {
-                List<ProdOrderProcess> relations = createProcessRelations(prodOrderMain, sceneId);
+                List<ProdOrderProcess> relations = createProcessRelations(prodOrderMain, sceneId, routingDetailIdToExecIdMap);
                 processRelations.addAll(relations);
             } catch (Exception e) {
                 log.error("生成工单[{}]工序关系失败", prodOrderMain.getOrderId(), e);
@@ -543,35 +649,45 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 创建工单工序关系
+     ◦ 创建工单工序关系
+
      *
-     * @param prodOrderMain 工单信息
-     * @param sceneId       场景ID
-     * @return 工序关系列表
+     ◦ @param prodOrderMain 工单信息
+
+     ◦ @param sceneId       场景ID
+
+     ◦ @return 工序关系列表
+
      */
-    private List<ProdOrderProcess> createProcessRelations(ProdLaunchOrder prodOrderMain, String sceneId) {
+    private List<ProdOrderProcess> createProcessRelations(ProdLaunchOrder prodOrderMain, String sceneId, Map<Long, String> routingDetailIdToExecIdMap) {
         LambdaQueryWrapper<RoutingDetailConnect> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(RoutingDetailConnect::getRoutingHeaderId, prodOrderMain.getRoutingId())
-               .eq(RoutingDetailConnect::getIsdeleted, 0); // 添加 isdeleted=0 过滤条件
+                .eq(RoutingDetailConnect::getIsdeleted, 0); // 添加 isdeleted=0 过滤条件
 
         List<RoutingDetailConnect> connections = routingDetailConnectService.list(wrapper);
 
         return connections.stream()
-                .map(connection -> createProcessRelation(prodOrderMain, connection, sceneId))
+                .map(connection -> createProcessRelation(prodOrderMain, connection, sceneId, routingDetailIdToExecIdMap))
                 .collect(Collectors.toList());
     }
 
     /**
-     * 创建单个工序关系
+     ◦ 创建单个工序关系
+
      *
-     * @param prodOrderMain 工单信息
-     * @param connection    工序连接
-     * @param sceneId       场景ID
-     * @return 工序关系
+     ◦ @param prodOrderMain 工单信息
+
+     ◦ @param connection    工序连接
+
+     ◦ @param sceneId       场景ID
+
+     ◦ @return 工序关系
+
      */
     private ProdOrderProcess createProcessRelation(ProdLaunchOrder prodOrderMain,
-                                                  RoutingDetailConnect connection,
-                                                  String sceneId) {
+                                                   RoutingDetailConnect connection,
+                                                   String sceneId,
+                                                   Map<Long, String> routingDetailIdToExecIdMap) {
         ProdOrderProcess prodOrderProcess = new ProdOrderProcess();
         prodOrderProcess.setSceneId(sceneId);
         prodOrderProcess.setOrderId(prodOrderMain.getOrderId());
@@ -579,16 +695,32 @@ public class LanuchServiceImpl implements LanuchService {
         prodOrderProcess.setTargetOrderId(prodOrderMain.getOrderId());
         prodOrderProcess.setTargetTaskSeq(connection.getDestoperation());
 
+        String execId = routingDetailIdToExecIdMap.get(connection.getSourceoperationid());
+        String targetExecId = routingDetailIdToExecIdMap.get(connection.getDestoperationid());
+
+        if (execId != null) {
+            prodOrderProcess.setExecId(execId);
+        }
+
+        if (targetExecId != null) {
+            prodOrderProcess.setTargetExecId(targetExecId);
+        }
+
         return prodOrderProcess;
     }
 
     /**
-     * 如果值为null或空白，返回默认值
+     ◦ 如果值为null或空白，返回默认值
+
      *
-     * @param value        原始值
-     * @param defaultValue 默认值
-     * @param <T>          类型
-     * @return 处理后的值
+     ◦ @param value        原始值
+
+     ◦ @param defaultValue 默认值
+
+     ◦ @param <T>          类型
+
+     ◦ @return 处理后的值
+
      */
     private <T> T defaultIfBlank(T value, T defaultValue) {
         if (value == null) {
@@ -603,14 +735,98 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     /**
-     * 如果值为null，返回默认值
+     ◦ 设备对照表
+
+     */
+    private void batchInsertEquipMent(
+            List<RoutingDetailEquip> routingDetailEquips,
+            String sceneId,List<ProdProcessExec> processExecList) {
+
+
+        if (CollectionUtils.isEmpty(routingDetailEquips)) {
+            log.warn("工艺设备列表为空，跳过设备对照表生成");
+            return;
+        }
+
+
+
+        // 创建ProdEquipment列表
+        List<ProdEquipment> prodEquipments = new java.util.ArrayList<>();
+
+        // 遍历RoutingDetailEquip列表，转换为ProdEquipment对象
+        for (RoutingDetailEquip routingDetailEquip : routingDetailEquips) {
+            ProdEquipment prodEquipment = new ProdEquipment();
+            prodEquipment.setSceneId(sceneId);
+            prodEquipment.setEquipId(routingDetailEquip.getEquipId().longValue());
+            // prodEquipment.setEquipCode(routingDetailEquip.getName());
+            prodEquipment.setEquipName(routingDetailEquip.getName());
+            prodEquipment.setResourceId(routingDetailEquip.getType1());
+
+            double duration = routingDetailEquip.getDuration() != null ? routingDetailEquip.getDuration().doubleValue() : 0.0;
+            double outputQuantity = routingDetailEquip.getOutputQuantity() != null ? routingDetailEquip.getOutputQuantity().doubleValue() : 0.0;
+            double speed = (outputQuantity > 0) ? duration / outputQuantity : 0.0;
+            prodEquipment.setSpeed(speed);
+            // 从映射中获取execId，避免额外的数据库查询
+            // 修复：使用equals比较，并处理null值
+            String execId = processExecList.stream()
+                    .filter(exec -> {
+                        Long execRoutingDetailId = exec.getRoutingDetailId();
+                        Long equipRoutingDetailId = routingDetailEquip.getRoutingDetailId();
+
+                        // 处理null值
+                        if (execRoutingDetailId == null || equipRoutingDetailId == null) {
+                            return false;
+                        }
+
+                        // 使用equals比较
+                        return execRoutingDetailId.equals(equipRoutingDetailId);
+                    })
+                    .findFirst()
+                    .map(ProdProcessExec::getExecId)
+                    .orElse(null);
+            if (execId != null) {
+                prodEquipment.setExecId(execId);
+            } else {
+                log.warn("未找到routingDetailId={}对应的execId", routingDetailEquip.getRoutingDetailId());
+            }
+
+            prodEquipments.add(prodEquipment);
+        }
+
+        // 批量保存
+        if (!prodEquipments.isEmpty()) {
+            prodEquipmentService.saveBatch(prodEquipments);
+        }
+
+
+
+    }
+
+    /**
+     ◦ 获取工艺工序列表
+
      *
-     * @param value        原始值
-     * @param defaultValue 默认值
-     * @param <T>          类型
-     * @return 处理后的值
+     ◦ @param routingHeaderId 工艺头ID
+
+     ◦ @return 工序列表
+
      */
-    private <T> T defaultIfNull(T value, T defaultValue) {
-        return value != null ? value : defaultValue;
+    private List<RoutingDetailEquip> getRoutingDetailEquip(Integer routingHeaderId) {
+
+
+        List<RoutingDetailEquip> detailEquips = routingDetailEquipService.lambdaQuery()
+                .eq(RoutingDetailEquip::getRoutingHeaderId, routingHeaderId)
+                .eq(RoutingDetailEquip::getIsdeleted, 0)
+                .list();// 添加 is_deleted=0 过滤条件
+
+
+        if (CollectionUtils.isEmpty(detailEquips)) {
+            log.error("工艺下无设备信息: {}", routingHeaderId);
+            throw new RuntimeException("工艺下无设备信息: " + routingHeaderId);
+        }
+
+        return detailEquips;
     }
+
+
 }
\ No newline at end of file

src/main/java/com/aps/service/impl/ProdEquipmentServiceImpl.java

+package com.aps.service.impl;
+
+import com.aps.entity.ProdEquipment;
+import com.aps.mapper.ProdEquipmentMapper;
+import com.aps.service.ProdEquipmentService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author MyBatis-Plus
+ * @since 2025-11-27
+ */
+@Service
+public class ProdEquipmentServiceImpl extends ServiceImpl<ProdEquipmentMapper, ProdEquipment> implements ProdEquipmentService {
+
+}

src/main/java/com/aps/service/impl/ScheduleServiceImpl.java

@@ -41,7 +41,7 @@ public class ScheduleServiceImpl implements ScheduleService {
                 ));
 
         // 2. 构建工序-设备关系映射
-        Map<Integer, List<RoutingDetailEquip>> operationToEquipments = operationEquipments.stream()
+        Map<Long, List<RoutingDetailEquip>> operationToEquipments = operationEquipments.stream()
                 .collect(Collectors.groupingBy(RoutingDetailEquip::getRoutingDetailId));
 
         // 3. 按优先级和截止时间排序工单
@@ -69,7 +69,7 @@ public class ScheduleServiceImpl implements ScheduleService {
     private void processOrder(Mpsplannedorder order,
                               List<RoutingHeader> processes,
                               List<RoutingDetail> operations,
-                              Map<Integer, List<RoutingDetailEquip>> operationToEquipments,
+                              Map<Long, List<RoutingDetailEquip>> operationToEquipments,
                               Map<Integer, EquipmentScheduleState> equipmentStates,
                               List<ScheduledTask> scheduledTasks) {
 
@@ -103,7 +103,7 @@ public class ScheduleServiceImpl implements ScheduleService {
 
     private ScheduledTask scheduleOperation(Mpsplannedorder order,
                                             RoutingDetail operation,
-                                            Map<Integer, List<RoutingDetailEquip>> operationToEquipments,
+                                            Map<Long, List<RoutingDetailEquip>> operationToEquipments,
                                             Map<Integer, EquipmentScheduleState> equipmentStates,
                                             LocalDateTime lastOperationEndTime) {
 

src/main/resources/mapper/ProdEquipmentMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.aps.mapper.ProdEquipmentMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.aps.entity.ProdEquipment">
+        <id column="SCENE_ID" property="sceneId" />
+        <id column="EQUIP_ID" property="equipId" />
+        <id column="RESOURCE_ID" property="resourceId" />
+        <result column="EQUIP_CODE" property="equipCode" />
+        <result column="EQUIP_NAME" property="equipName" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        SCENE_ID, EQUIP_ID, EQUIP_CODE, EQUIP_NAME, RESOURCE_ID
+    </sql>
+
+</mapper>