场景复制

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

@@ -49,4 +49,16 @@ public class LanuchController {
     }
 
 
+    @PostMapping("/copyScene")
+    public R<String> copyScene(
+            @RequestParam String newSceneName,@RequestParam String oldSceneName,
+            @RequestHeader(required = false) String username) {
+        if (username == null || username.isEmpty()) {
+            username = "system";
+        }
+
+        return lanuchService.copyScene(oldSceneName,username,newSceneName);
+    }
+
+
 }
\ No newline at end of file

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

@@ -16,4 +16,13 @@ public interface LanuchService {
      * @return 结果
      */
     R<String> lanuch( String sceneId, String username);
+
+    /**
+     * 生成设备日历数据
+     *
+     * @author: jdt
+     * @return 结果
+     */
+    R<String> copyScene( String oldSceneId, String username,String newSceneId);
+
 }
\ No newline at end of file

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

@@ -22,6 +22,8 @@ import java.time.LocalTime;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static org.springframework.beans.BeanUtils.copyProperties;
+
 /**
  • 设备日历服务实现类
 
@@ -118,7 +120,56 @@ public class LanuchServiceImpl implements LanuchService {
         }
     }
 
+    /**
+     *复制数据
+     * @param oldSceneName
+     * @param newSceneName
+     * @return R<String> Result
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public R<String> copyScene(String oldSceneName,String username, String newSceneName) {
+        try {
+            // Validate input parameters
+            if (oldSceneName == null || oldSceneName.trim().isEmpty()) {
+                return R.failed("场景ID不能为空");
+            }
+
+            if (newSceneName == null || newSceneName.trim().isEmpty()) {
+                return R.failed("复制场景ID不能为空");
+            }
+
+
 
+            // 检查场景是否存在
+            ProdSceneConfig oldScene = prodSceneConfigService.lambdaQuery()
+                    .eq(ProdSceneConfig::getSceneName, oldSceneName)
+                    .one();
+
+            if (oldScene == null) {
+                return R.failed("源场景不存在");
+            }
+            //  创建场景
+            String newSceneId = createScene(newSceneName);
+            if (newSceneId == null) {
+                return R.failed("场景名称已存在");
+            }
+
+            // 复制数据
+            copyProdLaunchOrders(oldScene.getSceneId(), newSceneId);
+            copyProdProcessExecs(oldScene.getSceneId(), newSceneId);
+            copyProdOrderProcesses(oldScene.getSceneId(), newSceneId);
+            copyProdEquipments(oldScene.getSceneId(), newSceneId);
+            copyProdEquipSpecialCals(oldScene.getSceneId(), newSceneId);
+
+            log.info("场景数据复制完成，从 {} 到 {}", oldSceneName, newSceneName);
+            return R.ok("场景数据复制成功");
+
+        } catch (Exception e) {
+            log.error("复制场景数据失败", e);
+            throw new RuntimeException("复制场景数据失败: " + e.getMessage(), e);
+        }
+    }
 
 
 
@@ -859,4 +910,124 @@ public class LanuchServiceImpl implements LanuchService {
     }
 
 
+
+    /**
+     * Copy ProdLaunchOrder data
+     */
+    private void copyProdLaunchOrders(String oldSceneId, String newSceneId) {
+        List<ProdLaunchOrder> oldOrders = prodLaunchOrderService.lambdaQuery()
+                .eq(ProdLaunchOrder::getSceneId, oldSceneId)
+                .list();
+
+        List<ProdLaunchOrder> newOrders = oldOrders.stream()
+                .map(order -> {
+                    ProdLaunchOrder newOrder = new ProdLaunchOrder();
+                    // Copy all properties except sceneId
+                    copyProperties(order, newOrder);
+                    newOrder.setSceneId(newSceneId);
+                    newOrder.setOrderId(order.getOrderId()); // Generate new ID if needed
+                    return newOrder;
+                })
+                .collect(Collectors.toList());
+
+        if (!CollectionUtils.isEmpty(newOrders)) {
+            prodLaunchOrderService.saveBatch(newOrders);
+        }
+    }
+
+    /**
+     * Copy ProdProcessExec data
+     */
+    private void copyProdProcessExecs(String oldSceneId, String newSceneId) {
+        List<ProdProcessExec> oldExecs = prodProcessExecService.lambdaQuery()
+                .eq(ProdProcessExec::getSceneId, oldSceneId)
+                .list();
+
+        List<ProdProcessExec> newExecs = oldExecs.stream()
+                .map(exec -> {
+                    ProdProcessExec newExec = new ProdProcessExec();
+                    copyProperties(exec, newExec);
+                    newExec.setSceneId(newSceneId);
+                    newExec.setId(String.valueOf(SnowFlackIdWorker.getId()));
+                    return newExec;
+                })
+                .collect(Collectors.toList());
+
+        if (!CollectionUtils.isEmpty(newExecs)) {
+            prodProcessExecService.saveBatch(newExecs);
+        }
+    }
+
+    /**
+     * 复制 ProdOrderProcess
+     */
+    private void copyProdOrderProcesses(String oldSceneId, String newSceneId) {
+        List<ProdOrderProcess> oldProcesses = prodOrderProcessService.lambdaQuery()
+                .eq(ProdOrderProcess::getSceneId, oldSceneId)
+                .list();
+
+        List<ProdOrderProcess> newProcesses = oldProcesses.stream()
+                .map(process -> {
+                    ProdOrderProcess newProcess = new ProdOrderProcess();
+                    copyProperties(process, newProcess);
+                    newProcess.setSceneId(newSceneId);
+                    newProcess.setId(String.valueOf(SnowFlackIdWorker.getId()));
+                    return newProcess;
+                })
+                .collect(Collectors.toList());
+
+        if (!CollectionUtils.isEmpty(newProcesses)) {
+            prodOrderProcessService.saveBatch(newProcesses);
+        }
+    }
+
+    /**
+     * 复制 ProdEquipment
+     */
+    private void copyProdEquipments(String oldSceneId, String newSceneId) {
+        List<ProdEquipment> oldEquipments = prodEquipmentService.lambdaQuery()
+                .eq(ProdEquipment::getSceneId, oldSceneId)
+                .list();
+
+        List<ProdEquipment> newEquipments = oldEquipments.stream()
+                .map(equipment -> {
+                    ProdEquipment newEquipment = new ProdEquipment();
+                    copyProperties(equipment, newEquipment);
+                    newEquipment.setSceneId(newSceneId);
+                    newEquipment.setId(String.valueOf(SnowFlackIdWorker.getId()));
+                    return newEquipment;
+                })
+                .collect(Collectors.toList());
+
+        if (!CollectionUtils.isEmpty(newEquipments)) {
+            prodEquipmentService.saveBatch(newEquipments);
+        }
+    }
+
+    /**
+     * 复制 ProdEquipSpecialCal
+     */
+    private void copyProdEquipSpecialCals(String oldSceneId, String newSceneId) {
+        List<ProdEquipSpecialCal> oldCals = prodEquipSpecialCalService.lambdaQuery()
+                .eq(ProdEquipSpecialCal::getSceneId, oldSceneId)
+                .list();
+
+        List<ProdEquipSpecialCal> newCals = oldCals.stream()
+                .map(cal -> {
+                    ProdEquipSpecialCal newCal = new ProdEquipSpecialCal();
+                    copyProperties(cal, newCal);
+                    newCal.setSceneId(newSceneId);
+                    newCal.setId(String.valueOf(SnowFlackIdWorker.getId()));
+                    return newCal;
+                })
+                .collect(Collectors.toList());
+
+        if (!CollectionUtils.isEmpty(newCals)) {
+            prodEquipSpecialCalService.saveBatch(newCals);
+        }
+    }
+
+
+
+
 }
\ No newline at end of file