refactor(wms/flow): 调整客诉流程为串行模式并替换质量部为技术部

1.  将原并行的质量部+生产部流程改为技术部→生产部→陈总→吴部长的串行流程
2.  替换所有质量部相关描述为技术部，更新部门映射配置
3.  重构流程状态推进逻辑，新增getNextDept方法简化流程推进
4.  新增表单本地暂存功能，优化列表项UI布局
5.  更新流程步骤展示、状态文案和标签颜色配置

klp-flow/src/main/java/com/klp/flow/controller/TsComplaintAcceptController.java

@@ -99,7 +99,7 @@ public class TsComplaintAcceptController extends BaseController {
     }
 
     /**
-     * 发起流程：创建质量部+生产部并行任务
+     * 发起流程（串行）：创建技术部任务
      *
      * @param acceptId 受理单ID
      */

klp-flow/src/main/java/com/klp/flow/service/ITsComplaintAcceptService.java

@@ -48,7 +48,7 @@ public interface ITsComplaintAcceptService {
     Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
 
     /**
-     * 发起流程：创建质量部+生产部并行任务，更新flowStatus=1
+     * 发起流程（串行）：创建技术部任务，更新flowStatus=1
      */
     Boolean opinionDispatch(Long acceptId);
 }

klp-flow/src/main/java/com/klp/flow/service/impl/TsComplaintAcceptServiceImpl.java

@@ -115,7 +115,7 @@ public class TsComplaintAcceptServiceImpl implements ITsComplaintAcceptService {
                 }).collect(java.util.stream.Collectors.toList());
                 tsAcceptCoilRelMapper.insertBatch(relList);
             }
-            // 自动创建质量部+生产部并行任务，发起流程
+            // 自动创建技术部任务，发起串行流程
             opinionDispatch(add.getAcceptId());
         }
         return flag;
@@ -132,30 +132,23 @@ public class TsComplaintAcceptServiceImpl implements ITsComplaintAcceptService {
     }
 
     /**
-     * 发起流程
-     * 创建质量部(deptId=2) + 生产部(deptId=1) 两个并行代办任务
-     * 更新受理单flow_status=1（质量部·生产部处理中）
+     * 发起流程（串行）
+     * 创建技术部(deptId=2) 代办任务
+     * 更新受理单flow_status=1（技术部处理中）
      */
     @Override
     public Boolean opinionDispatch(Long acceptId) {
         if (acceptId == null) {
             return false;
         }
-        // 1. 创建质量部task deptId=2
-        TsComplaintTask qaTask = new TsComplaintTask();
-        qaTask.setAcceptId(acceptId);
-        qaTask.setDeptId(2L);
-        qaTask.setTaskStatus(0L);
-        qaTask.setRejectMark(0L);
-        tsComplaintTaskMapper.insert(qaTask);
-        // 2. 创建生产部task deptId=1
-        TsComplaintTask prodTask = new TsComplaintTask();
-        prodTask.setAcceptId(acceptId);
-        prodTask.setDeptId(1L);
-        prodTask.setTaskStatus(0L);
-        prodTask.setRejectMark(0L);
-        tsComplaintTaskMapper.insert(prodTask);
-        // 3. 更新受理单流程状态为1（质量部·生产部处理中）
+        // 1. 创建技术部task deptId=2
+        TsComplaintTask techTask = new TsComplaintTask();
+        techTask.setAcceptId(acceptId);
+        techTask.setDeptId(2L);
+        techTask.setTaskStatus(0L);
+        techTask.setRejectMark(0L);
+        tsComplaintTaskMapper.insert(techTask);
+        // 2. 更新受理单流程状态为1（技术部处理中）
         LambdaUpdateWrapper<TsComplaintAccept> uw = Wrappers.lambdaUpdate();
         uw.eq(TsComplaintAccept::getAcceptId, acceptId)
             .set(TsComplaintAccept::getFlowStatus, 1L);

klp-flow/src/main/java/com/klp/flow/service/impl/TsComplaintTaskServiceImpl.java

@@ -157,10 +157,11 @@ public class TsComplaintTaskServiceImpl implements ITsComplaintTaskService {
     }
 
     /**
-     * 同步受理单流程状态 — 串行推进逻辑
-     * Step 1: 质量部(deptId=2) + 生产部(deptId=1) 都完成 → 创建陈总task(deptId=4), flowStatus=2
-     * Step 2: 陈总完成 → 创建吴部长task(deptId=3), flowStatus=3
-     * Step 3: 吴部长完成 → flowStatus=4 已办结
+     * 同步受理单流程状态 — 严格串行推进逻辑
+     * Step 1: 技术部(deptId=2)完成 → 创建生产部task(deptId=1), flowStatus=2
+     * Step 2: 生产部(deptId=1)完成 → 创建陈总task(deptId=4), flowStatus=3
+     * Step 3: 陈总(deptId=4)完成 → 创建吴部长task(deptId=3), flowStatus=4
+     * Step 4: 吴部长(deptId=3)完成 → flowStatus=5 已办结
      */
     private void syncAcceptFlowStatus(Long acceptId) {
         if (acceptId == null) {
@@ -178,52 +179,49 @@ public class TsComplaintTaskServiceImpl implements ITsComplaintTaskService {
         Map<Long, List<TsComplaintTask>> taskByDept = taskList.stream()
             .collect(Collectors.groupingBy(TsComplaintTask::getDeptId));
 
-        // Step 1: 质量部(deptId=2) 和 生产部(deptId=1) 是否都完成
-        boolean qaDone = taskByDept.containsKey(2L) &&
-            taskByDept.get(2L).stream().allMatch(t -> t.getTaskStatus() != null && t.getTaskStatus() == 1L);
-        boolean prodDone = taskByDept.containsKey(1L) &&
-            taskByDept.get(1L).stream().allMatch(t -> t.getTaskStatus() != null && t.getTaskStatus() == 1L);
-
-        if (qaDone && prodDone) {
-            // 两者都完成 → 检查陈总节点(deptId=4)是否存在
-            boolean chenExists = taskByDept.containsKey(4L);
-            if (!chenExists) {
-                // 创建陈总task deptId=4
-                TsComplaintTask chenTask = new TsComplaintTask();
-                chenTask.setAcceptId(acceptId);
-                chenTask.setDeptId(4L);
-                chenTask.setRejectMark(0L);
-                chenTask.setTaskStatus(0L);
-                baseMapper.insert(chenTask);
-                updateFlowStatus(acceptId, 2L); // 待陈总审批
-            } else {
-                // 陈总节点已存在，检查是否完成
-                boolean chenDone = taskByDept.get(4L).stream()
-                    .allMatch(t -> t.getTaskStatus() != null && t.getTaskStatus() == 1L);
-                if (chenDone) {
-                    // 陈总完成 → 检查吴部长节点(deptId=3)是否存在
-                    boolean wuExists = taskByDept.containsKey(3L);
-                    if (!wuExists) {
-                        // 创建吴部长task deptId=3
-                        TsComplaintTask wuTask = new TsComplaintTask();
-                        wuTask.setAcceptId(acceptId);
-                        wuTask.setDeptId(3L);
-                        wuTask.setRejectMark(0L);
-                        wuTask.setTaskStatus(0L);
-                        baseMapper.insert(wuTask);
-                        updateFlowStatus(acceptId, 3L); // 待吴部长处理
-                    } else {
-                        // 吴部长已完成 → 办结
-                        boolean wuDone = taskByDept.get(3L).stream()
-                            .allMatch(t -> t.getTaskStatus() != null && t.getTaskStatus() == 1L);
-                        if (wuDone) {
-                            updateFlowStatus(acceptId, 4L); // 已办结
-                        }
-                    }
+        // 辅助方法：检查某部门的所有任务是否都已完成
+        java.util.function.BiFunction<Long, Long, Boolean> isDeptDone = (deptId, nextFlowStatus) -> {
+            if (!taskByDept.containsKey(deptId)) {
+                return false;
+            }
+            boolean done = taskByDept.get(deptId).stream()
+                .allMatch(t -> t.getTaskStatus() != null && t.getTaskStatus() == 1L);
+            if (done) {
+                // 检查是否已存在下一节点，若不存在则创建
+                Long nextDeptId = getNextDept(deptId);
+                if (nextDeptId != null && !taskByDept.containsKey(nextDeptId)) {
+                    TsComplaintTask nextTask = new TsComplaintTask();
+                    nextTask.setAcceptId(acceptId);
+                    nextTask.setDeptId(nextDeptId);
+                    nextTask.setRejectMark(0L);
+                    nextTask.setTaskStatus(0L);
+                    baseMapper.insert(nextTask);
+                    updateFlowStatus(acceptId, nextFlowStatus);
+                } else if (nextDeptId == null) {
+                    // 最后一步（吴部长完成）→ 办结
+                    updateFlowStatus(acceptId, 5L);
                 }
             }
-        }
-        // 质/产未全部完成时不做任何事，等待
+            return done;
+        };
+
+        // 按串行顺序依次推进：技术部→生产部→陈总→吴部长→办结
+        // flowStatus: 1→2→3→4→5
+        isDeptDone.apply(2L, 2L); // 技术部完成 → 生产部, flowStatus=2
+        isDeptDone.apply(1L, 3L); // 生产部完成 → 陈总, flowStatus=3
+        isDeptDone.apply(4L, 4L); // 陈总完成 → 吴部长, flowStatus=4
+        isDeptDone.apply(3L, 5L); // 吴部长完成 → 办结, flowStatus=5
+    }
+
+    /**
+     * 获取串行流程中当前部门完成后应创建的下一个部门
+     * 2(技术部) → 1(生产部) → 4(陈总) → 3(吴部长) → null(办结)
+     */
+    private Long getNextDept(Long deptId) {
+        if (deptId == 2L) return 1L;  // 技术部 → 生产部
+        if (deptId == 1L) return 4L;  // 生产部 → 陈总
+        if (deptId == 4L) return 3L;  // 陈总 → 吴部长
+        return null;                   // 吴部长 → 办结
     }
 
     /**