feat(wm-dispatch): #60 综合工单管理（创建/分派/处理/完成/统计）

- Entity: WorkOrder(增强), WorkOrderLog, WorkOrderAssignment
- DTO: CreateRequest, QueryRequest, AssignRequest, ProcessRequest, StatVO, BatchAssignRequest, BatchCancelRequest
- Mapper: WorkOrderMapper(增强统计SQL), WorkOrderLogMapper, WorkOrderAssignmentMapper
- Service: WorkOrderLifecycleService(全生命周期), WorkOrderLedgerService(台账查询), WorkOrderStatisticsService(统计分析)
- Controller: WorkOrderController(16个端点)
- DDL: V3__workorder.sql(3张表+索引)
- Test: WorkOrderLifecycleServiceTest(15个), WorkOrderStatisticsServiceTest(3个)

功能特性:
- 工单创建: 支持REPAIR/INSPECTION/COMPLAINT/EMERGENCY四种类型 + LOW/MEDIUM/HIGH/URGENT优先级 + 附件
- 工单分派: 手动/自动分派 + 多人协作(主负责人+协助人)
- 工单处理: 状态流转(待办→已分派→处理中→已完成/已驳回/已取消) + 处理日志
- 工单统计: 完成率/平均处理时长/按类型分布/按优先级分布/按人员分布/逾期数/今日统计

db/postgresql/V3__workorder.sql

@@ -0,0 +1,87 @@
+-- =============================================
+-- 智慧水务管理系统 - 综合工单管理 DDL
+-- 版本: V3
+-- 描述: 工单创建/分派/处理/完成/统计
+-- =============================================
+
+-- ==================== 工单主表 ====================
+CREATE TABLE IF NOT EXISTS dispatch_work_order (
+    id BIGSERIAL PRIMARY KEY,
+    order_no VARCHAR(50) UNIQUE NOT NULL,
+    title VARCHAR(200) NOT NULL,
+    description TEXT,
+    type VARCHAR(30) NOT NULL DEFAULT 'REPAIR',       -- REPAIR/INSPECTION/COMPLAINT/EMERGENCY
+    priority VARCHAR(20) NOT NULL DEFAULT 'MEDIUM',    -- LOW/MEDIUM/HIGH/URGENT
+    status INT NOT NULL DEFAULT 0,                     -- 0:待办 1:已分派 2:处理中 4:已完成 5:已驳回 6:已取消
+    assignee_id BIGINT,
+    assignee_name VARCHAR(50),
+    creator_id BIGINT,
+    creator_name VARCHAR(50),
+    source VARCHAR(50),                                 -- 来源: manual/phone/app/alert
+    facility_id BIGINT,
+    location VARCHAR(500),
+    longitude DOUBLE PRECISION,
+    latitude DOUBLE PRECISION,
+    attachments TEXT,                                   -- JSON数组
+    deadline TIMESTAMP,
+    assigned_at TIMESTAMP,
+    started_at TIMESTAMP,
+    completed_at TIMESTAMP,
+    result TEXT,
+    reject_reason TEXT,
+    remark TEXT,
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE dispatch_work_order IS '工单主表';
+COMMENT ON COLUMN dispatch_work_order.type IS '工单类型: REPAIR(维修)/INSPECTION(巡检)/COMPLAINT(投诉)/EMERGENCY(应急)';
+COMMENT ON COLUMN dispatch_work_order.priority IS '优先级: LOW/MEDIUM/HIGH/URGENT';
+COMMENT ON COLUMN dispatch_work_order.status IS '状态: 0待办/1已分派/2处理中/4已完成/5已驳回/6已取消';
+
+CREATE INDEX IF NOT EXISTS idx_wo_order_no ON dispatch_work_order(order_no);
+CREATE INDEX IF NOT EXISTS idx_wo_status ON dispatch_work_order(status);
+CREATE INDEX IF NOT EXISTS idx_wo_type ON dispatch_work_order(type);
+CREATE INDEX IF NOT EXISTS idx_wo_assignee ON dispatch_work_order(assignee_id);
+CREATE INDEX IF NOT EXISTS idx_wo_creator ON dispatch_work_order(creator_id);
+CREATE INDEX IF NOT EXISTS idx_wo_created_at ON dispatch_work_order(created_at);
+
+-- ==================== 工单处理日志 ====================
+CREATE TABLE IF NOT EXISTS dispatch_work_order_log (
+    id BIGSERIAL PRIMARY KEY,
+    work_order_id BIGINT NOT NULL REFERENCES dispatch_work_order(id),
+    order_no VARCHAR(50),
+    stage VARCHAR(30),
+    from_status INT,
+    to_status INT,
+    operator_id BIGINT,
+    operator_name VARCHAR(50),
+    action_desc TEXT,
+    attachments TEXT,
+    created_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE dispatch_work_order_log IS '工单处理日志';
+
+CREATE INDEX IF NOT EXISTS idx_wolog_wo_id ON dispatch_work_order_log(work_order_id);
+CREATE INDEX IF NOT EXISTS idx_wolog_order_no ON dispatch_work_order_log(order_no);
+
+-- ==================== 工单分派记录 ====================
+CREATE TABLE IF NOT EXISTS dispatch_work_order_assignment (
+    id BIGSERIAL PRIMARY KEY,
+    work_order_id BIGINT NOT NULL REFERENCES dispatch_work_order(id),
+    order_no VARCHAR(50),
+    assigner_id BIGINT,
+    assigner_name VARCHAR(50),
+    assignee_id BIGINT,
+    assignee_name VARCHAR(50),
+    role VARCHAR(20) NOT NULL DEFAULT 'PRIMARY',       -- PRIMARY/ASSISTANT
+    assignment_note TEXT,
+    assignment_type VARCHAR(20) DEFAULT 'MANUAL',      -- MANUAL/AUTO
+    status INT DEFAULT 1,                              -- 1:活跃 0:已移除
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE dispatch_work_order_assignment IS '工单分派记录（支持多人协作）';
+
+CREATE INDEX IF NOT EXISTS idx_woassign_wo_id ON dispatch_work_order_assignment(work_order_id);
+CREATE INDEX IF NOT EXISTS idx_woassign_assignee ON dispatch_work_order_assignment(assignee_id);

wm-dispatch/src/main/java/com/water/dispatch/controller/WorkOrderController.java

@@ -0,0 +1,152 @@
+package com.water.dispatch.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.water.common.core.result.R;
+import com.water.dispatch.entity.WorkOrder;
+import com.water.dispatch.entity.WorkOrderAssignment;
+import com.water.dispatch.entity.WorkOrderLog;
+import com.water.dispatch.entity.dto.*;
+import com.water.dispatch.service.WorkOrderLedgerService;
+import com.water.dispatch.service.WorkOrderLifecycleService;
+import com.water.dispatch.service.WorkOrderStatisticsService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 综合工单管理 - 创建/分派/处理/完成/统计
+ * 状态流转: PENDING(0) → ASSIGNED(1) → IN_PROGRESS(2) → COMPLETED(4) / REJECTED(5) / CANCELLED(6)
+ */
+@Tag(name = "综合工单管理")
+@RestController
+@RequestMapping("/api/dispatch/workorder")
+@RequiredArgsConstructor
+public class WorkOrderController {
+
+    private final WorkOrderLifecycleService lifecycleService;
+    private final WorkOrderLedgerService ledgerService;
+    private final WorkOrderStatisticsService statisticsService;
+
+    // ==================== 工单创建 ====================
+
+    @Operation(summary = "1. 创建工单")
+    @PostMapping
+    public R<WorkOrder> create(@RequestBody WorkOrderCreateRequest req) {
+        return R.ok(lifecycleService.create(req));
+    }
+
+    // ==================== 工单分派 ====================
+
+    @Operation(summary = "2. 分派工单（手动/自动 + 多人协作）")
+    @PostMapping("/{id}/assign")
+    public R<WorkOrder> assign(@PathVariable Long id, @RequestBody WorkOrderAssignRequest req) {
+        return R.ok(lifecycleService.assign(id, req));
+    }
+
+    // ==================== 工单处理 ====================
+
+    @Operation(summary = "3. 开始处理工单")
+    @PostMapping("/{id}/start")
+    public R<WorkOrder> startProcess(@PathVariable Long id, @RequestBody WorkOrderProcessRequest req) {
+        return R.ok(lifecycleService.startProcess(id, req));
+    }
+
+    @Operation(summary = "4. 完成工单")
+    @PostMapping("/{id}/complete")
+    public R<WorkOrder> complete(@PathVariable Long id, @RequestBody WorkOrderProcessRequest req) {
+        return R.ok(lifecycleService.complete(id, req));
+    }
+
+    @Operation(summary = "5. 驳回工单")
+    @PostMapping("/{id}/reject")
+    public R<WorkOrder> reject(@PathVariable Long id, @RequestBody WorkOrderProcessRequest req) {
+        return R.ok(lifecycleService.reject(id, req));
+    }
+
+    @Operation(summary = "6. 取消工单")
+    @PostMapping("/{id}/cancel")
+    public R<WorkOrder> cancel(@PathVariable Long id, @RequestBody WorkOrderProcessRequest req) {
+        return R.ok(lifecycleService.cancel(id, req));
+    }
+
+    // ==================== 查询 ====================
+
+    @Operation(summary = "7. 获取工单详情（按ID）")
+    @GetMapping("/{id}")
+    public R<WorkOrder> getById(@PathVariable Long id) {
+        return R.ok(lifecycleService.getById(id));
+    }
+
+    @Operation(summary = "8. 根据工单编号获取详情")
+    @GetMapping("/no/{orderNo}")
+    public R<WorkOrder> getByOrderNo(@PathVariable String orderNo) {
+        return R.ok(lifecycleService.getByOrderNo(orderNo));
+    }
+
+    @Operation(summary = "9. 工单分页查询")
+    @GetMapping("/page")
+    public R<IPage<WorkOrder>> queryPage(WorkOrderQueryRequest req) {
+        return R.ok(ledgerService.queryPage(req));
+    }
+
+    @Operation(summary = "10. 工单列表查询")
+    @GetMapping("/list")
+    public R<List<WorkOrder>> queryList(WorkOrderQueryRequest req) {
+        return R.ok(ledgerService.queryList(req));
+    }
+
+    // ==================== 处理记录 & 分派记录 ====================
+
+    @Operation(summary = "11. 获取工单处理日志")
+    @GetMapping("/{id}/logs")
+    public R<List<WorkOrderLog>> getLogs(@PathVariable Long id) {
+        return R.ok(lifecycleService.getLogs(id));
+    }
+
+    @Operation(summary = "12. 获取工单分派记录")
+    @GetMapping("/{id}/assignments")
+    public R<List<WorkOrderAssignment>> getAssignments(@PathVariable Long id) {
+        return R.ok(lifecycleService.getAssignments(id));
+    }
+
+    // ==================== 统计 ====================
+
+    @Operation(summary = "13. 工单统计概览（完成率/平均时长/类型分布/人员分布）")
+    @GetMapping("/statistics")
+    public R<WorkOrderStatVO> statistics() {
+        return R.ok(statisticsService.statistics());
+    }
+
+    // ==================== 导出 ====================
+
+    @Operation(summary = "14. 工单数据导出")
+    @GetMapping("/export")
+    public R<List<WorkOrder>> exportData(WorkOrderQueryRequest req) {
+        return R.ok(ledgerService.exportData(req));
+    }
+
+    // ==================== 批量操作 ====================
+
+    @Operation(summary = "15. 批量分派工单")
+    @PostMapping("/batch-assign")
+    public R<List<WorkOrder>> batchAssign(@RequestBody WorkOrderBatchAssignRequest req) {
+        List<WorkOrder> results = new java.util.ArrayList<>();
+        for (Long id : req.getWorkOrderIds()) {
+            results.add(lifecycleService.assign(id, req));
+        }
+        return R.ok(results);
+    }
+
+    @Operation(summary = "16. 批量取消工单")
+    @PostMapping("/batch-cancel")
+    public R<List<WorkOrder>> batchCancel(@RequestBody WorkOrderBatchCancelRequest req) {
+        List<WorkOrder> results = new java.util.ArrayList<>();
+        for (Long id : req.getWorkOrderIds()) {
+            results.add(lifecycleService.cancel(id, req));
+        }
+        return R.ok(results);
+    }
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/WorkOrder.java

@@ -1,12 +1,98 @@
 package com.water.dispatch.entity;
+
 import com.baomidou.mybatisplus.annotation.*;
-import lombok.Data; import java.time.LocalDateTime;
-@Data @TableName("dispatch_work_order")
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单实体 - 综合工单管理
+ * 类型: REPAIR(维修)/INSPECTION(巡检)/COMPLAINT(投诉)/EMERGENCY(应急)
+ * 优先级: LOW/MEDIUM/HIGH/URGENT
+ * 状态: PENDING(待办)/ASSIGNED(已分派)/IN_PROGRESS(处理中)/COMPLETED(已完成)/REJECTED(已驳回)/CANCELLED(已取消)
+ */
+@Data
+@TableName("dispatch_work_order")
 public class WorkOrder {
-    @TableId(type = IdType.AUTO) private Long id;
-    private String orderNo, title, description, type, priority;
-    private Integer status; private Long assigneeId, creatorId;
-    private LocalDateTime deadline, completedAt;
-    @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime;
-    @TableField(fill=FieldFill.INSERT_UPDATE) private LocalDateTime updatedTime;
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 工单编号 */
+    private String orderNo;
+
+    /** 工单标题 */
+    private String title;
+
+    /** 工单描述 */
+    private String description;
+
+    /** 工单类型: REPAIR/INSPECTION/COMPLAINT/EMERGENCY */
+    private String type;
+
+    /** 优先级: LOW/MEDIUM/HIGH/URGENT */
+    private String priority;
+
+    /** 状态: PENDING/ASSIGNED/IN_PROGRESS/COMPLETED/REJECTED/CANCELLED */
+    private Integer status;
+
+    /** 主负责人ID */
+    private Long assigneeId;
+
+    /** 主负责人姓名 */
+    private String assigneeName;
+
+    /** 创建人ID */
+    private Long creatorId;
+
+    /** 创建人姓名 */
+    private String creatorName;
+
+    /** 来源 */
+    private String source;
+
+    /** 关联设施ID */
+    private Long facilityId;
+
+    /** 地点描述 */
+    private String location;
+
+    /** 经度 */
+    private Double longitude;
+
+    /** 纬度 */
+    private Double latitude;
+
+    /** 附件URL列表(JSON) */
+    private String attachments;
+
+    /** 截止时间 */
+    private LocalDateTime deadline;
+
+    /** 分派时间 */
+    private LocalDateTime assignedAt;
+
+    /** 开始处理时间 */
+    private LocalDateTime startedAt;
+
+    /** 完成时间 */
+    private LocalDateTime completedAt;
+
+    /** 处理结果 */
+    private String result;
+
+    /** 驳回原因 */
+    private String rejectReason;
+
+    /** 备注 */
+    private String remark;
+
+    @TableLogic
+    private Integer deleted;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
 }

wm-dispatch/src/main/java/com/water/dispatch/entity/WorkOrderAssignment.java

@@ -0,0 +1,53 @@
+package com.water.dispatch.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单分派记录 - 支持多人协作
+ */
+@Data
+@TableName("dispatch_work_order_assignment")
+public class WorkOrderAssignment {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 工单ID */
+    private Long workOrderId;
+
+    /** 工单编号 */
+    private String orderNo;
+
+    /** 分派人ID */
+    private Long assignerId;
+
+    /** 分派人姓名 */
+    private String assignerName;
+
+    /** 被分派人ID */
+    private Long assigneeId;
+
+    /** 被分派人姓名 */
+    private String assigneeName;
+
+    /** 角色: PRIMARY(主负责人)/ASSISTANT(协助人) */
+    private String role;
+
+    /** 分派说明 */
+    private String assignmentNote;
+
+    /** 分派方式: MANUAL(手动)/AUTO(自动) */
+    private String assignmentType;
+
+    /** 状态: ACTIVE(活跃)/REMOVED(已移除) */
+    private Integer status;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/WorkOrderLog.java

@@ -0,0 +1,47 @@
+package com.water.dispatch.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单处理日志 - 记录工单状态流转和处理过程
+ */
+@Data
+@TableName("dispatch_work_order_log")
+public class WorkOrderLog {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 工单ID */
+    private Long workOrderId;
+
+    /** 工单编号 */
+    private String orderNo;
+
+    /** 操作阶段 */
+    private String stage;
+
+    /** 操作前状态 */
+    private Integer fromStatus;
+
+    /** 操作后状态 */
+    private Integer toStatus;
+
+    /** 操作人ID */
+    private Long operatorId;
+
+    /** 操作人姓名 */
+    private String operatorName;
+
+    /** 操作描述 */
+    private String actionDesc;
+
+    /** 附件 */
+    private String attachments;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderAssignRequest.java

@@ -0,0 +1,40 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 工单分派请求
+ */
+@Data
+public class WorkOrderAssignRequest {
+
+    /** 操作人ID */
+    private Long assignerId;
+
+    /** 操作人姓名 */
+    private String assignerName;
+
+    /** 主负责人ID */
+    private Long primaryAssigneeId;
+
+    /** 主负责人姓名 */
+    private String primaryAssigneeName;
+
+    /** 分派说明 */
+    private String assignmentNote;
+
+    /** 分派方式: MANUAL/AUTO */
+    private String assignmentType;
+
+    /** 协助人列表 */
+    private List<AssistantInfo> assistants;
+
+    @Data
+    public static class AssistantInfo {
+        private Long userId;
+        private String userName;
+        private String note;
+    }
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderBatchAssignRequest.java

@@ -0,0 +1,17 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+
+/**
+ * 批量分派工单请求
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class WorkOrderBatchAssignRequest extends WorkOrderAssignRequest {
+
+    /** 工单ID列表 */
+    private List<Long> workOrderIds;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderBatchCancelRequest.java

@@ -0,0 +1,17 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+
+/**
+ * 批量取消工单请求
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class WorkOrderBatchCancelRequest extends WorkOrderProcessRequest {
+
+    /** 工单ID列表 */
+    private List<Long> workOrderIds;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderCreateRequest.java

@@ -0,0 +1,54 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单创建请求
+ */
+@Data
+public class WorkOrderCreateRequest {
+
+    /** 工单标题 */
+    private String title;
+
+    /** 工单描述 */
+    private String description;
+
+    /** 工单类型: REPAIR/INSPECTION/COMPLAINT/EMERGENCY */
+    private String type;
+
+    /** 优先级: LOW/MEDIUM/HIGH/URGENT */
+    private String priority;
+
+    /** 创建人ID */
+    private Long creatorId;
+
+    /** 创建人姓名 */
+    private String creatorName;
+
+    /** 来源 */
+    private String source;
+
+    /** 关联设施ID */
+    private Long facilityId;
+
+    /** 地点描述 */
+    private String location;
+
+    /** 经度 */
+    private Double longitude;
+
+    /** 纬度 */
+    private Double latitude;
+
+    /** 附件URL列表(JSON) */
+    private String attachments;
+
+    /** 截止时间 */
+    private LocalDateTime deadline;
+
+    /** 备注 */
+    private String remark;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderProcessRequest.java

@@ -0,0 +1,28 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+
+/**
+ * 工单处理请求（开始处理/完成/驳回）
+ */
+@Data
+public class WorkOrderProcessRequest {
+
+    /** 操作人ID */
+    private Long operatorId;
+
+    /** 操作人姓名 */
+    private String operatorName;
+
+    /** 处理结果(完成时) */
+    private String result;
+
+    /** 驳回原因(驳回时) */
+    private String rejectReason;
+
+    /** 附件 */
+    private String attachments;
+
+    /** 备注 */
+    private String remark;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderQueryRequest.java

@@ -0,0 +1,48 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单查询请求
+ */
+@Data
+public class WorkOrderQueryRequest {
+
+    /** 工单编号 */
+    private String orderNo;
+
+    /** 工单标题(模糊) */
+    private String title;
+
+    /** 工单类型 */
+    private String type;
+
+    /** 优先级 */
+    private String priority;
+
+    /** 状态 */
+    private Integer status;
+
+    /** 负责人ID */
+    private Long assigneeId;
+
+    /** 创建人ID */
+    private Long creatorId;
+
+    /** 来源 */
+    private String source;
+
+    /** 查询开始时间 */
+    private LocalDateTime startTime;
+
+    /** 查询结束时间 */
+    private LocalDateTime endTime;
+
+    /** 页码 */
+    private Integer pageNum = 1;
+
+    /** 每页大小 */
+    private Integer pageSize = 10;
+}

wm-dispatch/src/main/java/com/water/dispatch/entity/dto/WorkOrderStatVO.java

@@ -0,0 +1,42 @@
+package com.water.dispatch.entity.dto;
+
+import lombok.Data;
+
+import java.util.Map;
+
+/**
+ * 工单统计VO
+ */
+@Data
+public class WorkOrderStatVO {
+
+    /** 总数 */
+    private Long total;
+
+    /** 按状态分布 */
+    private Map<Integer, Long> byStatus;
+
+    /** 按类型分布 */
+    private Map<String, Long> byType;
+
+    /** 按优先级分布 */
+    private Map<String, Long> byPriority;
+
+    /** 完成率(%) */
+    private Double completionRate;
+
+    /** 平均处理时长(小时) */
+    private Double avgProcessHours;
+
+    /** 逾期工单数 */
+    private Long overdueCount;
+
+    /** 今日新建 */
+    private Long todayCreated;
+
+    /** 今日完成 */
+    private Long todayCompleted;
+
+    /** 按人员工单分布: assigneeName → count */
+    private Map<String, Long> byAssignee;
+}

wm-dispatch/src/main/java/com/water/dispatch/mapper/WorkOrderAssignmentMapper.java

@@ -0,0 +1,9 @@
+package com.water.dispatch.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.dispatch.entity.WorkOrderAssignment;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface WorkOrderAssignmentMapper extends BaseMapper<WorkOrderAssignment> {
+}

wm-dispatch/src/main/java/com/water/dispatch/mapper/WorkOrderLogMapper.java

@@ -0,0 +1,9 @@
+package com.water.dispatch.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.dispatch.entity.WorkOrderLog;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface WorkOrderLogMapper extends BaseMapper<WorkOrderLog> {
+}

wm-dispatch/src/main/java/com/water/dispatch/mapper/WorkOrderMapper.java

@@ -1,5 +1,31 @@
 package com.water.dispatch.mapper;
+
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.water.dispatch.entity.WorkOrder;
 import org.apache.ibatis.annotations.Mapper;
-@Mapper public interface WorkOrderMapper extends BaseMapper<WorkOrder> {}
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface WorkOrderMapper extends BaseMapper<WorkOrder> {
+
+    @Select("SELECT status, COUNT(*) as cnt FROM dispatch_work_order WHERE deleted=0 GROUP BY status")
+    List<Map<String, Object>> countByStatus();
+
+    @Select("SELECT type, COUNT(*) as cnt FROM dispatch_work_order WHERE deleted=0 GROUP BY type")
+    List<Map<String, Object>> countByType();
+
+    @Select("SELECT priority, COUNT(*) as cnt FROM dispatch_work_order WHERE deleted=0 GROUP BY priority")
+    List<Map<String, Object>> countByPriority();
+
+    @Select("SELECT COALESCE(assignee_name, '未分派') as assignee, COUNT(*) as cnt FROM dispatch_work_order WHERE deleted=0 GROUP BY assignee_name")
+    List<Map<String, Object>> countByAssignee();
+
+    @Select("SELECT COUNT(*) FROM dispatch_work_order WHERE deleted=0 AND status NOT IN (4,5,6) AND deadline < NOW()")
+    long countOverdue();
+
+    @Select("SELECT AVG(EXTRACT(EPOCH FROM (completed_at - started_at))/3600.0) FROM dispatch_work_order WHERE deleted=0 AND status=4 AND started_at IS NOT NULL AND completed_at IS NOT NULL")
+    Double avgProcessHours();
+}

wm-dispatch/src/main/java/com/water/dispatch/service/WorkOrderLedgerService.java

@@ -0,0 +1,83 @@
+package com.water.dispatch.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.dispatch.entity.WorkOrder;
+import com.water.dispatch.entity.dto.WorkOrderQueryRequest;
+import com.water.dispatch.mapper.WorkOrderMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 工单台账服务 - 多维度查询
+ */
+@Service
+@RequiredArgsConstructor
+public class WorkOrderLedgerService {
+
+    private final WorkOrderMapper workOrderMapper;
+
+    /**
+     * 分页查询
+     */
+    public IPage<WorkOrder> queryPage(WorkOrderQueryRequest req) {
+        Page<WorkOrder> page = new Page<>(req.getPageNum(), req.getPageSize());
+        LambdaQueryWrapper<WorkOrder> wrapper = buildWrapper(req);
+        wrapper.orderByDesc(WorkOrder::getCreatedAt);
+        return workOrderMapper.selectPage(page, wrapper);
+    }
+
+    /**
+     * 列表查询（不分页）
+     */
+    public List<WorkOrder> queryList(WorkOrderQueryRequest req) {
+        LambdaQueryWrapper<WorkOrder> wrapper = buildWrapper(req);
+        wrapper.orderByDesc(WorkOrder::getCreatedAt);
+        return workOrderMapper.selectList(wrapper);
+    }
+
+    /**
+     * 导出数据
+     */
+    public List<WorkOrder> exportData(WorkOrderQueryRequest req) {
+        return queryList(req);
+    }
+
+    private LambdaQueryWrapper<WorkOrder> buildWrapper(WorkOrderQueryRequest req) {
+        LambdaQueryWrapper<WorkOrder> wrapper = new LambdaQueryWrapper<>();
+        if (req.getOrderNo() != null && !req.getOrderNo().isEmpty()) {
+            wrapper.like(WorkOrder::getOrderNo, req.getOrderNo());
+        }
+        if (req.getTitle() != null && !req.getTitle().isEmpty()) {
+            wrapper.like(WorkOrder::getTitle, req.getTitle());
+        }
+        if (req.getType() != null && !req.getType().isEmpty()) {
+            wrapper.eq(WorkOrder::getType, req.getType());
+        }
+        if (req.getPriority() != null && !req.getPriority().isEmpty()) {
+            wrapper.eq(WorkOrder::getPriority, req.getPriority());
+        }
+        if (req.getStatus() != null) {
+            wrapper.eq(WorkOrder::getStatus, req.getStatus());
+        }
+        if (req.getAssigneeId() != null) {
+            wrapper.eq(WorkOrder::getAssigneeId, req.getAssigneeId());
+        }
+        if (req.getCreatorId() != null) {
+            wrapper.eq(WorkOrder::getCreatorId, req.getCreatorId());
+        }
+        if (req.getSource() != null && !req.getSource().isEmpty()) {
+            wrapper.eq(WorkOrder::getSource, req.getSource());
+        }
+        if (req.getStartTime() != null) {
+            wrapper.ge(WorkOrder::getCreatedAt, req.getStartTime());
+        }
+        if (req.getEndTime() != null) {
+            wrapper.le(WorkOrder::getCreatedAt, req.getEndTime());
+        }
+        return wrapper;
+    }
+}

wm-dispatch/src/main/java/com/water/dispatch/service/WorkOrderLifecycleService.java

@@ -0,0 +1,260 @@
+package com.water.dispatch.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.common.core.exception.BusinessException;
+import com.water.dispatch.entity.WorkOrder;
+import com.water.dispatch.entity.WorkOrderAssignment;
+import com.water.dispatch.entity.WorkOrderLog;
+import com.water.dispatch.entity.dto.WorkOrderAssignRequest;
+import com.water.dispatch.entity.dto.WorkOrderCreateRequest;
+import com.water.dispatch.entity.dto.WorkOrderProcessRequest;
+import com.water.dispatch.mapper.WorkOrderAssignmentMapper;
+import com.water.dispatch.mapper.WorkOrderLogMapper;
+import com.water.dispatch.mapper.WorkOrderMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+/**
+ * 工单全生命周期服务
+ * 状态流转: PENDING(0) → ASSIGNED(1) → IN_PROGRESS(2) → COMPLETED(4) / REJECTED(5) / CANCELLED(6)
+ */
+@Service
+@RequiredArgsConstructor
+public class WorkOrderLifecycleService {
+
+    /** 状态常量 */
+    public static final int STATUS_PENDING = 0;
+    public static final int STATUS_ASSIGNED = 1;
+    public static final int STATUS_IN_PROGRESS = 2;
+    public static final int STATUS_COMPLETED = 4;
+    public static final int STATUS_REJECTED = 5;
+    public static final int STATUS_CANCELLED = 6;
+
+    private final WorkOrderMapper workOrderMapper;
+    private final WorkOrderLogMapper logMapper;
+    private final WorkOrderAssignmentMapper assignmentMapper;
+
+    // ==================== 创建 ====================
+
+    @Transactional
+    public WorkOrder create(WorkOrderCreateRequest req) {
+        WorkOrder wo = new WorkOrder();
+        wo.setOrderNo(generateOrderNo());
+        wo.setTitle(req.getTitle());
+        wo.setDescription(req.getDescription());
+        wo.setType(req.getType() != null ? req.getType() : "REPAIR");
+        wo.setPriority(req.getPriority() != null ? req.getPriority() : "MEDIUM");
+        wo.setStatus(STATUS_PENDING);
+        wo.setCreatorId(req.getCreatorId());
+        wo.setCreatorName(req.getCreatorName());
+        wo.setSource(req.getSource());
+        wo.setFacilityId(req.getFacilityId());
+        wo.setLocation(req.getLocation());
+        wo.setLongitude(req.getLongitude());
+        wo.setLatitude(req.getLatitude());
+        wo.setAttachments(req.getAttachments());
+        wo.setDeadline(req.getDeadline());
+        wo.setRemark(req.getRemark());
+        workOrderMapper.insert(wo);
+
+        addLog(wo, "CREATED", null, STATUS_PENDING, req.getCreatorId(), req.getCreatorName(), "创建工单");
+        return wo;
+    }
+
+    // ==================== 分派 ====================
+
+    @Transactional
+    public WorkOrder assign(Long workOrderId, WorkOrderAssignRequest req) {
+        WorkOrder wo = getOrderOrThrow(workOrderId);
+        if (wo.getStatus() != STATUS_PENDING && wo.getStatus() != STATUS_ASSIGNED) {
+            throw new BusinessException("当前状态不允许分派: " + wo.getStatus());
+        }
+
+        // 设置主负责人
+        wo.setAssigneeId(req.getPrimaryAssigneeId());
+        wo.setAssigneeName(req.getPrimaryAssigneeName());
+        wo.setStatus(STATUS_ASSIGNED);
+        wo.setAssignedAt(LocalDateTime.now());
+        workOrderMapper.updateById(wo);
+
+        // 记录主负责人分派
+        addAssignment(wo, req.getAssignerId(), req.getAssignerName(),
+                req.getPrimaryAssigneeId(), req.getPrimaryAssigneeName(),
+                "PRIMARY", req.getAssignmentNote(),
+                req.getAssignmentType() != null ? req.getAssignmentType() : "MANUAL");
+
+        // 记录协助人分派
+        if (req.getAssistants() != null) {
+            for (WorkOrderAssignRequest.AssistantInfo assistant : req.getAssistants()) {
+                addAssignment(wo, req.getAssignerId(), req.getAssignerName(),
+                        assistant.getUserId(), assistant.getUserName(),
+                        "ASSISTANT", assistant.getNote(),
+                        req.getAssignmentType() != null ? req.getAssignmentType() : "MANUAL");
+            }
+        }
+
+        addLog(wo, "ASSIGNED", STATUS_PENDING, STATUS_ASSIGNED,
+                req.getAssignerId(), req.getAssignerName(),
+                "分派给: " + req.getPrimaryAssigneeName());
+        return wo;
+    }
+
+    // ==================== 开始处理 ====================
+
+    @Transactional
+    public WorkOrder startProcess(Long workOrderId, WorkOrderProcessRequest req) {
+        WorkOrder wo = getOrderOrThrow(workOrderId);
+        if (wo.getStatus() != STATUS_ASSIGNED) {
+            throw new BusinessException("当前状态不允许开始处理: " + wo.getStatus());
+        }
+
+        wo.setStatus(STATUS_IN_PROGRESS);
+        wo.setStartedAt(LocalDateTime.now());
+        workOrderMapper.updateById(wo);
+
+        addLog(wo, "IN_PROGRESS", STATUS_ASSIGNED, STATUS_IN_PROGRESS,
+                req.getOperatorId(), req.getOperatorName(), "开始处理工单");
+        return wo;
+    }
+
+    // ==================== 完成 ====================
+
+    @Transactional
+    public WorkOrder complete(Long workOrderId, WorkOrderProcessRequest req) {
+        WorkOrder wo = getOrderOrThrow(workOrderId);
+        if (wo.getStatus() != STATUS_IN_PROGRESS) {
+            throw new BusinessException("当前状态不允许完成: " + wo.getStatus());
+        }
+
+        wo.setStatus(STATUS_COMPLETED);
+        wo.setCompletedAt(LocalDateTime.now());
+        wo.setResult(req.getResult());
+        workOrderMapper.updateById(wo);
+
+        addLog(wo, "COMPLETED", STATUS_IN_PROGRESS, STATUS_COMPLETED,
+                req.getOperatorId(), req.getOperatorName(),
+                "完成工单: " + (req.getResult() != null ? req.getResult() : ""));
+        return wo;
+    }
+
+    // ==================== 驳回 ====================
+
+    @Transactional
+    public WorkOrder reject(Long workOrderId, WorkOrderProcessRequest req) {
+        WorkOrder wo = getOrderOrThrow(workOrderId);
+        if (wo.getStatus() == STATUS_COMPLETED || wo.getStatus() == STATUS_CANCELLED || wo.getStatus() == STATUS_REJECTED) {
+            throw new BusinessException("当前状态不允许驳回: " + wo.getStatus());
+        }
+
+        int fromStatus = wo.getStatus();
+        wo.setStatus(STATUS_REJECTED);
+        wo.setRejectReason(req.getRejectReason());
+        workOrderMapper.updateById(wo);
+
+        addLog(wo, "REJECTED", fromStatus, STATUS_REJECTED,
+                req.getOperatorId(), req.getOperatorName(),
+                "驳回: " + (req.getRejectReason() != null ? req.getRejectReason() : ""));
+        return wo;
+    }
+
+    // ==================== 取消 ====================
+
+    @Transactional
+    public WorkOrder cancel(Long workOrderId, WorkOrderProcessRequest req) {
+        WorkOrder wo = getOrderOrThrow(workOrderId);
+        if (wo.getStatus() == STATUS_COMPLETED || wo.getStatus() == STATUS_CANCELLED) {
+            throw new BusinessException("当前状态不允许取消: " + wo.getStatus());
+        }
+
+        int fromStatus = wo.getStatus();
+        wo.setStatus(STATUS_CANCELLED);
+        workOrderMapper.updateById(wo);
+
+        addLog(wo, "CANCELLED", fromStatus, STATUS_CANCELLED,
+                req.getOperatorId(), req.getOperatorName(),
+                "取消工单" + (req.getRemark() != null ? ": " + req.getRemark() : ""));
+        return wo;
+    }
+
+    // ==================== 查询 ====================
+
+    public WorkOrder getById(Long id) {
+        return getOrderOrThrow(id);
+    }
+
+    public WorkOrder getByOrderNo(String orderNo) {
+        WorkOrder wo = workOrderMapper.selectOne(
+                new LambdaQueryWrapper<WorkOrder>()
+                        .eq(WorkOrder::getOrderNo, orderNo));
+        if (wo == null) {
+            throw new BusinessException("工单不存在: " + orderNo);
+        }
+        return wo;
+    }
+
+    public List<WorkOrderLog> getLogs(Long workOrderId) {
+        return logMapper.selectList(
+                new LambdaQueryWrapper<WorkOrderLog>()
+                        .eq(WorkOrderLog::getWorkOrderId, workOrderId)
+                        .orderByAsc(WorkOrderLog::getCreatedAt));
+    }
+
+    public List<WorkOrderAssignment> getAssignments(Long workOrderId) {
+        return assignmentMapper.selectList(
+                new LambdaQueryWrapper<WorkOrderAssignment>()
+                        .eq(WorkOrderAssignment::getWorkOrderId, workOrderId)
+                        .eq(WorkOrderAssignment::getStatus, 1)
+                        .orderByAsc(WorkOrderAssignment::getCreatedAt));
+    }
+
+    // ==================== Internal ====================
+
+    private WorkOrder getOrderOrThrow(Long id) {
+        WorkOrder wo = workOrderMapper.selectById(id);
+        if (wo == null) {
+            throw new BusinessException("工单不存在: " + id);
+        }
+        return wo;
+    }
+
+    private String generateOrderNo() {
+        return "WO-" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
+                + "-" + (int) (Math.random() * 9000 + 1000);
+    }
+
+    private void addLog(WorkOrder wo, String stage, Integer fromStatus, Integer toStatus,
+                        Long operatorId, String operatorName, String desc) {
+        WorkOrderLog log = new WorkOrderLog();
+        log.setWorkOrderId(wo.getId());
+        log.setOrderNo(wo.getOrderNo());
+        log.setStage(stage);
+        log.setFromStatus(fromStatus);
+        log.setToStatus(toStatus);
+        log.setOperatorId(operatorId);
+        log.setOperatorName(operatorName);
+        log.setActionDesc(desc);
+        logMapper.insert(log);
+    }
+
+    private void addAssignment(WorkOrder wo, Long assignerId, String assignerName,
+                               Long assigneeId, String assigneeName,
+                               String role, String note, String assignmentType) {
+        WorkOrderAssignment a = new WorkOrderAssignment();
+        a.setWorkOrderId(wo.getId());
+        a.setOrderNo(wo.getOrderNo());
+        a.setAssignerId(assignerId);
+        a.setAssignerName(assignerName);
+        a.setAssigneeId(assigneeId);
+        a.setAssigneeName(assigneeName);
+        a.setRole(role);
+        a.setAssignmentNote(note);
+        a.setAssignmentType(assignmentType);
+        a.setStatus(1); // ACTIVE
+        assignmentMapper.insert(a);
+    }
+}

wm-dispatch/src/main/java/com/water/dispatch/service/WorkOrderStatisticsService.java

@@ -0,0 +1,84 @@
+package com.water.dispatch.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.dispatch.entity.WorkOrder;
+import com.water.dispatch.entity.dto.WorkOrderStatVO;
+import com.water.dispatch.mapper.WorkOrderMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 工单统计服务 - 完成率/平均处理时长/按类型分布/按人员分布
+ */
+@Service
+@RequiredArgsConstructor
+public class WorkOrderStatisticsService {
+
+    private final WorkOrderMapper workOrderMapper;
+
+    /**
+     * 统计概览
+     */
+    public WorkOrderStatVO statistics() {
+        WorkOrderStatVO vo = new WorkOrderStatVO();
+
+        // 总数
+        vo.setTotal(workOrderMapper.selectCount(new LambdaQueryWrapper<>()));
+
+        // 按状态分布
+        Map<Integer, Long> byStatus = new HashMap<>();
+        workOrderMapper.countByStatus().forEach(m ->
+                byStatus.put(((Number) m.get("status")).intValue(), ((Number) m.get("cnt")).longValue()));
+        vo.setByStatus(byStatus);
+
+        // 按类型分布
+        Map<String, Long> byType = new HashMap<>();
+        workOrderMapper.countByType().forEach(m ->
+                byType.put(String.valueOf(m.get("type")), ((Number) m.get("cnt")).longValue()));
+        vo.setByType(byType);
+
+        // 按优先级分布
+        Map<String, Long> byPriority = new HashMap<>();
+        workOrderMapper.countByPriority().forEach(m ->
+                byPriority.put(String.valueOf(m.get("priority")), ((Number) m.get("cnt")).longValue()));
+        vo.setByPriority(byPriority);
+
+        // 按人员分布
+        Map<String, Long> byAssignee = new HashMap<>();
+        workOrderMapper.countByAssignee().forEach(m ->
+                byAssignee.put(String.valueOf(m.get("assignee")), ((Number) m.get("cnt")).longValue()));
+        vo.setByAssignee(byAssignee);
+
+        // 完成率
+        long completed = byStatus.getOrDefault(WorkOrderLifecycleService.STATUS_COMPLETED, 0L);
+        vo.setCompletionRate(vo.getTotal() > 0 ? Math.round(completed * 10000.0 / vo.getTotal()) / 100.0 : 0.0);
+
+        // 平均处理时长
+        Double avgHours = workOrderMapper.avgProcessHours();
+        vo.setAvgProcessHours(avgHours != null ? Math.round(avgHours * 100.0) / 100.0 : 0.0);
+
+        // 逾期数
+        vo.setOverdueCount(workOrderMapper.countOverdue());
+
+        // 今日统计
+        LocalDateTime todayStart = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
+        LocalDateTime todayEnd = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
+        vo.setTodayCreated(workOrderMapper.selectCount(
+                new LambdaQueryWrapper<WorkOrder>()
+                        .ge(WorkOrder::getCreatedAt, todayStart)
+                        .le(WorkOrder::getCreatedAt, todayEnd)));
+        vo.setTodayCompleted(workOrderMapper.selectCount(
+                new LambdaQueryWrapper<WorkOrder>()
+                        .eq(WorkOrder::getStatus, WorkOrderLifecycleService.STATUS_COMPLETED)
+                        .ge(WorkOrder::getCompletedAt, todayStart)
+                        .le(WorkOrder::getCompletedAt, todayEnd)));
+
+        return vo;
+    }
+}

wm-dispatch/src/test/java/com/water/dispatch/service/WorkOrderLifecycleServiceTest.java

@@ -0,0 +1,347 @@
+package com.water.dispatch.service;
+
+import com.water.common.core.exception.BusinessException;
+import com.water.dispatch.entity.WorkOrder;
+import com.water.dispatch.entity.WorkOrderAssignment;
+import com.water.dispatch.entity.WorkOrderLog;
+import com.water.dispatch.entity.dto.WorkOrderAssignRequest;
+import com.water.dispatch.entity.dto.WorkOrderCreateRequest;
+import com.water.dispatch.entity.dto.WorkOrderProcessRequest;
+import com.water.dispatch.mapper.WorkOrderAssignmentMapper;
+import com.water.dispatch.mapper.WorkOrderLogMapper;
+import com.water.dispatch.mapper.WorkOrderMapper;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class WorkOrderLifecycleServiceTest {
+
+    @Mock
+    private WorkOrderMapper workOrderMapper;
+    @Mock
+    private WorkOrderLogMapper logMapper;
+    @Mock
+    private WorkOrderAssignmentMapper assignmentMapper;
+
+    @InjectMocks
+    private WorkOrderLifecycleService lifecycleService;
+
+    // ==================== 1. 工单创建测试 ====================
+
+    @Test
+    void testCreateWorkOrder() {
+        when(workOrderMapper.insert(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderCreateRequest req = new WorkOrderCreateRequest();
+        req.setTitle("管道破裂维修");
+        req.setDescription("主管道漏水，需紧急维修");
+        req.setType("EMERGENCY");
+        req.setPriority("URGENT");
+        req.setCreatorId(1L);
+        req.setCreatorName("张三");
+        req.setLocation("某某路100号");
+
+        WorkOrder result = lifecycleService.create(req);
+
+        assertNotNull(result.getOrderNo());
+        assertTrue(result.getOrderNo().startsWith("WO-"));
+        assertEquals(0, result.getStatus()); // PENDING
+        assertEquals("EMERGENCY", result.getType());
+        assertEquals("URGENT", result.getPriority());
+        assertEquals("管道破裂维修", result.getTitle());
+        verify(workOrderMapper).insert(any());
+        verify(logMapper).insert(any());
+    }
+
+    @Test
+    void testCreateWorkOrderDefaultType() {
+        when(workOrderMapper.insert(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderCreateRequest req = new WorkOrderCreateRequest();
+        req.setTitle("测试工单");
+        req.setCreatorId(1L);
+        req.setCreatorName("张三");
+
+        WorkOrder result = lifecycleService.create(req);
+
+        assertEquals("REPAIR", result.getType());
+        assertEquals("MEDIUM", result.getPriority());
+    }
+
+    // ==================== 2. 工单分派测试 ====================
+
+    @Test
+    void testAssignWorkOrder() {
+        WorkOrder wo = buildWorkOrder(1L, 0);
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+        when(assignmentMapper.insert(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderAssignRequest req = new WorkOrderAssignRequest();
+        req.setAssignerId(10L);
+        req.setAssignerName("管理员");
+        req.setPrimaryAssigneeId(2L);
+        req.setPrimaryAssigneeName("李四");
+        req.setAssignmentNote("请尽快处理");
+        req.setAssignmentType("MANUAL");
+
+        WorkOrder result = lifecycleService.assign(1L, req);
+
+        assertEquals(1, result.getStatus()); // ASSIGNED
+        assertEquals(2L, result.getAssigneeId());
+        assertEquals("李四", result.getAssigneeName());
+        assertNotNull(result.getAssignedAt());
+        verify(assignmentMapper).insert(any());
+        verify(logMapper).insert(any());
+    }
+
+    @Test
+    void testAssignWorkOrderWithAssistants() {
+        WorkOrder wo = buildWorkOrder(1L, 0);
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+        when(assignmentMapper.insert(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderAssignRequest req = new WorkOrderAssignRequest();
+        req.setAssignerId(10L);
+        req.setAssignerName("管理员");
+        req.setPrimaryAssigneeId(2L);
+        req.setPrimaryAssigneeName("李四");
+
+        WorkOrderAssignRequest.AssistantInfo assistant = new WorkOrderAssignRequest.AssistantInfo();
+        assistant.setUserId(3L);
+        assistant.setUserName("王五");
+        assistant.setNote("协助维修");
+        req.setAssistants(List.of(assistant));
+
+        WorkOrder result = lifecycleService.assign(1L, req);
+
+        assertEquals(1, result.getStatus());
+        // 主负责人 + 1协助人 = 2次insert
+        ArgumentCaptor<WorkOrderAssignment> captor = ArgumentCaptor.forClass(WorkOrderAssignment.class);
+        verify(assignmentMapper, times(2)).insert(captor.capture());
+
+        List<WorkOrderAssignment> assignments = captor.getAllValues();
+        assertEquals("PRIMARY", assignments.get(0).getRole());
+        assertEquals("ASSISTANT", assignments.get(1).getRole());
+    }
+
+    @Test
+    void testAssignWorkOrderWrongStatus() {
+        WorkOrder wo = buildWorkOrder(1L, 2); // IN_PROGRESS
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+
+        WorkOrderAssignRequest req = new WorkOrderAssignRequest();
+        req.setPrimaryAssigneeId(2L);
+        req.setPrimaryAssigneeName("李四");
+
+        assertThrows(BusinessException.class, () -> lifecycleService.assign(1L, req));
+    }
+
+    // ==================== 3. 工单处理测试 ====================
+
+    @Test
+    void testStartProcess() {
+        WorkOrder wo = buildWorkOrder(1L, 1); // ASSIGNED
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        req.setOperatorId(2L);
+        req.setOperatorName("李四");
+
+        WorkOrder result = lifecycleService.startProcess(1L, req);
+
+        assertEquals(2, result.getStatus()); // IN_PROGRESS
+        assertNotNull(result.getStartedAt());
+    }
+
+    @Test
+    void testStartProcessWrongStatus() {
+        WorkOrder wo = buildWorkOrder(1L, 0); // PENDING
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        req.setOperatorId(2L);
+        req.setOperatorName("李四");
+
+        assertThrows(BusinessException.class, () -> lifecycleService.startProcess(1L, req));
+    }
+
+    // ==================== 4. 工单完成测试 ====================
+
+    @Test
+    void testCompleteWorkOrder() {
+        WorkOrder wo = buildWorkOrder(1L, 2); // IN_PROGRESS
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        req.setOperatorId(2L);
+        req.setOperatorName("李四");
+        req.setResult("管道已修复，测试通过");
+
+        WorkOrder result = lifecycleService.complete(1L, req);
+
+        assertEquals(4, result.getStatus()); // COMPLETED
+        assertNotNull(result.getCompletedAt());
+        assertEquals("管道已修复，测试通过", result.getResult());
+
+        ArgumentCaptor<WorkOrderLog> logCaptor = ArgumentCaptor.forClass(WorkOrderLog.class);
+        verify(logMapper).insert(logCaptor.capture());
+        assertEquals("COMPLETED", logCaptor.getValue().getStage());
+    }
+
+    @Test
+    void testCompleteWorkOrderWrongStatus() {
+        WorkOrder wo = buildWorkOrder(1L, 1); // ASSIGNED
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        req.setOperatorId(2L);
+        req.setOperatorName("李四");
+
+        assertThrows(BusinessException.class, () -> lifecycleService.complete(1L, req));
+    }
+
+    // ==================== 5. 工单驳回测试 ====================
+
+    @Test
+    void testRejectWorkOrder() {
+        WorkOrder wo = buildWorkOrder(1L, 1); // ASSIGNED
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        req.setOperatorId(3L);
+        req.setOperatorName("王五");
+        req.setRejectReason("信息不足，无法处理");
+
+        WorkOrder result = lifecycleService.reject(1L, req);
+
+        assertEquals(5, result.getStatus()); // REJECTED
+        assertEquals("信息不足，无法处理", result.getRejectReason());
+    }
+
+    @Test
+    void testRejectCompletedWorkOrder() {
+        WorkOrder wo = buildWorkOrder(1L, 4); // COMPLETED
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        assertThrows(BusinessException.class, () -> lifecycleService.reject(1L, req));
+    }
+
+    // ==================== 6. 工单取消测试 ====================
+
+    @Test
+    void testCancelWorkOrder() {
+        WorkOrder wo = buildWorkOrder(1L, 0); // PENDING
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        req.setOperatorId(1L);
+        req.setOperatorName("张三");
+        req.setRemark("重复报修");
+
+        WorkOrder result = lifecycleService.cancel(1L, req);
+
+        assertEquals(6, result.getStatus()); // CANCELLED
+    }
+
+    @Test
+    void testCancelAlreadyCompletedWorkOrder() {
+        WorkOrder wo = buildWorkOrder(1L, 4); // COMPLETED
+        when(workOrderMapper.selectById(1L)).thenReturn(wo);
+
+        WorkOrderProcessRequest req = new WorkOrderProcessRequest();
+        assertThrows(BusinessException.class, () -> lifecycleService.cancel(1L, req));
+    }
+
+    // ==================== 7. 工单不存在测试 ====================
+
+    @Test
+    void testWorkOrderNotFound() {
+        when(workOrderMapper.selectById(999L)).thenReturn(null);
+        assertThrows(BusinessException.class, () -> lifecycleService.getById(999L));
+    }
+
+    // ==================== 8. 完整生命周期测试 ====================
+
+    @Test
+    void testFullLifecycle() {
+        // 创建
+        when(workOrderMapper.insert(any())).thenReturn(1);
+        when(logMapper.insert(any())).thenReturn(1);
+        when(assignmentMapper.insert(any())).thenReturn(1);
+
+        WorkOrderCreateRequest createReq = new WorkOrderCreateRequest();
+        createReq.setTitle("全流程测试工单");
+        createReq.setType("REPAIR");
+        createReq.setPriority("HIGH");
+        createReq.setCreatorId(1L);
+        createReq.setCreatorName("张三");
+
+        WorkOrder wo = lifecycleService.create(createReq);
+        wo.setId(100L);
+        assertEquals(0, wo.getStatus());
+
+        // 分派
+        when(workOrderMapper.selectById(100L)).thenReturn(wo);
+        when(workOrderMapper.updateById(any())).thenReturn(1);
+
+        WorkOrderAssignRequest assignReq = new WorkOrderAssignRequest();
+        assignReq.setAssignerId(10L);
+        assignReq.setAssignerName("管理员");
+        assignReq.setPrimaryAssigneeId(2L);
+        assignReq.setPrimaryAssigneeName("李四");
+        lifecycleService.assign(100L, assignReq);
+        assertEquals(1, wo.getStatus());
+
+        // 开始处理
+        lifecycleService.startProcess(100L, new WorkOrderProcessRequest() {{
+            setOperatorId(2L); setOperatorName("李四");
+        }});
+        assertEquals(2, wo.getStatus());
+
+        // 完成
+        lifecycleService.complete(100L, new WorkOrderProcessRequest() {{
+            setOperatorId(2L); setOperatorName("李四"); setResult("维修完成");
+        }});
+        assertEquals(4, wo.getStatus());
+    }
+
+    // ==================== Helper ====================
+
+    private WorkOrder buildWorkOrder(Long id, int status) {
+        WorkOrder wo = new WorkOrder();
+        wo.setId(id);
+        wo.setOrderNo("WO-TEST-001");
+        wo.setTitle("测试工单");
+        wo.setType("REPAIR");
+        wo.setPriority("MEDIUM");
+        wo.setStatus(status);
+        wo.setCreatorId(1L);
+        wo.setCreatorName("张三");
+        return wo;
+    }
+}

wm-dispatch/src/test/java/com/water/dispatch/service/WorkOrderStatisticsServiceTest.java

@@ -0,0 +1,102 @@
+package com.water.dispatch.service;
+
+import com.water.dispatch.entity.dto.WorkOrderStatVO;
+import com.water.dispatch.mapper.WorkOrderMapper;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class WorkOrderStatisticsServiceTest {
+
+    @Mock
+    private WorkOrderMapper workOrderMapper;
+
+    @InjectMocks
+    private WorkOrderStatisticsService statisticsService;
+
+    @Test
+    void testStatisticsBasic() {
+        when(workOrderMapper.selectCount(any())).thenReturn(100L);
+        when(workOrderMapper.countByStatus()).thenReturn(List.of(
+                Map.of("status", 0, "cnt", 20L),
+                Map.of("status", 1, "cnt", 15L),
+                Map.of("status", 2, "cnt", 10L),
+                Map.of("status", 4, "cnt", 50L),
+                Map.of("status", 5, "cnt", 3L),
+                Map.of("status", 6, "cnt", 2L)));
+        when(workOrderMapper.countByType()).thenReturn(List.of(
+                Map.of("type", "REPAIR", "cnt", 40L),
+                Map.of("type", "INSPECTION", "cnt", 30L),
+                Map.of("type", "COMPLAINT", "cnt", 20L),
+                Map.of("type", "EMERGENCY", "cnt", 10L)));
+        when(workOrderMapper.countByPriority()).thenReturn(List.of(
+                Map.of("priority", "LOW", "cnt", 20L),
+                Map.of("priority", "MEDIUM", "cnt", 40L),
+                Map.of("priority", "HIGH", "cnt", 30L),
+                Map.of("priority", "URGENT", "cnt", 10L)));
+        when(workOrderMapper.countByAssignee()).thenReturn(List.of(
+                Map.of("assignee", "李四", "cnt", 25L),
+                Map.of("assignee", "王五", "cnt", 20L)));
+        when(workOrderMapper.avgProcessHours()).thenReturn(4.5);
+        when(workOrderMapper.countOverdue()).thenReturn(3L);
+
+        WorkOrderStatVO stat = statisticsService.statistics();
+
+        assertEquals(100L, stat.getTotal());
+        assertEquals(50.0, stat.getCompletionRate()); // 50/100 = 50%
+        assertEquals(4.5, stat.getAvgProcessHours());
+        assertEquals(3L, stat.getOverdueCount());
+        assertEquals(4, stat.getByType().size());
+        assertEquals(4, stat.getByPriority().size());
+        assertEquals(2, stat.getByAssignee().size());
+        assertEquals(25L, stat.getByAssignee().get("李四"));
+    }
+
+    @Test
+    void testStatisticsEmptyData() {
+        when(workOrderMapper.selectCount(any())).thenReturn(0L);
+        when(workOrderMapper.countByStatus()).thenReturn(List.of());
+        when(workOrderMapper.countByType()).thenReturn(List.of());
+        when(workOrderMapper.countByPriority()).thenReturn(List.of());
+        when(workOrderMapper.countByAssignee()).thenReturn(List.of());
+        when(workOrderMapper.avgProcessHours()).thenReturn(null);
+        when(workOrderMapper.countOverdue()).thenReturn(0L);
+
+        WorkOrderStatVO stat = statisticsService.statistics();
+
+        assertEquals(0L, stat.getTotal());
+        assertEquals(0.0, stat.getCompletionRate());
+        assertEquals(0.0, stat.getAvgProcessHours());
+        assertEquals(0L, stat.getOverdueCount());
+        assertTrue(stat.getByType().isEmpty());
+        assertTrue(stat.getByAssignee().isEmpty());
+    }
+
+    @Test
+    void testStatisticsCompletionRateRounding() {
+        when(workOrderMapper.selectCount(any())).thenReturn(3L);
+        when(workOrderMapper.countByStatus()).thenReturn(List.of(
+                Map.of("status", 4, "cnt", 1L)));
+        when(workOrderMapper.countByType()).thenReturn(List.of());
+        when(workOrderMapper.countByPriority()).thenReturn(List.of());
+        when(workOrderMapper.countByAssignee()).thenReturn(List.of());
+        when(workOrderMapper.avgProcessHours()).thenReturn(1.23456);
+        when(workOrderMapper.countOverdue()).thenReturn(0L);
+
+        WorkOrderStatVO stat = statisticsService.statistics();
+
+        // 1/3 = 33.33%
+        assertEquals(33.33, stat.getCompletionRate());
+        assertEquals(1.23, stat.getAvgProcessHours());
+    }
+}