返回数据格式修改

src/main/java/com/aps/common/exception/GlobalExceptionHandler.java

+package com.aps.common.exception;
+
+import com.aps.common.util.R;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.ibatis.binding.BindingException;
+import org.mybatis.spring.MyBatisSystemException;
+import org.springframework.dao.DataAccessException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.validation.BindException;
+import org.springframework.validation.FieldError;
+import org.springframework.web.HttpMediaTypeNotSupportedException;
+import org.springframework.web.HttpRequestMethodNotSupportedException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
+import org.springframework.web.servlet.NoHandlerFoundException;
+
+import java.sql.SQLException;
+import java.util.Objects;
+
+/**
+ * 全局异常处理器
+ * 统一处理系统中的各种异常，返回统一格式的错误信息
+ */
+@Slf4j
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    /**
+     * 处理非法参数异常
+     */
+    @ExceptionHandler(IllegalArgumentException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleIllegalArgumentException(IllegalArgumentException e) {
+        log.debug("参数校验失败: {}", e.getMessage());
+        return R.failed(400, e.getMessage());
+    }
+
+    /**
+     * 处理场景生成异常
+     */
+    @ExceptionHandler(SceneGenerationException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleSceneGenerationException(SceneGenerationException e) {
+        log.debug("场景生成异常: {}", e.getMessage());
+        return R.failed(400, e.getMessage());
+    }
+
+    /**
+     * 处理自定义业务异常
+     */
+    @ExceptionHandler(RuntimeException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleRuntimeException(RuntimeException e) {
+        log.debug("运行时异常: {}", e.getMessage());
+        return R.failed(500, e.getMessage());
+    }
+
+    /**
+     * 处理MyBatis绑定异常
+     */
+    @ExceptionHandler(BindingException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleBindingException(BindingException e) {
+        log.debug("MyBatis绑定异常: {}", e.getMessage());
+        return R.failed(500, "数据绑定异常: " + e.getMessage());
+    }
+
+    /**
+     * 处理MyBatis系统异常
+     */
+    @ExceptionHandler(MyBatisSystemException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleMyBatisSystemException(MyBatisSystemException e) {
+        log.debug("MyBatis系统异常: {}", e.getMessage());
+        Throwable cause = e.getCause();
+        if (cause != null && cause.getMessage().contains("ORA-17004")) {
+            return R.failed(500, "数据库列类型无效，请检查查询参数是否正确");
+        }
+        return R.failed(500, "数据库操作异常: " + (cause != null ? cause.getMessage() : e.getMessage()));
+    }
+
+    /**
+     * 处理SQL异常
+     */
+    @ExceptionHandler(SQLException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleSQLException(SQLException e) {
+        log.debug("SQL异常: {}", e.getMessage());
+        return R.failed(500, "数据库访问异常: " + e.getMessage());
+    }
+
+    /**
+     * 处理数据访问异常
+     */
+    @ExceptionHandler(DataAccessException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleDataAccessException(DataAccessException e) {
+        log.debug("数据访问异常: {}", e.getMessage());
+        return R.failed(500, "数据访问异常: " + e.getMessage());
+    }
+
+    /**
+     * 处理参数验证异常(MethodArgumentNotValidException)
+     */
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
+        log.debug("参数验证异常: {}", e.getMessage());
+        FieldError fieldError = e.getBindingResult().getFieldError();
+        if (fieldError != null) {
+            return R.failed(400, Objects.requireNonNull(fieldError.getDefaultMessage()));
+        }
+        return R.failed(400, "参数验证失败");
+    }
+
+    /**
+     * 处理参数绑定异常(BindException)
+     */
+    @ExceptionHandler(BindException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleBindException(BindException e) {
+        log.debug("参数绑定异常: {}", e.getMessage());
+        FieldError fieldError = e.getBindingResult().getFieldError();
+        if (fieldError != null) {
+            return R.failed(400, Objects.requireNonNull(fieldError.getDefaultMessage()));
+        }
+        return R.failed(400, "参数绑定失败");
+    }
+
+    /**
+     * 处理请求参数缺失异常
+     */
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleMissingServletRequestParameterException(MissingServletRequestParameterException e) {
+        log.debug("请求参数缺失: {}", e.getMessage());
+        return R.failed(400, "缺少必要参数: " + e.getParameterName());
+    }
+
+    /**
+     * 处理参数类型不匹配异常
+     */
+    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e) {
+        log.debug("参数类型不匹配: {}", e.getMessage());
+        return R.failed(400, "参数类型不匹配: " + e.getName());
+    }
+
+    /**
+     * 处理HTTP消息不可读异常
+     */
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
+        log.debug("HTTP消息不可读: {}", e.getMessage());
+        return R.failed(400, "请求体格式错误");
+    }
+
+    /**
+     * 处理HTTP请求方法不支持异常
+     */
+    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
+    @ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
+    public R<Void> handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
+        log.debug("HTTP请求方法不支持: {}", e.getMessage());
+        return R.failed(405, "请求方法不支持: " + e.getMethod());
+    }
+
+    /**
+     * 处理HTTP媒体类型不支持异常
+     */
+    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
+    @ResponseStatus(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
+    public R<Void> handleHttpMediaTypeNotSupportedException(HttpMediaTypeNotSupportedException e) {
+        log.debug("HTTP媒体类型不支持: {}", e.getMessage());
+        return R.failed(415, "媒体类型不支持: " + e.getContentType());
+    }
+
+    /**
+     * 处理404异常
+     */
+    @ExceptionHandler(NoHandlerFoundException.class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    public R<Void> handleNoHandlerFoundException(NoHandlerFoundException e) {
+        log.debug("404异常: {}", e.getMessage());
+        return R.failed(404, "请求的资源不存在: " + e.getRequestURL());
+    }
+
+    /**
+     * 处理其他未捕获的异常
+     */
+    @ExceptionHandler(Exception.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleException(Exception e) {
+        log.debug("未知异常: {}", e.getMessage());
+        return R.failed(500, "系统异常，请联系管理员");
+    }
+}
\ No newline at end of file

src/main/java/com/aps/common/exception/SceneGenerationException.java

+package com.aps.common.exception;
+
+/**
+ * 场景生成异常类
+ * 用于标识场景生成过程中的业务异常
+ */
+public class SceneGenerationException extends RuntimeException {
+    
+    public SceneGenerationException(String message) {
+        super(message);
+    }
+    
+    public SceneGenerationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
\ No newline at end of file

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

@@ -122,6 +122,18 @@ public class SwaggerMapParamConfig {
                                 "}"
                 ));
                 break;
+
+
+            case "getResourceGantt":
+            case "getProductGantt":
+                properties.put("sceneId", new StringSchema().description("场景ID").example("B571EF6682DB463AB2977B1055A74112"));
+                examples.put("示例", createExample(
+                        "请求示例",
+                        "{\n" +
+                                "  \"sceneId\": \"B571EF6682DB463AB2977B1055A74112\"\n" +
+                                "}"
+                ));
+                break;
         }
 
         if (!properties.isEmpty()) {
@@ -160,6 +172,11 @@ public class SwaggerMapParamConfig {
                 return "删除场景请求参数";
             case "getAllScene":
                 return "获取场景列表请求参数";
+
+            case "getResourceGantt":
+
+            case "getProductGantt":
+                return "获取资源甘特图请求参数";
             default:
                 return "请求参数";
         }

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

@@ -37,10 +37,6 @@ public class LanuchController {
         String sceneName = params.get("sceneName");
         String userId = params.get("userId");
 
-        if (sceneName == null || sceneName.trim().isEmpty()) {
-            return R.failed("场景名称不能为空");
-        }
-
         return lanuchService.lanuch(sceneName, userId);
     }
 
@@ -52,16 +48,8 @@ public class LanuchController {
     public R<Chromosome> schedule(@RequestBody Map<String, String> params) {
         String sceneId = params.get("sceneId");
 
-        if (sceneId == null || sceneId.trim().isEmpty()) {
-            return R.failed("场景ID不能为空");
-        }
-
-        try {
         Chromosome scheduleChromosomes = planResultService.schedule(sceneId);
         return R.ok(scheduleChromosomes);
-        } catch (Exception e) {
-            return R.failed("排程执行失败: " + e.getMessage());
-        }
     }
 
     /**
@@ -74,16 +62,6 @@ public class LanuchController {
         String newSceneName = params.get("newSceneName");
         String userId = params.get("userId");
 
-        if (oldSceneId == null || oldSceneId.trim().isEmpty()) {
-            return R.failed("原场景ID不能为空");
-        }
-        if (newSceneName == null || newSceneName.trim().isEmpty()) {
-            return R.failed("新场景名称不能为空");
-        }
-
-        if (userId == null || userId.trim().isEmpty()) {
-            return R.failed("用户名不能为空");
-        }
         return lanuchService.copyScene(oldSceneId, userId, newSceneName);
     }
 
@@ -95,10 +73,6 @@ public class LanuchController {
     public R<String> exportPlan(@RequestBody Map<String, String> params) {
         String sceneId = params.get("sceneId");
 
-        if (sceneId == null || sceneId.trim().isEmpty()) {
-            return R.failed("场景ID不能为空");
-        }
-
         return lanuchService.exportPlan(sceneId);
     }
 
@@ -110,12 +84,8 @@ public class LanuchController {
     public R<Boolean> deleteScene(@RequestBody Map<String, String> params) {
         String sceneId = params.get("sceneId");
 
-        if (sceneId == null || sceneId.trim().isEmpty()) {
-            return R.failed("场景ID不能为空");
-        }
-
         boolean result = prodSceneConfigService.deleteSceneById(sceneId);
-        return result ? R.ok(true) : R.failed("删除场景失败");
+        return result ? R.ok(true) : R.ok(false, "删除场景失败");
     }
 
     /**
@@ -126,10 +96,6 @@ public class LanuchController {
     public R<List<ProdSceneConfig>> getAllScene(@RequestBody Map<String, String> params) {
         String userId = params.get("userId");
 
-        if (userId == null || userId.trim().isEmpty()) {
-            return R.failed("用户ID不能为空");
-        }
-
         List<ProdSceneConfig> scenes = prodSceneConfigService.lambdaQuery()
                 .eq(ProdSceneConfig::getCreateUser, userId)
                 .list();

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

 package com.aps.controller.gantt;
 
 
+import com.aps.common.util.R;
 import com.aps.entity.Algorithm.Chromosome;
 import com.aps.entity.Algorithm.GAScheduleResult;
 import com.aps.entity.basic.ScheduleChromosome;
@@ -22,6 +23,7 @@ import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 @Slf4j
@@ -464,35 +466,35 @@ public class ResourceGanttController {
 
 
 
-
-    @GetMapping("/productGantt")
-    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
-    public List<ProductGanttVO> getProductGantt(@RequestParam String sceneId) {
-        // 从PlanResultService获取ScheduleChromosome列表
-        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
-
-        // 转换为 ResourceGanttVO 格式
-        List<ProductGanttVO> productGanttVOList= new ArrayList<>();
-        List<ProductGanttVO> resourceGanttVOs = convertToProductGanttVO1(schedule);
-        productGanttVOList.addAll(resourceGanttVOs);
-
-        return productGanttVOList;
-    }
-
-
-    @GetMapping("/resourceGantt")
-    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
-    public List<ResourceGanttVO> getResourceGantt(@RequestParam String sceneId) {
-        // 从PlanResultService获取ScheduleChromosome列表
-        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
-
-        // 转换为 ResourceGanttVO 格式
-        List<ResourceGanttVO> resourceGanttVOList = new ArrayList<>();
-        List<ResourceGanttVO> resourceGanttVOs = convertToResourceGanttVO1(schedule);
-        resourceGanttVOList.addAll(resourceGanttVOs);
-
-        return resourceGanttVOList;
-    }
+//
+//    @GetMapping("/productGantt")
+//    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
+//    public List<ProductGanttVO> getProductGantt(@RequestParam String sceneId) {
+//        // 从PlanResultService获取ScheduleChromosome列表
+//        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
+//
+//        // 转换为 ResourceGanttVO 格式
+//        List<ProductGanttVO> productGanttVOList= new ArrayList<>();
+//        List<ProductGanttVO> resourceGanttVOs = convertToProductGanttVO1(schedule);
+//        productGanttVOList.addAll(resourceGanttVOs);
+//
+//        return productGanttVOList;
+//    }
+//
+//
+//    @GetMapping("/resourceGantt")
+//    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
+//    public List<ResourceGanttVO> getResourceGantt(@RequestParam String sceneId) {
+//        // 从PlanResultService获取ScheduleChromosome列表
+//        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
+//
+//        // 转换为 ResourceGanttVO 格式
+//        List<ResourceGanttVO> resourceGanttVOList = new ArrayList<>();
+//        List<ResourceGanttVO> resourceGanttVOs = convertToResourceGanttVO1(schedule);
+//        resourceGanttVOList.addAll(resourceGanttVOs);
+//
+//        return resourceGanttVOList;
+//    }
 
 
 
@@ -683,6 +685,100 @@ public class ResourceGanttController {
 
 
 
+    @GetMapping("/productGantt")
+    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
+    public List<ProductGanttVO> productGantt(@RequestParam String sceneId) {
+        // 从PlanResultService获取ScheduleChromosome列表
+        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
+        if ( schedule == null) {
+            return new ArrayList<>();
+        }
+
+        // 转换为 ProductGanttVO 格式
+        List<ProductGanttVO> productGanttVOList= new ArrayList<>();
+        List<ProductGanttVO> resourceGanttVOs = planResultService.convertToProductGanttVO1(schedule);
+        productGanttVOList.addAll(resourceGanttVOs);
+
+        return productGanttVOList;
+    }
+
+
+    @GetMapping("/resourceGantt")
+    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
+    public List<ResourceGanttVO> resourceGantt(@RequestParam String sceneId) {
+        // 从PlanResultService获取ScheduleChromosome列表
+        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
+        // 如果找不到对应的场景，返回空列表
+        if ( schedule == null) {
+            return new ArrayList<>();
+        }
+
+        List<Machine> machineList = planResultService.InitCalendarToAllMachines1(schedule.getScenarioID());
+
+        // 转换为 ResourceGanttVO 格式
+        List<ResourceGanttVO> resourceGanttVOList = new ArrayList<>();
+        List<ResourceGanttVO> resourceGanttVOs = planResultService.convertToResourceGanttVO1(schedule, machineList);
+        resourceGanttVOList.addAll(resourceGanttVOs);
+
+        return resourceGanttVOList;
+    }
+
+
+
+    @PostMapping("/getResourceGantt")
+    @Operation(summary = "获取资源甘特图数据", description = "获取资源甘特图数据")
+    public R<List<ResourceGanttVO>> getResourceGantt(@RequestBody Map<String, Object> params) {
+        // 从参数中获取sceneId
+        String sceneId = (String) params.get("sceneId");
+
+        // 校验sceneId是否存在
+        if (sceneId == null || sceneId.isEmpty()) {
+            throw new IllegalArgumentException("场景ID不能为空");
+        }
+
+        // 校验能否获取对应的文件
+        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
+        if (schedule == null) {
+            throw new RuntimeException("未找到对应的场景文件");
+        }
+
+        List<Machine> machineList = planResultService.InitCalendarToAllMachines1(schedule.getScenarioID());
+
+        // 转换为 ResourceGanttVO 格式
+        List<ResourceGanttVO> resourceGanttVOList = new ArrayList<>();
+        List<ResourceGanttVO> resourceGanttVOs = planResultService.convertToResourceGanttVO1(schedule, machineList);
+        resourceGanttVOList.addAll(resourceGanttVOs);
+
+        return R.ok(resourceGanttVOList);
+    }
+
+
+
+
+    @PostMapping("/getProductGantt")
+    @Operation(summary = "获取产品甘特图数据", description = "获取产品甘特图数据")
+    public R<List<ProductGanttVO>> getProductGantt(@RequestBody Map<String, Object> params) {
+        // 从参数中获取sceneId
+        String sceneId = (String) params.get("sceneId");
+
+        // 校验sceneId是否存在
+        if (sceneId == null || sceneId.isEmpty()) {
+            throw new IllegalArgumentException("场景ID不能为空");
+        }
+
+        // 校验能否获取对应的文件
+        Chromosome schedule = sceneService.loadChromosomeFromFile(sceneId);
+        if (schedule == null) {
+            throw new RuntimeException("未找到对应的场景文件");
+        }
+
+        // 转换为 ProductGanttVO 格式
+        List<ProductGanttVO> productGanttVOList= new ArrayList<>();
+        List<ProductGanttVO> resourceGanttVOs = planResultService.convertToProductGanttVO1(schedule);
+        productGanttVOList.addAll(resourceGanttVOs);
+
+        return R.ok(productGanttVOList);
+    }
 
 
 

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

 package com.aps.service.impl;
 
+import com.aps.common.exception.SceneGenerationException;
 import com.aps.common.util.R;
 import com.aps.common.util.SnowFlackIdWorker;
 import com.aps.entity.*;
@@ -76,68 +77,53 @@ public class LanuchServiceImpl implements LanuchService {
     @Autowired
     RoutingDiscreteParamService  routingDiscreteParamService;
     /**
-     ◦ 生成场景数据
-
+     * 生成场景数据
      *
      *
-     ◦ @param sceneName        场景名称
-
-     ◦ @param username         操作用户
-
-     ◦ @return 处理结果
-
+     * @param sceneName        场景名称
+     * @param username         操作用户
+     * @return 处理结果
      */
     @Override
     @Transactional(rollbackFor = Exception.class)
     public R<String> lanuch( String sceneName, String username) {
-        try {
         // 参数校验
         if (sceneName == null || sceneName.trim().isEmpty()) {
-                return R.failed("场景名称不能为空");
+            throw new IllegalArgumentException("场景名称不能为空");
         }
 
-
+        if (username == null || username.trim().isEmpty()) {
+            throw new IllegalArgumentException("用户ID不能为空");
+        }
 
         // 1. 创建场景
         String sceneId = createScene(sceneName, username);
         if (sceneId == null) {
-                return R.failed("场景名称已存在");
+            throw new RuntimeException("场景名称已存在");
         }
 
         prodEquipSpecialCalService.copyFromEquipCapacityDef(sceneId);
 
-//            List<ApsOrder> apsOrders = apsOrderService.lambdaQuery()
-//                    .eq(ApsOrder::getIsdeleted, 0)
-//                    .like(ApsOrder::getCode, "佟礼测试数据")
-//                    .list();
-
-
-
         List<ApsOrder> apsOrders = apsOrderService.lambdaQuery()
                 .eq(ApsOrder::getIsdeleted, 0)
                 .eq(ApsOrder::getSchedulestatus, 1)
-                    .eq(ApsOrder::getCreatoruserid,"1025")
+                .eq(ApsOrder::getCreatoruserid,username)
                 .list();
         if (CollectionUtils.isEmpty(apsOrders)) {
-                return R.failed("工单列表不能为空");
+            prodSceneConfigService.deleteSceneById(sceneId);
+            throw new SceneGenerationException("工单列表不能为空");
         }
         // 4. 处理订单数据转换
         List<ProdLaunchOrder> prodLaunchOrders = processOrderData(sceneId, apsOrders);
 
-
         // 5. 转换工单于工序执行表
         convertToProcessExecBatch(prodLaunchOrders, sceneId);
 
-
         // 6. 生成工序关联关系
         generateProcessRelationsBatch(prodLaunchOrders, sceneId);
 
         log.info("场景数据生成完成，场景ID：{}", sceneId);
         return R.ok("场景数据生成成功");
-        } catch (Exception e) {
-            log.error("生成场景数据失败", e);
-            return R.failed("生成场景数据失败: " + e.getMessage());
-        }
     }
 
     /**
@@ -149,17 +135,18 @@ public class LanuchServiceImpl implements LanuchService {
     @Override
     @Transactional(rollbackFor = Exception.class)
     public R<String> copyScene(String oldSceneId,String username, String newSceneName) {
-        try {
         // Validate input parameters
         if (oldSceneId == null || oldSceneId.trim().isEmpty()) {
-                return R.failed("场景ID不能为空");
+            throw new IllegalArgumentException("原场景ID不能为空");
         }
 
         if (newSceneName == null || newSceneName.trim().isEmpty()) {
-                return R.failed("复制场景ID不能为空");
+            throw new IllegalArgumentException("复制场景ID不能为空");
         }
 
-
+        if (username == null || username.trim().isEmpty()) {
+            throw new IllegalArgumentException("用户名不能为空");
+        }
 
         // 检查场景是否存在
         ProdSceneConfig oldScene = prodSceneConfigService.lambdaQuery()
@@ -167,12 +154,12 @@ public class LanuchServiceImpl implements LanuchService {
                 .one();
 
         if (oldScene == null) {
-                return R.failed("源场景不存在");
+            throw new RuntimeException("源场景不存在");
         }
         //  创建场景
         String newSceneId = createScene(newSceneName, username);
         if (newSceneId == null) {
-                return R.failed("场景名称已存在");
+            throw new RuntimeException("场景名称已存在");
         }
 
         // 复制数据
@@ -186,15 +173,8 @@ public class LanuchServiceImpl implements LanuchService {
         copyChromosomeFile(oldScene.getSceneId(), newSceneId);
 
         return R.ok("场景数据复制成功");
-
-        } catch (Exception e) {
-            log.error("复制场景数据失败", e);
-            throw new RuntimeException("复制场景数据失败: " + e.getMessage(), e);
-        }
     }
 
-
-
     /**
      *下发计划
      * @param sceneId
@@ -203,10 +183,13 @@ public class LanuchServiceImpl implements LanuchService {
     @Override
     @Transactional(rollbackFor = Exception.class)
     public R<String> exportPlan(String sceneId) {
-        try {
+        if (sceneId == null || sceneId.trim().isEmpty()) {
+            throw new IllegalArgumentException("场景ID不能为空");
+        }
+
         Chromosome chromosome = sceneService.loadChromosomeFromFile(sceneId);
         if (chromosome == null || chromosome.getResult() == null || chromosome.getResult().isEmpty()) {
-                return R.failed("未找到排程结果");
+            throw new RuntimeException("未找到排程结果");
         }
 
         List<Order> prodLanuchList = chromosome.getOrders();
@@ -216,45 +199,32 @@ public class LanuchServiceImpl implements LanuchService {
             MesOrder mesOrder = new MesOrder();
 
             mesOrder.setMesCode(prodLaunchOrder.getOrderId());
-//                mesOrder.setSerie(prodLaunchOrder.getSerie());
             mesOrder.setMaterialId(prodLaunchOrder.getMaterialId());
-                mesOrder.setQuantity((long) prodLaunchOrder.getQuantity());
-//                mesOrder.setDemandStartDate(prodLaunchOrder.getStartDate());
-//                mesOrder.setDemandFinishDate(prodLaunchOrder.getEndDate());
-//                mesOrder.setRoutingId(prodLaunchOrder.getRoutingId() != null ? Long.valueOf(prodLaunchOrder.getRoutingId()) : null);
-//                mesOrder.setProductCode(prodLaunchOrder.getMaterialCode());
-//                mesOrder.setStatus(1L); // Default status
+            mesOrder.setQuantity(0L);
             mesOrderList.add(mesOrder);
         }
 
-
         boolean saved = mesOrderService.saveBatch(mesOrderList);
 
         if (saved) {
             log.info("插入 {} 条数据到mes_order", mesOrderList.size());
         } else {
             log.error("插入失败");
-                return R.failed("插入mes_order失败");
+            throw new RuntimeException("插入mes_order失败");
         }
 
         List<ProdProcessExec> processExecList = prodProcessExecService.lambdaQuery()
                 .eq(ProdProcessExec::getSceneId, sceneId)
                 .list();
 
-
-
-
         // 遍历GAScheduleResult结果并转换为dispatch
         List<Dispatch> dispatches = new ArrayList<>();
         for (GAScheduleResult gaResult : chromosome.getResult()) {
-
-
             ProdProcessExec prodProcessExec = processExecList.stream()
                     .filter(processExec -> processExec.getExecId().equals(gaResult.getExecId()))
                     .findFirst()
                     .orElse(null);
 
-
             Dispatch dispatch = new Dispatch();
             // 更新相关字段
             dispatch.setENof(gaResult.getOrderId());
@@ -279,18 +249,10 @@ public class LanuchServiceImpl implements LanuchService {
         if (savedDispatch) {
             return R.ok("计划下发成功，共处理 " + dispatches.size() + " 条记录");
         } else {
-                return R.failed("保存到数据库失败");
-            }
-        } catch (NumberFormatException e) {
-            log.error("数据转换失败，场景ID: " + sceneId, e);
-            return R.failed("数据转换失败，请检查数据格式: " + e.getMessage());
-        } catch (Exception e) {
-            log.error("下发计划失败，场景ID: " + sceneId, e);
-            return R.failed("下发计划失败: " + e.getMessage());
+            throw new RuntimeException("保存到数据库失败");
         }
     }
 
-
     /**
      ◦ 处理订单数据：批量转换ProdOrderMain到ProdLaunchOrder
 
@@ -299,28 +261,19 @@ public class LanuchServiceImpl implements LanuchService {
 
      */
     private List<ProdLaunchOrder> processOrderData(String sceneId, List<ApsOrder> prodOrderMainList) {
-
-
         // 批量转换并插入
         List<ProdLaunchOrder> launchOrderList = prodOrderMainList.stream()
                 .map(order -> convertToLaunchOrder(order, sceneId))
                 .filter(Objects::nonNull)
                 .collect(Collectors.toList());
 
-
-
         // 批量插入
         if (!launchOrderList .isEmpty()) {
             for (ProdLaunchOrder order : launchOrderList ) {
-                try {
                 prodLaunchOrderService.save(order); // 单条插入
-                } catch (Exception e) {
-                    log.error("保存订单失败: {}", order.getOrderId(), e);
-                }
             }
         }
 
-
         log.info("成功处理{}条订单数据", prodOrderMainList.size());
 
         return launchOrderList;
@@ -338,44 +291,19 @@ public class LanuchServiceImpl implements LanuchService {
 
      */
     private ProdLaunchOrder convertToLaunchOrder(ApsOrder order, String sceneId) {
-        try {
         ProdLaunchOrder launchOrder = new ProdLaunchOrder();
         launchOrder.setOrderId(order.getId());
         launchOrder.setSceneId(sceneId);
         launchOrder.setSerie(order.getSeries());
         launchOrder.setCreateUser(String.valueOf(order.getCreatoruserid()));
         launchOrder.setMaterialCode(order.getMmcode());
-//            launchOrder.setStartDate(order.get);
         launchOrder.setEndDate(order.getDeliverytime());
-//            launchOrder.setOrderPriority(order.getPrioritry());
         launchOrder.setOrderPriority(1);
         launchOrder.setQuantity(order.getQuantity());
         launchOrder.setMaterialId(order.getMmid());
-
-            String mmid = order.getMmid();
-//            // 通过mmid查找对应的工艺
-//            if (mmid != null && !mmid.isEmpty()) {
-//                LambdaQueryWrapper<RoutingHeader> routingWrapper = new LambdaQueryWrapper<>();
-//                routingWrapper.eq(RoutingHeader::getMaterialId, mmid);
-//                routingWrapper.eq(RoutingHeader::getIsDeleted, 0); // 添加判断 is_deleted=0
-//                List<RoutingHeader> routingHeaders = routingHeaderService.list(routingWrapper);
-//                RoutingHeader routingHeader = null;
-//                if (!CollectionUtils.isEmpty(routingHeaders)) {
-//                    routingHeader = routingHeaders.get(0);
-//                }
-//
-//                if (routingHeader != null) {
-//                    launchOrder.setRoutingId(routingHeader.getId());
-//                    launchOrder.setRoutingCode(defaultIfBlank(routingHeader.getCode(), ""));
-//                }
-//            }
         launchOrder.setRoutingId(order.getRoutingid());
         launchOrder.setRoutingCode(order.getRoutingcode());
         return launchOrder;
-        } catch (Exception e) {
-            log.error("转换订单[{}]失败", order.getId(), e);
-            return null;
-        }
     }
 
     /**
@@ -564,14 +492,8 @@ public class LanuchServiceImpl implements LanuchService {
             return;
         }
 
-
         for (ProdLaunchOrder prodOrderMain : order) {
-            try {
             convertToProcessExec(prodOrderMain, sceneId);
-            } catch (Exception e) {
-                log.error("转换工单[{}]到工序执行表失败", prodOrderMain.getOrderId(), e);
-                continue;
-            }
         }
 
         log.info("完成{}个工单的工序转换",order.size());
@@ -589,23 +511,16 @@ public class LanuchServiceImpl implements LanuchService {
 
      */
     public boolean convertToProcessExec(ProdLaunchOrder prodOrderMain, String sceneId) {
-
-
         // 查询对应的工艺
         RoutingHeader routingHeader = getRoutingHeader(prodOrderMain.getRoutingId());
 
         // 查询该工艺下的所有工序
-
         List<RoutingDetail> routingDetails = getRoutingDetails(routingHeader.getId());
-
         List<RoutingDetailEquip> routingDetailEquip = getRoutingDetailEquip(routingHeader.getId());
 
-
         // 批量插入新的工序工单记录
         batchInsertProcessExec(prodOrderMain, routingDetails, sceneId,routingDetailEquip);
 
-
-
         return true;
     }
 
@@ -657,7 +572,6 @@ public class LanuchServiceImpl implements LanuchService {
         return routingDetails;
     }
 
-
     /**
      ◦ 批量插入工序执行记录
 
@@ -672,8 +586,6 @@ public class LanuchServiceImpl implements LanuchService {
     public void batchInsertProcessExec(ProdLaunchOrder prodOrderMain,
                                        List<RoutingDetail> routingDetails,
                                        String sceneId, List<RoutingDetailEquip> routingDetailEquip)  {
-
-
         List<ProdProcessExec> processExecList = routingDetails.stream()
                 .map(detail -> createProcessExec(prodOrderMain, detail, sceneId))
                 .collect(Collectors.toList());
@@ -686,14 +598,6 @@ public class LanuchServiceImpl implements LanuchService {
         }
     }
 
-    // 添加一个方法来更新execId映射
-    /*
-    private void updateExecIdMapping(List<ProdProcessExec> processExecList) {
-        // 这里可以将processExecList中的数据添加到一个全局映射中，供其他方法使用
-        // 由于当前设计限制，暂不实现全局映射，但保留此方法以备将来扩展
-    }
-    */
-
     /**
      ◦ 创建工序执行记录
 
@@ -717,7 +621,6 @@ public class LanuchServiceImpl implements LanuchService {
         prodProcessExec.setTaskSeq(detail.getTaskSeq());
         prodProcessExec.setRoutingDetailName(detail.getName());
         prodProcessExec.setMachineId(detail.getEquipTypeId());
-//        prodProcessExec.setResourceGroup(String.valueOf(detail.getResourceId()));
         prodProcessExec.setPlanQty(prodOrderMain.getQuantity());
         prodProcessExec.setTargetStartDate(prodOrderMain.getStartDate());
         prodProcessExec.setTargetEndDate(prodOrderMain.getEndDate());
@@ -728,16 +631,11 @@ public class LanuchServiceImpl implements LanuchService {
         prodProcessExec.setPreprocessingTime(detail.getPreprocessingTime());
         prodProcessExec.setPostprocessingTime(detail.getPostprocessingTime());
         prodProcessExec.setId(String.valueOf(SnowFlackIdWorker.getId()));
-
-
         prodProcessExec.setConnectProperty(detail.getConnectProperty());
-
-
         prodProcessExec.setRoutingId(prodOrderMain.getRoutingId());
         prodProcessExec.setRoutingCode(prodOrderMain.getRoutingCode());
         prodProcessExec.setConnectPropertyName(detail.getConnectPropertyName());
 
-
         prodProcessExec.setSpeed(
                 Optional.ofNullable(detail.getRuntime())
                         .filter(out -> detail.getSingleOut() != null)
@@ -750,8 +648,6 @@ public class LanuchServiceImpl implements LanuchService {
         return prodProcessExec;
     }
 
-
-
     /**
      ◦ 批量生成工序关联关系
 
@@ -798,10 +694,6 @@ public class LanuchServiceImpl implements LanuchService {
         log.info("完成{}个工单的工序关系生成", prodOrderMains.size());
     }
 
-
-
-
-
     /**
      ◦ 生成工序关联关系
 
@@ -819,13 +711,8 @@ public class LanuchServiceImpl implements LanuchService {
         List<ProdOrderProcess> processRelations = new java.util.ArrayList<>();
 
         for (ProdLaunchOrder prodOrderMain : prodOrderMains) {
-            try {
             List<ProdOrderProcess> relations = createProcessRelations(prodOrderMain, sceneId, routingDetailIdToExecIdMap);
             processRelations.addAll(relations);
-            } catch (Exception e) {
-                log.error("生成工单[{}]工序关系失败", prodOrderMain.getOrderId(), e);
-                continue;
-            }
         }
 
         // 批量保存（增加严格校验）
@@ -904,14 +791,12 @@ public class LanuchServiceImpl implements LanuchService {
         if (execId != null) {
             prodOrderProcess.setExecId(execId);
         }else {
-
             prodOrderProcess.setExecId("ttt");
         }
 
         if (targetExecId != null) {
             prodOrderProcess.setTargetExecId(targetExecId);
         }else {
-
             prodOrderProcess.setTargetExecId("ttt");
         }
 
@@ -950,15 +835,11 @@ public class LanuchServiceImpl implements LanuchService {
     public List<ProdEquipment> batchInsertEquipMent(
             List<RoutingDetailEquip> routingDetailEquips,
             String sceneId,List<ProdProcessExec> processExecList,Boolean isSave) {
-
-
         if (CollectionUtils.isEmpty(routingDetailEquips)) {
             log.warn("工艺设备列表为空，跳过设备对照表生成");
             return null;
         }
 
-
-
         // 创建ProdEquipment列表
         List<ProdEquipment> prodEquipments = new java.util.ArrayList<>();
 
@@ -983,7 +864,6 @@ public class LanuchServiceImpl implements LanuchService {
                             .orElse(0.0)
             );
 
-
             String execId = processExecList.stream()
                     .filter(exec -> {
                         Long execRoutingDetailId = exec.getRoutingDetailId();
@@ -1027,14 +907,11 @@ public class LanuchServiceImpl implements LanuchService {
 
      */
     public 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);
@@ -1043,8 +920,6 @@ public class LanuchServiceImpl implements LanuchService {
         return detailEquips;
     }
 
-
-
     /**
      * Copy ProdLaunchOrder data
      */
@@ -1167,8 +1042,6 @@ public class LanuchServiceImpl implements LanuchService {
     private void copyChromosomeFile(String oldSceneId, String newSceneId) {
         try {
             // 检查源场景是否有染色体文件
-
-
             if (sceneService.chromosomeFileExists(oldSceneId)) {
                 // 从源场景加载染色体
                 Chromosome chromosome = sceneService.loadChromosomeFromFile(oldSceneId);
@@ -1186,11 +1059,8 @@ public class LanuchServiceImpl implements LanuchService {
             }
         } catch (Exception e) {
             log.error("复制染色体文件时发生异常，从场景 {} 到场景 {}", oldSceneId, newSceneId, e);
+            // 重新抛出异常，让全局异常处理器处理
+            throw e;
         }
     }
-
-
-
-
-
 }
\ No newline at end of file

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

@@ -1174,4 +1174,215 @@ private  GlobalParam InitGlobalParam()
 
 
     }
+
+
+
+
+    /**
+     * 将 ScheduleChromosome 转换为 ResourceGanttVO 列表
+     * @param scheduleChromosome 调度结果
+     * @param machineList 机器列表
+     * @return 转换后的数据
+     */
+    public List<com.aps.entity.Gantt.ResourceGanttVO> convertToResourceGanttVO1(Chromosome scheduleChromosome, List<Machine> machineList) {
+        List<com.aps.entity.Gantt.ResourceGanttVO> resourceGanttVOList = new ArrayList<>();
+
+        // 遍历所有机器资源
+        if (machineList != null) {
+            for (int i = 0; i < machineList.size(); i++) {
+                Machine machine = machineList.get(i);
+
+                com.aps.entity.Gantt.ResourceGanttVO resourceGanttVO = new com.aps.entity.Gantt.ResourceGanttVO();
+                resourceGanttVO.setId(machine.getId());
+                resourceGanttVO.setName(machine.getId()+"号设备");
+                resourceGanttVO.setShift(convertToShiftVO(machine));
+                // 转换任务列表
+                List<com.aps.entity.Gantt.TaskVO> taskVOList = new ArrayList<>();
+                if (scheduleChromosome.getResult() != null) {
+                    // 筛选出属于当前设备的任务
+                    List<GAScheduleResult> machineGenes = scheduleChromosome.getResult().stream()
+                            .filter(gene -> gene.getMachineId()==(machine.getId()))
+                            .collect(Collectors.toList());
+
+                    // 按开始时间排序
+                    machineGenes.sort((g1, g2) -> Integer.compare(g1.getStartTime(), g2.getStartTime()));
+
+                    for (GAScheduleResult gene : machineGenes) {
+                        com.aps.entity.Gantt.TaskVO taskVO = new com.aps.entity.Gantt.TaskVO();
+//                        taskVO.setId(gene.getId()); // 临时处理
+                        taskVO.setPlanId(gene.getOrderId()); // 默认值
+//                        taskVO.setProductType(0); // 默认值
+//                        taskVO.setProductName("产品"+gene.getProductId());
+                        taskVO.setProductId(gene.getProductId()); // 默认值
+                        taskVO.setQuantity(gene.getQuantity());
+                        taskVO.setStart(scheduleChromosome.getBaseTime().plusSeconds(gene.getStartTime()));
+                        taskVO.setEnd(scheduleChromosome.getBaseTime().plusSeconds(gene.getEndTime()));
+                        taskVO.setSetup(0); // 默认值
+                        taskVO.setTeardown(gene.getTeardownTime()); // 默认值
+                        taskVO.setEquipChange(gene.getChangeoverTime()); // 默认值
+                        taskVO.setEquipCooling(0); // 默认值
+                        taskVO.setEquipType(resourceGanttVO.getType());
+                        taskVO.setEquipName(resourceGanttVO.getName());
+//                        taskVO.setDuration(calculateDuration(
+//                                scheduleChromosome.getBaseTime().plusMinutes(gene.getStartTime()),
+//                                scheduleChromosome.getBaseTime().plusMinutes(gene.getEndTime()))); // 计算持续时间
+
+                        taskVO.setDuration(0); //
+                        taskVO.setEquipId(machine.getId());
+                        taskVO.setShopId(machine.getId());
+                        taskVO.setShopName(resourceGanttVO.getShopName());
+                        taskVO.setStatus(0); // 默认值
+
+                        taskVO.setDetailId((long) gene.getStartTime()); // 将productId和operationID组合为detailId
+                        taskVO.setHeaderId(gene.getEndTime()); // 默认值
+//                        taskVO.setHeaderName("工艺"+gene.getProductId()); // 默认值
+//                        taskVO.setSeq(gene.getSequenceId()); // 使用工序ID
+//                        taskVO.setSeqName( "工序名称"+gene.getSequenceId());
+                        taskVO.setProcessingTime(gene.getProcessingTime());
+//                        taskVO.setAbsoluteStart(scheduleChromosome.getBaseTime().plusMinutes(gene.getStartTime()));
+//                        taskVO.setAbsoluteEnd(scheduleChromosome.getBaseTime().plusMinutes(gene.getEndTime()));
+                        taskVOList.add(taskVO);
+
+                        // 调试：检查machine中的shifts状态
+//                        if (machine.getShifts() != null) {
+//                            for (Shift shift : machine.getShifts()) {
+//                                System.out.println("Before setting shifts - Shift status: " + shift.getStatus());
+//                            }
+//                        }
+
+                        taskVO.setAbsolutePreparationTime(gene.getTeardownTime());
+
+
+
+                    }
+                }
+
+                resourceGanttVO.setList(taskVOList);
+                resourceGanttVOList.add(resourceGanttVO);
+            }
+        }
+
+        return resourceGanttVOList;
+    }
+
+    /**
+     * 将 ScheduleChromosome 转换为 ProductGanttVO 列表
+     * @param scheduleChromosome 调度结果
+     * @return 转换后的数据
+     */
+    public List<com.aps.entity.Gantt.ProductGanttVO> convertToProductGanttVO1(Chromosome scheduleChromosome) {
+        List<com.aps.entity.Gantt.ProductGanttVO> productGanttVOList = new ArrayList<>();
+
+        // 按产品ID和工单ID分组基因
+        if (scheduleChromosome.getResult() != null) {
+            // 按工单ID分组
+            scheduleChromosome.getResult().stream()
+                    .collect(Collectors.groupingBy(GAScheduleResult::getOrderId))
+                    .forEach((orderId, genes) -> {
+                        if (!genes.isEmpty()) {
+                            com.aps.entity.Gantt.ProductGanttVO productGanttVO = new com.aps.entity.Gantt.ProductGanttVO();
+                            GAScheduleResult firstGene = genes.get(0);
+                            productGanttVO.setId(firstGene.getOrderId());
+                            productGanttVO.setProductName("产品"+firstGene.getProductId()); // 默认值，实际应从订单数据获取
+                            productGanttVO.setProductType(0);
+                            productGanttVO.setProductId(firstGene.getProductId());
+                            // 计算总数量（假设同一批次）
+                            productGanttVO.setQuantity(firstGene.getQuantity());
+                            productGanttVO.setCode("编号"+firstGene.getProductId()); // 默认值
+                            productGanttVO.setShopId(firstGene.getMachineId()); // 默认值
+                            productGanttVO.setShopName(firstGene.getMachineId()+"号线"); // 默认值
+                            productGanttVO.setStatus("已发布");
+//                            productGanttVO.setHeaderId(firstGene.getProductId());
+                            productGanttVO.setHeaderName("工艺"+firstGene.getProductId()); // 默认值
+
+                            // 计算开始和结束时间
+                            int minStartTime = genes.stream()
+                                    .mapToInt(GAScheduleResult::getStartTime)
+                                    .min()
+                                    .orElse(0);
+                            int maxEndTime = genes.stream()
+                                    .mapToInt(GAScheduleResult::getEndTime)
+                                    .max()
+                                    .orElse(0);
+
+                            productGanttVO.setStartDate(scheduleChromosome.getBaseTime().plusMinutes(minStartTime));
+                            productGanttVO.setEndDate(scheduleChromosome.getBaseTime().plusMinutes(maxEndTime));
+
+                            // 转换任务列表
+                            List<com.aps.entity.Gantt.TaskVO> taskVOList = new ArrayList<>();
+//                            // 按工序顺序排序
+//                            genes.sort((g1, g2) -> Integer.compare(g1.getSequenceId(), g2.getSequenceId()));
+
+                            for (int i = 0; i < genes.size(); i++) {
+                                GAScheduleResult gene = genes.get(i);
+                                com.aps.entity.Gantt.TaskVO taskVO = new com.aps.entity.Gantt.TaskVO();
+                                taskVO.setId(gene.getOrderId()); // 生成唯一ID
+                                taskVO.setPlanId(String.valueOf(orderId));
+                                taskVO.setProductType(0);
+                                taskVO.setProductName("产品"+gene.getProductId());
+                                taskVO.setProductId(String.valueOf(gene.getProductId()));
+                                taskVO.setQuantity(gene.getQuantity());
+                                taskVO.setStart(scheduleChromosome.getBaseTime().plusSeconds(gene.getStartTime()));
+                                taskVO.setEnd(scheduleChromosome.getBaseTime().plusSeconds(gene.getEndTime()));
+                                taskVO.setSetup(0); // 默认值
+                                taskVO.setTeardown(gene.getTeardownTime()); // 默认值
+                                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(
+                                        scheduleChromosome.getBaseTime().plusMinutes(gene.getStartTime()),
+                                        scheduleChromosome.getBaseTime().plusMinutes(gene.getEndTime())));
+                                taskVO.setEquipId(gene.getMachineId()); // 生成设备ID
+                                taskVO.setShopId(gene.getMachineId());
+                                taskVO.setShopName(gene.getMachineId()+"车间");
+                                taskVO.setStatus(0);
+//                                taskVO.setDetailId((long) gene.getProductId() * 1000 + gene.getOperationId());
+//                                taskVO.setHeaderId(gene.getProductId());
+                                taskVO.setHeaderName("工艺"+gene.getProductId());
+//                                taskVO.setSeq(gene.getSequenceId());
+//                                taskVO.setSeqName("工序名称"+gene.getSequenceId());
+//                                taskVO.setAbsoluteStart(scheduleChromosome.getBaseTime().plusMinutes(gene.getStartTime()));
+//                                taskVO.setAbsoluteEnd(scheduleChromosome.getBaseTime().plusMinutes(gene.getEndTime()));
+
+                                taskVOList.add(taskVO);
+                            }
+
+                            productGanttVO.setList(taskVOList);
+                            productGanttVOList.add(productGanttVO);
+                        }
+                    });
+        }
+
+        return productGanttVOList;
+    }
+
+
+
+
+    private ShiftVO convertToShiftVO(Machine machine) {
+        ShiftVO shiftVO= new ShiftVO();
+        shiftVO.setId(machine.getId());
+        shiftVO.setName(machine.getName());
+        shiftVO.setShifts(machine.getShifts());
+        shiftVO.setMaintenanceWindows(machine.getMaintenanceWindows());
+        // 注意：tasks 字段需要在其他地方设置，因为 Machine 类中没有任务信息
+        return shiftVO;
+    }
+
+
+    /**
+     * 计算任务持续时间（分钟）
+     * @param start 开始时间
+     * @param end 结束时间
+     * @return 持续时间（分钟）
+     */
+    private Integer calculateDuration(LocalDateTime start, LocalDateTime end) {
+        if (start == null || end == null) {
+            return 0;
+        }
+        return Math.toIntExact(java.time.Duration.between(start, end).toMinutes());
+    }
+
+
 }
\ No newline at end of file