插单

src/main/java/com/aps/controller/gantt/ResourceGanttController.java

@@ -400,11 +400,23 @@ public class ResourceGanttController {
         return R.ok("复制成功");
     }
 
+    @PostMapping("/orderInsert")
+    @Operation(summary = "订单插单", description = "在指定订单后插入新订单")
+    public R<String> insertOrder(@RequestBody Map<String, Object> params) {
+        log.info("insertOrder 请求参数: {}", params);
 
+        String sceneId = ParamValidator.getString(params, "sceneId", "场景ID");
+        String afterOrderId = ParamValidator.getString(params, "afterOrderId", "插入位置订单ID");
+        
+        // 获取新订单信息
+        @SuppressWarnings("unchecked")
+        Map<String, Object> newOrderData = (Map<String, Object>) params.get("newOrder");
 
+        ParamValidator.validateSceneExists(sceneService, sceneId);
 
-
-
+        Chromosome result = planResultService.InsertOrder(sceneId, afterOrderId, newOrderData);
+        return R.ok("插单成功");
+    }
 
     @PostMapping("/ordermerge")
     @Operation(summary = "订单合并", description = "订单合并")

src/main/java/com/aps/service/Algorithm/GeneticDecoder.java

@@ -282,7 +282,7 @@ if(finishedOrder==null||finishedOrder.size()==0)
     public void decode(Chromosome chromosome) {
 
 
-        List<OrderMaterialRequirement> orderMaterials = materialRequirementService.buildMultiLevelRequirementNetwork(chromosome, sceneId, baseTime,_globalParam);
+//        List<OrderMaterialRequirement> orderMaterials = materialRequirementService.buildMultiLevelRequirementNetwork(chromosome, sceneId, baseTime,_globalParam);
         chromosome.setScenarioID(sceneId);
         if(_globalParam.isIsCheckSf()) {
          int isnew=   generateGlobalOpList(chromosome);

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

@@ -115,12 +115,22 @@ public class LanuchServiceImpl implements LanuchService {
         if (apsOrderIds.isEmpty()) {
             apsOrders = new ArrayList<>();
         } else {
-            apsOrders = apsOrderService.lambdaQuery()
-                    .eq(ApsOrder::getIsdeleted, 0)
-                    .eq(ApsOrder::getStatus, 4)
-//                    .eq(ApsOrder::getCreatoruserid, username)
-                    .in(ApsOrder::getId, apsOrderIds)
-                    .list();
+            // Oracle IN子句限制最多1000个值，需要分批查询
+            apsOrders = new ArrayList<>();
+            int batchSize = 1000;
+            for (int i = 0; i < apsOrderIds.size(); i += batchSize) {
+                int endIndex = Math.min(i + batchSize, apsOrderIds.size());
+                List<String> batchIds = apsOrderIds.subList(i, endIndex);
+                
+                List<ApsOrder> batchOrders = apsOrderService.lambdaQuery()
+                        .eq(ApsOrder::getIsdeleted, 0)
+                        .eq(ApsOrder::getStatus, 4)
+//                        .eq(ApsOrder::getCreatoruserid, username)
+                        .in(ApsOrder::getId, batchIds)
+                        .list();
+                
+                apsOrders.addAll(batchOrders);
+            }
         }
         if (CollectionUtils.isEmpty(apsOrders)) {
             throw new SceneGenerationException("工单列表不能为空");
@@ -527,8 +537,37 @@ public class LanuchServiceImpl implements LanuchService {
         }
         launchOrder.setQuantity(order.getQuantity());
         launchOrder.setMaterialId(order.getMmid());
-        launchOrder.setRoutingId(order.getRoutingid());
-        launchOrder.setRoutingCode(order.getRoutingcode());
+        
+        // 处理routingId：如果ApsOrder中没有，则根据物料ID查询
+        if (order.getRoutingid() != null) {
+            launchOrder.setRoutingId(order.getRoutingid());
+            launchOrder.setRoutingCode(order.getRoutingcode());
+        } else {
+            // 根据物料ID查询工艺路线
+            if (order.getMmid() != null && !order.getMmid().trim().isEmpty()) {
+                RoutingHeader routingHeader = routingHeaderService.lambdaQuery()
+                        .eq(RoutingHeader::getMaterialId, order.getMmid())
+                        .eq(RoutingHeader::getIsDeleted, 0)
+                        .orderByDesc(RoutingHeader::getCreationTime)
+                        .last("FETCH FIRST 1 ROWS ONLY")
+                        .one();
+                
+                if (routingHeader != null) {
+                    launchOrder.setRoutingId(routingHeader.getId());
+                    launchOrder.setRoutingCode(routingHeader.getCode());
+                    log.info("订单 {} 的物料 {} 自动匹配工艺路线: ID={}, Code={}", 
+                            order.getCode(), order.getMmid(), routingHeader.getId(), routingHeader.getCode());
+                } else {
+                    log.warn("订单 {} 的物料 {} 没有配置工艺路线", order.getCode(), order.getMmid());
+                    // 这里可以选择抛出异常或设置默认值
+                    throw new RuntimeException("订单 " + order.getCode() + " 的物料 " + order.getMmid() + " 没有配置工艺路线");
+                }
+            } else {
+                log.error("订单 {} 没有物料ID，无法查询工艺路线", order.getCode());
+                throw new RuntimeException("订单 " + order.getCode() + " 没有物料ID");
+            }
+        }
+        
         return launchOrder;
     }
 
@@ -800,19 +839,33 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
     public List<RoutingDetail> getRoutingDetails(List<Long> routingHeaderIds) {
-        LambdaQueryWrapper<RoutingDetail> wrapper = new LambdaQueryWrapper<>();
-        wrapper.in(RoutingDetail::getRoutingHeaderId, routingHeaderIds)
-                .eq(RoutingDetail::getIsDeleted, 0) // 添加 is_deleted=0 过滤条件
-                .orderByAsc(RoutingDetail::getTaskSeq);
+        if (routingHeaderIds.isEmpty()) {
+            return new ArrayList<>();
+        }
+        
+        // Oracle IN子句限制最多1000个值，需要分批查询
+        List<RoutingDetail> allRoutingDetails = new ArrayList<>();
+        int batchSize = 1000;
+        
+        for (int i = 0; i < routingHeaderIds.size(); i += batchSize) {
+            int endIndex = Math.min(i + batchSize, routingHeaderIds.size());
+            List<Long> batchIds = routingHeaderIds.subList(i, endIndex);
+            
+            LambdaQueryWrapper<RoutingDetail> wrapper = new LambdaQueryWrapper<>();
+            wrapper.in(RoutingDetail::getRoutingHeaderId, batchIds)
+                    .eq(RoutingDetail::getIsDeleted, 0) // 添加 is_deleted=0 过滤条件
+                    .orderByAsc(RoutingDetail::getTaskSeq);
 
-        List<RoutingDetail> routingDetails = routingDetailMapper.selectList(wrapper);
+            List<RoutingDetail> batchDetails = routingDetailMapper.selectList(wrapper);
+            allRoutingDetails.addAll(batchDetails);
+        }
 
-        if (CollectionUtils.isEmpty(routingDetails)) {
+        if (CollectionUtils.isEmpty(allRoutingDetails)) {
             log.error("工艺下无工序信息: {}", routingHeaderIds);
             throw new RuntimeException("工艺下无工序信息: " + routingHeaderIds);
         }
 
-        return routingDetails;
+        return allRoutingDetails;
     }
 
     /**

src/main/java/com/aps/service/plan/PlanResultService.java

@@ -98,6 +98,8 @@ public class PlanResultService {
     @Autowired
     private OrderSortService orderSortService;
 
+    @Autowired
+    private LanuchService lanuchService;
 
     @Autowired
     private MaterialInfoMapper materialInfoMapper;
@@ -231,7 +233,8 @@ public class PlanResultService {
             kpiCalculator.calculatekpi();
             
             // 添加锁定期工单到调度结果中
-//           lockedOrderProcessorService.addLockedOrdersToResult(chromosome);
+            // 这里会从 Dispatch 表加载锁定期工单，并添加到 chromosome.result 中
+//            lockedOrderProcessorService.addLockedOrdersToResult(chromosome);
 
             _sceneService.saveChromosomeToFile(chromosome, SceneId);
 
@@ -1240,6 +1243,17 @@ public class PlanResultService {
                         entry.setPriority(order.getActualPriority());
                     });
         }
+        
+        // 更新调度结果中的数量（关键：处理锁定期工单）
+        List<GAScheduleResult> results = chromosome.getResult();
+        if (results != null) {
+            results.stream()
+                    .filter(result -> result.getOrderId() != null && result.getOrderId().equals(order.getOrderId()))
+                    .forEach(result -> {
+                        result.setQuantity(order.getQuantity());
+                        log.info("更新调度结果中的订单数量: OrderId={}, 新数量={}", order.getOrderId(), order.getQuantity());
+                    });
+        }
     }
     
     /**
@@ -1424,6 +1438,91 @@ public class PlanResultService {
         _sceneService.saveChromosomeToFile(chromosome, SceneId);
         return  chromosome;
     }
+
+    /**
+     * 插单功能：在指定订单后插入新订单
+     * 步骤1：先将新订单数据插入数据库
+     * 步骤2：使用类似复制订单的方式将新订单加入排产
+     * 
+     * @param SceneId 场景ID
+     * @param afterOrderId 插入位置订单ID（新订单将排在此订单后面）
+     * @param newOrderData 新订单数据
+     * @return 更新后的Chromosome
+     */
+    public Chromosome InsertOrder(String SceneId, String afterOrderId, Map<String, Object> newOrderData) {
+        // 步骤1：调用LanuchService的insertOrder方法，将新订单插入数据库
+        String orderCode = (String) newOrderData.get("orderCode");
+        String materialId = (String) newOrderData.get("materialId");
+        Double quantity = ((Number) newOrderData.get("quantity")).doubleValue();
+        
+        LocalDateTime startDate = null;
+        LocalDateTime endDate = null;
+        Integer priority = 1;
+        
+        if (newOrderData.containsKey("startDate")) {
+            startDate = LocalDateTime.parse((String) newOrderData.get("startDate"));
+        }
+        if (newOrderData.containsKey("endDate")) {
+            endDate = LocalDateTime.parse((String) newOrderData.get("endDate"));
+        }
+        if (newOrderData.containsKey("priority")) {
+            priority = ((Number) newOrderData.get("priority")).intValue();
+        }
+        
+        // 调用insertOrder插入数据库
+        R<String> insertResult = lanuchService.insertOrder(SceneId, orderCode, materialId, 
+                                                          startDate, endDate, priority, quantity);
+        
+//        if (!insertResult.isSuccess()) {
+//            throw new RuntimeException("插单失败: " + insertResult.getMsg());
+//        }
+//
+        // 从返回消息中提取新订单ID
+        String message = insertResult.getData();
+        String newOrderId = message.substring(message.indexOf("订单ID: ") + 6);
+        
+        log.info("新订单已插入数据库，订单ID: {}", newOrderId);
+        
+        // 步骤2：使用类似SpiltOrder的方式，将新订单加入排产
+        // 这里需要重新加载场景，因为数据库已经有新订单了
+        // 然后使用类似复制的逻辑，将新订单排在afterOrderId后面
+        
+        GlobalParam globalParam = new GlobalParam();
+        Chromosome chromosome = _sceneService.loadChromosomeFromFile(SceneId);
+        
+        // 从数据库加载新插入的订单及其工序
+        ProdLaunchOrder newLaunchOrder = _prodLaunchOrderService.lambdaQuery()
+                .eq(ProdLaunchOrder::getSceneId, SceneId)
+                .eq(ProdLaunchOrder::getOrderId, newOrderId)
+                .one();
+        
+        if (newLaunchOrder == null) {
+            throw new RuntimeException("未找到新插入的订单: " + newOrderId);
+        }
+        
+        // 加载新订单的工序
+        List<ProdProcessExec> newProcessExecs = _prodProcessExecService.lambdaQuery()
+                .eq(ProdProcessExec::getSceneId, SceneId)
+                .eq(ProdProcessExec::getOrderId, newOrderId)
+                .orderBy(true, true, ProdProcessExec::getTaskSeq)
+                .list();
+        
+        if (newProcessExecs.isEmpty()) {
+            throw new RuntimeException("新订单没有工序: " + newOrderId);
+        }
+        
+        log.info("加载新订单: OrderId={}, OrderCode={}, 工序数={}", 
+                newOrderId, newLaunchOrder.getOrderCode(), newProcessExecs.size());
+        
+        // 调用ScheduleOperationService的方法将新订单加入排产
+        ScheduleOperationService scheduleOperation = new ScheduleOperationService(materialRequirementService, this);
+        scheduleOperation.InsertOrder(chromosome, afterOrderId, newOrderId, newLaunchOrder, newProcessExecs, globalParam);
+        
+        WriteScheduleSummary(chromosome);
+        _sceneService.saveChromosomeToFile(chromosome, SceneId);
+        return chromosome;
+    }
+
     public Chromosome  MergeOrder(String SceneId,String sourceorderId,String targetorderId) {