KPI修改

src/main/java/com/aps/config/SwaggerMapParamConfig.java

@@ -468,6 +468,16 @@ public class SwaggerMapParamConfig {
                                 "}"
                 ));
                 break;
+            
+            case "getSceneVersion":
+                properties.put("sceneId", new StringSchema().description("场景ID").example("FAADE046165147629931D5EA6A9015E8"));
+                examples.put("获取场景文件数字示例", createExample(
+                        "获取指定场景ID的文件数字",
+                        "{\n" +
+                                "  \"sceneId\": \"FAADE046165147629931D5EA6A9015E8\"\n" +
+                                "}"
+                ));
+                break;
         }
 
         if (!properties.isEmpty()) {
@@ -554,6 +564,8 @@ public class SwaggerMapParamConfig {
                 return "更新APS时间配置请求参数";
             case "revert":
                 return "回退版本请求参数";
+            case "getSceneVersion":
+                return "获取场景文件数字请求参数";
             default:
                 return "请求参数";
         }

src/main/java/com/aps/controller/common/ChromosomeDataController.java

@@ -84,7 +84,7 @@ public class ChromosomeDataController {
             // 直接调用服务层的list查询方法
             List<Object> result = chromosomeDataService.queryChromosomeDataList(sceneId, entityName, paged);
 
-            System.out.println("查询结果: " + result);
+
             if (result == null) {
                 return R.ok(Collections.emptyList(), "查询成功，但未找到匹配的数据");
             }

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

@@ -532,7 +532,7 @@ public class ResourceGanttController {
                                 taskVO.setEnd(scheduleChromosome.getBaseTime().plusMinutes(gene.getAbsoluteEndTime()));
                                 taskVO.setSetup(gene.getAbsolutePreparationTime()*60); // 默认值
                                 taskVO.setTeardown(gene.getAbsoluteTeardownTime()*60); // 默认值
-                                taskVO.setEquipChange(gene.getSetupTime()*60); // 默认值
+                                taskVO.setEquipChange(gene.getSetupTime()*60); // 默认값
                                 taskVO.setEquipCooling(0); // 默认值
 //                            taskVO.setEquipType("PTT-" + (i+1) + "-" + gene.getOperationName().toUpperCase().substring(0, Math.min(3, gene.getOperationName().length())));
 //                            taskVO.setEquipName(gene.getOperationName());
@@ -628,8 +628,8 @@ public class ResourceGanttController {
                         taskVO.setEnd(scheduleChromosome.getBaseTime().plusSeconds(gene.getEndTime()));
                         taskVO.setSetup(0); // 默认值
                         taskVO.setTeardown(gene.getTeardownTime()); // 默认值
-                        taskVO.setEquipChange(gene.getChangeOverTime()); // 默认值
-                        taskVO.setEquipCooling(0); // 默认值
+                        taskVO.setEquipChange(gene.getChangeOverTime()); // 默认값
+                        taskVO.setEquipCooling(0); // 默认값
                         taskVO.setEquipType(resourceGanttVO.getType());
                         taskVO.setEquipName(resourceGanttVO.getName());
 //                        taskVO.setDuration(calculateDuration(
@@ -739,8 +739,8 @@ public class ResourceGanttController {
                                 taskVO.setEnd(scheduleChromosome.getBaseTime().plusSeconds(gene.getEndTime()));
                                 taskVO.setSetup(0); // 默认值
                                 taskVO.setTeardown(gene.getTeardownTime()); // 默认值
-                                taskVO.setEquipChange(gene.getChangeOverTime()); // 默认值
-                                taskVO.setEquipCooling(0); // 默认值
+                                taskVO.setEquipChange(gene.getChangeOverTime()); // 默认값
+                                taskVO.setEquipCooling(0); // 默认값
 //                            taskVO.setEquipType("PTT-" + (i+1) + "-" + gene.getOperationName().toUpperCase().substring(0, Math.min(3, gene.getOperationName().length())));
 //                            taskVO.setEquipName(gene.getOperationName());
                                 taskVO.setDuration(calculateDuration(
@@ -896,6 +896,12 @@ public class ResourceGanttController {
 
     }
 
-
+    @PostMapping("/getSceneVersion")
+    @Operation(summary = "获取版本号", description = "获取所有版本号")
+    public R<List<Integer>> getSceneVersion(@RequestBody Map<String, Object> params) {
+        String sceneId = ParamValidator.getString(params, "sceneId", "场景ID");
+        List<Integer> numbers = planResultService.getSceneFileNumbers(sceneId);
+        return R.ok(numbers);
+    }
 
 }
\ No newline at end of file

src/main/java/com/aps/entity/Algorithm/Chromosome.java

@@ -123,44 +123,48 @@ public class Chromosome {
     private String ScenarioName;
     private LocalDateTime BaseTime ; // 当前基准时间
 
-    //最大设备利用率
-    private  double machineMaxRate;
-    //最小设备利用率
-    private  double machineMinRate;
-//设备等待时长
-    private  double machineWaitTime;
-
-
-//订单及时完成率
-    private  double orderOnTime;
-
-    //最大延迟
-    private  double orderMaxDelay;
-
-    //最小延迟
-    private  double orderMinDelay;
-
-    //平均延迟
-    private  double orderAvgDelay;
-
-    //最长生产周期
-    private  double orderMaxProductTime;
-
-    //最短生产周期
-    private  double orderMinProductTime;
-
-    //平均生产周期
-    private  double orderAvgProductTime;
-
-    //最大流量
-    private  double orderMaxFlow;
-
-    //最小流量
-    private  double orderMinFlow;
-
-    //平均流量
-    private  double orderAvgFlow;
 
 
+//
+//    //最大设备利用率
+//    private  double machineMaxRate;
+//    //最小设备利用率
+//    private  double machineMinRate;
+////设备等待时长
+//    private  double machineWaitTime;
+//
+//
+////订单及时完成率
+//    private  double orderOnTime;
+//
+//    //最大延迟
+//    private  double orderMaxDelay;
+//
+//    //最小延迟
+//    private  double orderMinDelay;
+//
+//    //平均延迟
+//    private  double orderAvgDelay;
+//
+//    //最长生产周期
+//    private  double orderMaxProductTime;
+//
+//    //最短生产周期
+//    private  double orderMinProductTime;
+//
+//    //平均生产周期
+//    private  double orderAvgProductTime;
+//
+//    //最大流量
+//    private  double orderMaxFlow;
+//
+//    //最小流量
+//    private  double orderMinFlow;
+//
+//    //平均流量
+//    private  double orderAvgFlow;
+
+
+    private  List<KpiMetrics> kpiMetrics;
 
 }

src/main/java/com/aps/entity/Algorithm/KpiMetrics.java

+package com.aps.entity.Algorithm;
+
+import lombok.Data;
+
+/**
+ * KPI指标类 - 用于存储调度算法的关键性能指标
+ */
+@Data
+public class KpiMetrics {
+    /**
+     * ID
+     */
+    private String id;
+    
+    /**
+     * 名称
+     */
+    private String name;
+    
+    /**
+     * 提示信息
+     */
+    private String tip;
+    
+    /**
+     * 类型 (0 表示某种类型)
+     */
+    private Integer type;
+    
+    /**
+     * 状态 (1 启用, 0 禁用)
+     */
+    private Integer status;
+
+
+    /**
+     * 数值
+     */
+    private Double value;
+
+}
\ No newline at end of file

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

@@ -3,16 +3,14 @@ package com.aps.service.Algorithm;
 import com.aps.common.util.ProductionDeepCopyUtil;
 import com.aps.entity.Algorithm.Chromosome;
 import com.aps.entity.Algorithm.GAScheduleResult;
+import com.aps.entity.Algorithm.KpiMetrics;
 import com.aps.entity.basic.Machine;
 import com.aps.entity.basic.Order;
 import com.aps.entity.basic.TimeSegment;
 
 import java.time.Duration;
 import java.time.LocalDateTime;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -30,24 +28,25 @@ public class KpiCalculator {
     public void calculatekpi() {
         calculateMachine();
         calculateOrder();
+        List<KpiMetrics> kpiMetrics = new ArrayList<>();
         //最大设备利用率
         double machineMaxRate = chromosome.getMachines().stream()
                 .mapToDouble(Machine::getRate)
                 .max()
                 .orElse(0);
-        chromosome.setMachineMaxRate(machineMaxRate);
+        addKpi(kpiMetrics,"最大设备利用率", machineMaxRate, "实际工作时间/计划工作时间 最大", 0, 1);
         //最小设备利用率
         double machineMinRate = chromosome.getMachines().stream()
                 .mapToDouble(Machine::getRate)
                 .min()
                 .orElse(0);
-        chromosome.setMachineMinRate(machineMinRate);
+        addKpi(kpiMetrics,"最小设备利用率", machineMinRate, "实际工作时间/计划工作时间 最小", 0, 1);
 
         double machineActualWorkTime = chromosome.getMachines().stream()
                 .mapToDouble(Machine::getActualWorkTime)
                 .sum();
         double machineallWorkTime= calculateAllTimeSegmentsTotalDuration();
-        chromosome.setMachineWaitTime((machineallWorkTime-machineActualWorkTime)/60/60);
+        addKpi(kpiMetrics,"设备等待时间", (machineallWorkTime-machineActualWorkTime)/60/60, "生产周期内，设备时长 与 （设备所有工序时长+设备停机时长）之间的差值", 2, 1);
 
         // 订单按时完成的数量
         double orderNoDelayCount = chromosome.getOrders().stream()
@@ -55,67 +54,68 @@ public class KpiCalculator {
                 .count();
         //
         double orderOnTime = Math.round(orderNoDelayCount / chromosome.getOrders().size() * 10000) / 10000 * 100;
-        chromosome.setOrderOnTime(orderOnTime);
+        addKpi(kpiMetrics,"订单按时完成率", orderOnTime, "规定时间内交付的订单数量/所有订单数量", 0, 1);
         //最大延迟
         double OrderMaxDelay = chromosome.getOrders().stream()
                 .mapToDouble(Order::getDelayHours)
                 .max()
                 .orElse(0);
-        chromosome.setOrderMaxDelay(OrderMaxDelay);
+        addKpi(kpiMetrics,"最大延迟", OrderMaxDelay, "所有订单的延迟时间最大值", 2, 1);
         //最小延迟
         double OrderMinDelay = chromosome.getOrders().stream()
                 .mapToDouble(Order::getDelayHours)
                 .min()
                 .orElse(0);
-        chromosome.setOrderMinDelay(OrderMinDelay);
+        addKpi(kpiMetrics,"最小延迟", OrderMinDelay, "所有订单的延迟时间最小值", 2, 1);
 
         double OrderSumDelay = chromosome.getOrders().stream()
                 .mapToDouble(Order::getDelayHours)
                 .sum();
         //平均延迟
         double OrderDelay = Math.round(OrderSumDelay / chromosome.getOrders().size() * 100) / 100;
-        chromosome.setOrderAvgDelay(OrderDelay);
+        addKpi(kpiMetrics,"平均延迟", OrderDelay, "所有订单的延迟时间平均值", 2, 1);
         //最长生产周期
         double OrderMaxProductTime = chromosome.getOrders().stream()
                 .mapToDouble(Order::getOrderProductTime)
                 .max()
                 .orElse(0);
-        chromosome.setOrderMaxProductTime(OrderMaxProductTime);
+        addKpi(kpiMetrics,"最长生产周期", OrderMaxProductTime, "订单在计划中的实际存续时长", 2, 1);
         //最小生产周期
         double OrderMinProductTime = chromosome.getOrders().stream()
                 .mapToDouble(Order::getOrderProductTime)
                 .min()
                 .orElse(0);
-        chromosome.setOrderMinProductTime(OrderMinProductTime);
+        addKpi(kpiMetrics,"最短生产周期", OrderMinProductTime, "订单在计划中的实际存续时长", 2, 1);
 
         double OrderSumProductTime = chromosome.getOrders().stream()
                 .mapToDouble(Order::getOrderProductTime)
                 .sum();
         //平均生产周期
         double OrderProductTime= Math.round(OrderSumProductTime / chromosome.getOrders().size() * 100) / 100;
-        chromosome.setOrderAvgProductTime(OrderProductTime);
+        addKpi(kpiMetrics,"平均生产周期", OrderProductTime, "订单在计划中的实际存续时长", 2, 1);
 
         //最大流量
         double OrderMaxFlow = chromosome.getOrders().stream()
                 .mapToDouble(Order::getOrderFlow)
                 .max()
                 .orElse(0);
-        chromosome.setOrderMaxFlow(OrderMaxFlow);
+        addKpi(kpiMetrics,"最大流量", OrderMaxFlow, "订单的最短理论耗时与其在计划中的实际耗时的比值最大值", 0, 1);
 
         //最小流量
         double OrderMinFlow = chromosome.getOrders().stream()
                 .mapToDouble(Order::getOrderFlow)
                 .min()
                 .orElse(0);
-        chromosome.setOrderMinFlow(OrderMinFlow);
+        addKpi(kpiMetrics,"最小流量", OrderMinFlow, "订单的最短理论耗时与其在计划中的实际耗时的比值最小值", 0, 1);
 
 
         double OrderSumFlow = chromosome.getOrders().stream()
-                .mapToDouble(Order::getDelayHours)
+                .mapToDouble(Order::getOrderFlow)
                 .sum();
         //平均流量
         double OrderFlow= Math.round(OrderSumFlow / chromosome.getOrders().size() * 100) / 100;
-        chromosome.setOrderAvgFlow(OrderFlow);
+        addKpi(kpiMetrics,"平均流量", OrderFlow, "订单的最短理论耗时与其在计划中的实际耗时的比值", 0, 1);
+        chromosome.setKpiMetrics(kpiMetrics);
 
 
     }
@@ -136,7 +136,7 @@ public class KpiCalculator {
         // 计划工作时间：最后一个任务结束时间 - 第一个任务开始时间
         int firstTaskStart = list.stream()
                 .mapToInt(GAScheduleResult::getStartTime)
-                .max()
+                .min()
                 .orElse(0);
         int lastTaskEnd =  list.stream()
                 .mapToInt(GAScheduleResult::getEndTime)
@@ -175,7 +175,6 @@ public class KpiCalculator {
 //            int lastTaskEnd = sortedTasks.get(sortedTasks.size() - 1).getEndTime();
 //            double plannedWorkTime = lastTaskEnd - firstTaskStart;
 
-
             double rate =  Math.round((actualWorkTime / plannedWorkTime) * 10000) / 10000.0*100;
             machine.setRate(rate);
         }
@@ -217,7 +216,7 @@ public class KpiCalculator {
                     .sum();
 
             Order order=  chromosome.getOrders().stream()
-                    .filter(t->t.getOrderId()==orderId)
+                    .filter(t->t.getOrderId().equals(orderId))
                     .findFirst()
                     .orElse(null);
             if(order==null)
@@ -231,20 +230,20 @@ public class KpiCalculator {
             order.setOrderStart(actualStartTime);
             order.setMachineProcessingTime(orderProcessingTime);
 
-            Duration Orderduration = Duration.between(actualCompletionTime, actualStartTime);
+            Duration Orderduration = Duration.between(actualStartTime,actualCompletionTime);
             double orderProductTime  =Orderduration.getSeconds();
-            order.setOrderProductTime(orderProductTime/60/60);
+            order.setOrderProductTime(orderProductTime);
             double flow=Math.round(orderProcessingTime/orderProductTime *10000)/10000*100;
 
             order.setOrderFlow(flow);
             // 计算延迟时间（若提前完成则延迟为0）
             if (actualCompletionTime.isAfter(order.getDueDate())) {
                 Duration duration = Duration.between(order.getDueDate(), actualCompletionTime);
-                double delayHours = duration.toMinutes() / 60.0; // 转换为小时
+                double delayHours = duration.getSeconds(); // 转换为秒
                 order.setDelayHours(delayHours);
             } else {
                 Duration duration = Duration.between(actualCompletionTime,order.getDueDate());
-                double delayHours = duration.toMinutes() / 60.0; // 转换为小时
+                double delayHours = duration.getSeconds(); // 转换为秒
                 order.setDelayHours(0-delayHours);
             }
         }
@@ -290,4 +289,16 @@ public class KpiCalculator {
         return totalSeconds;
     }
 
+
+
+    private void addKpi(List<KpiMetrics> kpiList, String name, double value, String tip, int type, int status) {
+        KpiMetrics kpi = new KpiMetrics();
+        kpi.setId(UUID.randomUUID().toString());
+        kpi.setName(name);
+        kpi.setTip(tip);
+        kpi.setType(type);
+        kpi.setValue(value);
+        kpi.setStatus(status);
+        kpiList.add(kpi);
+    }
 }

src/main/java/com/aps/service/common/ChromosomeDataService.java

@@ -135,6 +135,13 @@ public class ChromosomeDataService {
                 config.setEntityName(entityName);
                 config.setDataSource(DataSourceType.FILE);
                 config.setFieldName("allOperations");
+            }
+            // 特殊处理：当实体是KpiMetrics时，映射到kpiMetrics字段
+            else if ("kpimetrics".equalsIgnoreCase(key)) {
+                config = new EntityConfig();
+                config.setEntityName(entityName);
+                config.setDataSource(DataSourceType.FILE);
+                config.setFieldName("kpiMetrics");
             } else {
                 // 自动创建数据库配置（默认行为）
                 config = createDefaultDbConfig(entityName);
@@ -148,23 +155,6 @@ public class ChromosomeDataService {
         return config;
     }
 //
-//    /**
-//     * 创建默认的数据库配置
-//     */
-//    private EntityConfig createDefaultDbConfig(String entityName) {
-//        EntityConfig config = new EntityConfig();
-//        config.setEntityName(entityName);
-//        config.setDataSource(DataSourceType.DATABASE);
-//
-//        // 默认表名与实体名相同
-//        String tableName = "t_" + entityName.toUpperCase(); // Oracle表名通常大写
-//        config.setTableName(tableName);
-//
-//        // 如果没有对应的实体类，设置为null，查询返回Map
-//        config.setEntityClass(null);
-//
-//        return config;
-//    }
 
 
 
@@ -280,6 +270,11 @@ public class ChromosomeDataService {
                 return extractMachineOptionsFromEntries(result);
             }
             
+            // 如果实体是KpiMetrics，直接返回结果
+            if ("kpimetrics".equalsIgnoreCase(config.getEntityName())) {
+                return result;
+            }
+            
             return result;
         } catch (NoSuchFieldException e) {
             throw new RuntimeException("Chromosome类中未找到字段: " + config.getFieldName(), e);
@@ -929,30 +924,24 @@ public class ChromosomeDataService {
             List<?> entryList = (List<?>) data;
             List<MachineOption> result = new ArrayList<>();
             
-            System.out.println("提取MachineOption: Entry列表大小 = " + entryList.size());
             
             for (Object obj : entryList) {
                 if (obj instanceof Entry) {
                     Entry entry = (Entry) obj;
                     if (entry.getMachineOptions() != null) {
-                        System.out.println("Entry ID: " + entry.getId() + ", MachineOptions大小: " + entry.getMachineOptions().size());
                         // 返回所有Entry中的MachineOption
                         result.addAll(entry.getMachineOptions());
                     } else {
-                        System.out.println("Entry ID: " + entry.getId() + ", MachineOptions为null");
                     }
                 }
             }
             
-            System.out.println("总共提取到MachineOption数量: " + result.size());
             return result;
         } else if (data instanceof Entry) {
             Entry entry = (Entry) data;
-            System.out.println("单个Entry的MachineOptions大小: " + (entry.getMachineOptions() != null ? entry.getMachineOptions().size() : 0));
             return entry.getMachineOptions() != null ? entry.getMachineOptions() : new ArrayList<>();
         }
         
-        System.out.println("数据类型不是Entry或Entry列表，返回空列表");
         return new ArrayList<>(); // 如果不是Entry类型，返回空列表
     }
 }
\ No newline at end of file

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

@@ -21,6 +21,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.io.File;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
@@ -1953,5 +1954,68 @@ private  GlobalParam InitGlobalParam()
 
 
     }
+    
+    /**
+     * 获取指定场景ID的文件数字
+     * @param sceneId 场景ID
+     * @return 包含文件名后数字的列表
+     */
+    public List<Integer> getSceneFileNumbers(String sceneId) {
+        List<Integer> numbers = new ArrayList<>();
+        SceneChromsome sceneChromsome=(SceneChromsome)redisUtils.get("SceneId."+sceneId);
+        if (sceneChromsome==null){
+            return numbers;
+        }
+
+        Integer   currultVersion =sceneChromsome.getVersion();
 
-    }
+
\ No newline at end of file
+        // 获取结果目录
+        File resultDir = new File("result");
+        if (!resultDir.exists() || !resultDir.isDirectory()) {
+            return numbers;
+        }
+        
+        // 获取目录中的所有文件
+        File[] files = resultDir.listFiles();
+        if (files == null) {
+            return numbers;
+        }
+        
+        // 定义要查找的前缀
+        String prefix = "chromosome_result_" + sceneId + "_";
+        String suffix = "_.json";
+        
+        for (File file : files) {
+            if (file.isFile()) {
+                String fileName = file.getName();
+                
+                // 检查文件名是否以指定前缀开始，并以指定后缀结束
+                if (fileName.startsWith(prefix) && fileName.endsWith(suffix)) {
+                    // 提取前缀和后缀之间的部分
+                    String middlePart = fileName.substring(
+                        prefix.length(), 
+                        fileName.length() - suffix.length()
+                    );
+                    
+                    // 尝试将中间部分解析为数字
+                    try {
+                        int number = Integer.parseInt(middlePart);
+                        // 只添加小于当前版本的数字
+                        if (number < currultVersion) {
+                            numbers.add(number);
+                        }
+                    } catch (NumberFormatException e) {
+                        // 如果中间部分不是数字，则跳过该文件
+                        continue;
+                    }
+                }
+            }
+        }
+        
+        // 对数字列表进行排序（从小到大）
+        Collections.sort(numbers);
+        
+        return numbers;
+    }
+}
\ No newline at end of file