滚动排产修改

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

@@ -2,10 +2,7 @@ package com.aps.service.plan;
 
 import com.aps.common.util.ProductionDeepCopyUtil;
 import com.aps.common.util.redis.RedisUtils;
-import com.aps.entity.Algorithm.Chromosome;
-import com.aps.entity.Algorithm.GAScheduleResult;
-import com.aps.entity.Algorithm.GlobalOperationInfo;
-import com.aps.entity.Algorithm.ScheduleResultDetail;
+import com.aps.entity.Algorithm.*;
 import com.aps.entity.ApsTimeConfig;
 import com.aps.entity.Dispatch;
 import com.aps.entity.MesShiftWorkSched;
@@ -546,10 +543,12 @@ public class LockedOrderProcessorService {
                     .orElse(0);
             
             int nextAvailableId = maxExistingId + 1;
+            Map<Integer, Integer> lockedEntryIdMapping = new HashMap<>();
             
             // 为锁定期Entry重新分配ID
             for (Entry lockedEntry : data.entries.values()) {
                 int oldId = lockedEntry.getId();
+                lockedEntryIdMapping.put(oldId, nextAvailableId);
                 lockedEntry.setId(nextAvailableId);
                 
                 // 更新对应的GAScheduleResult的operationId（包括result和resultOld）
@@ -577,6 +576,76 @@ public class LockedOrderProcessorService {
                 nextAvailableId++;
             }
             
+            // 同步更新锁定期Entry内部依赖中的工序ID引用（仅修正本批次重分配的ID）
+            for (Entry lockedEntry : data.entries.values()) {
+                if (lockedEntry.getPrevEntryIds() != null) {
+                    for (OperationDependency dep : lockedEntry.getPrevEntryIds()) {
+                        if (dep == null) {
+                            continue;
+                        }
+                        Integer newPrev = lockedEntryIdMapping.get(dep.getPrevOperationId());
+                        if (newPrev != null) {
+                            dep.setPrevOperationId(newPrev);
+                        }
+                        Integer newNext = lockedEntryIdMapping.get(dep.getNextOperationId());
+                        if (newNext != null) {
+                            dep.setNextOperationId(newNext);
+                        }
+                    }
+                }
+
+                if (lockedEntry.getNextEntryIds() != null) {
+                    for (OperationDependency dep : lockedEntry.getNextEntryIds()) {
+                        if (dep == null) {
+                            continue;
+                        }
+                        Integer newPrev = lockedEntryIdMapping.get(dep.getPrevOperationId());
+                        if (newPrev != null) {
+                            dep.setPrevOperationId(newPrev);
+                        }
+                        Integer newNext = lockedEntryIdMapping.get(dep.getNextOperationId());
+                        if (newNext != null) {
+                            dep.setNextOperationId(newNext);
+                        }
+                    }
+                }
+            }
+
+            // 同步更新锁定期Entry内部依赖中的工序ID引用（仅修正本批次重分配的ID）
+            for (Entry lockedEntry : data.entries.values()) {
+                if (lockedEntry.getPrevEntryIds() != null) {
+                    for (OperationDependency dep : lockedEntry.getPrevEntryIds()) {
+                        if (dep == null) {
+                            continue;
+                        }
+                        Integer newPrev = lockedEntryIdMapping.get(dep.getPrevOperationId());
+                        if (newPrev != null) {
+                            dep.setPrevOperationId(newPrev);
+                        }
+                        Integer newNext = lockedEntryIdMapping.get(dep.getNextOperationId());
+                        if (newNext != null) {
+                            dep.setNextOperationId(newNext);
+                        }
+                    }
+                }
+
+                if (lockedEntry.getNextEntryIds() != null) {
+                    for (OperationDependency dep : lockedEntry.getNextEntryIds()) {
+                        if (dep == null) {
+                            continue;
+                        }
+                        Integer newPrev = lockedEntryIdMapping.get(dep.getPrevOperationId());
+                        if (newPrev != null) {
+                            dep.setPrevOperationId(newPrev);
+                        }
+                        Integer newNext = lockedEntryIdMapping.get(dep.getNextOperationId());
+                        if (newNext != null) {
+                            dep.setNextOperationId(newNext);
+                        }
+                    }
+                }
+            }
+
             chromosome.getAllOperations().addAll(data.entries.values());
             log.debug("成功添加 {} 个锁定期Entry到allOperations中，大小从{}变为{}，ID范围: {}-{}", 
                 data.entries.size(), beforeEntrySize, chromosome.getAllOperations().size(),

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

@@ -1288,6 +1288,10 @@ public class PlanResultService {
         GlobalParam globalParam=new GlobalParam();
         Chromosome chromosome= _sceneService.loadChromosomeFromFile(SceneId);
 
+        // 拖拽前清理历史工单在设备上的静态占位段，确保历史工单移动后可释放产能
+        int releasedCount = releaseLockedOccupancyForDrag(chromosome);
+
+
 
         //  WriteScheduleSummary(chromosome);
         ScheduleOperationService ScheduleOperation=new ScheduleOperationService(materialRequirementService,this);
@@ -1298,6 +1302,114 @@ public class PlanResultService {
         _sceneService.saveChromosomeToFile(chromosome, SceneId);
         return  chromosome;
     }
+    /**
+     * 释放历史工单占用段（拖拽前调用）
+     */
+    private int releaseLockedOccupancyForDrag(Chromosome chromosome) {
+        if (chromosome == null || chromosome.getInitMachines() == null || chromosome.getInitMachines().isEmpty()) {
+            return 0;
+        }
+
+        int releasedCount = 0;
+        for (Machine machine : chromosome.getInitMachines()) {
+            if (machine == null || machine.getAvailability() == null || machine.getAvailability().isEmpty()) {
+                continue;
+            }
+
+            for (TimeSegment segment : machine.getAvailability()) {
+                if (segment == null) {
+                    continue;
+                }
+
+                boolean lockedOccupyKey = segment.getKey() != null && segment.getKey().startsWith("LOCKED_OCCUPY_");
+                boolean usedRegularOrMaintenance = segment.isUsed()
+                        && (segment.getType() == SegmentType.REGULAR || segment.getType() == SegmentType.MAINTENANCE);
+
+                if (lockedOccupyKey || usedRegularOrMaintenance) {
+                    releasedCount++;
+                    segment.setUsed(false);
+                    segment.setType(SegmentType.REGULAR);
+                    if (lockedOccupyKey) {
+                        segment.setKey(UUID.randomUUID().toString());
+                    }
+                }
+            }
+
+            machine.getAvailability().sort(Comparator.comparing(TimeSegment::getStart));
+        }
+
+        return releasedCount;
+    }
+
+    private long countMachineAvailabilitySegments(Chromosome chromosome, Long machineId) {
+        if (chromosome == null || machineId == null || chromosome.getInitMachines() == null) {
+            return 0;
+        }
+
+        return chromosome.getInitMachines().stream()
+                .filter(Objects::nonNull)
+                .filter(m -> m.getId() == machineId)
+                .findFirst()
+                .map(m -> m.getAvailability() == null ? 0L : (long) m.getAvailability().size())
+                .orElse(0L);
+    }
+
+    private long countMachineUsedMaintenanceSegments(Chromosome chromosome, Long machineId) {
+        if (chromosome == null || machineId == null || chromosome.getInitMachines() == null) {
+            return 0;
+        }
+
+        return chromosome.getInitMachines().stream()
+                .filter(Objects::nonNull)
+                .filter(m -> m.getId() == machineId)
+                .findFirst()
+                .map(m -> m.getAvailability() == null ? 0L : m.getAvailability().stream()
+                        .filter(Objects::nonNull)
+                        .filter(seg -> seg.getType() == SegmentType.MAINTENANCE && seg.isUsed())
+                        .count())
+                .orElse(0L);
+    }
+
+    private long countMachineUsedSegments(Chromosome chromosome, Long machineId, SegmentType type) {
+        if (chromosome == null || machineId == null || chromosome.getInitMachines() == null) {
+            return 0;
+        }
+
+        return chromosome.getInitMachines().stream()
+                .filter(Objects::nonNull)
+                .filter(m -> m.getId() == machineId)
+                .findFirst()
+                .map(m -> m.getAvailability() == null ? 0L : m.getAvailability().stream()
+                        .filter(Objects::nonNull)
+                        .filter(TimeSegment::isUsed)
+                        .filter(seg -> type == null || seg.getType() == type)
+                        .count())
+                .orElse(0L);
+    }
+
+    private String machineSegmentSnapshot(Chromosome chromosome, Long machineId, int limit) {
+        if (chromosome == null || machineId == null || chromosome.getInitMachines() == null) {
+            return "[]";
+        }
+
+        Machine machine = chromosome.getInitMachines().stream()
+                .filter(Objects::nonNull)
+                .filter(m -> m.getId() == machineId)
+                .findFirst()
+                .orElse(null);
+
+        if (machine == null || machine.getAvailability() == null || machine.getAvailability().isEmpty()) {
+            return "[]";
+        }
+
+        return machine.getAvailability().stream()
+                .filter(Objects::nonNull)
+                .sorted(Comparator.comparing(TimeSegment::getStart))
+                .limit(Math.max(limit, 1))
+                .map(seg -> String.format("%s|used=%s|%s~%s", seg.getType(), seg.isUsed(), seg.getStart(), seg.getEnd()))
+                .collect(Collectors.joining("; "));
+    }
+
     public Chromosome  Move(String SceneId,List<Integer> opId, LocalDateTime newStartTime,
                             Long newMachineId,int lockStartTime) {