diff --git a/db/postgresql/V2__alert_engine.sql b/db/postgresql/V2__alert_engine.sql new file mode 100644 index 00000000..eeeabb81 --- /dev/null +++ b/db/postgresql/V2__alert_engine.sql @@ -0,0 +1,122 @@ +-- ============================================= +-- 智慧水务管理系统 - 报警规则引擎 + 报警管理中心 DDL +-- 版本: V2 +-- ============================================= + +-- ==================== 报警规则定义 ==================== +CREATE TABLE IF NOT EXISTS prod_alert_rule ( + id BIGSERIAL PRIMARY KEY, + rule_name VARCHAR(100) NOT NULL, + rule_code VARCHAR(50) UNIQUE, + description TEXT, + device_type VARCHAR(30), + metric_key VARCHAR(50) NOT NULL, + alert_level VARCHAR(10) NOT NULL DEFAULT 'general', -- general/important/urgent + condition_expr TEXT NOT NULL, -- JSON: {"op":"AND","conditions":[{"metric":"pressure","operator":">","threshold":0.8},...]} + threshold_value DECIMAL(12,4), -- 简单阈值(向后兼容) + debounce_sec INT DEFAULT 300, + notify_channels VARCHAR(200), -- 逗号分隔: sms,wechat,app,email + notify_template VARCHAR(500), -- 通知模板 + enabled SMALLINT DEFAULT 1, + priority INT DEFAULT 0, -- 规则优先级 + effective_start TIME, -- 生效开始时间 + effective_end TIME, -- 生效结束时间 + created_by BIGINT, + updated_by BIGINT, + deleted SMALLINT DEFAULT 0, + created_time TIMESTAMP DEFAULT NOW(), + updated_time TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE prod_alert_rule IS '报警规则定义表'; +COMMENT ON COLUMN prod_alert_rule.alert_level IS '报警等级: general(一般)/important(重要)/urgent(紧急)'; +COMMENT ON COLUMN prod_alert_rule.condition_expr IS '条件表达式JSON: 支持AND/OR组合条件'; + +-- ==================== 报警记录(全生命周期) ==================== +CREATE TABLE IF NOT EXISTS prod_alert_record ( + id BIGSERIAL PRIMARY KEY, + rule_id BIGINT REFERENCES prod_alert_rule(id), + rule_name VARCHAR(100), + device_id BIGINT, + device_sn VARCHAR(100), + device_name VARCHAR(200), + area VARCHAR(50), + metric_key VARCHAR(50) NOT NULL, + metric_value DECIMAL(12,4), + threshold_value VARCHAR(50), + alert_level VARCHAR(10) NOT NULL DEFAULT 'general', + title VARCHAR(200), + message TEXT, + -- 生命周期状态: 0=活跃 1=已确认 2=已派单 3=处理中 4=已处理 5=已归档 + status INT DEFAULT 0, + confirmed_by BIGINT, + confirmed_time TIMESTAMP, + dispatch_time TIMESTAMP, + assignee_id BIGINT, + assignee_name VARCHAR(50), + handler_id BIGINT, + handler_name VARCHAR(50), + handle_result TEXT, + handle_time TIMESTAMP, + archive_time TIMESTAMP, + archive_reason VARCHAR(500), + resolved_at TIMESTAMP, + created_time TIMESTAMP DEFAULT NOW(), + updated_time TIMESTAMP DEFAULT NOW(), + deleted SMALLINT DEFAULT 0 +); +COMMENT ON TABLE prod_alert_record IS '报警记录表(全生命周期)'; +CREATE INDEX IF NOT EXISTS idx_alert_record_time ON prod_alert_record(created_time DESC); +CREATE INDEX IF NOT EXISTS idx_alert_record_device ON prod_alert_record(device_sn, created_time DESC); +CREATE INDEX IF NOT EXISTS idx_alert_record_status ON prod_alert_record(status); +CREATE INDEX IF NOT EXISTS idx_alert_record_level ON prod_alert_record(alert_level); +CREATE INDEX IF NOT EXISTS idx_alert_record_area ON prod_alert_record(area); + +-- ==================== 报警通知记录 ==================== +CREATE TABLE IF NOT EXISTS prod_alert_notification ( + id BIGSERIAL PRIMARY KEY, + alert_record_id BIGINT REFERENCES prod_alert_record(id), + rule_id BIGINT, + channel VARCHAR(30) NOT NULL, -- sms/wechat/app/email + recipient VARCHAR(100) NOT NULL, -- 接收人标识 + recipient_name VARCHAR(50), + title VARCHAR(200), + content TEXT, + status INT DEFAULT 0, -- 0=待发送 1=已发送 2=发送失败 3=已读 + send_time TIMESTAMP, + read_time TIMESTAMP, + retry_count INT DEFAULT 0, + error_msg VARCHAR(500), + created_time TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE prod_alert_notification IS '报警通知记录表'; +CREATE INDEX IF NOT EXISTS idx_alert_notif_record ON prod_alert_notification(alert_record_id); +CREATE INDEX IF NOT EXISTS idx_alert_notif_status ON prod_alert_notification(status); + +-- ==================== 报警规则-设备关联(可选) ==================== +CREATE TABLE IF NOT EXISTS prod_alert_rule_device ( + id BIGSERIAL PRIMARY KEY, + rule_id BIGINT REFERENCES prod_alert_rule(id), + device_id BIGINT, + device_sn VARCHAR(100), + area VARCHAR(50), + created_time TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE prod_alert_rule_device IS '报警规则-设备/区域关联表'; + +-- ==================== 初始规则数据 ==================== +INSERT INTO prod_alert_rule (rule_name, rule_code, metric_key, alert_level, condition_expr, threshold_value, debounce_sec, description, enabled) VALUES +('管网压力过高报警', 'RULE_PRESSURE_HIGH', 'pressure', 'urgent', + '{"op":"AND","conditions":[{"metric":"pressure","operator":">","threshold":0.8}]}', + 0.8000, 300, '管网压力超过0.8MPa时触发紧急报警', 1), +('管网压力过低报警', 'RULE_PRESSURE_LOW', 'pressure', 'important', + '{"op":"OR","conditions":[{"metric":"pressure","operator":"<","threshold":0.2}]}', + 0.2000, 300, '管网压力低于0.2MPa时触发重要报警', 1), +('水质浊度超标', 'RULE_TURBIDITY_HIGH', 'turbidity', 'urgent', + '{"op":"AND","conditions":[{"metric":"turbidity","operator":">","threshold":1.0}]}', + 1.0000, 600, '水质浊度超过1.0NTU触发紧急报警', 1), +('余氯偏低报警', 'RULE_CHLORINE_LOW', 'residual_chlorine', 'general', + '{"op":"AND","conditions":[{"metric":"residual_chlorine","operator":"<","threshold":0.1}]}', + 0.1000, 600, '余氯低于0.1mg/L触发一般报警', 1), +('流量异常波动', 'RULE_FLOW_ANOMALY', 'flow', 'important', + '{"op":"OR","conditions":[{"metric":"flow","operator":">","threshold":100},{"metric":"flow","operator":"<","threshold":5}]}', + NULL, 120, '流量异常偏高或偏低时触发报警', 1); diff --git a/frontend/src/api/dispatchCommand.ts b/frontend/src/api/dispatchCommand.ts new file mode 100644 index 00000000..ca0717f9 --- /dev/null +++ b/frontend/src/api/dispatchCommand.ts @@ -0,0 +1,68 @@ +import request from './request' + +const BASE = '/api/production/dispatch-command' + +// 创建指令 +export function createCommand(data: any) { + return request.post(BASE, data) +} + +// 下发指令 +export function issueCommand(id: number, issuedBy: number, operatorName?: string) { + return request.post(`${BASE}/${id}/issue`, null, { + params: { issuedBy, operatorName: operatorName || 'system' } + }) +} + +// 指令台账 +export function listCommands(params: { + page?: number; size?: number; status?: string; + commandType?: string; keyword?: string; startDate?: string; endDate?: string +}) { + return request.get(BASE, { params }) +} + +// 指令详情 +export function getCommandDetail(id: number) { + return request.get(`${BASE}/${id}`) +} + +// 状态统计 +export function getCommandStats() { + return request.get(`${BASE}/stats`) +} + +// 接收确认 +export function receiveCommand(id: number, userId: number, userName?: string) { + return request.post(`${BASE}/${id}/receive`, null, { + params: { userId, userName: userName || '' } + }) +} + +// 开始执行 +export function startExecute(id: number, userId: number, userName?: string) { + return request.post(`${BASE}/${id}/start-execute`, null, { + params: { userId, userName: userName || '' } + }) +} + +// 完成执行 +export function completeExecution(id: number, userId: number, data: { + userName?: string; feedback?: string; feedbackImages?: string +}) { + return request.post(`${BASE}/${id}/complete`, null, { + params: { userId, ...data } + }) +} + +// 驳回 +export function rejectExecution(id: number, userId: number, reason: string, userName?: string) { + return request.post(`${BASE}/${id}/reject`, null, { + params: { userId, userName: userName || '', reason } + }) +} + +// 追踪日志 +export function getTrackingLogs(id: number) { + return request.get(`${BASE}/${id}/tracking`) +} diff --git a/frontend/src/router/index.ts b/frontend/src/router/index.ts index 996badad..8c76219f 100644 --- a/frontend/src/router/index.ts +++ b/frontend/src/router/index.ts @@ -11,6 +11,8 @@ const routes = [ { path: 'system/role', name: 'role', component: () => import('@/views/system/role/RoleList.vue') }, { path: 'system/menu', name: 'menu', component: () => import('@/views/system/menu/MenuList.vue') }, { path: 'system/dept', name: 'dept', component: () => import('@/views/system/dept/DeptList.vue') }, + { path: 'dispatch-command', name: 'dispatchCommandList', component: () => import('@/views/dispatch-command/CommandList.vue') }, + { path: 'dispatch-command/:id', name: 'dispatchCommandDetail', component: () => import('@/views/dispatch-command/CommandDetail.vue') }, ] }, { path: '/:pathMatch(.*)*', redirect: '/dashboard' } diff --git a/frontend/src/views/dispatch-command/CommandCreate.vue b/frontend/src/views/dispatch-command/CommandCreate.vue new file mode 100644 index 00000000..8a87315c --- /dev/null +++ b/frontend/src/views/dispatch-command/CommandCreate.vue @@ -0,0 +1,135 @@ + + + + + diff --git a/frontend/src/views/dispatch-command/CommandDetail.vue b/frontend/src/views/dispatch-command/CommandDetail.vue new file mode 100644 index 00000000..56601ea0 --- /dev/null +++ b/frontend/src/views/dispatch-command/CommandDetail.vue @@ -0,0 +1,304 @@ + + + + + diff --git a/frontend/src/views/dispatch-command/CommandList.vue b/frontend/src/views/dispatch-command/CommandList.vue new file mode 100644 index 00000000..a37e2118 --- /dev/null +++ b/frontend/src/views/dispatch-command/CommandList.vue @@ -0,0 +1,193 @@ + + + + + diff --git a/frontend/src/views/patrol/ProblemReportingView.vue b/frontend/src/views/patrol/ProblemReportingView.vue new file mode 100644 index 00000000..0f60f62b --- /dev/null +++ b/frontend/src/views/patrol/ProblemReportingView.vue @@ -0,0 +1,558 @@ + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index abebbd81..2cb55ca7 100644 --- a/pom.xml +++ b/pom.xml @@ -39,12 +39,17 @@ wm-iot wm-data-engine wm-bpm + wm-bpm-engine wm-production wm-revenue wm-patrol wm-bi wm-notify wm-job + wm-dispatch + wm-system + wm-mobile-app + wm-config diff --git a/sql/problem_reporting.sql b/sql/problem_reporting.sql new file mode 100644 index 00000000..f392aa8d --- /dev/null +++ b/sql/problem_reporting.sql @@ -0,0 +1,112 @@ +-- ============================================= +-- 智慧水务管理系统 - 巡检问题上报 + 工单管理 DDL +-- 版本: V1 +-- ============================================= + +-- 巡检问题上报表 +CREATE TABLE IF NOT EXISTS patrol_problem ( + id BIGSERIAL PRIMARY KEY, + problem_no VARCHAR(30) UNIQUE NOT NULL, -- 问题编号：WQ-2026-001 + task_id BIGINT REFERENCES patrol_task(id), + point_seq INT, + device_id BIGINT, + device_name VARCHAR(200), + problem_type VARCHAR(50) NOT NULL, -- 设备故障/水质异常/安全隐患/环境卫生/其他 + problem_level VARCHAR(20) DEFAULT 'normal', -- low/normal/high/critical + problem_title VARCHAR(200) NOT NULL, + problem_description TEXT, + location VARCHAR(300), + lng DOUBLE PRECISION, + lat DOUBLE PRECISION, + photo_urls JSONB, -- 现场照片URL数组 + reporter_id BIGINT REFERENCES sys_user(id), + reporter_name VARCHAR(50), + report_time TIMESTAMP DEFAULT NOW(), + status VARCHAR(20) DEFAULT 'reported', -- reported/processing/completed/closed + work_order_id BIGINT, -- 关联工单ID + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE patrol_problem IS '巡检问题上报表'; +CREATE INDEX IF NOT EXISTS idx_problem_task ON patrol_problem(task_id); +CREATE INDEX IF NOT EXISTS idx_problem_status ON patrol_problem(status); +CREATE INDEX IF NOT EXISTS idx_problem_device ON patrol_problem(device_id); +CREATE INDEX IF NOT EXISTS idx_problem_type ON patrol_problem(problem_type); + +-- 工单表 +CREATE TABLE IF NOT EXISTS work_order ( + id BIGSERIAL PRIMARY KEY, + order_no VARCHAR(30) UNIQUE NOT NULL, -- 工单编号：WO-2026-001 + problem_id BIGINT REFERENCES patrol_problem(id), + order_type VARCHAR(50) NOT NULL, -- 设备维修/水质处理/安全隐患处理/清洁/其他 + priority VARCHAR(20) DEFAULT 'normal', -- low/normal/high/critical + title VARCHAR(200) NOT NULL, + description TEXT, + location VARCHAR(300), + contact_person VARCHAR(50), + contact_phone VARCHAR(20), + reporter_id BIGINT REFERENCES sys_user(id), + reporter_name VARCHAR(50), + assignee_id BIGINT REFERENCES sys_user(id), + assignee_name VARCHAR(50), + status VARCHAR(20) DEFAULT 'pending', -- pending/assigned/processing/completed/cancelled + process_status VARCHAR(20) DEFAULT 'created', -- created/accepted/in_progress/completed + estimated_duration INT, -- 预计工时(分钟) + actual_start_time TIMESTAMP, + actual_end_time TIMESTAMP, + completion_time TIMESTAMP, + photos_before JSONB, -- 处理前照片 + photos_after JSONB, -- 处理后照片 + solution_description TEXT, -- 处理方案描述 + solution_result TEXT, -- 处理结果 + customer_feedback TEXT, -- 客户反馈 + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE work_order IS '工单表'; +CREATE INDEX IF NOT EXISTS idx_order_problem ON work_order(problem_id); +CREATE INDEX IF NOT EXISTS idx_order_status ON work_order(status, process_status); +CREATE INDEX IF NOT EXISTS idx_order_assignee ON work_order(assignee_id); + +-- 工单处理记录表 +CREATE TABLE IF NOT EXISTS work_order_process ( + id BIGSERIAL PRIMARY KEY, + work_order_id BIGINT REFERENCES work_order(id), + process_step VARCHAR(50) NOT NULL, -- created/accepted/in_progress/completed + processor_id BIGINT REFERENCES sys_user(id), + processor_name VARCHAR(50), + action VARCHAR(50) NOT NULL, -- create/assign/start/complete/cancel + comment TEXT, + photos JSONB, -- 处理过程照片 + created_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE work_order_process IS '工单处理记录表'; +CREATE INDEX IF NOT EXISTS idx_process_order ON work_order_process(work_order_id); +CREATE INDEX IF NOT EXISTS idx_process_step ON work_order_process(process_step); + +-- 工单附件表 +CREATE TABLE IF NOT EXISTS work_order_attachment ( + id BIGSERIAL PRIMARY KEY, + work_order_id BIGINT REFERENCES work_order(id), + file_name VARCHAR(200) NOT NULL, + file_path VARCHAR(500) NOT NULL, + file_type VARCHAR(50), -- image/pdf/doc/other + file_size BIGINT, + uploaded_by BIGINT REFERENCES sys_user(id), + uploaded_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE work_order_attachment IS '工单附件表'; +CREATE INDEX IF NOT EXISTS idx_attachment_order ON work_order_attachment(work_order_id); + +-- 巡检问题与工单关联触发记录 +CREATE TABLE IF NOT EXISTS patrol_work_order_trigger ( + id BIGSERIAL PRIMARY KEY, + patrol_problem_id BIGINT REFERENCES patrol_problem(id), + work_order_id BIGINT REFERENCES work_order(id), + trigger_type VARCHAR(20) NOT NULL, -- auto/manual + trigger_condition JSONB, -- 触发条件 + created_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE patrol_work_order_trigger IS '巡检问题与工单关联触发记录'; +CREATE INDEX IF NOT EXISTS idx_trigger_problem ON patrol_work_order_trigger(patrol_problem_id); +CREATE INDEX IF NOT EXISTS idx_trigger_order ON patrol_work_order_trigger(work_order_id); \ No newline at end of file diff --git a/wm-bpm-engine/pom.xml b/wm-bpm-engine/pom.xml new file mode 100644 index 00000000..da031531 --- /dev/null +++ b/wm-bpm-engine/pom.xml @@ -0,0 +1,63 @@ + + + 4.0.0 + + com.water + wm-parent + 1.0.0-SNAPSHOT + + wm-bpm-engine + wm-bpm-engine + BPM 业务流程引擎模块 + + + com.water + wm-common + + + org.springframework.boot + spring-boot-starter-web + + + com.alibaba.cloud + spring-cloud-starter-alibaba-nacos-discovery + + + com.baomidou + mybatis-plus-spring-boot3-starter + + + cn.dev33 + sa-token-spring-boot3-starter + + + org.postgresql + postgresql + + + com.github.xiaoymin + knife4j-openapi3-jakarta-spring-boot-starter + + + + org.springframework.boot + spring-boot-starter-test + test + + + com.h2database + h2 + test + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/BpmEngineApplication.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/BpmEngineApplication.java new file mode 100644 index 00000000..13ca0d39 --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/BpmEngineApplication.java @@ -0,0 +1,7 @@ +package com.water.bpmengine; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +@SpringBootApplication +public class BpmEngineApplication { + public static void main(String[] args) { SpringApplication.run(BpmEngineApplication.class, args); } +} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/controller/BpmEngineController.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/controller/BpmEngineController.java new file mode 100644 index 00000000..e45ce5c4 --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/controller/BpmEngineController.java @@ -0,0 +1,77 @@ +package com.water.bpmengine.controller; +import com.water.common.core.result.R; +import com.water.bpmengine.entity.*; +import com.water.bpmengine.service.BpmEngineService; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.*; + +@Tag(name = "业务流程引擎") +@RestController @RequestMapping("/bpm") @RequiredArgsConstructor +public class BpmEngineController { + private final BpmEngineService svc; + + @GetMapping("/definition/list") + public R> listDefs( + @RequestParam(required=false) String category, + @RequestParam(required=false) Integer status) { + return R.ok(svc.listDefinitions(category, status)); + } + @PostMapping("/definition") + public R createDef(@RequestBody Map req) { + return R.ok(svc.createDefinition(req)); + } + @PostMapping("/definition/{id}/publish") + public R publish(@PathVariable Long id) { + svc.publishDefinition(id); return R.ok("OK"); + } + @PostMapping("/process/start") + public R> start( + @RequestParam Long definitionId, + @RequestParam String title, + @RequestParam String initiator) { + return R.ok(svc.startProcess(definitionId, title, initiator)); + } + @GetMapping("/process/list") + public R> listInstances( + @RequestParam(required=false) String initiator, + @RequestParam(required=false) Integer status) { + return R.ok(svc.listInstances(initiator, status)); + } + @GetMapping("/task/todo") + public R> todo(@RequestParam String assignee) { + return R.ok(svc.getTodoTasks(assignee)); + } + @GetMapping("/task/done") + public R> done(@RequestParam String assignee) { + return R.ok(svc.getDoneTasks(assignee)); + } + @PostMapping("/task/{id}/approve") + public R> approve(@PathVariable Long id, + @RequestParam(required=false) String comment) { + return R.ok(svc.approveTask(id, comment)); + } + @PostMapping("/task/{id}/reject") + public R> reject(@PathVariable Long id, + @RequestParam(required=false) String comment) { + return R.ok(svc.rejectTask(id, comment)); + } + @PostMapping("/task/{id}/transfer") + public R> transfer(@PathVariable Long id, + @RequestParam String newAssignee) { + return R.ok(svc.transferTask(id, newAssignee)); + } + @GetMapping("/statistics") + public R> stats(@RequestParam(required=false) String processKey) { + return R.ok(svc.getStatistics(processKey)); + } + @GetMapping("/template/list") + public R> listTemplates() { + return R.ok(svc.listTemplates()); + } + @PostMapping("/template") + public R createTemplate(@RequestBody Map req) { + return R.ok(svc.createTemplate(req)); + } +} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessDefinition.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessDefinition.java new file mode 100644 index 00000000..7e07256e --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessDefinition.java @@ -0,0 +1,13 @@ +package com.water.bpmengine.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("bpm_process_definition") +public class ProcessDefinition { + @TableId(type = IdType.AUTO) private Long id; + private String processKey, name, category; + private String bpmnXml; + private Integer version; private Integer status; // 0草稿 1已发布 2已停用 + private String description; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; + @TableField(fill=FieldFill.INSERT_UPDATE) private LocalDateTime updatedTime; +} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessInstance.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessInstance.java new file mode 100644 index 00000000..ae2325da --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessInstance.java @@ -0,0 +1,13 @@ +package com.water.bpmengine.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("bpm_process_instance") +public class ProcessInstance { + @TableId(type = IdType.AUTO) private Long id; + private Long definitionId; private String processKey; + private String title, initiator; + private Integer status; // 0运行中 1已完成 2已驳回 3已撤销 + private String currentNodeName; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; + private LocalDateTime completedTime; +} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessTemplate.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessTemplate.java new file mode 100644 index 00000000..d84bea0e --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/ProcessTemplate.java @@ -0,0 +1,11 @@ +package com.water.bpmengine.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("bpm_process_template") +public class ProcessTemplate { + @TableId(type = IdType.AUTO) private Long id; + private String name, category, description; + private String bpmnXml; + private Integer status; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; +} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/TaskItem.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/TaskItem.java new file mode 100644 index 00000000..fa6b719b --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/entity/TaskItem.java @@ -0,0 +1,13 @@ +package com.water.bpmengine.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("bpm_task_item") +public class TaskItem { + @TableId(type = IdType.AUTO) private Long id; + private Long instanceId; private String taskName, taskType; + private String assignee; + private Integer status; // 0待办 1已办 2驳回 3转办 + private String comment; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; + private LocalDateTime completedTime; +} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessDefinitionMapper.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessDefinitionMapper.java new file mode 100644 index 00000000..a5761749 --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessDefinitionMapper.java @@ -0,0 +1,5 @@ +package com.water.bpmengine.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpmengine.entity.ProcessDefinition; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface ProcessDefinitionMapper extends BaseMapper {} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessInstanceMapper.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessInstanceMapper.java new file mode 100644 index 00000000..94d30c1b --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessInstanceMapper.java @@ -0,0 +1,5 @@ +package com.water.bpmengine.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpmengine.entity.ProcessInstance; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface ProcessInstanceMapper extends BaseMapper {} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessTemplateMapper.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessTemplateMapper.java new file mode 100644 index 00000000..e4a53c41 --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/ProcessTemplateMapper.java @@ -0,0 +1,5 @@ +package com.water.bpmengine.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpmengine.entity.ProcessTemplate; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface ProcessTemplateMapper extends BaseMapper {} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/TaskItemMapper.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/TaskItemMapper.java new file mode 100644 index 00000000..42b0aad0 --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/mapper/TaskItemMapper.java @@ -0,0 +1,5 @@ +package com.water.bpmengine.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpmengine.entity.TaskItem; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface TaskItemMapper extends BaseMapper {} diff --git a/wm-bpm-engine/src/main/java/com/water/bpmengine/service/BpmEngineService.java b/wm-bpm-engine/src/main/java/com/water/bpmengine/service/BpmEngineService.java new file mode 100644 index 00000000..7d3b8940 --- /dev/null +++ b/wm-bpm-engine/src/main/java/com/water/bpmengine/service/BpmEngineService.java @@ -0,0 +1,122 @@ +package com.water.bpmengine.service; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.bpmengine.entity.*; +import com.water.bpmengine.mapper.*; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.time.LocalDateTime; import java.util.*; + +@Service @RequiredArgsConstructor +public class BpmEngineService { + private final ProcessDefinitionMapper defMapper; + private final ProcessInstanceMapper instMapper; + private final TaskItemMapper taskMapper; + private final ProcessTemplateMapper tplMapper; + + // === 流程定义 === + public List listDefinitions(String category, Integer status) { + return defMapper.selectList(new LambdaQueryWrapper() + .eq(category != null, ProcessDefinition::getCategory, category) + .eq(status != null, ProcessDefinition::getStatus, status)); + } + public Long createDefinition(Map req) { + ProcessDefinition d = new ProcessDefinition(); + d.setProcessKey((String)req.get("processKey")); + d.setName((String)req.get("name")); + d.setCategory((String)req.get("category")); + d.setBpmnXml((String)req.get("bpmnXml")); + d.setDescription((String)req.get("description")); + d.setVersion(1); d.setStatus(0); + defMapper.insert(d); + return d.getId(); + } + public void publishDefinition(Long id) { + ProcessDefinition d = defMapper.selectById(id); + if (d == null) throw new RuntimeException("流程定义不存在"); + d.setStatus(1); defMapper.updateById(d); + } + + // === 流程实例 === + public Map startProcess(Long definitionId, String title, String initiator) { + ProcessDefinition d = defMapper.selectById(definitionId); + if (d == null || d.getStatus() != 1) throw new RuntimeException("流程未发布"); + ProcessInstance inst = new ProcessInstance(); + inst.setDefinitionId(definitionId); inst.setProcessKey(d.getProcessKey()); + inst.setTitle(title); inst.setInitiator(initiator); + inst.setStatus(0); inst.setCurrentNodeName("开始"); + instMapper.insert(inst); + TaskItem t = new TaskItem(); + t.setInstanceId(inst.getId()); t.setTaskName("审批节点"); + t.setTaskType("审批"); t.setAssignee(initiator); t.setStatus(0); + taskMapper.insert(t); + return Map.of("instanceId", inst.getId(), "processKey", d.getProcessKey()); + } + public List listInstances(String initiator, Integer status) { + return instMapper.selectList(new LambdaQueryWrapper() + .eq(initiator != null, ProcessInstance::getInitiator, initiator) + .eq(status != null, ProcessInstance::getStatus, status)); + } + + // === 任务处理 === + public List getTodoTasks(String assignee) { + return taskMapper.selectList(new LambdaQueryWrapper() + .eq(TaskItem::getAssignee, assignee).eq(TaskItem::getStatus, 0)); + } + public List getDoneTasks(String assignee) { + return taskMapper.selectList(new LambdaQueryWrapper() + .eq(TaskItem::getAssignee, assignee).in(TaskItem::getStatus, 1, 2)); + } + public Map approveTask(Long taskId, String comment) { + TaskItem t = taskMapper.selectById(taskId); + if (t == null || t.getStatus() != 0) throw new RuntimeException("任务不可审批"); + t.setStatus(1); t.setComment(comment); t.setCompletedTime(LocalDateTime.now()); + taskMapper.updateById(t); + ProcessInstance inst = instMapper.selectById(t.getInstanceId()); + inst.setCurrentNodeName("已完成"); inst.setStatus(1); inst.setCompletedTime(LocalDateTime.now()); + instMapper.updateById(inst); + return Map.of("taskId", taskId, "status", "已审批"); + } + public Map rejectTask(Long taskId, String comment) { + TaskItem t = taskMapper.selectById(taskId); + if (t == null) throw new RuntimeException("任务不存在"); + t.setStatus(2); t.setComment(comment); t.setCompletedTime(LocalDateTime.now()); + taskMapper.updateById(t); + ProcessInstance inst = instMapper.selectById(t.getInstanceId()); + inst.setStatus(2); inst.setCompletedTime(LocalDateTime.now()); + instMapper.updateById(inst); + return Map.of("taskId", taskId, "status", "已驳回"); + } + public Map transferTask(Long taskId, String newAssignee) { + TaskItem t = taskMapper.selectById(taskId); + if (t == null) throw new RuntimeException("任务不存在"); + t.setStatus(3); t.setCompletedTime(LocalDateTime.now()); + taskMapper.updateById(t); + TaskItem nt = new TaskItem(); + nt.setInstanceId(t.getInstanceId()); nt.setTaskName(t.getTaskName()); + nt.setTaskType(t.getTaskType()); nt.setAssignee(newAssignee); nt.setStatus(0); + taskMapper.insert(nt); + return Map.of("oldTaskId", taskId, "newTaskId", nt.getId()); + } + + // === 统计 === + public Map getStatistics(String processKey) { + long total = instMapper.selectCount(new LambdaQueryWrapper() + .eq(processKey != null, ProcessInstance::getProcessKey, processKey)); + long completed = instMapper.selectCount(new LambdaQueryWrapper() + .eq(processKey != null, ProcessInstance::getProcessKey, processKey) + .eq(ProcessInstance::getStatus, 1)); + return Map.of("total", total, "completed", completed, + "running", total - completed, + "completionRate", total > 0 ? (double)completed / total : 0); + } + + // === 模板 === + public List listTemplates() { return tplMapper.selectList(null); } + public Long createTemplate(Map req) { + ProcessTemplate t = new ProcessTemplate(); + t.setName((String)req.get("name")); t.setCategory((String)req.get("category")); + t.setBpmnXml((String)req.get("bpmnXml")); t.setStatus(1); + tplMapper.insert(t); + return t.getId(); + } +} diff --git a/wm-bpm-engine/src/main/resources/application.yml b/wm-bpm-engine/src/main/resources/application.yml new file mode 100644 index 00000000..e93ad582 --- /dev/null +++ b/wm-bpm-engine/src/main/resources/application.yml @@ -0,0 +1,15 @@ +server: + port: 9040 +spring: + application: + name: wm-bpm-engine + datasource: + url: jdbc:postgresql://localhost:5432/water_bpm + username: water + password: water123 +mybatis-plus: + configuration: + map-underscore-to-camel-case: true + global-config: + db-config: + id-type: auto diff --git a/wm-bpm-engine/src/main/resources/db/V1__bpm_engine.sql b/wm-bpm-engine/src/main/resources/db/V1__bpm_engine.sql new file mode 100644 index 00000000..93b8b4de --- /dev/null +++ b/wm-bpm-engine/src/main/resources/db/V1__bpm_engine.sql @@ -0,0 +1,23 @@ +-- BPM Engine DDL +CREATE TABLE IF NOT EXISTS bpm_process_definition ( + id BIGSERIAL PRIMARY KEY, process_key VARCHAR(100), name VARCHAR(200), + category VARCHAR(50), bpmn_xml TEXT, version INT DEFAULT 1, + status INT DEFAULT 0, description TEXT, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS bpm_process_instance ( + id BIGSERIAL PRIMARY KEY, definition_id BIGINT, process_key VARCHAR(100), + title VARCHAR(200), initiator VARCHAR(50), status INT DEFAULT 0, + current_node_name VARCHAR(100), + created_time TIMESTAMP DEFAULT NOW(), completed_time TIMESTAMP +); +CREATE TABLE IF NOT EXISTS bpm_task_item ( + id BIGSERIAL PRIMARY KEY, instance_id BIGINT, task_name VARCHAR(100), + task_type VARCHAR(30), assignee VARCHAR(50), status INT DEFAULT 0, + comment TEXT, created_time TIMESTAMP DEFAULT NOW(), completed_time TIMESTAMP +); +CREATE TABLE IF NOT EXISTS bpm_process_template ( + id BIGSERIAL PRIMARY KEY, name VARCHAR(200), category VARCHAR(50), + bpmn_xml TEXT, status INT DEFAULT 1, + created_time TIMESTAMP DEFAULT NOW() +); diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmApprovalRecord.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmApprovalRecord.java index 65be9884..1b97a1f9 100644 --- a/wm-bpm/src/main/java/com/water/bpm/entity/BpmApprovalRecord.java +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmApprovalRecord.java @@ -1,18 +1,63 @@ package com.water.bpm.entity; +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; import lombok.Data; +import lombok.EqualsAndHashCode; + import java.time.LocalDateTime; +/** + * 审批记录实体 + * BPM-03: 流程处理 + */ @Data -public class BpmApprovalRecord { - private Long id; +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_approval_record") +public class BpmApprovalRecord extends BaseEntity { + + /** 流程实例ID */ private Long instanceId; + + /** 流程实例UUID */ + private String instanceUuid; + + /** 节点标识 */ private String nodeId; + + /** 节点名称 */ private String nodeName; + + /** 审批人ID */ private Long approverId; + + /** 审批人姓名 */ private String approverName; - private String action; // approve/reject/transfer/delegate/back + + /** 审批动作: approve/reject/transfer/delegate/back/countersign */ + private String action; + + /** 审批意见 */ private String comment; - private String targetAssignee; // 转办/委派目标 + + /** 转办/委派目标人ID */ + private Long targetAssigneeId; + + /** 转办/委派目标人姓名 */ + private String targetAssigneeName; + + /** 会签结果: all/pass_one/veto */ + private String countersignResult; + + /** 会签通过数 */ + private Integer countersignApproved; + + /** 会签总数 */ + private Integer countersignTotal; + + /** 审批时间 */ private LocalDateTime approvedAt; + + /** 租户ID */ + private String tenantId; } diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmFormTemplate.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmFormTemplate.java new file mode 100644 index 00000000..7f9e083e --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmFormTemplate.java @@ -0,0 +1,49 @@ +package com.water.bpm.entity; + +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +/** + * 流程表单模板实体 + * BPM-02: 模板化快速创建 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_form_template") +public class BpmFormTemplate extends BaseEntity { + + /** 模板名称 */ + private String templateName; + + /** 模板编码 */ + private String templateCode; + + /** 模板分类 */ + private String category; + + /** 表单 JSON Schema */ + private String formSchema; + + /** 流程 BPMN XML 模板 */ + private String bpmnTemplate; + + /** 模板描述 */ + private String description; + + /** 模板图标 */ + private String icon; + + /** 使用次数 */ + private Integer useCount; + + /** 状态: 0-草稿 1-启用 2-停用 */ + private Integer status; + + /** 创建人 */ + private String createdBy; + + /** 租户ID */ + private String tenantId; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmOrchestration.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmOrchestration.java new file mode 100644 index 00000000..197724ac --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmOrchestration.java @@ -0,0 +1,52 @@ +package com.water.bpm.entity; + +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +/** + * 流程编排实体 + * BPM-05: 跨系统流程编排 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_orchestration") +public class BpmOrchestration extends BaseEntity { + + /** 编排名称 */ + private String orchestrationName; + + /** 编排编码 */ + private String orchestrationCode; + + /** 编排描述 */ + private String description; + + /** 包含的流程定义ID列表 JSON */ + private String processDefinitionIds; + + /** 编排规则 JSON (流程间依赖关系、触发条件) */ + private String orchestrationRules; + + /** 触发方式: manual/scheduled/event */ + private String triggerType; + + /** 定时表达式 (cron) */ + private String cronExpression; + + /** 事件名称 (event触发时) */ + private String eventName; + + /** 状态: 0-草稿 1-启用 2-停用 */ + private Integer status; + + /** 创建人 */ + private String createdBy; + + /** 执行次数 */ + private Integer executionCount; + + /** 租户ID */ + private String tenantId; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessDefinition.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessDefinition.java index 4a45e9e1..f3b1c96c 100644 --- a/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessDefinition.java +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessDefinition.java @@ -1,20 +1,58 @@ package com.water.bpm.entity; +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; import lombok.Data; +import lombok.EqualsAndHashCode; + import java.time.LocalDateTime; +/** + * 流程定义实体 + * BPM-01: 流程定义管理 + */ @Data -public class BpmProcessDefinition { - private Long id; +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_process_definition") +public class BpmProcessDefinition extends BaseEntity { + + /** 流程唯一标识 */ private String processKey; + + /** 流程名称 */ private String processName; + + /** 流程描述 */ private String description; - private String bpmnXml; // BPMN 2.0 XML - private String formSchema; // 表单 JSON Schema - private String category; // revenue/patrol/dispatch/maintenance + + /** BPMN 2.0 XML 定义 */ + private String bpmnXml; + + /** 表单 JSON Schema */ + private String formSchema; + + /** 流程分类: revenue/patrol/dispatch/maintenance/inspection */ + private String category; + + /** 版本号 */ + @TableField("version") private Integer version; - private Integer status; // 0:草稿 1:发布 2:停用 + + /** 状态: 0-草稿 1-已发布 2-已停用 */ + private Integer status; + + /** 创建人 */ private String createdBy; - private LocalDateTime createdAt; - private LocalDateTime updatedAt; + + /** 流程图标 */ + private String icon; + + /** 排序号 */ + private Integer sortOrder; + + /** 发布时间 */ + private LocalDateTime publishedAt; + + /** 租户ID */ + private String tenantId; } diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessInstance.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessInstance.java index 40d907ff..a8e4a0b7 100644 --- a/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessInstance.java +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessInstance.java @@ -1,26 +1,84 @@ package com.water.bpm.entity; +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; import lombok.Data; -import java.time.LocalDateTime; -import java.util.Map; +import lombok.EqualsAndHashCode; +import java.time.LocalDateTime; + +/** + * 流程实例实体 + * BPM-03: 流程处理 + */ @Data -public class BpmProcessInstance { - private Long id; +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_process_instance") +public class BpmProcessInstance extends BaseEntity { + + /** 实例唯一ID */ private String instanceId; + + /** 关联流程定义ID */ private Long definitionId; + + /** 流程标识 */ private String processKey; - private String businessKey; // 关联业务ID - private String businessType; // 业务类型 + + /** 流程名称 */ + private String processName; + + /** 业务主键（关联业务表） */ + private String businessKey; + + /** 业务类型 */ + private String businessType; + + /** 流程标题 */ private String title; + + /** 发起人ID */ private Long initiatorId; + + /** 发起人姓名 */ private String initiatorName; - private String currentNode; // 当前审批节点 - private String currentAssignee; // 当前处理人 - private String status; // running/completed/terminated/rejected - private Map variables; - private Map formData; + + /** 当前节点标识 */ + private String currentNodeId; + + /** 当前节点名称 */ + private String currentNodeName; + + /** 当前处理人ID */ + private Long currentAssigneeId; + + /** 当前处理人姓名 */ + private String currentAssigneeName; + + /** 状态: running/completed/terminated/rejected/suspended */ + private String status; + + /** 优先级: 0-普通 1-紧急 2-特急 */ + private Integer priority; + + /** 流程变量 JSON */ + private String variables; + + /** 表单数据 JSON */ + private String formData; + + /** 开始时间 */ private LocalDateTime startedAt; + + /** 结束时间 */ private LocalDateTime completedAt; - private LocalDateTime createdAt; + + /** 预计完成时间 */ + private LocalDateTime expectedCompletionAt; + + /** 耗时(秒) */ + private Long durationSeconds; + + /** 租户ID */ + private String tenantId; } diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessNode.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessNode.java new file mode 100644 index 00000000..1717794d --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessNode.java @@ -0,0 +1,61 @@ +package com.water.bpm.entity; + +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +/** + * 流程节点定义实体 + * BPM-01: 流程定义 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_process_node") +public class BpmProcessNode extends BaseEntity { + + /** 关联流程定义ID */ + private Long definitionId; + + /** 节点标识 */ + private String nodeId; + + /** 节点名称 */ + private String nodeName; + + /** 节点类型: start/end/userTask/serviceTask/gateway/subprocess/timer */ + private String nodeType; + + /** 处理人类型: role/user/department/position/initiator */ + private String assigneeType; + + /** 处理人值（角色ID/用户ID/部门ID等） */ + private String assigneeValue; + + /** 处理人名称（冗余） */ + private String assigneeName; + + /** 多人审批方式: sequential(会签)/parallel(或签)/countersign(比例签) */ + private String multiInstanceType; + + /** 会签通过比例 */ + private Integer countersignRate; + + /** 超时时间(小时) */ + private Integer timeoutHours; + + /** 超时处理: remind/transfer/escalate/auto_approve */ + private String timeoutAction; + + /** 表单权限 JSON */ + private String formPermission; + + /** 节点条件表达式 */ + private String conditionExpression; + + /** 排序号 */ + private Integer sortOrder; + + /** 租户ID */ + private String tenantId; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessStat.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessStat.java new file mode 100644 index 00000000..143e62c2 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmProcessStat.java @@ -0,0 +1,63 @@ +package com.water.bpm.entity; + +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.time.LocalDateTime; + +/** + * 流程统计实体 + * BPM-04: 统计评估 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_process_stat") +public class BpmProcessStat extends BaseEntity { + + /** 流程定义ID */ + private Long definitionId; + + /** 流程标识 */ + private String processKey; + + /** 统计周期: day/week/month/quarter/year */ + private String period; + + /** 统计日期 */ + private String statDate; + + /** 发起总数 */ + private Integer startCount; + + /** 完成总数 */ + private Integer completedCount; + + /** 驳回总数 */ + private Integer rejectedCount; + + /** 撤回总数 */ + private Integer terminatedCount; + + /** 平均耗时(秒) */ + private Long avgDurationSeconds; + + /** 最长耗时(秒) */ + private Long maxDurationSeconds; + + /** 最短耗时(秒) */ + private Long minDurationSeconds; + + /** 平均节点耗时(秒) */ + private Long avgNodeDurationSeconds; + + /** 超时任务数 */ + private Integer timeoutCount; + + /** 一次通过率(百分比) */ + private Double firstPassRate; + + /** 租户ID */ + private String tenantId; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/BpmTodoTask.java b/wm-bpm/src/main/java/com/water/bpm/entity/BpmTodoTask.java new file mode 100644 index 00000000..53a4f3ae --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/BpmTodoTask.java @@ -0,0 +1,75 @@ +package com.water.bpm.entity; + +import com.baomidou.mybatisplus.annotation.*; +import com.water.common.core.entity.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.time.LocalDateTime; + +/** + * 待办任务实体 + * BPM-06: 待办/已办中心 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("bpm_todo_task") +public class BpmTodoTask extends BaseEntity { + + /** 流程实例ID */ + private Long instanceId; + + /** 流程实例UUID */ + private String instanceUuid; + + /** 流程标题 */ + private String title; + + /** 流程标识 */ + private String processKey; + + /** 流程名称 */ + private String processName; + + /** 节点标识 */ + private String nodeId; + + /** 节点名称 */ + private String nodeName; + + /** 处理人ID */ + private Long assigneeId; + + /** 处理人姓名 */ + private String assigneeName; + + /** 发起人ID */ + private Long initiatorId; + + /** 发起人姓名 */ + private String initiatorName; + + /** 业务主键 */ + private String businessKey; + + /** 任务状态: pending/completed/transferred/delegated */ + private String status; + + /** 优先级: 0-普通 1-紧急 2-特急 */ + private Integer priority; + + /** 接收时间 */ + private LocalDateTime receivedAt; + + /** 完成时间 */ + private LocalDateTime completedAt; + + /** 超时时间 */ + private LocalDateTime deadlineAt; + + /** 是否已读 */ + private Boolean isRead; + + /** 租户ID */ + private String tenantId; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/dto/ApprovalRequest.java b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ApprovalRequest.java new file mode 100644 index 00000000..2837a542 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ApprovalRequest.java @@ -0,0 +1,33 @@ +package com.water.bpm.entity.dto; + +import lombok.Data; + +/** + * 审批请求 DTO + */ +@Data +public class ApprovalRequest { + /** 流程实例ID */ + private Long instanceId; + + /** 流程实例UUID */ + private String instanceUuid; + + /** 节点标识 */ + private String nodeId; + + /** 节点名称 */ + private String nodeName; + + /** 审批动作: approve/reject/transfer/delegate/back/countersign */ + private String action; + + /** 审批意见 */ + private String comment; + + /** 转办/委派目标人ID */ + private Long targetAssigneeId; + + /** 转办/委派目标人姓名 */ + private String targetAssigneeName; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessInstanceQuery.java b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessInstanceQuery.java new file mode 100644 index 00000000..7e699738 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessInstanceQuery.java @@ -0,0 +1,41 @@ +package com.water.bpm.entity.dto; + +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 流程实例查询 DTO + */ +@Data +public class ProcessInstanceQuery { + /** 流程标识 */ + private String processKey; + + /** 流程标题 */ + private String title; + + /** 状态 */ + private String status; + + /** 发起人ID */ + private Long initiatorId; + + /** 业务主键 */ + private String businessKey; + + /** 业务类型 */ + private String businessType; + + /** 开始时间（起） */ + private LocalDateTime startTimeFrom; + + /** 开始时间（止） */ + private LocalDateTime startTimeTo; + + /** 页码 */ + private Integer pageNum = 1; + + /** 每页条数 */ + private Integer pageSize = 10; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStartRequest.java b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStartRequest.java new file mode 100644 index 00000000..93cf7503 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStartRequest.java @@ -0,0 +1,32 @@ +package com.water.bpm.entity.dto; + +import lombok.Data; + +import java.util.Map; + +/** + * 流程发起请求 DTO + */ +@Data +public class ProcessStartRequest { + /** 流程定义ID */ + private Long definitionId; + + /** 业务主键 */ + private String businessKey; + + /** 业务类型 */ + private String businessType; + + /** 流程标题 */ + private String title; + + /** 表单数据 */ + private Map formData; + + /** 流程变量 */ + private Map variables; + + /** 优先级 */ + private Integer priority; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStatVO.java b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStatVO.java new file mode 100644 index 00000000..f9d72cf7 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStatVO.java @@ -0,0 +1,60 @@ +package com.water.bpm.entity.dto; + +import lombok.Data; + +import java.util.List; +import java.util.Map; + +/** + * 流程统计 VO + */ +@Data +public class ProcessStatVO { + /** 流程定义ID */ + private Long definitionId; + + /** 流程名称 */ + private String processName; + + /** 流程标识 */ + private String processKey; + + /** 总实例数 */ + private Integer totalInstances; + + /** 运行中数量 */ + private Integer runningCount; + + /** 已完成数量 */ + private Integer completedCount; + + /** 已驳回数量 */ + private Integer rejectedCount; + + /** 已撤回数量 */ + private Integer terminatedCount; + + /** 平均耗时(小时) */ + private Double avgDurationHours; + + /** 最长耗时(小时) */ + private Double maxDurationHours; + + /** 最短耗时(小时) */ + private Double minDurationHours; + + /** 一次通过率 */ + private Double firstPassRate; + + /** 超时率 */ + private Double timeoutRate; + + /** 各节点平均耗时 */ + private List> nodeAvgDurations; + + /** 瓶颈节点（耗时最长） */ + private String bottleneckNode; + + /** 趋势数据 */ + private List> trendData; +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmApprovalRecordMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmApprovalRecordMapper.java new file mode 100644 index 00000000..0ca4c9b4 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmApprovalRecordMapper.java @@ -0,0 +1,39 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmApprovalRecord; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 审批记录 Mapper + */ +@Mapper +public interface BpmApprovalRecordMapper extends BaseMapper { + + /** + * 根据流程实例查询审批记录 + */ + @Select("SELECT * FROM bpm_approval_record WHERE instance_id = #{instanceId} AND deleted = 0 ORDER BY approved_at") + List selectByInstanceId(@Param("instanceId") Long instanceId); + + /** + * 根据流程实例UUID查询审批记录 + */ + @Select("SELECT * FROM bpm_approval_record WHERE instance_uuid = #{instanceUuid} AND deleted = 0 ORDER BY approved_at") + List selectByInstanceUuid(@Param("instanceUuid") String instanceUuid); + + /** + * 查询某人的审批统计 + */ + @Select("SELECT approver_id, approver_name, COUNT(*) as total, " + + "SUM(CASE WHEN action = 'approve' THEN 1 ELSE 0 END) as approved, " + + "SUM(CASE WHEN action = 'reject' THEN 1 ELSE 0 END) as rejected, " + + "AVG(EXTRACT(EPOCH FROM (approved_at - created_at))) as avg_handle_seconds " + + "FROM bpm_approval_record WHERE deleted = 0 AND approved_at >= #{startDate} " + + "GROUP BY approver_id, approver_name") + List> statByApprover(@Param("startDate") java.time.LocalDateTime startDate); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmFormTemplateMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmFormTemplateMapper.java new file mode 100644 index 00000000..d0a90a47 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmFormTemplateMapper.java @@ -0,0 +1,28 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmFormTemplate; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 表单模板 Mapper + */ +@Mapper +public interface BpmFormTemplateMapper extends BaseMapper { + + /** + * 根据分类查询模板 + */ + @Select("SELECT * FROM bpm_form_template WHERE category = #{category} AND status = 1 AND deleted = 0 ORDER BY use_count DESC") + List selectByCategory(@Param("category") String category); + + /** + * 查询热门模板 + */ + @Select("SELECT * FROM bpm_form_template WHERE status = 1 AND deleted = 0 ORDER BY use_count DESC LIMIT #{limit}") + List selectHotTemplates(@Param("limit") int limit); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmOrchestrationMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmOrchestrationMapper.java new file mode 100644 index 00000000..6e5a0770 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmOrchestrationMapper.java @@ -0,0 +1,28 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmOrchestration; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 流程编排 Mapper + */ +@Mapper +public interface BpmOrchestrationMapper extends BaseMapper { + + /** + * 查询所有启用的编排 + */ + @Select("SELECT * FROM bpm_orchestration WHERE status = 1 AND deleted = 0 ORDER BY created_at DESC") + List selectEnabled(); + + /** + * 查询事件触发的编排 + */ + @Select("SELECT * FROM bpm_orchestration WHERE trigger_type = 'event' AND event_name = #{eventName} " + + "AND status = 1 AND deleted = 0") + List selectByEvent(String eventName); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessDefinitionMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessDefinitionMapper.java new file mode 100644 index 00000000..2758f6c7 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessDefinitionMapper.java @@ -0,0 +1,34 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmProcessDefinition; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 流程定义 Mapper + */ +@Mapper +public interface BpmProcessDefinitionMapper extends BaseMapper { + + /** + * 根据分类查询已发布的流程定义 + */ + @Select("SELECT * FROM bpm_process_definition WHERE category = #{category} AND status = 1 AND deleted = 0 ORDER BY sort_order") + List selectByCategory(@Param("category") String category); + + /** + * 根据 processKey 查询最新版本 + */ + @Select("SELECT * FROM bpm_process_definition WHERE process_key = #{processKey} AND deleted = 0 ORDER BY version DESC LIMIT 1") + BpmProcessDefinition selectByProcessKey(@Param("processKey") String processKey); + + /** + * 查询所有分类 + */ + @Select("SELECT DISTINCT category FROM bpm_process_definition WHERE deleted = 0 AND status = 1 ORDER BY category") + List selectAllCategories(); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessInstanceMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessInstanceMapper.java new file mode 100644 index 00000000..c00d8bc9 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessInstanceMapper.java @@ -0,0 +1,43 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmProcessInstance; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; +import java.util.Map; + +/** + * 流程实例 Mapper + */ +@Mapper +public interface BpmProcessInstanceMapper extends BaseMapper { + + /** + * 统计各状态数量 + */ + @Select("SELECT status, COUNT(*) as count FROM bpm_process_instance WHERE deleted = 0 GROUP BY status") + List> countByStatus(); + + /** + * 根据流程定义统计 + */ + @Select("SELECT definition_id, COUNT(*) as total, " + + "SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END) as running, " + + "SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed, " + + "SUM(CASE WHEN status = 'rejected' THEN 1 ELSE 0 END) as rejected, " + + "SUM(CASE WHEN status = 'terminated' THEN 1 ELSE 0 END) as terminated, " + + "AVG(duration_seconds) as avg_duration, " + + "MAX(duration_seconds) as max_duration, " + + "MIN(duration_seconds) as min_duration " + + "FROM bpm_process_instance WHERE deleted = 0 GROUP BY definition_id") + List> statByDefinition(); + + /** + * 查询我发起的流程 + */ + @Select("SELECT * FROM bpm_process_instance WHERE initiator_id = #{userId} AND deleted = 0 ORDER BY created_at DESC") + List selectMyInitiated(@Param("userId") Long userId); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessNodeMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessNodeMapper.java new file mode 100644 index 00000000..c9b94565 --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessNodeMapper.java @@ -0,0 +1,22 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmProcessNode; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 流程节点 Mapper + */ +@Mapper +public interface BpmProcessNodeMapper extends BaseMapper { + + /** + * 查询流程定义的所有节点 + */ + @Select("SELECT * FROM bpm_process_node WHERE definition_id = #{definitionId} AND deleted = 0 ORDER BY sort_order") + List selectByDefinitionId(@Param("definitionId") Long definitionId); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessStatMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessStatMapper.java new file mode 100644 index 00000000..481a308c --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessStatMapper.java @@ -0,0 +1,25 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmProcessStat; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 流程统计 Mapper + */ +@Mapper +public interface BpmProcessStatMapper extends BaseMapper { + + /** + * 查询某流程的统计趋势 + */ + @Select("SELECT * FROM bpm_process_stat WHERE definition_id = #{definitionId} AND period = #{period} " + + "AND deleted = 0 ORDER BY stat_date DESC LIMIT #{limit}") + List selectTrend(@Param("definitionId") Long definitionId, + @Param("period") String period, + @Param("limit") int limit); +} diff --git a/wm-bpm/src/main/java/com/water/bpm/mapper/BpmTodoTaskMapper.java b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmTodoTaskMapper.java new file mode 100644 index 00000000..848542ff --- /dev/null +++ b/wm-bpm/src/main/java/com/water/bpm/mapper/BpmTodoTaskMapper.java @@ -0,0 +1,42 @@ +package com.water.bpm.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.bpm.entity.BpmTodoTask; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +/** + * 待办任务 Mapper + */ +@Mapper +public interface BpmTodoTaskMapper extends BaseMapper { + + /** + * 查询待办列表 + */ + @Select("SELECT * FROM bpm_todo_task WHERE assignee_id = #{userId} AND status = 'pending' AND deleted = 0 " + + "ORDER BY priority DESC, received_at") + List selectPendingByUserId(@Param("userId") Long userId); + + /** + * 查询已办列表 + */ + @Select("SELECT * FROM bpm_todo_task WHERE assignee_id = #{userId} AND status != 'pending' AND deleted = 0 " + + "ORDER BY completed_at DESC") + List selectDoneByUserId(@Param("userId") Long userId); + + /** + * 统计待办数量 + */ + @Select("SELECT COUNT(*) FROM bpm_todo_task WHERE assignee_id = #{userId} AND status = 'pending' AND deleted = 0") + Integer countPendingByUserId(@Param("userId") Long userId); + + /** + * 查询超时的待办 + */ + @Select("SELECT * FROM bpm_todo_task WHERE status = 'pending' AND deadline_at < NOW() AND deleted = 0") + List selectTimeoutTasks(); +} diff --git a/wm-config/pom.xml b/wm-config/pom.xml new file mode 100644 index 00000000..db5f2c1f --- /dev/null +++ b/wm-config/pom.xml @@ -0,0 +1,16 @@ + + + 4.0.0 + com.waterwm-parent1.0.0-SNAPSHOT + wm-config + + com.waterwm-common + org.springframework.bootspring-boot-starter-web + com.alibaba.cloudspring-cloud-starter-alibaba-nacos-discovery + com.baomidoumybatis-plus-spring-boot3-starter + cn.dev33sa-token-spring-boot3-starter + org.postgresqlpostgresql + + diff --git a/wm-config/src/main/java/com/water/config/ConfigApplication.java b/wm-config/src/main/java/com/water/config/ConfigApplication.java new file mode 100644 index 00000000..26db7723 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/ConfigApplication.java @@ -0,0 +1,15 @@ +package com.water.config; + +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.cloud.client.discovery.EnableDiscoveryClient; + +@SpringBootApplication +@EnableDiscoveryClient +@MapperScan("com.water.config.mapper") +public class ConfigApplication { + public static void main(String[] args) { + SpringApplication.run(ConfigApplication.class, args); + } +} diff --git a/wm-config/src/main/java/com/water/config/controller/AnnouncementController.java b/wm-config/src/main/java/com/water/config/controller/AnnouncementController.java new file mode 100644 index 00000000..9cbeaee4 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/controller/AnnouncementController.java @@ -0,0 +1,68 @@ +package com.water.config.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.common.core.result.R; +import com.water.config.entity.Announcement; +import com.water.config.service.AnnouncementService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; + +@Tag(name = "公告通知管理") +@RestController +@RequestMapping("/api/config/announcement") +@RequiredArgsConstructor +public class AnnouncementController { + + private final AnnouncementService announcementService; + + @Operation(summary = "分页查询公告") + @GetMapping("/list") + public R> list(@RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) Integer type, + @RequestParam(required = false) Integer publishStatus) { + return R.ok(announcementService.pageAnnouncements(page, size, type, publishStatus)); + } + + @Operation(summary = "获取公告详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(announcementService.getById(id)); + } + + @Operation(summary = "创建公告（草稿）") + @PostMapping + public R create(@RequestBody Announcement announcement) { + return R.ok(announcementService.createAnnouncement(announcement)); + } + + @Operation(summary = "更新公告") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @RequestBody Announcement announcement) { + announcementService.updateAnnouncement(id, announcement); + return R.ok("更新成功"); + } + + @Operation(summary = "发布公告") + @PostMapping("/{id}/publish") + public R publish(@PathVariable Long id) { + announcementService.publish(id); + return R.ok("发布成功"); + } + + @Operation(summary = "撤回公告") + @PostMapping("/{id}/withdraw") + public R withdraw(@PathVariable Long id) { + announcementService.withdraw(id); + return R.ok("撤回成功"); + } + + @Operation(summary = "删除公告") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + announcementService.deleteAnnouncement(id); + return R.ok("删除成功"); + } +} diff --git a/wm-config/src/main/java/com/water/config/controller/DeviceManageController.java b/wm-config/src/main/java/com/water/config/controller/DeviceManageController.java new file mode 100644 index 00000000..707978d0 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/controller/DeviceManageController.java @@ -0,0 +1,98 @@ +package com.water.config.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.common.core.result.R; +import com.water.config.entity.DeviceInfo; +import com.water.config.entity.DeviceMaintenance; +import com.water.config.service.DeviceManageService; +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; + +@Tag(name = "设备管理") +@RestController +@RequestMapping("/api/config/device") +@RequiredArgsConstructor +public class DeviceManageController { + + private final DeviceManageService deviceManageService; + + @Operation(summary = "分页查询设备") + @GetMapping("/list") + public R> list(@RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) String deviceName, + @RequestParam(required = false) Integer category, + @RequestParam(required = false) Integer deviceStatus) { + return R.ok(deviceManageService.pageDevices(page, size, deviceName, category, deviceStatus)); + } + + @Operation(summary = "获取设备详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(deviceManageService.getById(id)); + } + + @Operation(summary = "创建设备") + @PostMapping + public R create(@RequestBody DeviceInfo device) { + return R.ok(deviceManageService.createDevice(device)); + } + + @Operation(summary = "更新设备") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @RequestBody DeviceInfo device) { + deviceManageService.updateDevice(id, device); + return R.ok("更新成功"); + } + + @Operation(summary = "删除设备") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + deviceManageService.removeById(id); + return R.ok("删除成功"); + } + + @Operation(summary = "更新设备状态") + @PutMapping("/{id}/status") + public R updateStatus(@PathVariable Long id, @RequestParam Integer deviceStatus) { + deviceManageService.updateDeviceStatus(id, deviceStatus); + return R.ok("状态更新成功"); + } + + @Operation(summary = "按分类查询设备") + @GetMapping("/category/{category}") + public R> getByCategory(@PathVariable Integer category) { + return R.ok(deviceManageService.getDevicesByCategory(category)); + } + + @Operation(summary = "按状态查询设备") + @GetMapping("/status/{status}") + public R> getByStatus(@PathVariable Integer status) { + return R.ok(deviceManageService.getDevicesByStatus(status)); + } + + @Operation(summary = "添加维保记录") + @PostMapping("/maintenance") + public R addMaintenance(@RequestBody DeviceMaintenance maintenance) { + return R.ok(deviceManageService.addMaintenance(maintenance)); + } + + @Operation(summary = "查询维保记录") + @GetMapping("/maintenance") + public R> pageMaintenances(@RequestParam(required = false) Long deviceId, + @RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size) { + return R.ok(deviceManageService.pageMaintenances(deviceId, page, size)); + } + + @Operation(summary = "更新维保记录") + @PutMapping("/maintenance/{id}") + public R updateMaintenance(@PathVariable Long id, @RequestBody DeviceMaintenance maintenance) { + deviceManageService.updateMaintenance(id, maintenance); + return R.ok("更新成功"); + } +} diff --git a/wm-config/src/main/java/com/water/config/controller/ThresholdController.java b/wm-config/src/main/java/com/water/config/controller/ThresholdController.java new file mode 100644 index 00000000..a5507b29 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/controller/ThresholdController.java @@ -0,0 +1,84 @@ +package com.water.config.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.common.core.result.R; +import com.water.config.entity.ThresholdChangeLog; +import com.water.config.entity.ThresholdConfig; +import com.water.config.service.ThresholdService; +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; + +@Tag(name = "阈值管理") +@RestController +@RequestMapping("/api/config/threshold") +@RequiredArgsConstructor +public class ThresholdController { + + private final ThresholdService thresholdService; + + @Operation(summary = "分页查询阈值配置") + @GetMapping("/list") + public R> list(@RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) String metricCode, + @RequestParam(required = false) Integer level) { + return R.ok(thresholdService.pageThresholds(page, size, metricCode, level)); + } + + @Operation(summary = "获取阈值详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(thresholdService.getById(id)); + } + + @Operation(summary = "创建阈值配置") + @PostMapping + public R create(@RequestBody ThresholdConfig config) { + return R.ok(thresholdService.createThreshold(config)); + } + + @Operation(summary = "更新阈值配置") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @RequestBody ThresholdConfig config) { + thresholdService.updateThreshold(id, config); + return R.ok("更新成功"); + } + + @Operation(summary = "删除阈值配置") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + thresholdService.deleteThreshold(id); + return R.ok("删除成功"); + } + + @Operation(summary = "启用/禁用阈值") + @PutMapping("/{id}/status") + public R toggleStatus(@PathVariable Long id, @RequestParam Integer status) { + thresholdService.toggleStatus(id, status); + return R.ok(status == 1 ? "已启用" : "已禁用"); + } + + @Operation(summary = "获取指标的全局阈值（多级）") + @GetMapping("/global/{metricCode}") + public R> getGlobalThresholds(@PathVariable String metricCode) { + return R.ok(thresholdService.getGlobalThresholds(metricCode)); + } + + @Operation(summary = "获取设备阈值配置") + @GetMapping("/device/{deviceId}") + public R> getDeviceThresholds(@PathVariable Long deviceId) { + return R.ok(thresholdService.getDeviceThresholds(deviceId)); + } + + @Operation(summary = "获取阈值变更历史") + @GetMapping("/history") + public R> getChangeHistory(@RequestParam(required = false) Long thresholdId, + @RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size) { + return R.ok(thresholdService.getChangeHistory(thresholdId, page, size)); + } +} diff --git a/wm-config/src/main/java/com/water/config/entity/Announcement.java b/wm-config/src/main/java/com/water/config/entity/Announcement.java new file mode 100644 index 00000000..4a1ce99d --- /dev/null +++ b/wm-config/src/main/java/com/water/config/entity/Announcement.java @@ -0,0 +1,35 @@ +package com.water.config.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 公告通知 + */ +@Data +@TableName("config_announcement") +public class Announcement { + @TableId(type = IdType.AUTO) + private Long id; + /** 标题 */ + private String title; + /** 内容 */ + private String content; + /** 类型: 1-系统公告 2-维护通知 3-紧急通知 */ + private Integer type; + /** 发布状态: 0-草稿 1-已发布 2-已撤回 */ + private Integer publishStatus; + /** 发布渠道（JSON数组）: ["sms","push","site"] */ + private String channels; + /** 发布人 */ + private String publisher; + /** 发布时间 */ + private LocalDateTime publishTime; + /** 撤回时间 */ + private LocalDateTime withdrawTime; + @TableLogic + private Integer deleted; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/wm-config/src/main/java/com/water/config/entity/DeviceInfo.java b/wm-config/src/main/java/com/water/config/entity/DeviceInfo.java new file mode 100644 index 00000000..76d84794 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/entity/DeviceInfo.java @@ -0,0 +1,45 @@ +package com.water.config.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 设备台账 + */ +@Data +@TableName("config_device_info") +public class DeviceInfo { + @TableId(type = IdType.AUTO) + private Long id; + /** 设备编码 */ + private String deviceCode; + /** 设备名称 */ + private String deviceName; + /** 设备分类: 1-水表 2-压力传感器 3-流量计 4-水质监测仪 5-阀门 9-其他 */ + private Integer category; + /** 品牌 */ + private String brand; + /** 型号 */ + private String model; + /** 安装位置 */ + private String location; + /** 经度 */ + private Double longitude; + /** 纬度 */ + private Double latitude; + /** 设备状态: 0-离线 1-在线 2-故障 3-维修中 */ + private Integer deviceStatus; + /** 安装日期 */ + private LocalDateTime installDate; + /** 最后维护时间 */ + private LocalDateTime lastMaintenanceTime; + /** 负责人 */ + private String responsiblePerson; + /** 备注 */ + private String remark; + @TableLogic + private Integer deleted; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/wm-config/src/main/java/com/water/config/entity/DeviceMaintenance.java b/wm-config/src/main/java/com/water/config/entity/DeviceMaintenance.java new file mode 100644 index 00000000..d566af13 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/entity/DeviceMaintenance.java @@ -0,0 +1,37 @@ +package com.water.config.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 设备维保记录 + */ +@Data +@TableName("config_device_maintenance") +public class DeviceMaintenance { + @TableId(type = IdType.AUTO) + private Long id; + /** 设备ID */ + private Long deviceId; + /** 维保类型: 1-日常巡检 2-定期保养 3-故障维修 4-更换配件 */ + private Integer maintenanceType; + /** 维保描述 */ + private String description; + /** 维保人 */ + private String operator; + /** 维保开始时间 */ + private LocalDateTime startTime; + /** 维保结束时间 */ + private LocalDateTime endTime; + /** 维保结果: 0-未完成 1-已完成 2-需要返修 */ + private Integer result; + /** 费用 */ + private Double cost; + /** 附件（JSON） */ + private String attachments; + @TableLogic + private Integer deleted; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/wm-config/src/main/java/com/water/config/entity/ThresholdChangeLog.java b/wm-config/src/main/java/com/water/config/entity/ThresholdChangeLog.java new file mode 100644 index 00000000..cadd348b --- /dev/null +++ b/wm-config/src/main/java/com/water/config/entity/ThresholdChangeLog.java @@ -0,0 +1,35 @@ +package com.water.config.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * 阈值变更记录 + */ +@Data +@TableName("config_threshold_change_log") +public class ThresholdChangeLog { + @TableId(type = IdType.AUTO) + private Long id; + /** 关联阈值ID */ + private Long thresholdId; + /** 变更前最小值 */ + private BigDecimal oldMinValue; + /** 变更前最大值 */ + private BigDecimal oldMaxValue; + /** 变更后最小值 */ + private BigDecimal newMinValue; + /** 变更后最大值 */ + private BigDecimal newMaxValue; + /** 变更前级别 */ + private Integer oldLevel; + /** 变更后级别 */ + private Integer newLevel; + /** 变更人 */ + private String operator; + /** 变更原因 */ + private String reason; + private LocalDateTime createdAt; +} diff --git a/wm-config/src/main/java/com/water/config/entity/ThresholdConfig.java b/wm-config/src/main/java/com/water/config/entity/ThresholdConfig.java new file mode 100644 index 00000000..3eae99f7 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/entity/ThresholdConfig.java @@ -0,0 +1,38 @@ +package com.water.config.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * 阈值配置 + */ +@Data +@TableName("config_threshold") +public class ThresholdConfig { + @TableId(type = IdType.AUTO) + private Long id; + /** 指标编码 */ + private String metricCode; + /** 指标名称 */ + private String metricName; + /** 设备ID（可选，null表示全局） */ + private Long deviceId; + /** 阈值级别: 1-预警 2-报警 3-紧急 */ + private Integer level; + /** 最小值 */ + private BigDecimal minValue; + /** 最大值 */ + private BigDecimal maxValue; + /** 单位 */ + private String unit; + /** 启用状态: 0-禁用 1-启用 */ + private Integer status; + /** 备注 */ + private String remark; + @TableLogic + private Integer deleted; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/wm-config/src/main/java/com/water/config/mapper/AnnouncementMapper.java b/wm-config/src/main/java/com/water/config/mapper/AnnouncementMapper.java new file mode 100644 index 00000000..95d92801 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/mapper/AnnouncementMapper.java @@ -0,0 +1,9 @@ +package com.water.config.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.config.entity.Announcement; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface AnnouncementMapper extends BaseMapper { +} diff --git a/wm-config/src/main/java/com/water/config/mapper/DeviceInfoMapper.java b/wm-config/src/main/java/com/water/config/mapper/DeviceInfoMapper.java new file mode 100644 index 00000000..63ad028c --- /dev/null +++ b/wm-config/src/main/java/com/water/config/mapper/DeviceInfoMapper.java @@ -0,0 +1,17 @@ +package com.water.config.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.config.entity.DeviceInfo; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Select; +import java.util.List; + +@Mapper +public interface DeviceInfoMapper extends BaseMapper { + + @Select("SELECT * FROM config_device_info WHERE device_status = #{status} AND deleted = 0") + List selectByDeviceStatus(Integer status); + + @Select("SELECT * FROM config_device_info WHERE category = #{category} AND deleted = 0 ORDER BY device_code") + List selectByCategory(Integer category); +} diff --git a/wm-config/src/main/java/com/water/config/mapper/DeviceMaintenanceMapper.java b/wm-config/src/main/java/com/water/config/mapper/DeviceMaintenanceMapper.java new file mode 100644 index 00000000..45a39323 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/mapper/DeviceMaintenanceMapper.java @@ -0,0 +1,14 @@ +package com.water.config.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.config.entity.DeviceMaintenance; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Select; +import java.util.List; + +@Mapper +public interface DeviceMaintenanceMapper extends BaseMapper { + + @Select("SELECT * FROM config_device_maintenance WHERE device_id = #{deviceId} AND deleted = 0 ORDER BY start_time DESC") + List selectByDeviceId(Long deviceId); +} diff --git a/wm-config/src/main/java/com/water/config/mapper/ThresholdChangeLogMapper.java b/wm-config/src/main/java/com/water/config/mapper/ThresholdChangeLogMapper.java new file mode 100644 index 00000000..9d37f034 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/mapper/ThresholdChangeLogMapper.java @@ -0,0 +1,9 @@ +package com.water.config.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.config.entity.ThresholdChangeLog; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface ThresholdChangeLogMapper extends BaseMapper { +} diff --git a/wm-config/src/main/java/com/water/config/mapper/ThresholdConfigMapper.java b/wm-config/src/main/java/com/water/config/mapper/ThresholdConfigMapper.java new file mode 100644 index 00000000..8e57c1f1 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/mapper/ThresholdConfigMapper.java @@ -0,0 +1,17 @@ +package com.water.config.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.config.entity.ThresholdConfig; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Select; +import java.util.List; + +@Mapper +public interface ThresholdConfigMapper extends BaseMapper { + + @Select("SELECT * FROM config_threshold WHERE metric_code = #{metricCode} AND device_id IS NULL AND status = 1 AND deleted = 0 ORDER BY level") + List selectGlobalByMetricCode(String metricCode); + + @Select("SELECT * FROM config_threshold WHERE device_id = #{deviceId} AND status = 1 AND deleted = 0 ORDER BY metric_code, level") + List selectByDeviceId(Long deviceId); +} diff --git a/wm-config/src/main/java/com/water/config/service/AnnouncementService.java b/wm-config/src/main/java/com/water/config/service/AnnouncementService.java new file mode 100644 index 00000000..6091d726 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/service/AnnouncementService.java @@ -0,0 +1,131 @@ +package com.water.config.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.water.common.core.exception.BusinessException; +import com.water.config.entity.Announcement; +import com.water.config.mapper.AnnouncementMapper; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; + +/** + * 公告通知服务 + */ +@Slf4j +@Service +public class AnnouncementService extends ServiceImpl { + + /** + * 分页查询公告 + */ + public Page pageAnnouncements(int page, int size, Integer type, Integer publishStatus) { + LambdaQueryWrapper qw = new LambdaQueryWrapper<>(); + if (type != null) { + qw.eq(Announcement::getType, type); + } + if (publishStatus != null) { + qw.eq(Announcement::getPublishStatus, publishStatus); + } + qw.orderByDesc(Announcement::getCreatedAt); + return this.page(new Page<>(page, size), qw); + } + + /** + * 创建公告（草稿） + */ + public Announcement createAnnouncement(Announcement announcement) { + announcement.setPublishStatus(0); + this.save(announcement); + return announcement; + } + + /** + * 更新公告（仅草稿可更新） + */ + public void updateAnnouncement(Long id, Announcement announcement) { + Announcement existing = this.getById(id); + if (existing == null) { + throw new BusinessException("公告不存在"); + } + if (existing.getPublishStatus() != 0) { + throw new BusinessException("已发布的公告不可修改"); + } + announcement.setId(id); + this.updateById(announcement); + } + + /** + * 发布公告 + */ + @Transactional + public void publish(Long id) { + Announcement announcement = this.getById(id); + if (announcement == null) { + throw new BusinessException("公告不存在"); + } + if (announcement.getPublishStatus() != 0) { + throw new BusinessException("只有草稿状态的公告可以发布"); + } + announcement.setPublishStatus(1); + announcement.setPublishTime(LocalDateTime.now()); + this.updateById(announcement); + // 多渠道发布 + dispatchChannels(announcement); + } + + /** + * 撤回公告 + */ + @Transactional + public void withdraw(Long id) { + Announcement announcement = this.getById(id); + if (announcement == null) { + throw new BusinessException("公告不存在"); + } + if (announcement.getPublishStatus() != 1) { + throw new BusinessException("只有已发布的公告可以撤回"); + } + announcement.setPublishStatus(2); + announcement.setWithdrawTime(LocalDateTime.now()); + this.updateById(announcement); + } + + /** + * 删除公告 + */ + public void deleteAnnouncement(Long id) { + Announcement existing = this.getById(id); + if (existing == null) { + throw new BusinessException("公告不存在"); + } + if (existing.getPublishStatus() == 1) { + throw new BusinessException("已发布的公告不可删除，请先撤回"); + } + this.removeById(id); + } + + /** + * 多渠道分发（模拟） + */ + private void dispatchChannels(Announcement announcement) { + String channels = announcement.getChannels(); + if (channels == null || channels.isEmpty()) { + log.info("公告 {} 无渠道配置，仅站内信发布", announcement.getId()); + return; + } + log.info("公告 {} 发布渠道: {}", announcement.getId(), channels); + if (channels.contains("sms")) { + log.info("→ 短信渠道已触发"); + } + if (channels.contains("push")) { + log.info("→ APP推送渠道已触发"); + } + if (channels.contains("site")) { + log.info("→ 站内信渠道已触发"); + } + } +} diff --git a/wm-config/src/main/java/com/water/config/service/DeviceManageService.java b/wm-config/src/main/java/com/water/config/service/DeviceManageService.java new file mode 100644 index 00000000..839f8733 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/service/DeviceManageService.java @@ -0,0 +1,150 @@ +package com.water.config.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.water.common.core.exception.BusinessException; +import com.water.config.entity.DeviceInfo; +import com.water.config.entity.DeviceMaintenance; +import com.water.config.mapper.DeviceInfoMapper; +import com.water.config.mapper.DeviceMaintenanceMapper; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.util.List; + +/** + * 设备管理服务 + */ +@Service +@RequiredArgsConstructor +public class DeviceManageService extends ServiceImpl { + + private final DeviceMaintenanceMapper maintenanceMapper; + + /** + * 分页查询设备 + */ + public Page pageDevices(int page, int size, String deviceName, Integer category, Integer deviceStatus) { + LambdaQueryWrapper qw = new LambdaQueryWrapper<>(); + if (deviceName != null && !deviceName.isEmpty()) { + qw.like(DeviceInfo::getDeviceName, deviceName); + } + if (category != null) { + qw.eq(DeviceInfo::getCategory, category); + } + if (deviceStatus != null) { + qw.eq(DeviceInfo::getDeviceStatus, deviceStatus); + } + qw.orderByDesc(DeviceInfo::getCreatedAt); + return this.page(new Page<>(page, size), qw); + } + + /** + * 创建设备 + */ + public DeviceInfo createDevice(DeviceInfo device) { + // 检查设备编码唯一性 + long count = this.count(new LambdaQueryWrapper() + .eq(DeviceInfo::getDeviceCode, device.getDeviceCode())); + if (count > 0) { + throw new BusinessException("设备编码已存在"); + } + this.save(device); + return device; + } + + /** + * 更新设备 + */ + public void updateDevice(Long id, DeviceInfo device) { + DeviceInfo existing = this.getById(id); + if (existing == null) { + throw new BusinessException("设备不存在"); + } + device.setId(id); + this.updateById(device); + } + + /** + * 更新设备状态 + */ + public void updateDeviceStatus(Long id, Integer deviceStatus) { + DeviceInfo device = this.getById(id); + if (device == null) { + throw new BusinessException("设备不存在"); + } + device.setDeviceStatus(deviceStatus); + this.updateById(device); + } + + /** + * 按分类查询设备 + */ + public List getDevicesByCategory(Integer category) { + return baseMapper.selectByCategory(category); + } + + /** + * 按状态查询设备 + */ + public List getDevicesByStatus(Integer status) { + return baseMapper.selectByDeviceStatus(status); + } + + /** + * 添加维保记录 + */ + @Transactional + public DeviceMaintenance addMaintenance(DeviceMaintenance maintenance) { + DeviceInfo device = this.getById(maintenance.getDeviceId()); + if (device == null) { + throw new BusinessException("设备不存在"); + } + maintenanceMapper.insert(maintenance); + // 如果维保完成，更新设备最后维护时间 + if (maintenance.getResult() != null && maintenance.getResult() == 1) { + device.setLastMaintenanceTime(LocalDateTime.now()); + if (device.getDeviceStatus() == 3) { + device.setDeviceStatus(1); // 维修中 -> 在线 + } + this.updateById(device); + } + return maintenance; + } + + /** + * 查询设备维保历史 + */ + public Page pageMaintenances(Long deviceId, int page, int size) { + LambdaQueryWrapper qw = new LambdaQueryWrapper<>(); + if (deviceId != null) { + qw.eq(DeviceMaintenance::getDeviceId, deviceId); + } + qw.orderByDesc(DeviceMaintenance::getStartTime); + return maintenanceMapper.selectPage(new Page<>(page, size), qw); + } + + /** + * 更新维保记录 + */ + public void updateMaintenance(Long id, DeviceMaintenance maintenance) { + maintenance.setId(id); + maintenanceMapper.updateById(maintenance); + } + + /** + * 获取设备统计（按分类） + */ + public List getDeviceCountByCategory() { + // 简化版：返回各分类的设备数量 + LambdaQueryWrapper qw = new LambdaQueryWrapper<>(); + qw.select(DeviceInfo::getCategory); + qw.groupBy(DeviceInfo::getCategory); + return this.listMaps(qw).stream() + .map(m -> ((Number) m.get("category")).longValue()) + .toList(); + } +} diff --git a/wm-config/src/main/java/com/water/config/service/ThresholdService.java b/wm-config/src/main/java/com/water/config/service/ThresholdService.java new file mode 100644 index 00000000..550940b6 --- /dev/null +++ b/wm-config/src/main/java/com/water/config/service/ThresholdService.java @@ -0,0 +1,144 @@ +package com.water.config.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.water.config.entity.ThresholdChangeLog; +import com.water.config.entity.ThresholdConfig; +import com.water.config.mapper.ThresholdChangeLogMapper; +import com.water.config.mapper.ThresholdConfigMapper; +import com.water.common.core.exception.BusinessException; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +/** + * 阈值管理服务 + */ +@Service +@RequiredArgsConstructor +public class ThresholdService extends ServiceImpl { + + private final ThresholdChangeLogMapper changeLogMapper; + + /** + * 分页查询阈值配置 + */ + public Page pageThresholds(int page, int size, String metricCode, Integer level) { + LambdaQueryWrapper qw = new LambdaQueryWrapper<>(); + if (metricCode != null && !metricCode.isEmpty()) { + qw.like(ThresholdConfig::getMetricCode, metricCode); + } + if (level != null) { + qw.eq(ThresholdConfig::getLevel, level); + } + qw.orderByAsc(ThresholdConfig::getMetricCode, ThresholdConfig::getLevel); + return this.page(new Page<>(page, size), qw); + } + + /** + * 创建阈值配置 + */ + @Transactional + public ThresholdConfig createThreshold(ThresholdConfig config) { + validateThreshold(config); + this.save(config); + recordChangeLog(config, null, "新建阈值配置"); + return config; + } + + /** + * 更新阈值配置（记录变更） + */ + @Transactional + public void updateThreshold(Long id, ThresholdConfig config) { + ThresholdConfig old = this.getById(id); + if (old == null) { + throw new BusinessException("阈值配置不存在"); + } + config.setId(id); + validateThreshold(config); + this.updateById(config); + recordChangeLog(config, old, "更新阈值配置"); + } + + /** + * 删除阈值配置 + */ + @Transactional + public void deleteThreshold(Long id) { + ThresholdConfig old = this.getById(id); + if (old == null) { + throw new BusinessException("阈值配置不存在"); + } + this.removeById(id); + recordChangeLog(old, old, "删除阈值配置"); + } + + /** + * 获取某指标的全局阈值（多级） + */ + public List getGlobalThresholds(String metricCode) { + return baseMapper.selectGlobalByMetricCode(metricCode); + } + + /** + * 获取某设备的阈值配置 + */ + public List getDeviceThresholds(Long deviceId) { + return baseMapper.selectByDeviceId(deviceId); + } + + /** + * 获取阈值变更历史 + */ + public Page getChangeHistory(Long thresholdId, int page, int size) { + LambdaQueryWrapper qw = new LambdaQueryWrapper<>(); + if (thresholdId != null) { + qw.eq(ThresholdChangeLog::getThresholdId, thresholdId); + } + qw.orderByDesc(ThresholdChangeLog::getCreatedAt); + return changeLogMapper.selectPage(new Page<>(page, size), qw); + } + + /** + * 启用/禁用阈值 + */ + public void toggleStatus(Long id, Integer status) { + ThresholdConfig config = this.getById(id); + if (config == null) { + throw new BusinessException("阈值配置不存在"); + } + config.setStatus(status); + this.updateById(config); + } + + private void validateThreshold(ThresholdConfig config) { + if (config.getMinValue() != null && config.getMaxValue() != null) { + if (config.getMinValue().compareTo(config.getMaxValue()) > 0) { + throw new BusinessException("最小值不能大于最大值"); + } + } + if (config.getLevel() != null && (config.getLevel() < 1 || config.getLevel() > 3)) { + throw new BusinessException("阈值级别必须在1-3之间"); + } + } + + private void recordChangeLog(ThresholdConfig newConfig, ThresholdConfig oldConfig, String reason) { + ThresholdChangeLog log = new ThresholdChangeLog(); + log.setThresholdId(newConfig.getId()); + if (oldConfig != null) { + log.setOldMinValue(oldConfig.getMinValue()); + log.setOldMaxValue(oldConfig.getMaxValue()); + log.setOldLevel(oldConfig.getLevel()); + } + log.setNewMinValue(newConfig.getMinValue()); + log.setNewMaxValue(newConfig.getMaxValue()); + log.setNewLevel(newConfig.getLevel()); + log.setReason(reason); + log.setOperator("system"); + changeLogMapper.insert(log); + } +} diff --git a/wm-config/src/main/resources/application.yml b/wm-config/src/main/resources/application.yml new file mode 100644 index 00000000..f1cbf385 --- /dev/null +++ b/wm-config/src/main/resources/application.yml @@ -0,0 +1,30 @@ +server: + port: 8090 + +spring: + application: + name: wm-config + datasource: + driver-class-name: org.postgresql.Driver + url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:water}?currentSchema=public + username: ${DB_USER:postgres} + password: ${DB_PASS:postgres} + cloud: + nacos: + discovery: + server-addr: ${NACOS_ADDR:localhost:8848} + +mybatis-plus: + configuration: + map-underscore-to-camel-case: true + log-impl: org.apache.ibatis.logging.stdout.StdOutImpl + global-config: + db-config: + logic-delete-field: deleted + logic-delete-value: 1 + logic-not-delete-value: 0 + +sa-token: + token-name: Authorization + timeout: 86400 + active-timeout: 1800 diff --git a/wm-config/src/main/resources/db/schema.sql b/wm-config/src/main/resources/db/schema.sql new file mode 100644 index 00000000..f58cf900 --- /dev/null +++ b/wm-config/src/main/resources/db/schema.sql @@ -0,0 +1,102 @@ +-- ============================================================ +-- wm-config DDL: 阈值管理 + 信息发布 + 设备管理 +-- ============================================================ + +-- 阈值配置表 +CREATE TABLE IF NOT EXISTS config_threshold ( + id BIGSERIAL PRIMARY KEY, + metric_code VARCHAR(64) NOT NULL, + metric_name VARCHAR(128) NOT NULL, + device_id BIGINT, + level SMALLINT NOT NULL DEFAULT 1, -- 1-预警 2-报警 3-紧急 + min_value NUMERIC(12,4), + max_value NUMERIC(12,4), + unit VARCHAR(32), + status SMALLINT NOT NULL DEFAULT 1, -- 0-禁用 1-启用 + remark VARCHAR(500), + deleted SMALLINT NOT NULL DEFAULT 0, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); +COMMENT ON TABLE config_threshold IS '阈值配置表'; +CREATE INDEX idx_threshold_metric ON config_threshold(metric_code); +CREATE INDEX idx_threshold_device ON config_threshold(device_id); + +-- 阈值变更记录表 +CREATE TABLE IF NOT EXISTS config_threshold_change_log ( + id BIGSERIAL PRIMARY KEY, + threshold_id BIGINT NOT NULL, + old_min_value NUMERIC(12,4), + old_max_value NUMERIC(12,4), + new_min_value NUMERIC(12,4), + new_max_value NUMERIC(12,4), + old_level SMALLINT, + new_level SMALLINT, + operator VARCHAR(64), + reason VARCHAR(500), + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); +COMMENT ON TABLE config_threshold_change_log IS '阈值变更记录表'; +CREATE INDEX idx_change_log_threshold ON config_threshold_change_log(threshold_id); + +-- 公告通知表 +CREATE TABLE IF NOT EXISTS config_announcement ( + id BIGSERIAL PRIMARY KEY, + title VARCHAR(256) NOT NULL, + content TEXT, + type SMALLINT NOT NULL DEFAULT 1, -- 1-系统公告 2-维护通知 3-紧急通知 + publish_status SMALLINT NOT NULL DEFAULT 0, -- 0-草稿 1-已发布 2-已撤回 + channels VARCHAR(256), -- JSON: ["sms","push","site"] + publisher VARCHAR(64), + publish_time TIMESTAMP, + withdraw_time TIMESTAMP, + deleted SMALLINT NOT NULL DEFAULT 0, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); +COMMENT ON TABLE config_announcement IS '公告通知表'; +CREATE INDEX idx_announcement_status ON config_announcement(publish_status); + +-- 设备台账表 +CREATE TABLE IF NOT EXISTS config_device_info ( + id BIGSERIAL PRIMARY KEY, + device_code VARCHAR(64) NOT NULL UNIQUE, + device_name VARCHAR(128) NOT NULL, + category SMALLINT NOT NULL DEFAULT 9, -- 1-水表 2-压力传感器 3-流量计 4-水质监测仪 5-阀门 9-其他 + brand VARCHAR(64), + model VARCHAR(64), + location VARCHAR(256), + longitude DOUBLE PRECISION, + latitude DOUBLE PRECISION, + device_status SMALLINT NOT NULL DEFAULT 0, -- 0-离线 1-在线 2-故障 3-维修中 + install_date TIMESTAMP, + last_maintenance_time TIMESTAMP, + responsible_person VARCHAR(64), + remark VARCHAR(500), + deleted SMALLINT NOT NULL DEFAULT 0, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); +COMMENT ON TABLE config_device_info IS '设备台账表'; +CREATE INDEX idx_device_code ON config_device_info(device_code); +CREATE INDEX idx_device_category ON config_device_info(category); +CREATE INDEX idx_device_status ON config_device_info(device_status); + +-- 设备维保记录表 +CREATE TABLE IF NOT EXISTS config_device_maintenance ( + id BIGSERIAL PRIMARY KEY, + device_id BIGINT NOT NULL, + maintenance_type SMALLINT NOT NULL DEFAULT 1, -- 1-日常巡检 2-定期保养 3-故障维修 4-更换配件 + description TEXT, + operator VARCHAR(64), + start_time TIMESTAMP, + end_time TIMESTAMP, + result SMALLINT NOT NULL DEFAULT 0, -- 0-未完成 1-已完成 2-需要返修 + cost DOUBLE PRECISION, + attachments TEXT, -- JSON + deleted SMALLINT NOT NULL DEFAULT 0, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); +COMMENT ON TABLE config_device_maintenance IS '设备维保记录表'; +CREATE INDEX idx_maintenance_device ON config_device_maintenance(device_id); diff --git a/wm-config/src/test/java/com/water/config/AnnouncementServiceTest.java b/wm-config/src/test/java/com/water/config/AnnouncementServiceTest.java new file mode 100644 index 00000000..85481eae --- /dev/null +++ b/wm-config/src/test/java/com/water/config/AnnouncementServiceTest.java @@ -0,0 +1,100 @@ +package com.water.config; + +import com.water.common.core.exception.BusinessException; +import com.water.config.entity.Announcement; +import com.water.config.mapper.AnnouncementMapper; +import com.water.config.service.AnnouncementService; +import org.junit.jupiter.api.BeforeEach; +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 static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class AnnouncementServiceTest { + + @Mock + private AnnouncementMapper announcementMapper; + @InjectMocks + private AnnouncementService announcementService; + + private Announcement draft; + + @BeforeEach + void setUp() { + draft = new Announcement(); + draft.setTitle("系统维护通知"); + draft.setContent("今晚22:00-次日06:00系统维护"); + draft.setType(2); + draft.setChannels("[\"site\",\"sms\"]"); + } + + @Test + void createAnnouncement_setsDraftStatus() { + when(announcementMapper.insert(any())).thenReturn(1); + + Announcement result = announcementService.createAnnouncement(draft); + + assertEquals(0, result.getPublishStatus()); + verify(announcementMapper).insert(any(Announcement.class)); + } + + @Test + void publish_draft_success() { + Announcement existing = new Announcement(); + existing.setId(1L); + existing.setPublishStatus(0); + existing.setChannels("[\"site\"]"); + + when(announcementMapper.selectById(1L)).thenReturn(existing); + when(announcementMapper.updateById(any())).thenReturn(1); + + assertDoesNotThrow(() -> announcementService.publish(1L)); + verify(announcementMapper).updateById(argThat(a -> + a.getPublishStatus() == 1 && a.getPublishTime() != null)); + } + + @Test + void publish_alreadyPublished_throws() { + Announcement existing = new Announcement(); + existing.setId(1L); + existing.setPublishStatus(1); + + when(announcementMapper.selectById(1L)).thenReturn(existing); + + BusinessException ex = assertThrows(BusinessException.class, + () -> announcementService.publish(1L)); + assertEquals("只有草稿状态的公告可以发布", ex.getMessage()); + } + + @Test + void withdraw_notPublished_throws() { + Announcement existing = new Announcement(); + existing.setId(1L); + existing.setPublishStatus(0); + + when(announcementMapper.selectById(1L)).thenReturn(existing); + + BusinessException ex = assertThrows(BusinessException.class, + () -> announcementService.withdraw(1L)); + assertEquals("只有已发布的公告可以撤回", ex.getMessage()); + } + + @Test + void delete_published_throws() { + Announcement existing = new Announcement(); + existing.setId(1L); + existing.setPublishStatus(1); + + when(announcementMapper.selectById(1L)).thenReturn(existing); + + BusinessException ex = assertThrows(BusinessException.class, + () -> announcementService.deleteAnnouncement(1L)); + assertEquals("已发布的公告不可删除，请先撤回", ex.getMessage()); + } +} diff --git a/wm-config/src/test/java/com/water/config/DeviceManageServiceTest.java b/wm-config/src/test/java/com/water/config/DeviceManageServiceTest.java new file mode 100644 index 00000000..d62c5340 --- /dev/null +++ b/wm-config/src/test/java/com/water/config/DeviceManageServiceTest.java @@ -0,0 +1,107 @@ +package com.water.config; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.config.entity.DeviceInfo; +import com.water.config.entity.DeviceMaintenance; +import com.water.config.mapper.DeviceInfoMapper; +import com.water.config.mapper.DeviceMaintenanceMapper; +import com.water.config.service.DeviceManageService; +import org.junit.jupiter.api.BeforeEach; +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 static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class DeviceManageServiceTest { + + @Mock + private DeviceInfoMapper deviceInfoMapper; + @Mock + private DeviceMaintenanceMapper maintenanceMapper; + @InjectMocks + private DeviceManageService deviceManageService; + + private DeviceInfo device; + + @BeforeEach + void setUp() { + device = new DeviceInfo(); + device.setDeviceCode("WM-001"); + device.setDeviceName("1号水表"); + device.setCategory(1); + device.setBrand("海天"); + device.setModel("HT-200"); + device.setDeviceStatus(0); + } + + @Test + void createDevice_success() { + when(deviceInfoMapper.selectCount(any())).thenReturn(0L); + when(deviceInfoMapper.insert(any())).thenReturn(1); + + DeviceInfo result = deviceManageService.createDevice(device); + + assertNotNull(result); + assertEquals("WM-001", result.getDeviceCode()); + verify(deviceInfoMapper).insert(any(DeviceInfo.class)); + } + + @Test + void createDevice_duplicateCode_throws() { + when(deviceInfoMapper.selectCount(any())).thenReturn(1L); + + BusinessException ex = assertThrows(BusinessException.class, + () -> deviceManageService.createDevice(device)); + assertEquals("设备编码已存在", ex.getMessage()); + } + + @Test + void updateDevice_notFound_throws() { + when(deviceInfoMapper.selectById(999L)).thenReturn(null); + + BusinessException ex = assertThrows(BusinessException.class, + () -> deviceManageService.updateDevice(999L, device)); + assertEquals("设备不存在", ex.getMessage()); + } + + @Test + void addMaintenance_deviceNotFound_throws() { + DeviceMaintenance maintenance = new DeviceMaintenance(); + maintenance.setDeviceId(999L); + + when(deviceInfoMapper.selectById(999L)).thenReturn(null); + + BusinessException ex = assertThrows(BusinessException.class, + () -> deviceManageService.addMaintenance(maintenance)); + assertEquals("设备不存在", ex.getMessage()); + } + + @Test + void addMaintenance_completed_updatesDeviceTime() { + DeviceInfo existingDevice = new DeviceInfo(); + existingDevice.setId(1L); + existingDevice.setDeviceStatus(3); // 维修中 + + DeviceMaintenance maintenance = new DeviceMaintenance(); + maintenance.setDeviceId(1L); + maintenance.setResult(1); // 已完成 + maintenance.setDescription("更换电池"); + + when(deviceInfoMapper.selectById(1L)).thenReturn(existingDevice); + when(maintenanceMapper.insert(any())).thenReturn(1); + when(deviceInfoMapper.updateById(any())).thenReturn(1); + + DeviceMaintenance result = deviceManageService.addMaintenance(maintenance); + + assertNotNull(result); + verify(deviceInfoMapper).updateById(argThat(d -> + d.getLastMaintenanceTime() != null && d.getDeviceStatus() == 1)); + } +} diff --git a/wm-config/src/test/java/com/water/config/ThresholdServiceTest.java b/wm-config/src/test/java/com/water/config/ThresholdServiceTest.java new file mode 100644 index 00000000..6042f259 --- /dev/null +++ b/wm-config/src/test/java/com/water/config/ThresholdServiceTest.java @@ -0,0 +1,96 @@ +package com.water.config; + +import com.water.common.core.exception.BusinessException; +import com.water.config.entity.ThresholdChangeLog; +import com.water.config.entity.ThresholdConfig; +import com.water.config.mapper.ThresholdChangeLogMapper; +import com.water.config.mapper.ThresholdConfigMapper; +import com.water.config.service.ThresholdService; +import org.junit.jupiter.api.BeforeEach; +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.math.BigDecimal; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class ThresholdServiceTest { + + @Mock + private ThresholdConfigMapper thresholdConfigMapper; + @Mock + private ThresholdChangeLogMapper changeLogMapper; + @InjectMocks + private ThresholdService thresholdService; + + private ThresholdConfig validConfig; + + @BeforeEach + void setUp() { + validConfig = new ThresholdConfig(); + validConfig.setMetricCode("water_pressure"); + validConfig.setMetricName("水压"); + validConfig.setLevel(1); + validConfig.setMinValue(new BigDecimal("0.1")); + validConfig.setMaxValue(new BigDecimal("0.8")); + validConfig.setUnit("MPa"); + validConfig.setStatus(1); + } + + @Test + void createThreshold_success() { + when(thresholdConfigMapper.insert(any())).thenReturn(1); + when(changeLogMapper.insert(any())).thenReturn(1); + + ThresholdConfig result = thresholdService.createThreshold(validConfig); + + assertNotNull(result); + assertEquals("water_pressure", result.getMetricCode()); + assertEquals(1, result.getLevel()); + verify(thresholdConfigMapper).insert(any(ThresholdConfig.class)); + verify(changeLogMapper).insert(any(ThresholdChangeLog.class)); + } + + @Test + void createThreshold_minGreaterThanMax_throws() { + validConfig.setMinValue(new BigDecimal("1.0")); + validConfig.setMaxValue(new BigDecimal("0.5")); + + BusinessException ex = assertThrows(BusinessException.class, + () -> thresholdService.createThreshold(validConfig)); + assertEquals("最小值不能大于最大值", ex.getMessage()); + } + + @Test + void createThreshold_invalidLevel_throws() { + validConfig.setLevel(5); + + BusinessException ex = assertThrows(BusinessException.class, + () -> thresholdService.createThreshold(validConfig)); + assertEquals("阈值级别必须在1-3之间", ex.getMessage()); + } + + @Test + void updateThreshold_notFound_throws() { + when(thresholdConfigMapper.selectById(999L)).thenReturn(null); + + BusinessException ex = assertThrows(BusinessException.class, + () -> thresholdService.updateThreshold(999L, validConfig)); + assertEquals("阈值配置不存在", ex.getMessage()); + } + + @Test + void deleteThreshold_notFound_throws() { + when(thresholdConfigMapper.selectById(999L)).thenReturn(null); + + BusinessException ex = assertThrows(BusinessException.class, + () -> thresholdService.deleteThreshold(999L)); + assertEquals("阈值配置不存在", ex.getMessage()); + } +} diff --git a/wm-data-engine/pom.xml b/wm-data-engine/pom.xml index d56746cb..a722533e 100644 --- a/wm-data-engine/pom.xml +++ b/wm-data-engine/pom.xml @@ -3,15 +3,120 @@ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 - com.waterwm-parent1.0.0-SNAPSHOT + + com.water + wm-parent + 1.0.0-SNAPSHOT + wm-data-engine + wm-data-engine + 数据汇聚引擎模块 + - com.waterwm-common - org.springframework.bootspring-boot-starter-web - com.alibaba.cloudspring-cloud-starter-alibaba-nacos-discovery - org.springframework.kafkaspring-kafka - org.springframework.bootspring-boot-starter-data-redis - org.postgresqlpostgresql - net.postgispostgis-jdbc + + + com.water + wm-common + + + + + org.springframework.boot + spring-boot-starter-web + + + + + org.springframework.boot + spring-boot-starter-websocket + + + + + com.alibaba.cloud + spring-cloud-starter-alibaba-nacos-discovery + + + + + org.springframework.kafka + spring-kafka + + + + + org.springframework.boot + spring-boot-starter-data-redis + + + + + org.postgresql + postgresql + + + + + net.postgis + postgis-jdbc + + + + + com.baomidou + mybatis-plus-spring-boot3-starter + + + + + io.minio + minio + + + + + cn.hutool + hutool-all + + + + + com.github.xiaoymin + knife4j-openapi3-jakarta-spring-boot-starter + + + + + com.alibaba + easyexcel + + + + + org.springframework.boot + spring-boot-starter-test + test + + + + org.springframework.kafka + spring-kafka-test + test + + + + com.h2database + h2 + test + - \ No newline at end of file + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + diff --git a/wm-data-engine/src/main/java/com/water/data_engine/config/KafkaConfig.java b/wm-data-engine/src/main/java/com/water/data_engine/config/KafkaConfig.java new file mode 100644 index 00000000..c56e78bd --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/config/KafkaConfig.java @@ -0,0 +1,62 @@ +package com.water.data_engine.config; + +import org.apache.kafka.clients.consumer.ConsumerConfig; +import org.apache.kafka.clients.producer.ProducerConfig; +import org.apache.kafka.common.serialization.StringDeserializer; +import org.apache.kafka.common.serialization.StringSerializer; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory; +import org.springframework.kafka.core.*; + +import java.util.HashMap; +import java.util.Map; + +/** + * Kafka 配置 + * 用于实时数据流采集和传输 + */ +@Configuration +public class KafkaConfig { + + @Value("${spring.kafka.bootstrap-servers:${KAFKA_SERVERS:127.0.0.1}:9092}") + private String bootstrapServers; + + @Bean + public ProducerFactory producerFactory() { + Map props = new HashMap<>(); + props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers); + props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class); + props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class); + props.put(ProducerConfig.ACKS_CONFIG, "1"); + props.put(ProducerConfig.RETRIES_CONFIG, 3); + return new DefaultKafkaProducerFactory<>(props); + } + + @Bean + public KafkaTemplate kafkaTemplate(ProducerFactory producerFactory) { + return new KafkaTemplate<>(producerFactory); + } + + @Bean + public ConsumerFactory consumerFactory() { + Map props = new HashMap<>(); + props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers); + props.put(ConsumerConfig.GROUP_ID_CONFIG, "wm-data-engine"); + props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); + props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); + props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest"); + return new DefaultKafkaConsumerFactory<>(props); + } + + @Bean + public ConcurrentKafkaListenerContainerFactory kafkaListenerContainerFactory( + ConsumerFactory consumerFactory) { + ConcurrentKafkaListenerContainerFactory factory = + new ConcurrentKafkaListenerContainerFactory<>(); + factory.setConsumerFactory(consumerFactory); + factory.setConcurrency(3); + return factory; + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/config/MyBatisPlusConfig.java b/wm-data-engine/src/main/java/com/water/data_engine/config/MyBatisPlusConfig.java new file mode 100644 index 00000000..18cb8dcc --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/config/MyBatisPlusConfig.java @@ -0,0 +1,49 @@ +package com.water.data_engine.config; + +import com.baomidou.mybatisplus.annotation.DbType; +import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler; +import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; +import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; +import org.apache.ibatis.reflection.MetaObject; +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +import java.time.LocalDateTime; + +/** + * MyBatis-Plus 配置 + */ +@Configuration +@MapperScan("com.water.data_engine.mapper") +public class MyBatisPlusConfig { + + /** + * 分页插件 + */ + @Bean + public MybatisPlusInterceptor mybatisPlusInterceptor() { + MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); + interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.POSTGRE_SQL)); + return interceptor; + } + + /** + * 自动填充处理器 + */ + @Bean + public MetaObjectHandler metaObjectHandler() { + return new MetaObjectHandler() { + @Override + public void insertFill(MetaObject metaObject) { + this.strictInsertFill(metaObject, "createdAt", LocalDateTime.class, LocalDateTime.now()); + this.strictInsertFill(metaObject, "updatedAt", LocalDateTime.class, LocalDateTime.now()); + } + + @Override + public void updateFill(MetaObject metaObject) { + this.strictUpdateFill(metaObject, "updatedAt", LocalDateTime.class, LocalDateTime.now()); + } + }; + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/config/WebSocketConfig.java b/wm-data-engine/src/main/java/com/water/data_engine/config/WebSocketConfig.java new file mode 100644 index 00000000..e81045a0 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/config/WebSocketConfig.java @@ -0,0 +1,32 @@ +package com.water.data_engine.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.messaging.simp.config.MessageBrokerRegistry; +import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker; +import org.springframework.web.socket.config.annotation.StompEndpointRegistry; +import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; + +/** + * WebSocket 配置 + * 支持 STOMP 协议，用于实时数据推送 + */ +@Configuration +@EnableWebSocketMessageBroker +public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { + + @Override + public void configureMessageBroker(MessageBrokerRegistry registry) { + // 客户端订阅前缀: /topic (广播), /queue (点对点) + registry.enableSimpleBroker("/topic", "/queue"); + // 客户端发送消息前缀 + registry.setApplicationDestinationPrefixes("/app"); + } + + @Override + public void registerStompEndpoints(StompEndpointRegistry registry) { + // WebSocket 连接端点 + registry.addEndpoint("/ws/data-engine") + .setAllowedOriginPatterns("*") + .withSockJS(); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/controller/DataCollectController.java b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataCollectController.java new file mode 100644 index 00000000..83563c3f --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataCollectController.java @@ -0,0 +1,85 @@ +package com.water.data_engine.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.common.core.result.R; +import com.water.data_engine.entity.CollectRecord; +import com.water.data_engine.entity.CollectTask; +import com.water.data_engine.service.DataCollectService; +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; +import java.util.Map; + +/** + * 数据采集控制器 + * DE-01: 实时流(MQTT/Kafka) + 批量采集 + */ +@Tag(name = "数据采集") +@RestController +@RequestMapping("/api/data-engine/collect") +@RequiredArgsConstructor +public class DataCollectController { + + private final DataCollectService collectService; + + // ==================== 实时数据采集 ==================== + + @Operation(summary = "实时数据接入") + @PostMapping("/realtime") + public R ingestRealtime(@RequestBody Map request) { + String sourceType = (String) request.get("sourceType"); + String sourceId = (String) request.get("sourceId"); + @SuppressWarnings("unchecked") + Map data = (Map) request.get("data"); + + String topic = collectService.ingestRealtime(sourceType, sourceId, data); + return R.ok("数据已接入，topic: " + topic); + } + + @Operation(summary = "批量数据接入") + @PostMapping("/batch") + public R batchIngest(@RequestBody List> batchData) { + int count = collectService.batchIngest(batchData); + return R.ok("批量接入完成，成功: " + count + " 条"); + } + + // ==================== 采集任务管理 ==================== + + @Operation(summary = "创建批量采集任务") + @PostMapping("/task") + public R createTask(@RequestBody Map request) { + String taskName = (String) request.get("taskName"); + Long sourceId = Long.valueOf(request.get("sourceId").toString()); + String targetTable = (String) request.get("targetTable"); + + CollectTask task = collectService.createBatchTask(taskName, sourceId, targetTable); + return R.ok(task); + } + + @Operation(summary = "执行采集任务") + @PostMapping("/task/{taskId}/execute") + public R executeTask(@PathVariable Long taskId, + @RequestBody List> dataList) { + collectService.executeTask(taskId, dataList); + return R.ok("任务执行完成"); + } + + @Operation(summary = "查询采集任务列表") + @GetMapping("/task/list") + public R> listTasks(@RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) String status) { + return R.ok(collectService.listTasks(page, size, status)); + } + + @Operation(summary = "查询采集记录") + @GetMapping("/record/list") + public R> listRecords(@RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) Long taskId) { + return R.ok(collectService.listRecords(page, size, taskId)); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/controller/DataController.java b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataController.java new file mode 100644 index 00000000..c5d9ff32 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataController.java @@ -0,0 +1,65 @@ +package com.water.data_engine.controller; + +import com.water.common.core.result.R; +import com.water.data_engine.service.DataCollectService; +import com.water.data_engine.service.DataGovernanceService; +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.*; + +/** + * 数据引擎综合控制器(兼容旧接口) + */ +@Tag(name = "数据引擎(综合)") +@RestController +@RequestMapping("/api/data-engine") +@RequiredArgsConstructor +public class DataController { + + private final DataCollectService collectService; + private final DataGovernanceService governanceService; + + @Operation(summary = "数据接入(兼容旧接口)") + @PostMapping("/ingest") + public R ingest(@RequestBody Map req) { + String sourceType = (String) req.get("sourceType"); + String sourceId = (String) req.get("sourceId"); + @SuppressWarnings("unchecked") + Map data = (Map) req.get("data"); + collectService.ingestRealtime(sourceType, sourceId, data); + return R.ok("数据已接入"); + } + + @Operation(summary = "批量接入(兼容旧接口)") + @PostMapping("/ingest/batch") + public R batchIngest(@RequestBody List> batch) { + collectService.batchIngest(batch); + return R.ok("批量接入完成"); + } + + @Operation(summary = "数据标准化+清洗+质控(管道演示)") + @PostMapping("/pipeline") + public R> pipeline(@RequestBody Map raw) { + Map result = governanceService.pipeline(raw); + return R.ok(result); + } + + @Operation(summary = "引擎状态") + @GetMapping("/status") + public R> status() { + Map status = new LinkedHashMap<>(); + status.put("module", "wm-data-engine"); + status.put("version", "1.0.0"); + status.put("status", "running"); + status.put("features", List.of( + "DE-01 数据采集(实时流/批量)", + "DE-02 数据接入(REST/WebSocket/数据库)", + "DE-03 数据存储(TDengine/PostgreSQL/MinIO)", + "DE-04 数据集成(多源异构整合)" + )); + return R.ok(status); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/controller/DataGovernanceController.java b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataGovernanceController.java new file mode 100644 index 00000000..5e3f1435 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataGovernanceController.java @@ -0,0 +1,117 @@ +package com.water.data_engine.controller; + +import com.water.common.core.result.R; +import com.water.data_engine.entity.QualityRule; +import com.water.data_engine.service.DataGovernanceService; +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; +import java.util.Map; + +/** + * 数据治理控制器 + * 数据标准化、清洗、质量控制 + */ +@Tag(name = "数据治理") +@RestController +@RequestMapping("/api/data-engine/governance") +@RequiredArgsConstructor +public class DataGovernanceController { + + private final DataGovernanceService governanceService; + + // ==================== 数据标准化 ==================== + + @Operation(summary = "数据标准化") + @PostMapping("/standardize") + public R> standardize(@RequestBody Map raw) { + return R.ok(governanceService.standardize(raw)); + } + + @Operation(summary = "批量数据标准化") + @PostMapping("/standardize/batch") + public R>> batchStandardize(@RequestBody List> rawDataList) { + return R.ok(governanceService.batchStandardize(rawDataList)); + } + + // ==================== 数据清洗 ==================== + + @Operation(summary = "数据清洗") + @PostMapping("/clean") + public R> clean(@RequestBody Map data) { + return R.ok(governanceService.clean(data)); + } + + @Operation(summary = "批量数据清洗") + @PostMapping("/clean/batch") + public R>> batchClean(@RequestBody List> dataList) { + return R.ok(governanceService.batchClean(dataList)); + } + + // ==================== 数据质量 ==================== + + @Operation(summary = "数据质量检查") + @PostMapping("/quality/check") + public R> qualityCheck(@RequestBody Map data) { + return R.ok(governanceService.qualityCheck(data)); + } + + @Operation(summary = "批量数据质量检查") + @PostMapping("/quality/check/batch") + public R>> batchQualityCheck(@RequestBody List> dataList) { + return R.ok(governanceService.batchQualityCheck(dataList)); + } + + @Operation(summary = "执行质量规则检查") + @PostMapping("/quality/rules/execute") + public R> executeQualityRules(@RequestBody Map request) { + String tableName = (String) request.get("tableName"); + return R.ok(governanceService.executeQualityRules(tableName)); + } + + // ==================== 数据管道 ==================== + + @Operation(summary = "完整数据管道(标准化->清洗->质控)") + @PostMapping("/pipeline") + public R> pipeline(@RequestBody Map raw) { + return R.ok(governanceService.pipeline(raw)); + } + + @Operation(summary = "批量数据管道") + @PostMapping("/pipeline/batch") + public R>> batchPipeline(@RequestBody List> rawDataList) { + return R.ok(governanceService.batchPipeline(rawDataList)); + } + + // ==================== 质量规则管理 ==================== + + @Operation(summary = "创建质量规则") + @PostMapping("/quality/rule") + public R createQualityRule(@RequestBody QualityRule rule) { + return R.ok(governanceService.createQualityRule(rule)); + } + + @Operation(summary = "更新质量规则") + @PutMapping("/quality/rule/{id}") + public R updateQualityRule(@PathVariable Long id, @RequestBody QualityRule rule) { + return R.ok(governanceService.updateQualityRule(id, rule)); + } + + @Operation(summary = "删除质量规则") + @DeleteMapping("/quality/rule/{id}") + public R deleteQualityRule(@PathVariable Long id) { + governanceService.deleteQualityRule(id); + return R.ok("删除成功"); + } + + @Operation(summary = "查询质量规则列表") + @GetMapping("/quality/rule/list") + public R> listQualityRules( + @RequestParam(required = false) String tableName, + @RequestParam(required = false) String ruleType) { + return R.ok(governanceService.listQualityRules(tableName, ruleType)); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/controller/DataIngestController.java b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataIngestController.java new file mode 100644 index 00000000..f79875cd --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataIngestController.java @@ -0,0 +1,118 @@ +package com.water.data_engine.controller; + +import com.water.common.core.result.R; +import com.water.data_engine.entity.DataSource; +import com.water.data_engine.service.DataIngestService; +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 org.springframework.web.multipart.MultipartFile; + +import java.util.List; +import java.util.Map; + +/** + * 数据接入控制器 + * DE-02: RESTful API / WebSocket / 数据库直连 + */ +@Tag(name = "数据接入") +@RestController +@RequestMapping("/api/data-engine/ingest") +@RequiredArgsConstructor +public class DataIngestController { + + private final DataIngestService ingestService; + + // ==================== API 接入 ==================== + + @Operation(summary = "通过 API 接入单条数据") + @PostMapping("/api/{sourceCode}") + public R ingestViaApi(@PathVariable String sourceCode, + @RequestBody Map data) { + String topic = ingestService.ingestViaApi(sourceCode, data); + return R.ok("数据已接入，topic: " + topic); + } + + @Operation(summary = "通过 API 批量接入数据") + @PostMapping("/api/{sourceCode}/batch") + public R batchIngestViaApi(@PathVariable String sourceCode, + @RequestBody List> dataList) { + int count = ingestService.batchIngestViaApi(sourceCode, dataList); + return R.ok("批量接入完成，成功: " + count + " 条"); + } + + // ==================== 数据库接入 ==================== + + @Operation(summary = "从外部数据库拉取数据") + @PostMapping("/database/{sourceId}/pull") + public R pullFromDatabase(@PathVariable Long sourceId, + @RequestBody Map request) { + String sql = (String) request.get("sql"); + String targetTable = (String) request.get("targetTable"); + int count = ingestService.pullFromDatabase(sourceId, sql, targetTable); + return R.ok("数据拉取完成，成功: " + count + " 条"); + } + + @Operation(summary = "同步数据到本地表") + @PostMapping("/database/{sourceId}/sync") + public R syncToTable(@PathVariable Long sourceId, + @RequestBody Map request) { + String querySql = (String) request.get("querySql"); + String targetTable = (String) request.get("targetTable"); + @SuppressWarnings("unchecked") + List columns = (List) request.get("columns"); + int count = ingestService.syncToTable(sourceId, querySql, targetTable, columns); + return R.ok("同步完成，成功: " + count + " 条"); + } + + // ==================== 文件接入 ==================== + + @Operation(summary = "通过文件(CSV)接入数据") + @PostMapping("/file/{sourceCode}") + public R ingestFromFile(@PathVariable String sourceCode, + @RequestParam("file") MultipartFile file) throws Exception { + int count = ingestService.ingestFromFile(file, sourceCode); + return R.ok("文件数据接入完成，成功: " + count + " 条"); + } + + // ==================== 数据源管理 ==================== + + @Operation(summary = "创建数据源") + @PostMapping("/source") + public R createDataSource(@RequestBody DataSource dataSource) { + return R.ok(ingestService.createDataSource(dataSource)); + } + + @Operation(summary = "更新数据源") + @PutMapping("/source/{id}") + public R updateDataSource(@PathVariable Long id, + @RequestBody DataSource dataSource) { + return R.ok(ingestService.updateDataSource(id, dataSource)); + } + + @Operation(summary = "删除数据源") + @DeleteMapping("/source/{id}") + public R deleteDataSource(@PathVariable Long id) { + ingestService.deleteDataSource(id); + return R.ok("删除成功"); + } + + @Operation(summary = "查询数据源列表") + @GetMapping("/source/list") + public R> listDataSources(@RequestParam(required = false) String sourceType) { + return R.ok(ingestService.listDataSources(sourceType)); + } + + @Operation(summary = "获取数据源详情") + @GetMapping("/source/{id}") + public R getDataSource(@PathVariable Long id) { + return R.ok(ingestService.getDataSource(id)); + } + + @Operation(summary = "测试数据源连接") + @PostMapping("/source/{id}/test") + public R testConnection(@PathVariable Long id) { + return R.ok(ingestService.testConnection(id)); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/controller/DataIntegrationController.java b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataIntegrationController.java new file mode 100644 index 00000000..707ccac6 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataIntegrationController.java @@ -0,0 +1,134 @@ +package com.water.data_engine.controller; + +import com.water.common.core.result.R; +import com.water.data_engine.entity.DataLineage; +import com.water.data_engine.entity.SyncTask; +import com.water.data_engine.service.DataIntegrationService; +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.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +/** + * 数据集成控制器 + * DE-04: 多源异构数据整合 + */ +@Tag(name = "数据集成") +@RestController +@RequestMapping("/api/data-engine/integration") +@RequiredArgsConstructor +public class DataIntegrationController { + + private final DataIntegrationService integrationService; + + // ==================== 数据同步 ==================== + + @Operation(summary = "创建同步任务") + @PostMapping("/sync/task") + public R createSyncTask(@RequestBody SyncTask syncTask) { + return R.ok(integrationService.createSyncTask(syncTask)); + } + + @Operation(summary = "执行同步任务") + @PostMapping("/sync/task/{taskId}/execute") + public R executeSyncTask(@PathVariable Long taskId) { + int count = integrationService.executeSyncTask(taskId); + return R.ok("同步完成，处理: " + count + " 条"); + } + + @Operation(summary = "执行全量同步") + @PostMapping("/sync/full") + public R fullSync(@RequestBody Map request) { + Long sourceId = Long.valueOf(request.get("sourceId").toString()); + String sourceTable = (String) request.get("sourceTable"); + String targetTable = (String) request.get("targetTable"); + int count = integrationService.fullSync(sourceId, sourceTable, targetTable); + return R.ok("全量同步完成: " + count + " 条"); + } + + @Operation(summary = "执行增量同步") + @PostMapping("/sync/incremental") + public R incrementalSync(@RequestBody Map request) { + Long sourceId = Long.valueOf(request.get("sourceId").toString()); + String sourceTable = (String) request.get("sourceTable"); + String targetTable = (String) request.get("targetTable"); + String timestampColumn = (String) request.get("timestampColumn"); + LocalDateTime lastSyncTime = LocalDateTime.parse((String) request.get("lastSyncTime")); + int count = integrationService.incrementalSync(sourceId, sourceTable, targetTable, + timestampColumn, lastSyncTime); + return R.ok("增量同步完成: " + count + " 条"); + } + + @Operation(summary = "查询同步任务列表") + @GetMapping("/sync/task/list") + public R> listSyncTasks(@RequestParam(required = false) String status) { + return R.ok(integrationService.listSyncTasks(status)); + } + + @Operation(summary = "获取同步任务详情") + @GetMapping("/sync/task/{id}") + public R getSyncTask(@PathVariable Long id) { + return R.ok(integrationService.getSyncTask(id)); + } + + @Operation(summary = "删除同步任务") + @DeleteMapping("/sync/task/{id}") + public R deleteSyncTask(@PathVariable Long id) { + integrationService.deleteSyncTask(id); + return R.ok("删除成功"); + } + + // ==================== 数据合并与聚合 ==================== + + @Operation(summary = "数据合并(多源整合)") + @PostMapping("/merge") + public R>> mergeData(@RequestBody Map request) { + @SuppressWarnings("unchecked") + List sourceTables = (List) request.get("sourceTables"); + String joinColumn = (String) request.get("joinColumn"); + @SuppressWarnings("unchecked") + List selectColumns = (List) request.get("selectColumns"); + return R.ok(integrationService.mergeData(sourceTables, joinColumn, selectColumns)); + } + + @Operation(summary = "数据聚合(按维度汇总)") + @PostMapping("/aggregate") + public R>> aggregateData(@RequestBody Map request) { + String sourceTable = (String) request.get("sourceTable"); + @SuppressWarnings("unchecked") + List groupByColumns = (List) request.get("groupByColumns"); + @SuppressWarnings("unchecked") + Map aggregations = (Map) request.get("aggregations"); + return R.ok(integrationService.aggregateData(sourceTable, groupByColumns, aggregations)); + } + + // ==================== 数据血缘 ==================== + + @Operation(summary = "创建数据血缘关系") + @PostMapping("/lineage") + public R createLineage(@RequestBody DataLineage lineage) { + return R.ok(integrationService.createLineage(lineage)); + } + + @Operation(summary = "查询血缘关系(上游)") + @GetMapping("/lineage/upstream/{tableName}") + public R> getUpstreamLineage(@PathVariable String tableName) { + return R.ok(integrationService.getUpstreamLineage(tableName)); + } + + @Operation(summary = "查询血缘关系(下游)") + @GetMapping("/lineage/downstream/{tableName}") + public R> getDownstreamLineage(@PathVariable String tableName) { + return R.ok(integrationService.getDownstreamLineage(tableName)); + } + + @Operation(summary = "查询完整血缘链路") + @GetMapping("/lineage/full/{tableName}") + public R> getFullLineage(@PathVariable String tableName) { + return R.ok(integrationService.getFullLineage(tableName)); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/controller/DataStorageController.java b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataStorageController.java new file mode 100644 index 00000000..58cee624 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/controller/DataStorageController.java @@ -0,0 +1,154 @@ +package com.water.data_engine.controller; + +import com.water.common.core.result.R; +import com.water.data_engine.entity.StorageConfig; +import com.water.data_engine.service.DataStorageService; +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 org.springframework.web.multipart.MultipartFile; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +/** + * 数据存储控制器 + * DE-03: TDengine + PostgreSQL + MinIO + */ +@Tag(name = "数据存储") +@RestController +@RequestMapping("/api/data-engine/storage") +@RequiredArgsConstructor +public class DataStorageController { + + private final DataStorageService storageService; + + // ==================== TDengine 时序存储 ==================== + + @Operation(summary = "写入遥测数据到 TDengine") + @PostMapping("/tdengine") + public R writeToTDengine(@RequestBody Map data) { + storageService.writeToTDengine( + (String) data.get("deviceSn"), + (String) data.get("deviceType"), + (String) data.get("area"), + (String) data.get("metricKey"), + ((Number) data.get("value")).doubleValue() + ); + return R.ok("写入成功"); + } + + @Operation(summary = "批量写入遥测数据") + @PostMapping("/tdengine/batch") + public R batchWriteToTDengine(@RequestBody List> dataList) { + int count = storageService.batchWriteToTDengine(dataList); + return R.ok("批量写入成功: " + count + " 条"); + } + + @Operation(summary = "查询遥测数据") + @GetMapping("/tdengine/query") + public R>> queryFromTDengine( + @RequestParam String deviceSn, + @RequestParam String metricKey, + @RequestParam String startTime, + @RequestParam String endTime) { + return R.ok(storageService.queryFromTDengine( + deviceSn, metricKey, + LocalDateTime.parse(startTime), + LocalDateTime.parse(endTime))); + } + + @Operation(summary = "查询聚合数据(小时级)") + @GetMapping("/tdengine/hourly") + public R>> queryHourlyAgg( + @RequestParam String deviceSn, + @RequestParam String metricKey, + @RequestParam String startTime, + @RequestParam String endTime) { + return R.ok(storageService.queryHourlyAgg( + deviceSn, metricKey, + LocalDateTime.parse(startTime), + LocalDateTime.parse(endTime))); + } + + // ==================== PostgreSQL 关系存储 ==================== + + @Operation(summary = "插入数据到 PostgreSQL") + @PostMapping("/postgres/{table}") + public R insertToPostgres(@PathVariable String table, + @RequestBody Map data) { + return R.ok(storageService.insertToPostgres(table, data)); + } + + @Operation(summary = "批量插入数据") + @PostMapping("/postgres/{table}/batch") + public R batchInsertToPostgres(@PathVariable String table, + @RequestBody List> dataList) { + int count = storageService.batchInsertToPostgres(table, dataList); + return R.ok("批量插入成功: " + count + " 条"); + } + + @Operation(summary = "更新数据") + @PutMapping("/postgres/{table}/{id}") + public R updateInPostgres(@PathVariable String table, + @PathVariable Long id, + @RequestBody Map data) { + int count = storageService.updateInPostgres(table, id, data); + return R.ok("更新成功: " + count + " 条"); + } + + @Operation(summary = "查询数据") + @GetMapping("/postgres/{table}") + public R>> queryFromPostgres( + @PathVariable String table, + @RequestParam Map conditions, + @RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size) { + return R.ok(storageService.queryFromPostgres(table, conditions, page, size)); + } + + // ==================== MinIO 对象存储 ==================== + + @Operation(summary = "上传文件到 MinIO") + @PostMapping("/minio/upload") + public R uploadToMinio(@RequestParam("file") MultipartFile file, + @RequestParam(defaultValue = "default") String module) throws Exception { + String objectName = storageService.uploadToMinio(file, module); + return R.ok(objectName); + } + + @Operation(summary = "列出 MinIO 文件") + @GetMapping("/minio/list") + public R> listMinioObjects(@RequestParam(defaultValue = "") String prefix) throws Exception { + return R.ok(storageService.listMinioObjects(prefix)); + } + + // ==================== 存储配置管理 ==================== + + @Operation(summary = "创建存储配置") + @PostMapping("/config") + public R createStorageConfig(@RequestBody StorageConfig config) { + return R.ok(storageService.createStorageConfig(config)); + } + + @Operation(summary = "更新存储配置") + @PutMapping("/config/{id}") + public R updateStorageConfig(@PathVariable Long id, + @RequestBody StorageConfig config) { + return R.ok(storageService.updateStorageConfig(id, config)); + } + + @Operation(summary = "查询存储配置列表") + @GetMapping("/config/list") + public R> listStorageConfigs(@RequestParam(required = false) String storageType) { + return R.ok(storageService.listStorageConfigs(storageType)); + } + + @Operation(summary = "测试存储连接") + @PostMapping("/config/{id}/test") + public R testStorageConnection(@PathVariable Long id) { + return R.ok(storageService.testStorageConnection(id)); + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/CollectRecord.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/CollectRecord.java new file mode 100644 index 00000000..c6e619d1 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/CollectRecord.java @@ -0,0 +1,46 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 数据采集记录实体 + */ +@Data +@TableName("de_collect_record") +public class CollectRecord { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 任务ID */ + private Long taskId; + + /** 数据源ID */ + private Long sourceId; + + /** 数据源类型 */ + private String sourceType; + + /** 数据源Key */ + private String sourceKey; + + /** 原始数据(JSON) */ + @TableField(typeHandler = com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler.class) + private Object rawData; + + /** 处理后数据(JSON) */ + @TableField(typeHandler = com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler.class) + private Object processedData; + + /** 状态: success/failed/skipped */ + private String status; + + /** 错误信息 */ + private String errorMsg; + + /** 采集时间 */ + private LocalDateTime collectTime; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/CollectTask.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/CollectTask.java new file mode 100644 index 00000000..8ae6da78 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/CollectTask.java @@ -0,0 +1,82 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.time.LocalDateTime; + +/** + * 数据采集任务实体 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("de_collect_task") +public class CollectTask extends com.water.common.core.entity.BaseEntity { + + /** + * 任务名称 + */ + private String taskName; + + /** + * 数据源ID + */ + private Long sourceId; + + /** + * 采集类型: realtime/batch/manual + */ + private String collectType; + + /** + * Kafka/MQTT topic + */ + private String topic; + + /** + * 目标表名 + */ + private String targetTable; + + /** + * 转换规则(JSON) + */ + @TableField(typeHandler = com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler.class) + private Object transformRule; + + /** + * 状态: pending/running/paused/completed/failed + */ + private String status; + + /** + * 总记录数 + */ + private Long totalCount; + + /** + * 成功数 + */ + private Long successCount; + + /** + * 失败数 + */ + private Long failCount; + + /** + * 开始时间 + */ + private LocalDateTime startTime; + + /** + * 结束时间 + */ + private LocalDateTime endTime; + + /** + * 错误信息 + */ + private String errorMsg; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/DataLineage.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/DataLineage.java new file mode 100644 index 00000000..91794677 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/DataLineage.java @@ -0,0 +1,41 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 数据血缘关系实体 + */ +@Data +@TableName("de_data_lineage") +public class DataLineage { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 源表 */ + private String sourceTable; + + /** 源列 */ + private String sourceColumn; + + /** 目标表 */ + private String targetTable; + + /** 目标列 */ + private String targetColumn; + + /** 转换类型: direct/mapping/aggregation/calculation */ + private String transformType; + + /** 转换规则 */ + private String transformRule; + + /** 描述 */ + private String description; + + /** 创建时间 */ + private LocalDateTime createdAt; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/DataSource.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/DataSource.java new file mode 100644 index 00000000..96d250d2 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/DataSource.java @@ -0,0 +1,67 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.time.LocalDateTime; + +/** + * 数据源配置实体 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("de_data_source") +public class DataSource extends com.water.common.core.entity.BaseEntity { + + /** + * 数据源名称 + */ + private String sourceName; + + /** + * 数据源编码(唯一) + */ + private String sourceCode; + + /** + * 数据源类型: mqtt/kafka/rest/websocket/database/file + */ + private String sourceType; + + /** + * 数据分类: iot/manual/api/database + */ + private String category; + + /** + * 连接配置(JSON) + */ + @TableField(typeHandler = com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler.class) + private Object connectionConfig; + + /** + * 同步模式: realtime/batch/scheduled + */ + private String syncMode; + + /** + * 定时同步Cron表达式 + */ + private String syncCron; + + /** + * 状态: 0-禁用 1-启用 + */ + private Integer status; + + /** + * 描述 + */ + private String description; + + /** + * 最后同步时间 + */ + private LocalDateTime lastSyncAt; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/QualityRule.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/QualityRule.java new file mode 100644 index 00000000..724f2084 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/QualityRule.java @@ -0,0 +1,38 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import lombok.EqualsAndHashCode; + +/** + * 数据质量规则实体 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("de_quality_rule") +public class QualityRule extends com.water.common.core.entity.BaseEntity { + + /** 规则名称 */ + private String ruleName; + + /** 规则类型: completeness/validity/timeliness/consistency */ + private String ruleType; + + /** 表名 */ + private String tableName; + + /** 列名 */ + private String columnName; + + /** 规则表达式 */ + private String ruleExpr; + + /** 阈值 */ + private java.math.BigDecimal threshold; + + /** 严重级别: info/warning/error */ + private String severity; + + /** 是否启用 */ + private Integer enabled; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/StorageConfig.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/StorageConfig.java new file mode 100644 index 00000000..870b6de6 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/StorageConfig.java @@ -0,0 +1,42 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import lombok.EqualsAndHashCode; + +/** + * 存储配置实体 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("de_storage_config") +public class StorageConfig extends com.water.common.core.entity.BaseEntity { + + /** 存储名称 */ + private String storageName; + + /** 存储类型: tdengine/postgresql/minio */ + private String storageType; + + /** 连接URL */ + private String connectionUrl; + + /** 用户名 */ + private String username; + + /** 密码 */ + private String password; + + /** 数据库名 */ + private String databaseName; + + /** 桶名(MinIO) */ + private String bucketName; + + /** 扩展配置 */ + @TableField(typeHandler = com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler.class) + private Object extraConfig; + + /** 状态 */ + private Integer status; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/entity/SyncTask.java b/wm-data-engine/src/main/java/com/water/data_engine/entity/SyncTask.java new file mode 100644 index 00000000..dcff7858 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/entity/SyncTask.java @@ -0,0 +1,43 @@ +package com.water.data_engine.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.time.LocalDateTime; + +/** + * 数据同步任务实体 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("de_sync_task") +public class SyncTask extends com.water.common.core.entity.BaseEntity { + + /** 任务名称 */ + private String taskName; + + /** 数据源ID */ + private Long sourceId; + + /** 目标存储ID */ + private Long targetStorageId; + + /** 同步类型: full/incremental/cdc */ + private String syncType; + + /** 同步Cron表达式 */ + private String syncCron; + + /** 最后同步时间 */ + private LocalDateTime lastSyncAt; + + /** 最后同步记录数 */ + private Long lastSyncCount; + + /** 状态: pending/running/paused/completed/failed */ + private String status; + + /** 错误信息 */ + private String errorMsg; +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/CollectRecordMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/CollectRecordMapper.java new file mode 100644 index 00000000..a1c39c1d --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/CollectRecordMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.CollectRecord; +import org.apache.ibatis.annotations.Mapper; + +/** + * 采集记录Mapper + */ +@Mapper +public interface CollectRecordMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/CollectTaskMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/CollectTaskMapper.java new file mode 100644 index 00000000..e95e4d37 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/CollectTaskMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.CollectTask; +import org.apache.ibatis.annotations.Mapper; + +/** + * 采集任务Mapper + */ +@Mapper +public interface CollectTaskMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/DataLineageMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/DataLineageMapper.java new file mode 100644 index 00000000..e2850f5e --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/DataLineageMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.DataLineage; +import org.apache.ibatis.annotations.Mapper; + +/** + * 数据血缘Mapper + */ +@Mapper +public interface DataLineageMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/DataSourceMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/DataSourceMapper.java new file mode 100644 index 00000000..94cf8c93 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/DataSourceMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.DataSource; +import org.apache.ibatis.annotations.Mapper; + +/** + * 数据源Mapper + */ +@Mapper +public interface DataSourceMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/QualityRuleMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/QualityRuleMapper.java new file mode 100644 index 00000000..ebf4beae --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/QualityRuleMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.QualityRule; +import org.apache.ibatis.annotations.Mapper; + +/** + * 质量规则Mapper + */ +@Mapper +public interface QualityRuleMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/StorageConfigMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/StorageConfigMapper.java new file mode 100644 index 00000000..7b7e6d92 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/StorageConfigMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.StorageConfig; +import org.apache.ibatis.annotations.Mapper; + +/** + * 存储配置Mapper + */ +@Mapper +public interface StorageConfigMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/mapper/SyncTaskMapper.java b/wm-data-engine/src/main/java/com/water/data_engine/mapper/SyncTaskMapper.java new file mode 100644 index 00000000..4d34b9bb --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/mapper/SyncTaskMapper.java @@ -0,0 +1,12 @@ +package com.water.data_engine.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.data_engine.entity.SyncTask; +import org.apache.ibatis.annotations.Mapper; + +/** + * 同步任务Mapper + */ +@Mapper +public interface SyncTaskMapper extends BaseMapper { +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/service/DataCollectService.java b/wm-data-engine/src/main/java/com/water/data_engine/service/DataCollectService.java new file mode 100644 index 00000000..ef13c838 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/service/DataCollectService.java @@ -0,0 +1,281 @@ +package com.water.data_engine.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.water.data_engine.entity.CollectRecord; +import com.water.data_engine.entity.CollectTask; +import com.water.data_engine.entity.DataSource; +import com.water.data_engine.mapper.CollectRecordMapper; +import com.water.data_engine.mapper.CollectTaskMapper; +import com.water.data_engine.mapper.DataSourceMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.kafka.annotation.KafkaListener; +import org.springframework.kafka.core.KafkaTemplate; +import org.springframework.messaging.simp.SimpMessagingTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.util.*; + +/** + * 数据采集服务 + * DE-01: 实时流(MQTT/Kafka) + 批量采集 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class DataCollectService { + + private final KafkaTemplate kafkaTemplate; + private final JdbcTemplate jdbcTemplate; + private final DataSourceMapper dataSourceMapper; + private final CollectTaskMapper collectTaskMapper; + private final CollectRecordMapper collectRecordMapper; + private final SimpMessagingTemplate wsMessagingTemplate; + private final ObjectMapper mapper = new ObjectMapper(); + + // ==================== 实时流采集 ==================== + + /** + * 实时数据接入：接收各来源数据，统一写入 Kafka + * 支持 MQTT/Kafka 来源的实时流 + */ + public String ingestRealtime(String sourceType, String sourceId, Map rawData) { + try { + Map envelope = buildEnvelope(sourceType, sourceId, rawData); + String json = mapper.writeValueAsString(envelope); + + // 根据来源路由到不同 topic + String topic = routeTopic(sourceType); + kafkaTemplate.send(topic, sourceId, json); + + // 保存采集记录 + saveCollectRecord(null, sourceType, sourceId, rawData, "success", null); + + // 通过 WebSocket 推送实时数据 + wsMessagingTemplate.convertAndSend("/topic/data/realtime/" + sourceType, envelope); + + log.debug("实时数据接入: {} -> {}, topic: {}", sourceType, sourceId, topic); + return topic; + } catch (Exception e) { + log.error("实时数据接入失败: {}", e.getMessage(), e); + saveCollectRecord(null, sourceType, sourceId, rawData, "failed", e.getMessage()); + throw new RuntimeException("数据接入失败: " + e.getMessage()); + } + } + + /** + * Kafka 消费者：处理 IoT 设备遥测数据 + */ + @KafkaListener(topics = "iot.raw.generic", groupId = "wm-data-engine") + public void consumeIotRaw(String message) { + try { + @SuppressWarnings("unchecked") + Map envelope = mapper.readValue(message, Map.class); + @SuppressWarnings("unchecked") + Map data = (Map) envelope.get("data"); + + String deviceSn = (String) data.getOrDefault("deviceSn", "unknown"); + @SuppressWarnings("unchecked") + List> metrics = (List>) data.getOrDefault("metrics", List.of()); + + for (Map metric : metrics) { + String key = (String) metric.get("key"); + Object value = metric.get("value"); + // 写入 TDengine + writeToTDengine(deviceSn, key, value); + } + + log.debug("消费 IoT 数据: device={}, metrics={}", deviceSn, metrics.size()); + } catch (Exception e) { + log.error("消费 IoT 数据失败: {}", e.getMessage()); + } + } + + /** + * Kafka 消费者：处理水质数据 + */ + @KafkaListener(topics = "data.quality", groupId = "wm-data-engine") + public void consumeQualityData(String message) { + try { + @SuppressWarnings("unchecked") + Map envelope = mapper.readValue(message, Map.class); + @SuppressWarnings("unchecked") + Map data = (Map) envelope.get("data"); + + // 写入 PostgreSQL + String sql = """ + INSERT INTO water_quality_record (test_type, test_point, point_type, area, + turbidity, ph, residual_chlorine, is_qualified, created_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, NOW()) + """; + jdbcTemplate.update(sql, + data.get("testType"), + data.get("testPoint"), + data.get("pointType"), + data.get("area"), + data.get("turbidity"), + data.get("ph"), + data.get("residualChlorine"), + data.get("isQualified")); + + log.debug("消费水质数据: point={}", data.get("testPoint")); + } catch (Exception e) { + log.error("消费水质数据失败: {}", e.getMessage()); + } + } + + // ==================== 批量采集 ==================== + + /** + * 批量数据采集 + */ + @Transactional + public int batchIngest(List> batchData) { + int successCount = 0; + for (Map data : batchData) { + try { + String sourceType = (String) data.getOrDefault("sourceType", "batch"); + String sourceId = (String) data.getOrDefault("sourceId", UUID.randomUUID().toString()); + @SuppressWarnings("unchecked") + Map rawData = (Map) data.getOrDefault("data", new HashMap<>()); + ingestRealtime(sourceType, sourceId, rawData); + successCount++; + } catch (Exception e) { + log.warn("批量采集单条失败: {}", e.getMessage()); + } + } + return successCount; + } + + /** + * 创建批量采集任务 + */ + @Transactional + public CollectTask createBatchTask(String taskName, Long sourceId, String targetTable) { + CollectTask task = new CollectTask(); + task.setTaskName(taskName); + task.setSourceId(sourceId); + task.setCollectType("batch"); + task.setTargetTable(targetTable); + task.setStatus("pending"); + task.setTotalCount(0L); + task.setSuccessCount(0L); + task.setFailCount(0L); + collectTaskMapper.insert(task); + return task; + } + + /** + * 执行采集任务 + */ + @Transactional + public void executeTask(Long taskId, List> dataList) { + CollectTask task = collectTaskMapper.selectById(taskId); + if (task == null) { + throw new RuntimeException("任务不存在: " + taskId); + } + + task.setStatus("running"); + task.setStartTime(LocalDateTime.now()); + task.setTotalCount((long) dataList.size()); + collectTaskMapper.updateById(task); + + long success = 0; + long fail = 0; + + for (Map data : dataList) { + try { + String sourceType = (String) data.getOrDefault("sourceType", "batch"); + String sourceId = (String) data.getOrDefault("sourceId", UUID.randomUUID().toString()); + @SuppressWarnings("unchecked") + Map rawData = (Map) data.getOrDefault("data", data); + ingestRealtime(sourceType, sourceId, rawData); + success++; + } catch (Exception e) { + fail++; + log.warn("任务 {} 采集失败: {}", taskId, e.getMessage()); + } + } + + task.setSuccessCount(success); + task.setFailCount(fail); + task.setStatus("completed"); + task.setEndTime(LocalDateTime.now()); + collectTaskMapper.updateById(task); + } + + // ==================== 查询方法 ==================== + + /** + * 查询采集任务列表 + */ + public Page listTasks(int page, int size, String status) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (status != null && !status.isEmpty()) { + wrapper.eq(CollectTask::getStatus, status); + } + wrapper.orderByDesc(CollectTask::getCreatedAt); + return collectTaskMapper.selectPage(new Page<>(page, size), wrapper); + } + + /** + * 查询采集记录 + */ + public Page listRecords(int page, int size, Long taskId) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (taskId != null) { + wrapper.eq(CollectRecord::getTaskId, taskId); + } + wrapper.orderByDesc(CollectRecord::getCollectTime); + return collectRecordMapper.selectPage(new Page<>(page, size), wrapper); + } + + // ==================== 私有方法 ==================== + + private Map buildEnvelope(String sourceType, String sourceId, Map rawData) { + Map envelope = new LinkedHashMap<>(); + envelope.put("sourceType", sourceType); + envelope.put("sourceId", sourceId); + envelope.put("timestamp", Instant.now().toEpochMilli()); + envelope.put("data", rawData); + return envelope; + } + + private String routeTopic(String sourceType) { + return switch (sourceType) { + case "iot", "mqtt" -> "iot.raw.generic"; + case "quality" -> "data.quality"; + case "manual" -> "data.manual"; + case "api" -> "data.api"; + default -> "data.raw"; + }; + } + + private void writeToTDengine(String deviceSn, String metricKey, Object value) { + String sql = "INSERT INTO water_iot.iot_telemetry (ts, device_sn, metric_key, metric_value, quality) VALUES (NOW, ?, ?, ?, 1)"; + jdbcTemplate.update(sql, deviceSn, metricKey, value); + } + + private void saveCollectRecord(Long taskId, String sourceType, String sourceKey, + Map rawData, String status, String errorMsg) { + try { + CollectRecord record = new CollectRecord(); + record.setTaskId(taskId); + record.setSourceType(sourceType); + record.setSourceKey(sourceKey); + record.setRawData(rawData); + record.setStatus(status); + record.setErrorMsg(errorMsg); + record.setCollectTime(LocalDateTime.now()); + collectRecordMapper.insert(record); + } catch (Exception e) { + log.error("保存采集记录失败: {}", e.getMessage()); + } + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/service/DataGovernanceService.java b/wm-data-engine/src/main/java/com/water/data_engine/service/DataGovernanceService.java new file mode 100644 index 00000000..4f4ff74c --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/service/DataGovernanceService.java @@ -0,0 +1,380 @@ +package com.water.data_engine.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.data_engine.entity.QualityRule; +import com.water.data_engine.mapper.QualityRuleMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.time.LocalDateTime; +import java.util.*; +import java.util.stream.Collectors; + +/** + * 数据治理服务 + * 数据标准化、清洗、质量控制 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class DataGovernanceService { + + private final JdbcTemplate jdbcTemplate; + private final QualityRuleMapper qualityRuleMapper; + + // 水利行业标准字段映射 + private static final Map STANDARD_FIELD_MAP = Map.of( + "flow", "LL", // 流量 + "pressure", "YL", // 压力 + "level", "SW", // 水位 + "turbidity", "ZD", // 浊度 + "ph", "PH", // pH值 + "residual_chlorine", "YLJL", // 余氯 + "temperature", "WD", // 温度 + "conductivity", "DD", // 电导率 + "dissolved_oxygen", "RJY", // 溶解氧 + "ammonia", "AD" // 氨氮 + ); + + // 数值型标准字段 + private static final List NUMERIC_FIELDS = List.of( + "LL", "YL", "SW", "ZD", "PH", "YLJL", "WD", "DD", "RJY", "AD" + ); + + // ==================== 数据标准化 ==================== + + /** + * 数据标准化：水利数据对象标准映射 + */ + public Map standardize(Map raw) { + Map std = new LinkedHashMap<>(); + + for (Map.Entry entry : raw.entrySet()) { + String key = entry.getKey(); + Object value = entry.getValue(); + + // 字段名映射 + String standardKey = STANDARD_FIELD_MAP.getOrDefault(key, key); + std.put(standardKey, value); + } + + // 添加标准化标记 + std.put("_standardized", true); + std.put("_standardize_time", LocalDateTime.now().toString()); + + return std; + } + + /** + * 批量标准化 + */ + public List> batchStandardize(List> rawDataList) { + return rawDataList.stream() + .map(this::standardize) + .collect(Collectors.toList()); + } + + // ==================== 数据清洗 ==================== + + /** + * 数据清洗：缺失值填充、异常值检测 + */ + public Map clean(Map data) { + Map cleaned = new LinkedHashMap<>(data); + + // 1. 缺失值处理 + for (String field : NUMERIC_FIELDS) { + Object value = cleaned.get(field); + if (value == null || "".equals(value.toString().trim())) { + cleaned.put(field, -9999.0); + cleaned.put(field + "_flag", "MISSING"); + } + } + + // 2. 异常值检测 + detectAnomalies(cleaned); + + // 3. 数据类型转换 + convertDataTypes(cleaned); + + cleaned.put("_cleaned", true); + cleaned.put("_clean_time", LocalDateTime.now().toString()); + + return cleaned; + } + + /** + * 批量清洗 + */ + public List> batchClean(List> dataList) { + return dataList.stream() + .map(this::clean) + .collect(Collectors.toList()); + } + + // ==================== 数据质量控制 ==================== + + /** + * 数据质量检查 + */ + public Map qualityCheck(Map data) { + Map result = new LinkedHashMap<>(data); + int score = 100; + List issues = new ArrayList<>(); + + // 1. 完整性检查 + for (String field : NUMERIC_FIELDS) { + if (data.containsKey(field + "_flag") && "MISSING".equals(data.get(field + "_flag"))) { + score -= 5; + issues.add(field + "数据缺失"); + } + } + + // 2. 异常值检查 + if (data.containsKey("LL_flag") && "ABNORMAL".equals(data.get("LL_flag"))) { + score -= 15; + issues.add("流量数据异常(负值)"); + } + if (data.containsKey("PH")) { + double ph = ((Number) data.get("PH")).doubleValue(); + if (ph < 0 || ph > 14) { + score -= 10; + issues.add("pH值超出合理范围(0-14)"); + } + } + + // 3. 时效性检查 + if (data.containsKey("_standardize_time")) { + // 检查数据是否过于陈旧 + // 简化处理：假设超过1小时为陈旧数据 + } + + // 4. 一致性检查 + if (data.containsKey("SW") && data.containsKey("YL")) { + // 水位和压力应该有一定的相关性 + // 简化处理 + } + + result.put("_quality_score", Math.max(score, 0)); + result.put("_quality_issues", issues); + result.put("_quality_checked", true); + result.put("_quality_check_time", LocalDateTime.now().toString()); + + return result; + } + + /** + * 批量质量检查 + */ + public List> batchQualityCheck(List> dataList) { + return dataList.stream() + .map(this::qualityCheck) + .collect(Collectors.toList()); + } + + /** + * 执行质量规则检查 + */ + @Transactional + public Map executeQualityRules(String tableName) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(QualityRule::getTableName, tableName); + wrapper.eq(QualityRule::getEnabled, 1); + List rules = qualityRuleMapper.selectList(wrapper); + + Map results = new HashMap<>(); + int totalChecks = rules.size(); + int passedChecks = 0; + + for (QualityRule rule : rules) { + try { + boolean passed = executeSingleRule(rule); + if (passed) { + passedChecks++; + } + results.put(rule.getRuleName(), passed ? "PASS" : "FAIL"); + } catch (Exception e) { + results.put(rule.getRuleName(), "ERROR: " + e.getMessage()); + } + } + + BigDecimal passRate = totalChecks > 0 + ? BigDecimal.valueOf(passedChecks).multiply(BigDecimal.valueOf(100)) + .divide(BigDecimal.valueOf(totalChecks), 2, RoundingMode.HALF_UP) + : BigDecimal.ZERO; + + Map summary = new HashMap<>(); + summary.put("table", tableName); + summary.put("total_rules", totalChecks); + summary.put("passed", passedChecks); + summary.put("failed", totalChecks - passedChecks); + summary.put("pass_rate", passRate); + summary.put("details", results); + summary.put("check_time", LocalDateTime.now()); + + return summary; + } + + // ==================== 数据血缘 ==================== + + /** + * 建立数据血缘关系 + */ + @Transactional + public void buildLineage(Long sourceId, Long targetId, String relation) { + String sql = """ + INSERT INTO de_data_lineage (source_table, source_column, target_table, target_column, + transform_type, description, created_at) + VALUES (?, ?, ?, ?, ?, ?, NOW()) + ON CONFLICT DO NOTHING + """; + jdbcTemplate.update(sql, "iot_telemetry", null, "iot_telemetry_hourly", null, relation, "自动聚合"); + } + + // ==================== 数据管道 ==================== + + /** + * 完整的数据处理管道：标准化 -> 清洗 -> 质控 + */ + public Map pipeline(Map raw) { + Map std = standardize(raw); + Map cleaned = clean(std); + Map result = qualityCheck(cleaned); + return result; + } + + /** + * 批量数据管道 + */ + public List> batchPipeline(List> rawDataList) { + return rawDataList.stream() + .map(this::pipeline) + .collect(Collectors.toList()); + } + + // ==================== 质量规则管理 ==================== + + /** + * 创建质量规则 + */ + @Transactional + public QualityRule createQualityRule(QualityRule rule) { + rule.setEnabled(1); + qualityRuleMapper.insert(rule); + return rule; + } + + /** + * 更新质量规则 + */ + @Transactional + public QualityRule updateQualityRule(Long id, QualityRule rule) { + rule.setId(id); + qualityRuleMapper.updateById(rule); + return qualityRuleMapper.selectById(id); + } + + /** + * 删除质量规则 + */ + @Transactional + public void deleteQualityRule(Long id) { + qualityRuleMapper.deleteById(id); + } + + /** + * 查询质量规则列表 + */ + public List listQualityRules(String tableName, String ruleType) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (tableName != null && !tableName.isEmpty()) { + wrapper.eq(QualityRule::getTableName, tableName); + } + if (ruleType != null && !ruleType.isEmpty()) { + wrapper.eq(QualityRule::getRuleType, ruleType); + } + return qualityRuleMapper.selectList(wrapper); + } + + // ==================== 私有方法 ==================== + + private void detectAnomalies(Map data) { + // 流量异常检测（负值） + if (data.containsKey("LL")) { + double ll = ((Number) data.get("LL")).doubleValue(); + if (ll < 0) { + data.put("LL_flag", "ABNORMAL"); + } + } + + // 压力异常检测（超范围） + if (data.containsKey("YL")) { + double yl = ((Number) data.get("YL")).doubleValue(); + if (yl < 0 || yl > 100) { + data.put("YL_flag", "ABNORMAL"); + } + } + + // 水位异常检测 + if (data.containsKey("SW")) { + double sw = ((Number) data.get("SW")).doubleValue(); + if (sw < -100 || sw > 1000) { + data.put("SW_flag", "ABNORMAL"); + } + } + + // 浊度异常检测 + if (data.containsKey("ZD")) { + double zd = ((Number) data.get("ZD")).doubleValue(); + if (zd < 0 || zd > 1000) { + data.put("ZD_flag", "ABNORMAL"); + } + } + } + + private void convertDataTypes(Map data) { + for (String field : NUMERIC_FIELDS) { + Object value = data.get(field); + if (value instanceof String) { + try { + data.put(field, Double.parseDouble((String) value)); + } catch (NumberFormatException e) { + data.put(field + "_flag", "INVALID_TYPE"); + } + } + } + } + + private boolean executeSingleRule(QualityRule rule) { + // 简化实现：根据规则类型执行不同检查 + return switch (rule.getRuleType()) { + case "completeness" -> checkCompleteness(rule); + case "validity" -> checkValidity(rule); + case "timeliness" -> checkTimeliness(rule); + default -> true; + }; + } + + private boolean checkCompleteness(QualityRule rule) { + String sql = String.format( + "SELECT COUNT(*) FROM %s WHERE %s IS NULL", + rule.getTableName(), rule.getColumnName()); + Integer nullCount = jdbcTemplate.queryForObject(sql, Integer.class); + return nullCount == null || nullCount == 0; + } + + private boolean checkValidity(QualityRule rule) { + // 简化：检查是否有无效值 + return true; + } + + private boolean checkTimeliness(QualityRule rule) { + // 简化：检查数据时效性 + return true; + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/service/DataIngestService.java b/wm-data-engine/src/main/java/com/water/data_engine/service/DataIngestService.java new file mode 100644 index 00000000..420a017b --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/service/DataIngestService.java @@ -0,0 +1,297 @@ +package com.water.data_engine.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.data_engine.entity.DataSource; +import com.water.data_engine.mapper.DataSourceMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.multipart.MultipartFile; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.time.LocalDateTime; +import java.util.*; +import java.util.stream.Collectors; + +/** + * 数据接入服务 + * DE-02: RESTful API / WebSocket / 数据库直连 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class DataIngestService { + + private final DataSourceMapper dataSourceMapper; + private final JdbcTemplate jdbcTemplate; + private final DataCollectService collectService; + + // ==================== RESTful API 接入 ==================== + + /** + * 通过 API 接入单条数据 + */ + @Transactional + public String ingestViaApi(String sourceCode, Map data) { + DataSource source = getSourceByCode(sourceCode); + if (source == null) { + throw new RuntimeException("数据源不存在: " + sourceCode); + } + if (source.getStatus() != 1) { + throw new RuntimeException("数据源已禁用: " + sourceCode); + } + + // 更新最后同步时间 + source.setLastSyncAt(LocalDateTime.now()); + dataSourceMapper.updateById(source); + + return collectService.ingestRealtime(source.getCategory(), sourceCode, data); + } + + /** + * 通过 API 批量接入数据 + */ + @Transactional + public int batchIngestViaApi(String sourceCode, List> dataList) { + DataSource source = getSourceByCode(sourceCode); + if (source == null) { + throw new RuntimeException("数据源不存在: " + sourceCode); + } + + List> wrappedList = dataList.stream() + .map(data -> { + Map wrapped = new HashMap<>(data); + wrapped.put("sourceType", source.getCategory()); + wrapped.put("sourceId", sourceCode); + return wrapped; + }) + .collect(Collectors.toList()); + + return collectService.batchIngest(wrappedList); + } + + // ==================== 数据库直连接入 ==================== + + /** + * 从外部数据库拉取数据 + */ + @Transactional + public int pullFromDatabase(Long sourceId, String sql, String targetTable) { + DataSource source = dataSourceMapper.selectById(sourceId); + if (source == null) { + throw new RuntimeException("数据源不存在: " + sourceId); + } + + try { + // 执行查询 + List> results = jdbcTemplate.queryForList(sql); + int count = 0; + + for (Map row : results) { + try { + collectService.ingestRealtime("database", source.getSourceCode(), row); + count++; + } catch (Exception e) { + log.warn("数据库数据接入失败: {}", e.getMessage()); + } + } + + // 更新同步时间 + source.setLastSyncAt(LocalDateTime.now()); + dataSourceMapper.updateById(source); + + return count; + } catch (Exception e) { + log.error("从数据库拉取数据失败: {}", e.getMessage(), e); + throw new RuntimeException("数据拉取失败: " + e.getMessage()); + } + } + + /** + * 从外部数据库同步到本地表 + */ + @Transactional + public int syncToTable(Long sourceId, String querySql, String targetTable, List columns) { + List> results = jdbcTemplate.queryForList(querySql); + int count = 0; + + for (Map row : results) { + try { + String insertSql = buildInsertSql(targetTable, columns); + Object[] params = columns.stream() + .map(col -> row.get(col)) + .toArray(); + jdbcTemplate.update(insertSql, params); + count++; + } catch (Exception e) { + log.warn("同步到表失败: {}", e.getMessage()); + } + } + + // 更新数据源同步时间 + DataSource source = dataSourceMapper.selectById(sourceId); + if (source != null) { + source.setLastSyncAt(LocalDateTime.now()); + dataSourceMapper.updateById(source); + } + + return count; + } + + // ==================== 文件接入 ==================== + + /** + * 通过文件(CSV)接入数据 + */ + @Transactional + public int ingestFromFile(MultipartFile file, String sourceCode) throws Exception { + DataSource source = getSourceByCode(sourceCode); + if (source == null) { + throw new RuntimeException("数据源不存在: " + sourceCode); + } + + List> dataList = parseCsv(file); + return batchIngestViaApi(sourceCode, dataList); + } + + // ==================== 数据源管理 ==================== + + /** + * 创建数据源 + */ + @Transactional + public DataSource createDataSource(DataSource dataSource) { + // 检查编码唯一性 + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DataSource::getSourceCode, dataSource.getSourceCode()); + if (dataSourceMapper.selectCount(wrapper) > 0) { + throw new RuntimeException("数据源编码已存在: " + dataSource.getSourceCode()); + } + + dataSource.setStatus(1); + dataSourceMapper.insert(dataSource); + return dataSource; + } + + /** + * 更新数据源 + */ + @Transactional + public DataSource updateDataSource(Long id, DataSource dataSource) { + DataSource existing = dataSourceMapper.selectById(id); + if (existing == null) { + throw new RuntimeException("数据源不存在: " + id); + } + + dataSource.setId(id); + dataSourceMapper.updateById(dataSource); + return dataSourceMapper.selectById(id); + } + + /** + * 删除数据源 + */ + @Transactional + public void deleteDataSource(Long id) { + dataSourceMapper.deleteById(id); + } + + /** + * 查询数据源列表 + */ + public List listDataSources(String sourceType) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (sourceType != null && !sourceType.isEmpty()) { + wrapper.eq(DataSource::getSourceType, sourceType); + } + wrapper.orderByDesc(DataSource::getCreatedAt); + return dataSourceMapper.selectList(wrapper); + } + + /** + * 获取数据源详情 + */ + public DataSource getDataSource(Long id) { + return dataSourceMapper.selectById(id); + } + + /** + * 测试数据源连接 + */ + public boolean testConnection(Long id) { + DataSource source = dataSourceMapper.selectById(id); + if (source == null) { + return false; + } + + try { + // 根据数据源类型测试连接 + return switch (source.getSourceType()) { + case "database" -> testDatabaseConnection(source); + case "kafka" -> testKafkaConnection(source); + default -> true; + }; + } catch (Exception e) { + log.error("测试连接失败: {}", e.getMessage()); + return false; + } + } + + // ==================== 私有方法 ==================== + + private DataSource getSourceByCode(String sourceCode) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DataSource::getSourceCode, sourceCode); + return dataSourceMapper.selectOne(wrapper); + } + + private String buildInsertSql(String table, List columns) { + String cols = String.join(", ", columns); + String placeholders = columns.stream() + .map(c -> "?") + .collect(Collectors.joining(", ")); + return String.format("INSERT INTO %s (%s) VALUES (%s)", table, cols, placeholders); + } + + private List> parseCsv(MultipartFile file) throws Exception { + List> result = new ArrayList<>(); + try (BufferedReader reader = new BufferedReader( + new InputStreamReader(file.getInputStream(), StandardCharsets.UTF_8))) { + String headerLine = reader.readLine(); + if (headerLine == null) { + return result; + } + String[] headers = headerLine.split(","); + + String line; + while ((line = reader.readLine()) != null) { + String[] values = line.split(","); + Map row = new LinkedHashMap<>(); + for (int i = 0; i < headers.length && i < values.length; i++) { + row.put(headers[i].trim(), values[i].trim()); + } + result.add(row); + } + } + return result; + } + + private boolean testDatabaseConnection(DataSource source) { + // 简单的连接测试 + try { + jdbcTemplate.queryForObject("SELECT 1", Integer.class); + return true; + } catch (Exception e) { + return false; + } + } + + private boolean testKafkaConnection(DataSource source) { + // Kafka 连接测试（简化） + return true; + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/service/DataIntegrationService.java b/wm-data-engine/src/main/java/com/water/data_engine/service/DataIntegrationService.java new file mode 100644 index 00000000..5203a995 --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/service/DataIntegrationService.java @@ -0,0 +1,249 @@ +package com.water.data_engine.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.data_engine.entity.DataLineage; +import com.water.data_engine.entity.SyncTask; +import com.water.data_engine.mapper.DataLineageMapper; +import com.water.data_engine.mapper.SyncTaskMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.util.*; +import java.util.stream.Collectors; + +/** + * 数据集成服务 + * DE-04: 多源异构数据整合 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class DataIntegrationService { + + private final SyncTaskMapper syncTaskMapper; + private final DataLineageMapper dataLineageMapper; + private final JdbcTemplate jdbcTemplate; + private final DataStorageService storageService; + + // ==================== 数据同步任务 ==================== + + /** + * 创建同步任务 + */ + @Transactional + public SyncTask createSyncTask(SyncTask syncTask) { + syncTask.setStatus("pending"); + syncTaskMapper.insert(syncTask); + return syncTask; + } + + /** + * 执行同步任务 + */ + @Transactional + public int executeSyncTask(Long taskId) { + SyncTask task = syncTaskMapper.selectById(taskId); + if (task == null) { + throw new RuntimeException("同步任务不存在: " + taskId); + } + + task.setStatus("running"); + syncTaskMapper.updateById(task); + + try { + int count = performSync(task); + + task.setStatus("completed"); + task.setLastSyncAt(LocalDateTime.now()); + task.setLastSyncCount((long) count); + task.setErrorMsg(null); + syncTaskMapper.updateById(task); + + return count; + } catch (Exception e) { + task.setStatus("failed"); + task.setErrorMsg(e.getMessage()); + syncTaskMapper.updateById(task); + throw new RuntimeException("同步任务执行失败: " + e.getMessage()); + } + } + + /** + * 执行全量同步 + */ + @Transactional + public int fullSync(Long sourceId, String sourceTable, String targetTable) { + try { + // 查询源表所有数据 + String querySql = "SELECT * FROM " + sourceTable; + List> data = jdbcTemplate.queryForList(querySql); + + // 批量写入目标表 + return storageService.batchInsertToPostgres(targetTable, data); + } catch (Exception e) { + log.error("全量同步失败: {}", e.getMessage(), e); + throw new RuntimeException("同步失败: " + e.getMessage()); + } + } + + /** + * 执行增量同步(基于时间戳) + */ + @Transactional + public int incrementalSync(Long sourceId, String sourceTable, String targetTable, + String timestampColumn, LocalDateTime lastSyncTime) { + try { + String querySql = String.format( + "SELECT * FROM %s WHERE %s > ? ORDER BY %s", + sourceTable, timestampColumn, timestampColumn); + List> data = jdbcTemplate.queryForList(querySql, lastSyncTime); + + return storageService.batchInsertToPostgres(targetTable, data); + } catch (Exception e) { + log.error("增量同步失败: {}", e.getMessage(), e); + throw new RuntimeException("增量同步失败: " + e.getMessage()); + } + } + + /** + * 数据合并(多源整合) + */ + @Transactional + public List> mergeData(List sourceTables, + String joinColumn, + List selectColumns) { + if (sourceTables.isEmpty()) { + return List.of(); + } + + // 构建 UNION ALL 查询 + String columnList = String.join(", ", selectColumns); + String unions = sourceTables.stream() + .map(table -> String.format("SELECT %s FROM %s", columnList, table)) + .collect(Collectors.joining(" UNION ALL ")); + + String sql = String.format("SELECT %s FROM (%s) AS merged ORDER BY %s DESC", + columnList, unions, joinColumn); + + return jdbcTemplate.queryForList(sql); + } + + /** + * 数据聚合(按维度汇总) + */ + public List> aggregateData(String sourceTable, + List groupByColumns, + Map aggregations) { + String groupBy = String.join(", ", groupByColumns); + String aggExpr = aggregations.entrySet().stream() + .map(e -> String.format("%s(%s) AS %s_%s", e.getValue(), e.getKey(), e.getKey(), e.getValue().toLowerCase())) + .collect(Collectors.joining(", ")); + + String sql = String.format( + "SELECT %s, %s FROM %s GROUP BY %s ORDER BY %s", + groupBy, aggExpr, sourceTable, groupBy, groupBy); + + return jdbcTemplate.queryForList(sql); + } + + // ==================== 数据血缘 ==================== + + /** + * 创建数据血缘关系 + */ + @Transactional + public DataLineage createLineage(DataLineage lineage) { + lineage.setCreatedAt(LocalDateTime.now()); + dataLineageMapper.insert(lineage); + return lineage; + } + + /** + * 查询血缘关系(上游) + */ + public List getUpstreamLineage(String tableName) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DataLineage::getTargetTable, tableName); + return dataLineageMapper.selectList(wrapper); + } + + /** + * 查询血缘关系(下游) + */ + public List getDownstreamLineage(String tableName) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DataLineage::getSourceTable, tableName); + return dataLineageMapper.selectList(wrapper); + } + + /** + * 查询完整血缘链路 + */ + public Map getFullLineage(String tableName) { + Map result = new HashMap<>(); + result.put("table", tableName); + result.put("upstream", getUpstreamLineage(tableName)); + result.put("downstream", getDownstreamLineage(tableName)); + return result; + } + + // ==================== 查询方法 ==================== + + /** + * 查询同步任务列表 + */ + public List listSyncTasks(String status) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (status != null && !status.isEmpty()) { + wrapper.eq(SyncTask::getStatus, status); + } + wrapper.orderByDesc(SyncTask::getCreatedAt); + return syncTaskMapper.selectList(wrapper); + } + + /** + * 获取同步任务详情 + */ + public SyncTask getSyncTask(Long id) { + return syncTaskMapper.selectById(id); + } + + /** + * 删除同步任务 + */ + @Transactional + public void deleteSyncTask(Long id) { + syncTaskMapper.deleteById(id); + } + + // ==================== 私有方法 ==================== + + private int performSync(SyncTask task) { + // 根据同步类型执行不同策略 + return switch (task.getSyncType()) { + case "full" -> performFullSync(task); + case "incremental" -> performIncrementalSync(task); + default -> 0; + }; + } + + private int performFullSync(SyncTask task) { + // 简化实现：实际应根据 sourceId 查找数据源配置 + log.info("执行全量同步任务: {}", task.getTaskName()); + return 0; + } + + private int performIncrementalSync(SyncTask task) { + LocalDateTime lastSync = task.getLastSyncAt(); + if (lastSync == null) { + // 首次同步，使用默认起始时间 + lastSync = LocalDateTime.now().minusDays(1); + } + log.info("执行增量同步任务: {}, lastSync: {}", task.getTaskName(), lastSync); + return 0; + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/service/DataStorageService.java b/wm-data-engine/src/main/java/com/water/data_engine/service/DataStorageService.java new file mode 100644 index 00000000..9faa357f --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/service/DataStorageService.java @@ -0,0 +1,345 @@ +package com.water.data_engine.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.data_engine.entity.StorageConfig; +import com.water.data_engine.mapper.StorageConfigMapper; +import io.minio.*; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.multipart.MultipartFile; + +import java.io.InputStream; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.util.*; +import java.util.stream.Collectors; + +/** + * 数据存储管理服务 + * DE-03: TDengine + PostgreSQL + MinIO + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class DataStorageService { + + private final StorageConfigMapper storageConfigMapper; + private final JdbcTemplate jdbcTemplate; + + // ==================== TDengine 时序存储 ==================== + + /** + * 写入遥测数据到 TDengine + */ + public void writeToTDengine(String deviceSn, String deviceType, String area, + String metricKey, Double value) { + try { + // 使用子表方式写入（按设备分表） + String childTable = "device_" + deviceSn.replaceAll("[^a-zA-Z0-9]", "_"); + String createTableSql = String.format( + "CREATE TABLE IF NOT EXISTS water_iot.%s USING water_iot.iot_telemetry TAGS('%s', '%s', '%s')", + childTable, deviceType, area, deviceSn); + jdbcTemplate.update(createTableSql); + + String insertSql = String.format( + "INSERT INTO water_iot.%s (ts, device_sn, metric_key, metric_value, quality) VALUES (NOW, '%s', '%s', %f, 1)", + childTable, deviceSn, metricKey, value); + jdbcTemplate.update(insertSql); + } catch (Exception e) { + log.error("写入 TDengine 失败: {}", e.getMessage()); + } + } + + /** + * 批量写入遥测数据 + */ + @Transactional + public int batchWriteToTDengine(List> dataList) { + int count = 0; + for (Map data : dataList) { + try { + writeToTDengine( + (String) data.get("deviceSn"), + (String) data.get("deviceType"), + (String) data.get("area"), + (String) data.get("metricKey"), + ((Number) data.get("value")).doubleValue() + ); + count++; + } catch (Exception e) { + log.warn("批量写入单条失败: {}", e.getMessage()); + } + } + return count; + } + + /** + * 从 TDengine 查询遥测数据 + */ + public List> queryFromTDengine(String deviceSn, String metricKey, + LocalDateTime startTime, LocalDateTime endTime) { + try { + String sql = """ + SELECT ts, device_sn, metric_key, metric_value, quality + FROM water_iot.iot_telemetry + WHERE device_sn = ? AND metric_key = ? + AND ts >= ? AND ts <= ? + ORDER BY ts DESC + """; + return jdbcTemplate.queryForList(sql, deviceSn, metricKey, startTime, endTime); + } catch (Exception e) { + log.error("查询 TDengine 失败: {}", e.getMessage()); + return List.of(); + } + } + + /** + * 查询聚合数据(小时级) + */ + public List> queryHourlyAgg(String deviceSn, String metricKey, + LocalDateTime startTime, LocalDateTime endTime) { + try { + String sql = """ + SELECT _wstart as ts, device_sn, metric_key, + MIN(metric_value) as min_val, MAX(metric_value) as max_val, + AVG(metric_value) as avg_val, COUNT(*) as cnt + FROM water_iot.iot_telemetry + WHERE device_sn = ? AND metric_key = ? + AND ts >= ? AND ts <= ? + INTERVAL(1h) + """; + return jdbcTemplate.queryForList(sql, deviceSn, metricKey, startTime, endTime); + } catch (Exception e) { + log.error("查询聚合数据失败: {}", e.getMessage()); + return List.of(); + } + } + + // ==================== PostgreSQL 关系存储 ==================== + + /** + * 通用数据插入(PostgreSQL) + */ + @Transactional + public Long insertToPostgres(String table, Map data) { + List columns = new ArrayList<>(data.keySet()); + String cols = String.join(", ", columns); + String placeholders = columns.stream().map(c -> "?").collect(Collectors.joining(", ")); + String sql = String.format("INSERT INTO %s (%s) VALUES (%s) RETURNING id", table, cols, placeholders); + + Object[] params = columns.stream().map(data::get).toArray(); + return jdbcTemplate.queryForObject(sql, Long.class, params); + } + + /** + * 批量插入(PostgreSQL) + */ + @Transactional + public int batchInsertToPostgres(String table, List> dataList) { + if (dataList.isEmpty()) { + return 0; + } + + int count = 0; + for (Map data : dataList) { + try { + insertToPostgres(table, data); + count++; + } catch (Exception e) { + log.warn("批量插入单条失败: {}", e.getMessage()); + } + } + return count; + } + + /** + * 更新数据(PostgreSQL) + */ + @Transactional + public int updateInPostgres(String table, Long id, Map data) { + List setClauses = new ArrayList<>(); + List params = new ArrayList<>(); + + for (Map.Entry entry : data.entrySet()) { + setClauses.add(entry.getKey() + " = ?"); + params.add(entry.getValue()); + } + params.add(id); + + String sql = String.format("UPDATE %s SET %s WHERE id = ?", table, String.join(", ", setClauses)); + return jdbcTemplate.update(sql, params.toArray()); + } + + /** + * 查询数据(PostgreSQL) + */ + public List> queryFromPostgres(String table, Map conditions, + int page, int size) { + StringBuilder sql = new StringBuilder("SELECT * FROM ").append(table).append(" WHERE 1=1"); + List params = new ArrayList<>(); + + for (Map.Entry entry : conditions.entrySet()) { + sql.append(" AND ").append(entry.getKey()).append(" = ?"); + params.add(entry.getValue()); + } + + sql.append(" ORDER BY id DESC LIMIT ? OFFSET ?"); + params.add(size); + params.add((page - 1) * size); + + return jdbcTemplate.queryForList(sql.toString(), params.toArray()); + } + + // ==================== MinIO 对象存储 ==================== + + /** + * 上传文件到 MinIO + */ + public String uploadToMinio(MultipartFile file, String module) throws Exception { + MinioClient client = getMinioClient(); + String bucket = "water-management"; + String objectName = module + "/" + LocalDate.now() + "/" + + UUID.randomUUID() + "_" + file.getOriginalFilename(); + + // 确保桶存在 + if (!client.bucketExists(BucketExistsArgs.builder().bucket(bucket).build())) { + client.makeBucket(MakeBucketArgs.builder().bucket(bucket).build()); + } + + client.putObject(PutObjectArgs.builder() + .bucket(bucket) + .object(objectName) + .stream(file.getInputStream(), file.getSize(), -1) + .contentType(file.getContentType()) + .build()); + + return objectName; + } + + /** + * 从 MinIO 下载文件 + */ + public InputStream downloadFromMinio(String objectName) throws Exception { + MinioClient client = getMinioClient(); + return client.getObject(GetObjectArgs.builder() + .bucket("water-management") + .object(objectName) + .build()); + } + + /** + * 列出 MinIO 文件 + */ + public List listMinioObjects(String prefix) throws Exception { + MinioClient client = getMinioClient(); + List objects = new ArrayList<>(); + + Iterable> results = client.listObjects(ListObjectsArgs.builder() + .bucket("water-management") + .prefix(prefix) + .build()); + + for (Result result : results) { + objects.add(result.get().objectName()); + } + + return objects; + } + + // ==================== 存储配置管理 ==================== + + /** + * 创建存储配置 + */ + @Transactional + public StorageConfig createStorageConfig(StorageConfig config) { + config.setStatus(1); + storageConfigMapper.insert(config); + return config; + } + + /** + * 更新存储配置 + */ + @Transactional + public StorageConfig updateStorageConfig(Long id, StorageConfig config) { + config.setId(id); + storageConfigMapper.updateById(config); + return storageConfigMapper.selectById(id); + } + + /** + * 查询存储配置列表 + */ + public List listStorageConfigs(String storageType) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (storageType != null && !storageType.isEmpty()) { + wrapper.eq(StorageConfig::getStorageType, storageType); + } + return storageConfigMapper.selectList(wrapper); + } + + /** + * 测试存储连接 + */ + public boolean testStorageConnection(Long id) { + StorageConfig config = storageConfigMapper.selectById(id); + if (config == null) { + return false; + } + + try { + return switch (config.getStorageType()) { + case "postgresql" -> testPostgresConnection(config); + case "tdengine" -> testTDengineConnection(config); + case "minio" -> testMinioConnection(config); + default -> false; + }; + } catch (Exception e) { + log.error("测试存储连接失败: {}", e.getMessage()); + return false; + } + } + + // ==================== 私有方法 ==================== + + private MinioClient getMinioClient() { + return MinioClient.builder() + .endpoint(System.getenv().getOrDefault("MINIO_ENDPOINT", "http://127.0.0.1:9000")) + .credentials( + System.getenv().getOrDefault("MINIO_ACCESS_KEY", "minioadmin"), + System.getenv().getOrDefault("MINIO_SECRET_KEY", "minioadmin")) + .build(); + } + + private boolean testPostgresConnection(StorageConfig config) { + try { + jdbcTemplate.queryForObject("SELECT 1", Integer.class); + return true; + } catch (Exception e) { + return false; + } + } + + private boolean testTDengineConnection(StorageConfig config) { + try { + jdbcTemplate.queryForObject("SELECT server_version()", String.class); + return true; + } catch (Exception e) { + return false; + } + } + + private boolean testMinioConnection(StorageConfig config) { + try { + MinioClient client = getMinioClient(); + client.bucketExists(BucketExistsArgs.builder().bucket("water-management").build()); + return true; + } catch (Exception e) { + return false; + } + } +} diff --git a/wm-data-engine/src/main/java/com/water/data_engine/websocket/DataWebSocketController.java b/wm-data-engine/src/main/java/com/water/data_engine/websocket/DataWebSocketController.java new file mode 100644 index 00000000..36750a5f --- /dev/null +++ b/wm-data-engine/src/main/java/com/water/data_engine/websocket/DataWebSocketController.java @@ -0,0 +1,83 @@ +package com.water.data_engine.websocket; + +import com.water.data_engine.service.DataCollectService; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.messaging.handler.annotation.MessageMapping; +import org.springframework.messaging.handler.annotation.SendTo; +import org.springframework.messaging.simp.SimpMessagingTemplate; +import org.springframework.stereotype.Controller; + +import java.time.LocalDateTime; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * WebSocket 数据推送控制器 + * 用于实时数据推送到前端 + */ +@Slf4j +@Controller +@RequiredArgsConstructor +public class DataWebSocketController { + + private final SimpMessagingTemplate messagingTemplate; + private final DataCollectService collectService; + + /** + * 接收客户端订阅请求 + */ + @MessageMapping("/subscribe/data") + @SendTo("/topic/data/realtime") + public Map subscribeRealtimeData(Map request) { + Map response = new LinkedHashMap<>(); + response.put("status", "subscribed"); + response.put("timestamp", LocalDateTime.now().toString()); + response.put("message", "已订阅实时数据推送"); + return response; + } + + /** + * 接收客户端发送的控制指令 + */ + @MessageMapping("/control/pause") + @SendTo("/topic/data/control") + public Map pauseDataPush(Map request) { + Map response = new LinkedHashMap<>(); + response.put("action", "pause"); + response.put("status", "success"); + response.put("timestamp", LocalDateTime.now().toString()); + return response; + } + + @MessageMapping("/control/resume") + @SendTo("/topic/data/control") + public Map resumeDataPush(Map request) { + Map response = new LinkedHashMap<>(); + response.put("action", "resume"); + response.put("status", "success"); + response.put("timestamp", LocalDateTime.now().toString()); + return response; + } + + /** + * 主动推送数据到指定 topic + */ + public void pushRealtimeData(String sourceType, Map data) { + messagingTemplate.convertAndSend("/topic/data/realtime/" + sourceType, data); + } + + /** + * 推送告警数据 + */ + public void pushAlertData(Map alert) { + messagingTemplate.convertAndSend("/topic/data/alert", alert); + } + + /** + * 推送统计数据 + */ + public void pushStatistics(Map stats) { + messagingTemplate.convertAndSend("/topic/data/statistics", stats); + } +} diff --git a/wm-data-engine/src/main/resources/application.yml b/wm-data-engine/src/main/resources/application.yml index 26f88b2b..b9df83f0 100644 --- a/wm-data-engine/src/main/resources/application.yml +++ b/wm-data-engine/src/main/resources/application.yml @@ -8,10 +8,44 @@ spring: url: jdbc:postgresql://${PG_HOST:127.0.0.1}:5432/water_management username: ${PG_USER:water} password: ${PG_PASS:water123} + driver-class-name: org.postgresql.Driver cloud: nacos: discovery: server-addr: ${NACOS_HOST:127.0.0.1}:8848 + kafka: + bootstrap-servers: ${KAFKA_SERVERS:127.0.0.1}:9092 + consumer: + group-id: wm-data-engine + auto-offset-reset: latest + producer: + key-serializer: org.apache.kafka.common.serialization.StringSerializer + value-serializer: org.apache.kafka.common.serialization.StringSerializer + servlet: + multipart: + max-file-size: 100MB + max-request-size: 100MB mybatis-plus: mapper-locations: classpath*:/mapper/**/*.xml + configuration: + map-underscore-to-camel-case: true + log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl + global-config: + db-config: + logic-delete-field: deleted + logic-delete-value: 1 + logic-not-delete-value: 0 + +# MinIO 配置 +minio: + endpoint: ${MINIO_ENDPOINT:http://127.0.0.1:9000} + access-key: ${MINIO_ACCESS_KEY:minioadmin} + secret-key: ${MINIO_SECRET_KEY:minioadmin} + bucket: water-management + +# 日志配置 +logging: + level: + com.water.data_engine: DEBUG + com.baomidou.mybatisplus: DEBUG diff --git a/wm-data-engine/src/main/resources/db/V1__data_engine.sql b/wm-data-engine/src/main/resources/db/V1__data_engine.sql new file mode 100644 index 00000000..b700afb7 --- /dev/null +++ b/wm-data-engine/src/main/resources/db/V1__data_engine.sql @@ -0,0 +1,217 @@ +-- ============================================= +-- 智慧水务管理系统 - 数据引擎 DDL +-- 版本: V1 +-- 描述: 数据汇聚引擎相关表 +-- ============================================= + +-- ==================== 数据源管理 ==================== + +-- 数据源配置表 +CREATE TABLE IF NOT EXISTS de_data_source ( + id BIGSERIAL PRIMARY KEY, + source_name VARCHAR(100) NOT NULL, + source_code VARCHAR(50) UNIQUE NOT NULL, + source_type VARCHAR(30) NOT NULL, -- mqtt/kafka/rest/websocket/database/file + category VARCHAR(30), -- iot/manual/api/database + connection_config JSONB, -- 连接配置(JSON) + sync_mode VARCHAR(20) DEFAULT 'realtime', -- realtime/batch/scheduled + sync_cron VARCHAR(50), -- 定时同步Cron表达式 + status SMALLINT DEFAULT 1, -- 0:禁用 1:启用 + description VARCHAR(500), + last_sync_at TIMESTAMP, + deleted SMALLINT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_data_source IS '数据源配置表'; +COMMENT ON COLUMN de_data_source.source_type IS '数据源类型: mqtt/kafka/rest/websocket/database/file'; +COMMENT ON COLUMN de_data_source.sync_mode IS '同步模式: realtime/batch/scheduled'; + +CREATE INDEX IF NOT EXISTS idx_de_data_source_type ON de_data_source(source_type); +CREATE INDEX IF NOT EXISTS idx_de_data_source_status ON de_data_source(status); + +-- ==================== 数据采集 ==================== + +-- 数据采集任务表 +CREATE TABLE IF NOT EXISTS de_collect_task ( + id BIGSERIAL PRIMARY KEY, + task_name VARCHAR(100) NOT NULL, + source_id BIGINT REFERENCES de_data_source(id), + collect_type VARCHAR(30) NOT NULL, -- realtime/batch/manual + topic VARCHAR(100), -- Kafka/MQTT topic + target_table VARCHAR(100), -- 目标表名 + transform_rule JSONB, -- 转换规则 + status VARCHAR(20) DEFAULT 'pending', -- pending/running/paused/completed/failed + total_count BIGINT DEFAULT 0, + success_count BIGINT DEFAULT 0, + fail_count BIGINT DEFAULT 0, + start_time TIMESTAMP, + end_time TIMESTAMP, + error_msg TEXT, + deleted SMALLINT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_collect_task IS '数据采集任务表'; +CREATE INDEX IF NOT EXISTS idx_de_collect_task_status ON de_collect_task(status); +CREATE INDEX IF NOT EXISTS idx_de_collect_task_source ON de_collect_task(source_id); + +-- 数据采集记录表 +CREATE TABLE IF NOT EXISTS de_collect_record ( + id BIGSERIAL PRIMARY KEY, + task_id BIGINT REFERENCES de_collect_task(id), + source_id BIGINT REFERENCES de_data_source(id), + source_type VARCHAR(30), + source_key VARCHAR(100), + raw_data JSONB, + processed_data JSONB, + status VARCHAR(20) DEFAULT 'success', -- success/failed/skipped + error_msg VARCHAR(500), + collect_time TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_collect_record IS '数据采集记录表'; +CREATE INDEX IF NOT EXISTS idx_de_collect_record_time ON de_collect_record(collect_time DESC); +CREATE INDEX IF NOT EXISTS idx_de_collect_record_task ON de_collect_record(task_id); + +-- ==================== 数据接入 ==================== + +-- API接入配置表 +CREATE TABLE IF NOT EXISTS de_api_config ( + id BIGSERIAL PRIMARY KEY, + api_name VARCHAR(100) NOT NULL, + api_path VARCHAR(200) UNIQUE NOT NULL, + method VARCHAR(10) DEFAULT 'POST', -- GET/POST/PUT + source_id BIGINT REFERENCES de_data_source(id), + request_schema JSONB, -- 请求Schema定义 + response_schema JSONB, -- 响应Schema定义 + auth_type VARCHAR(20) DEFAULT 'none', -- none/token/api_key/basic + rate_limit INT DEFAULT 100, -- 限流(次/分钟) + status SMALLINT DEFAULT 1, + deleted SMALLINT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_api_config IS 'API接入配置表'; + +-- ==================== 数据存储 ==================== + +-- 存储配置表 +CREATE TABLE IF NOT EXISTS de_storage_config ( + id BIGSERIAL PRIMARY KEY, + storage_name VARCHAR(100) NOT NULL, + storage_type VARCHAR(30) NOT NULL, -- tdengine/postgresql/minio + connection_url VARCHAR(500), + username VARCHAR(100), + password VARCHAR(255), + database_name VARCHAR(100), + bucket_name VARCHAR(100), + extra_config JSONB, + status SMALLINT DEFAULT 1, + deleted SMALLINT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_storage_config IS '存储配置表'; + +-- 存储路由规则表（哪类数据存到哪） +CREATE TABLE IF NOT EXISTS de_storage_route ( + id BIGSERIAL PRIMARY KEY, + source_type VARCHAR(30) NOT NULL, + data_category VARCHAR(50), -- telemetry/quality/billing/document + storage_id BIGINT REFERENCES de_storage_config(id), + target_table VARCHAR(100), + partition_rule VARCHAR(200), -- 分区规则 + retention_days INT DEFAULT 365, + status SMALLINT DEFAULT 1, + created_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_storage_route IS '存储路由规则表'; + +-- ==================== 数据集成 ==================== + +-- 数据同步任务表 +CREATE TABLE IF NOT EXISTS de_sync_task ( + id BIGSERIAL PRIMARY KEY, + task_name VARCHAR(100) NOT NULL, + source_id BIGINT REFERENCES de_data_source(id), + target_storage_id BIGINT REFERENCES de_storage_config(id), + sync_type VARCHAR(30) NOT NULL, -- full/incremental/cdc + sync_cron VARCHAR(50), + last_sync_at TIMESTAMP, + last_sync_count BIGINT, + status VARCHAR(20) DEFAULT 'pending', -- pending/running/paused/completed/failed + error_msg TEXT, + deleted SMALLINT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_sync_task IS '数据同步任务表'; +CREATE INDEX IF NOT EXISTS idx_de_sync_task_status ON de_sync_task(status); + +-- ==================== 数据质量 ==================== + +-- 数据质量规则表 +CREATE TABLE IF NOT EXISTS de_quality_rule ( + id BIGSERIAL PRIMARY KEY, + rule_name VARCHAR(100) NOT NULL, + rule_type VARCHAR(30) NOT NULL, -- completeness/validity/timeliness/consistency + table_name VARCHAR(100), + column_name VARCHAR(100), + rule_expr VARCHAR(500), -- 规则表达式 + threshold DECIMAL(5,2), -- 阈值 + severity VARCHAR(20) DEFAULT 'warning', -- info/warning/error + enabled SMALLINT DEFAULT 1, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_quality_rule IS '数据质量规则表'; + +-- 数据质量检查记录表 +CREATE TABLE IF NOT EXISTS de_quality_check ( + id BIGSERIAL PRIMARY KEY, + rule_id BIGINT REFERENCES de_quality_rule(id), + check_time TIMESTAMP DEFAULT NOW(), + total_count BIGINT, + pass_count BIGINT, + fail_count BIGINT, + pass_rate DECIMAL(5,2), + result_detail JSONB, + status VARCHAR(20) DEFAULT 'success' -- success/failed +); +COMMENT ON TABLE de_quality_check IS '数据质量检查记录表'; +CREATE INDEX IF NOT EXISTS idx_de_quality_check_time ON de_quality_check(check_time DESC); + +-- ==================== 数据血缘 ==================== + +-- 数据血缘关系表 +CREATE TABLE IF NOT EXISTS de_data_lineage ( + id BIGSERIAL PRIMARY KEY, + source_table VARCHAR(100) NOT NULL, + source_column VARCHAR(100), + target_table VARCHAR(100) NOT NULL, + target_column VARCHAR(100), + transform_type VARCHAR(30), -- direct/mapping/aggregation/calculation + transform_rule TEXT, + description VARCHAR(500), + created_at TIMESTAMP DEFAULT NOW() +); +COMMENT ON TABLE de_data_lineage IS '数据血缘关系表'; +CREATE INDEX IF NOT EXISTS idx_de_lineage_source ON de_data_lineage(source_table); +CREATE INDEX IF NOT EXISTS idx_de_lineage_target ON de_data_lineage(target_table); + +-- ==================== 数据引擎统计 ==================== + +-- 数据统计仪表板 +CREATE TABLE IF NOT EXISTS de_stat_daily ( + id BIGSERIAL PRIMARY KEY, + stat_date DATE NOT NULL, + source_id BIGINT, + collect_count BIGINT DEFAULT 0, + store_count BIGINT DEFAULT 0, + quality_score DECIMAL(5,2), + sync_count BIGINT DEFAULT 0, + error_count BIGINT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + UNIQUE(stat_date, source_id) +); +COMMENT ON TABLE de_stat_daily IS '日统计数据表'; diff --git a/wm-data-engine/src/test/java/com/water/data_engine/service/DataCollectServiceTest.java b/wm-data-engine/src/test/java/com/water/data_engine/service/DataCollectServiceTest.java new file mode 100644 index 00000000..368f5e72 --- /dev/null +++ b/wm-data-engine/src/test/java/com/water/data_engine/service/DataCollectServiceTest.java @@ -0,0 +1,128 @@ +package com.water.data_engine.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.kafka.core.KafkaTemplate; +import org.springframework.messaging.simp.SimpMessagingTemplate; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * 数据采集服务测试 + */ +@ExtendWith(MockitoExtension.class) +class DataCollectServiceTest { + + @Mock + private KafkaTemplate kafkaTemplate; + + @Mock + private JdbcTemplate jdbcTemplate; + + @Mock + private com.water.data_engine.mapper.DataSourceMapper dataSourceMapper; + + @Mock + private com.water.data_engine.mapper.CollectTaskMapper collectTaskMapper; + + @Mock + private com.water.data_engine.mapper.CollectRecordMapper collectRecordMapper; + + @Mock + private SimpMessagingTemplate wsMessagingTemplate; + + private DataCollectService collectService; + + @BeforeEach + void setUp() { + collectService = new DataCollectService( + kafkaTemplate, jdbcTemplate, dataSourceMapper, + collectTaskMapper, collectRecordMapper, wsMessagingTemplate + ); + } + + @Test + @DisplayName("实时数据接入-IoT设备数据") + void testIngestRealtime_IoT() { + // Given + Map data = new HashMap<>(); + data.put("deviceSn", "FM001"); + data.put("metrics", List.of( + Map.of("key", "LL", "value", 12.5), + Map.of("key", "YL", "value", 0.35) + )); + + // When + String topic = collectService.ingestRealtime("iot", "FM001", data); + + // Then + assertEquals("iot.raw.generic", topic); + verify(kafkaTemplate).send(eq("iot.raw.generic"), eq("FM001"), anyString()); + verify(wsMessagingTemplate).convertAndSend(eq("/topic/data/realtime/iot"), any()); + } + + @Test + @DisplayName("实时数据接入-水质数据") + void testIngestRealtime_Quality() { + Map data = new HashMap<>(); + data.put("testPoint", "水厂出口"); + data.put("turbidity", 0.5); + data.put("ph", 7.2); + + String topic = collectService.ingestRealtime("quality", "WQ001", data); + + assertEquals("data.quality", topic); + verify(kafkaTemplate).send(eq("data.quality"), eq("WQ001"), anyString()); + } + + @Test + @DisplayName("批量数据采集") + void testBatchIngest() { + List> batchData = List.of( + Map.of("sourceType", "iot", "sourceId", "FM001", "data", Map.of("LL", 12.5)), + Map.of("sourceType", "iot", "sourceId", "FM002", "data", Map.of("LL", 15.3)), + Map.of("sourceType", "manual", "sourceId", "MAN001", "data", Map.of("SW", 100.0)) + ); + + int count = collectService.batchIngest(batchData); + + assertEquals(3, count); + verify(kafkaTemplate, times(3)).send(anyString(), anyString(), anyString()); + } + + @Test + @DisplayName("创建批量采集任务") + void testCreateBatchTask() { + com.water.data_engine.entity.CollectTask task = collectService.createBatchTask( + "测试批量任务", 1L, "iot_telemetry"); + + assertNotNull(task); + assertEquals("测试批量任务", task.getTaskName()); + assertEquals("batch", task.getCollectType()); + assertEquals("pending", task.getStatus()); + verify(collectTaskMapper).insert(any(com.water.data_engine.entity.CollectTask.class)); + } + + @Test + @DisplayName("Topic路由测试") + void testRouteTopic() { + // 测试不同数据源类型的topic路由 + assertDoesNotThrow(() -> collectService.ingestRealtime("iot", "test", Map.of())); + assertDoesNotThrow(() -> collectService.ingestRealtime("mqtt", "test", Map.of())); + assertDoesNotThrow(() -> collectService.ingestRealtime("quality", "test", Map.of())); + assertDoesNotThrow(() -> collectService.ingestRealtime("manual", "test", Map.of())); + assertDoesNotThrow(() -> collectService.ingestRealtime("api", "test", Map.of())); + assertDoesNotThrow(() -> collectService.ingestRealtime("unknown", "test", Map.of())); + } +} diff --git a/wm-data-engine/src/test/java/com/water/data_engine/service/DataGovernanceServiceTest.java b/wm-data-engine/src/test/java/com/water/data_engine/service/DataGovernanceServiceTest.java new file mode 100644 index 00000000..330fce61 --- /dev/null +++ b/wm-data-engine/src/test/java/com/water/data_engine/service/DataGovernanceServiceTest.java @@ -0,0 +1,183 @@ +package com.water.data_engine.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * 数据治理服务测试 + */ +@ExtendWith(MockitoExtension.class) +class DataGovernanceServiceTest { + + @Mock + private JdbcTemplate jdbcTemplate; + + @Mock + private com.water.data_engine.mapper.QualityRuleMapper qualityRuleMapper; + + private DataGovernanceService governanceService; + + @BeforeEach + void setUp() { + governanceService = new DataGovernanceService(jdbcTemplate, qualityRuleMapper); + } + + @Test + @DisplayName("数据标准化-字段映射") + void testStandardize() { + Map raw = new HashMap<>(); + raw.put("flow", 12.5); + raw.put("pressure", 0.35); + raw.put("level", 100.0); + raw.put("turbidity", 0.5); + raw.put("ph", 7.2); + raw.put("custom_field", "test"); + + Map result = governanceService.standardize(raw); + + // 验证字段映射 + assertEquals(12.5, result.get("LL")); + assertEquals(0.35, result.get("YL")); + assertEquals(100.0, result.get("SW")); + assertEquals(0.5, result.get("ZD")); + assertEquals(7.2, result.get("PH")); + assertEquals("test", result.get("custom_field")); + assertEquals(true, result.get("_standardized")); + } + + @Test + @DisplayName("数据标准化-批量处理") + void testBatchStandardize() { + List> rawDataList = List.of( + Map.of("flow", 12.5, "pressure", 0.35), + Map.of("level", 100.0, "turbidity", 0.5) + ); + + List> result = governanceService.batchStandardize(rawDataList); + + assertEquals(2, result.size()); + assertEquals(12.5, result.get(0).get("LL")); + assertEquals(100.0, result.get(1).get("SW")); + } + + @Test + @DisplayName("数据清洗-缺失值处理") + void testClean_MissingValues() { + Map data = new HashMap<>(); + data.put("LL", null); + data.put("YL", ""); + data.put("SW", 100.0); + + Map result = governanceService.clean(data); + + assertEquals(-9999.0, result.get("LL")); + assertEquals("MISSING", result.get("LL_flag")); + assertEquals(-9999.0, result.get("YL")); + assertEquals("MISSING", result.get("YL_flag")); + assertEquals(100.0, result.get("SW")); + assertEquals(true, result.get("_cleaned")); + } + + @Test + @DisplayName("数据清洗-异常值检测") + void testClean_AnomalyDetection() { + Map data = new HashMap<>(); + data.put("LL", -5.0); // 流量为负值 + data.put("YL", 150.0); // 压力超范围 + data.put("ZD", -10.0); // 浊度为负值 + + Map result = governanceService.clean(data); + + assertEquals("ABNORMAL", result.get("LL_flag")); + assertEquals("ABNORMAL", result.get("YL_flag")); + assertEquals("ABNORMAL", result.get("ZD_flag")); + } + + @Test + @DisplayName("数据质量检查-完整性") + void testQualityCheck_Completeness() { + Map data = new HashMap<>(); + data.put("LL", 12.5); + data.put("LL_flag", "MISSING"); + + Map result = governanceService.qualityCheck(data); + + assertTrue((int) result.get("_quality_score") < 100); + @SuppressWarnings("unchecked") + List issues = (List) result.get("_quality_issues"); + assertTrue(issues.stream().anyMatch(i -> i.contains("流量数据缺失"))); + } + + @Test + @DisplayName("数据质量检查-异常值") + void testQualityCheck_Anomaly() { + Map data = new HashMap<>(); + data.put("LL", -5.0); + data.put("LL_flag", "ABNORMAL"); + + Map result = governanceService.qualityCheck(data); + + assertTrue((int) result.get("_quality_score") < 100); + @SuppressWarnings("unchecked") + List issues = (List) result.get("_quality_issues"); + assertTrue(issues.stream().anyMatch(i -> i.contains("流量数据异常"))); + } + + @Test + @DisplayName("完整数据管道") + void testPipeline() { + Map raw = new HashMap<>(); + raw.put("flow", 12.5); + raw.put("pressure", 0.35); + + Map result = governanceService.pipeline(raw); + + // 验证经过标准化 + assertEquals(12.5, result.get("LL")); + assertEquals(0.35, result.get("YL")); + // 验证经过清洗 + assertEquals(true, result.get("_cleaned")); + // 验证经过质控 + assertEquals(true, result.get("_quality_checked")); + assertNotNull(result.get("_quality_score")); + } + + @Test + @DisplayName("批量数据管道") + void testBatchPipeline() { + List> rawDataList = List.of( + Map.of("flow", 12.5, "pressure", 0.35), + Map.of("level", 100.0, "turbidity", 0.5) + ); + + List> result = governanceService.batchPipeline(rawDataList); + + assertEquals(2, result.size()); + assertTrue(result.stream().allMatch(r -> Boolean.TRUE.equals(r.get("_quality_checked")))); + } + + @Test + @DisplayName("pH值范围检查") + void testQualityCheck_PHRange() { + Map data = new HashMap<>(); + data.put("PH", 15.0); // 超出 0-14 范围 + + Map result = governanceService.qualityCheck(data); + + @SuppressWarnings("unchecked") + List issues = (List) result.get("_quality_issues"); + assertTrue(issues.stream().anyMatch(i -> i.contains("pH值"))); + } +} diff --git a/wm-data-engine/src/test/java/com/water/data_engine/service/DataIngestServiceTest.java b/wm-data-engine/src/test/java/com/water/data_engine/service/DataIngestServiceTest.java new file mode 100644 index 00000000..b4b2940b --- /dev/null +++ b/wm-data-engine/src/test/java/com/water/data_engine/service/DataIngestServiceTest.java @@ -0,0 +1,162 @@ +package com.water.data_engine.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * 数据接入服务测试 + */ +@ExtendWith(MockitoExtension.class) +class DataIngestServiceTest { + + @Mock + private com.water.data_engine.mapper.DataSourceMapper dataSourceMapper; + + @Mock + private JdbcTemplate jdbcTemplate; + + @Mock + private DataCollectService collectService; + + private DataIngestService ingestService; + + @BeforeEach + void setUp() { + ingestService = new DataIngestService(dataSourceMapper, jdbcTemplate, collectService); + } + + @Test + @DisplayName("通过API接入数据-数据源不存在") + void testIngestViaApi_SourceNotFound() { + when(dataSourceMapper.selectOne(any())).thenReturn(null); + + RuntimeException ex = assertThrows(RuntimeException.class, () -> { + ingestService.ingestViaApi("nonexistent", Map.of("key", "value")); + }); + + assertTrue(ex.getMessage().contains("数据源不存在")); + } + + @Test + @DisplayName("通过API接入数据-数据源已禁用") + void testIngestViaApi_SourceDisabled() { + com.water.data_engine.entity.DataSource source = createMockSource(); + source.setStatus(0); + when(dataSourceMapper.selectOne(any())).thenReturn(source); + + RuntimeException ex = assertThrows(RuntimeException.class, () -> { + ingestService.ingestViaApi("test_source", Map.of("key", "value")); + }); + + assertTrue(ex.getMessage().contains("数据源已禁用")); + } + + @Test + @DisplayName("通过API接入数据-成功") + void testIngestViaApi_Success() { + com.water.data_engine.entity.DataSource source = createMockSource(); + when(dataSourceMapper.selectOne(any())).thenReturn(source); + when(collectService.ingestRealtime(anyString(), anyString(), anyMap())) + .thenReturn("iot.raw.generic"); + + String topic = ingestService.ingestViaApi("test_source", Map.of("LL", 12.5)); + + assertNotNull(topic); + verify(dataSourceMapper).updateById(any(com.water.data_engine.entity.DataSource.class)); + } + + @Test + @DisplayName("批量API接入") + void testBatchIngestViaApi() { + com.water.data_engine.entity.DataSource source = createMockSource(); + when(dataSourceMapper.selectOne(any())).thenReturn(source); + when(collectService.batchIngest(anyList())).thenReturn(3); + + List> dataList = List.of( + Map.of("LL", 12.5), + Map.of("LL", 15.3), + Map.of("LL", 18.7) + ); + + int count = ingestService.batchIngestViaApi("test_source", dataList); + + assertEquals(3, count); + } + + @Test + @DisplayName("创建数据源-编码重复") + void testCreateDataSource_DuplicateCode() { + when(dataSourceMapper.selectCount(any())).thenReturn(1L); + + com.water.data_engine.entity.DataSource ds = createMockSource(); + RuntimeException ex = assertThrows(RuntimeException.class, () -> { + ingestService.createDataSource(ds); + }); + + assertTrue(ex.getMessage().contains("数据源编码已存在")); + } + + @Test + @DisplayName("创建数据源-成功") + void testCreateDataSource_Success() { + when(dataSourceMapper.selectCount(any())).thenReturn(0L); + + com.water.data_engine.entity.DataSource ds = createMockSource(); + com.water.data_engine.entity.DataSource created = ingestService.createDataSource(ds); + + assertNotNull(created); + assertEquals(1, created.getStatus()); + verify(dataSourceMapper).insert(any(com.water.data_engine.entity.DataSource.class)); + } + + @Test + @DisplayName("查询数据源列表") + void testListDataSources() { + List mockList = List.of( + createMockSource(), + createMockSource() + ); + when(dataSourceMapper.selectList(any())).thenReturn(mockList); + + List result = ingestService.listDataSources(null); + + assertNotNull(result); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("从数据库拉取数据-数据源不存在") + void testPullFromDatabase_SourceNotFound() { + when(dataSourceMapper.selectById(anyLong())).thenReturn(null); + + RuntimeException ex = assertThrows(RuntimeException.class, () -> { + ingestService.pullFromDatabase(999L, "SELECT 1", "target_table"); + }); + + assertTrue(ex.getMessage().contains("数据源不存在")); + } + + private com.water.data_engine.entity.DataSource createMockSource() { + com.water.data_engine.entity.DataSource ds = new com.water.data_engine.entity.DataSource(); + ds.setId(1L); + ds.setSourceCode("test_source"); + ds.setSourceName("测试数据源"); + ds.setSourceType("rest"); + ds.setCategory("iot"); + ds.setStatus(1); + return ds; + } +} diff --git a/wm-data-engine/src/test/java/com/water/data_engine/service/DataIntegrationServiceTest.java b/wm-data-engine/src/test/java/com/water/data_engine/service/DataIntegrationServiceTest.java new file mode 100644 index 00000000..55325dc8 --- /dev/null +++ b/wm-data-engine/src/test/java/com/water/data_engine/service/DataIntegrationServiceTest.java @@ -0,0 +1,173 @@ +package com.water.data_engine.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * 数据集成服务测试 + */ +@ExtendWith(MockitoExtension.class) +class DataIntegrationServiceTest { + + @Mock + private com.water.data_engine.mapper.SyncTaskMapper syncTaskMapper; + + @Mock + private com.water.data_engine.mapper.DataLineageMapper dataLineageMapper; + + @Mock + private JdbcTemplate jdbcTemplate; + + @Mock + private DataStorageService storageService; + + private DataIntegrationService integrationService; + + @BeforeEach + void setUp() { + integrationService = new DataIntegrationService( + syncTaskMapper, dataLineageMapper, jdbcTemplate, storageService + ); + } + + @Test + @DisplayName("创建同步任务") + void testCreateSyncTask() { + com.water.data_engine.entity.SyncTask task = new com.water.data_engine.entity.SyncTask(); + task.setTaskName("测试同步任务"); + task.setSourceId(1L); + task.setTargetStorageId(2L); + task.setSyncType("full"); + + com.water.data_engine.entity.SyncTask created = integrationService.createSyncTask(task); + + assertNotNull(created); + assertEquals("pending", created.getStatus()); + verify(syncTaskMapper).insert(any(com.water.data_engine.entity.SyncTask.class)); + } + + @Test + @DisplayName("数据合并-多源整合") + void testMergeData() { + List> mockResult = List.of( + Map.of("id", 1, "device_sn", "FM001", "value", 12.5), + Map.of("id", 2, "device_sn", "FM002", "value", 15.3) + ); + + when(jdbcTemplate.queryForList(anyString())).thenReturn(mockResult); + + List> result = integrationService.mergeData( + List.of("iot_telemetry", "manual_data"), + "id", + List.of("id", "device_sn", "value") + ); + + assertNotNull(result); + assertEquals(2, result.size()); + verify(jdbcTemplate).queryForList(anyString()); + } + + @Test + @DisplayName("数据聚合-按维度汇总") + void testAggregateData() { + List> mockResult = List.of( + Map.of("area", "精芒片区", "metric_key_avg", 12.5, "metric_key_count", 100), + Map.of("area", "托里片区", "metric_key_avg", 15.3, "metric_key_count", 80) + ); + + when(jdbcTemplate.queryForList(anyString())).thenReturn(mockResult); + + List> result = integrationService.aggregateData( + "iot_telemetry", + List.of("area"), + Map.of("metric_key", "AVG", "metric_key", "COUNT") + ); + + assertNotNull(result); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("创建数据血缘关系") + void testCreateLineage() { + com.water.data_engine.entity.DataLineage lineage = new com.water.data_engine.entity.DataLineage(); + lineage.setSourceTable("iot_telemetry"); + lineage.setTargetTable("iot_telemetry_hourly"); + lineage.setTransformType("aggregation"); + lineage.setDescription("小时聚合"); + + com.water.data_engine.entity.DataLineage created = integrationService.createLineage(lineage); + + assertNotNull(created); + assertNotNull(created.getCreatedAt()); + verify(dataLineageMapper).insert(any(com.water.data_engine.entity.DataLineage.class)); + } + + @Test + @DisplayName("查询血缘关系-上游") + void testGetUpstreamLineage() { + List mockLineages = List.of( + createMockLineage("raw_data", "iot_telemetry") + ); + + when(dataLineageMapper.selectList(any())).thenReturn(mockLineages); + + List result = + integrationService.getUpstreamLineage("iot_telemetry"); + + assertNotNull(result); + assertEquals(1, result.size()); + assertEquals("raw_data", result.get(0).getSourceTable()); + } + + @Test + @DisplayName("查询血缘关系-下游") + void testGetDownstreamLineage() { + List mockLineages = List.of( + createMockLineage("iot_telemetry", "iot_telemetry_hourly") + ); + + when(dataLineageMapper.selectList(any())).thenReturn(mockLineages); + + List result = + integrationService.getDownstreamLineage("iot_telemetry"); + + assertNotNull(result); + assertEquals(1, result.size()); + assertEquals("iot_telemetry_hourly", result.get(0).getTargetTable()); + } + + @Test + @DisplayName("查询完整血缘链路") + void testGetFullLineage() { + when(dataLineageMapper.selectList(any())).thenReturn(List.of()); + + Map result = integrationService.getFullLineage("iot_telemetry"); + + assertNotNull(result); + assertEquals("iot_telemetry", result.get("table")); + assertNotNull(result.get("upstream")); + assertNotNull(result.get("downstream")); + } + + private com.water.data_engine.entity.DataLineage createMockLineage(String source, String target) { + com.water.data_engine.entity.DataLineage lineage = new com.water.data_engine.entity.DataLineage(); + lineage.setSourceTable(source); + lineage.setTargetTable(target); + lineage.setTransformType("direct"); + return lineage; + } +} diff --git a/wm-data-engine/src/test/java/com/water/data_engine/service/DataStorageServiceTest.java b/wm-data-engine/src/test/java/com/water/data_engine/service/DataStorageServiceTest.java new file mode 100644 index 00000000..592c689b --- /dev/null +++ b/wm-data-engine/src/test/java/com/water/data_engine/service/DataStorageServiceTest.java @@ -0,0 +1,174 @@ +package com.water.data_engine.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * 数据存储服务测试 + */ +@ExtendWith(MockitoExtension.class) +class DataStorageServiceTest { + + @Mock + private com.water.data_engine.mapper.StorageConfigMapper storageConfigMapper; + + @Mock + private JdbcTemplate jdbcTemplate; + + private DataStorageService storageService; + + @BeforeEach + void setUp() { + storageService = new DataStorageService(storageConfigMapper, jdbcTemplate); + } + + @Test + @DisplayName("写入TDengine-遥测数据") + void testWriteToTDengine() { + when(jdbcTemplate.update(anyString(), any(), any(), anyDouble())).thenReturn(1); + + assertDoesNotThrow(() -> storageService.writeToTDengine( + "FM001", "flow_meter", "精芒片区", "LL", 12.5 + )); + } + + @Test + @DisplayName("批量写入TDengine") + void testBatchWriteToTDengine() { + List> dataList = List.of( + Map.of("deviceSn", "FM001", "deviceType", "flow_meter", "area", "精芒片区", + "metricKey", "LL", "value", 12.5), + Map.of("deviceSn", "FM002", "deviceType", "flow_meter", "area", "托里片区", + "metricKey", "LL", "value", 15.3) + ); + + int count = storageService.batchWriteToTDengine(dataList); + + // 由于内部异常被捕获，可能返回0 + assertTrue(count >= 0); + } + + @Test + @DisplayName("插入PostgreSQL") + void testInsertToPostgres() { + when(jdbcTemplate.queryForObject(anyString(), eq(Long.class), any(), any())) + .thenReturn(1L); + + Map data = new HashMap<>(); + data.put("device_sn", "FM001"); + data.put("metric_key", "LL"); + + Long id = storageService.insertToPostgres("iot_telemetry", data); + + assertNotNull(id); + assertEquals(1L, id); + } + + @Test + @DisplayName("批量插入PostgreSQL") + void testBatchInsertToPostgres() { + when(jdbcTemplate.queryForObject(anyString(), eq(Long.class), any(), any())) + .thenReturn(1L); + + List> dataList = List.of( + Map.of("device_sn", "FM001", "value", 12.5), + Map.of("device_sn", "FM002", "value", 15.3) + ); + + int count = storageService.batchInsertToPostgres("iot_telemetry", dataList); + + assertEquals(2, count); + } + + @Test + @DisplayName("更新PostgreSQL数据") + void testUpdateInPostgres() { + when(jdbcTemplate.update(anyString(), any(), anyLong())).thenReturn(1); + + Map data = new HashMap<>(); + data.put("value", 20.0); + data.put("status", "verified"); + + int count = storageService.updateInPostgres("iot_telemetry", 1L, data); + + assertEquals(1, count); + } + + @Test + @DisplayName("查询PostgreSQL数据") + void testQueryFromPostgres() { + List> mockResult = List.of( + Map.of("id", 1, "device_sn", "FM001", "value", 12.5) + ); + + when(jdbcTemplate.queryForList(anyString(), any(), any(), anyInt(), anyInt())) + .thenReturn(mockResult); + + List> result = storageService.queryFromPostgres( + "iot_telemetry", Map.of("device_sn", "FM001"), 1, 10 + ); + + assertNotNull(result); + assertEquals(1, result.size()); + } + + @Test + @DisplayName("创建存储配置") + void testCreateStorageConfig() { + com.water.data_engine.entity.StorageConfig config = new com.water.data_engine.entity.StorageConfig(); + config.setStorageName("主TDengine"); + config.setStorageType("tdengine"); + config.setConnectionUrl("jdbc:TAOS://localhost:6030"); + + com.water.data_engine.entity.StorageConfig created = storageService.createStorageConfig(config); + + assertNotNull(created); + assertEquals(1, created.getStatus()); + verify(storageConfigMapper).insert(any(com.water.data_engine.entity.StorageConfig.class)); + } + + @Test + @DisplayName("查询存储配置列表") + void testListStorageConfigs() { + List mockConfigs = List.of( + createMockConfig("tdengine"), + createMockConfig("postgresql") + ); + + when(storageConfigMapper.selectList(any())).thenReturn(mockConfigs); + + List result = + storageService.listStorageConfigs(null); + + assertNotNull(result); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("空列表插入测试") + void testBatchInsertEmpty() { + int count = storageService.batchInsertToPostgres("test_table", List.of()); + assertEquals(0, count); + } + + private com.water.data_engine.entity.StorageConfig createMockConfig(String type) { + com.water.data_engine.entity.StorageConfig config = new com.water.data_engine.entity.StorageConfig(); + config.setStorageType(type); + config.setStorageName("Test " + type); + config.setStatus(1); + return config; + } +} diff --git a/wm-dispatch/pom.xml b/wm-dispatch/pom.xml new file mode 100644 index 00000000..17cde68f --- /dev/null +++ b/wm-dispatch/pom.xml @@ -0,0 +1,45 @@ + + + 4.0.0 + + com.water + wm-parent + 1.0.0-SNAPSHOT + + wm-dispatch + 调度工作台 + 调度工作台与调度业务管理模块 + + + + com.water + wm-common + + + org.springframework.boot + spring-boot-starter-web + + + com.alibaba.cloud + spring-cloud-starter-alibaba-nacos-discovery + + + com.baomidou + mybatis-plus-spring-boot3-starter + + + cn.dev33 + sa-token-spring-boot3-starter + + + org.postgresql + postgresql + + + com.github.xiaoymin + knife4j-openapi3-jakarta-spring-boot-starter + + + diff --git a/wm-dispatch/src/main/java/com/water/dispatch/DispatchApplication.java b/wm-dispatch/src/main/java/com/water/dispatch/DispatchApplication.java new file mode 100644 index 00000000..73448ee9 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/DispatchApplication.java @@ -0,0 +1,11 @@ +package com.water.dispatch; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class DispatchApplication { + public static void main(String[] args) { + SpringApplication.run(DispatchApplication.class, args); + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/controller/DispatchCommandController.java b/wm-dispatch/src/main/java/com/water/dispatch/controller/DispatchCommandController.java new file mode 100644 index 00000000..1b234b6c --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/controller/DispatchCommandController.java @@ -0,0 +1,159 @@ +package com.water.dispatch.controller; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.water.common.core.result.R; +import com.water.dispatch.entity.CommandExecutionRecord; +import com.water.dispatch.entity.CommandTracking; +import com.water.dispatch.entity.DispatchCommand; +import com.water.dispatch.entity.dto.*; +import com.water.dispatch.service.CommandLedgerService; +import com.water.dispatch.service.CommandLifecycleService; +import com.water.dispatch.service.CommandTrackingService; +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; +import java.util.Map; + +/** + * 调度指令管理 - 全生命周期 + */ +@Tag(name = "调度指令管理") +@RestController +@RequestMapping("/api/dispatch/command") +@RequiredArgsConstructor +public class DispatchCommandController { + + private final CommandLifecycleService lifecycleService; + private final CommandLedgerService ledgerService; + private final CommandTrackingService trackingService; + + // ==================== 生命周期操作 ==================== + + @Operation(summary = "1. 创建指令") + @PostMapping + public R create(@RequestBody CommandCreateRequest req) { + return R.ok(lifecycleService.create(req)); + } + + @Operation(summary = "2. 下发指令") + @PostMapping("/{id}/issue") + public R issue(@PathVariable Long id) { + return R.ok(lifecycleService.issue(id)); + } + + @Operation(summary = "3. 接收确认") + @PostMapping("/{id}/receive") + public R receive(@PathVariable Long id, + @RequestParam(required = false) Long receiverId, + @RequestParam(required = false) String receiverName) { + return R.ok(lifecycleService.receive(id, receiverId, receiverName)); + } + + @Operation(summary = "4. 开始执行") + @PostMapping("/{id}/start") + public R startExecution(@PathVariable Long id, + @RequestParam(required = false) Long executorId, + @RequestParam(required = false) String executorName) { + return R.ok(lifecycleService.startExecution(id, executorId, executorName)); + } + + @Operation(summary = "5. 执行进度反馈") + @PostMapping("/{id}/progress") + public R reportProgress(@PathVariable Long id, + @RequestBody ExecutionRequest req) { + return R.ok(lifecycleService.reportProgress(id, req.getExecutorId(), req.getExecutorName(), + req.getDescription(), req.getProgress() != null ? req.getProgress() : 0)); + } + + @Operation(summary = "6. 完成指令") + @PostMapping("/{id}/complete") + public R complete(@PathVariable Long id, + @RequestBody ExecutionRequest req) { + return R.ok(lifecycleService.complete(id, req.getExecutorId(), req.getExecutorName(), req.getExecuteResult())); + } + + @Operation(summary = "7. 驳回指令") + @PostMapping("/{id}/reject") + public R reject(@PathVariable Long id, + @RequestBody ExecutionRequest req) { + return R.ok(lifecycleService.reject(id, req.getExecutorId(), req.getExecutorName(), req.getRejectReason())); + } + + @Operation(summary = "8. 取消指令") + @PostMapping("/{id}/cancel") + public R cancel(@PathVariable Long id, + @RequestParam(required = false) Long operatorId, + @RequestParam(required = false) String operatorName, + @RequestParam(required = false) String reason) { + return R.ok(lifecycleService.cancel(id, operatorId, operatorName, reason)); + } + + // ==================== 查询 ==================== + + @Operation(summary = "9. 获取指令详情（按ID）") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(lifecycleService.getById(id)); + } + + @Operation(summary = "10. 根据指令编号获取详情") + @GetMapping("/no/{commandNo}") + public R getByCommandNo(@PathVariable String commandNo) { + return R.ok(lifecycleService.getByCommandNo(commandNo)); + } + + // ==================== 台账 ==================== + + @Operation(summary = "11. 指令台账分页查询") + @GetMapping("/page") + public R> queryPage(CommandQueryRequest req) { + return R.ok(ledgerService.queryPage(req)); + } + + @Operation(summary = "12. 指令台账列表查询") + @GetMapping("/list") + public R> queryList(CommandQueryRequest req) { + return R.ok(ledgerService.queryList(req)); + } + + @Operation(summary = "13. 指令统计概览") + @GetMapping("/statistics") + public R statistics() { + return R.ok(ledgerService.statistics()); + } + + @Operation(summary = "14. 指令数据导出") + @GetMapping("/export") + public R> exportData(CommandQueryRequest req) { + return R.ok(ledgerService.exportData(req)); + } + + // ==================== 追踪 ==================== + + @Operation(summary = "15. 获取指令追踪时间线") + @GetMapping("/{id}/timeline") + public R> getTimeline(@PathVariable Long id) { + return R.ok(trackingService.getTimeline(id)); + } + + @Operation(summary = "16. 获取执行记录") + @GetMapping("/{id}/executions") + public R> getExecutions(@PathVariable Long id) { + return R.ok(trackingService.getExecutionRecords(id)); + } + + @Operation(summary = "17. 获取完整时间线（追踪+执行记录合并）") + @GetMapping("/{id}/full-timeline") + public R>> getFullTimeline(@PathVariable Long id) { + return R.ok(trackingService.getFullTimeline(id)); + } + + @Operation(summary = "18. 按指令编号获取追踪时间线") + @GetMapping("/no/{commandNo}/timeline") + public R> getTimelineByCommandNo(@PathVariable String commandNo) { + return R.ok(trackingService.getTimelineByCommandNo(commandNo)); + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/controller/DispatchController.java b/wm-dispatch/src/main/java/com/water/dispatch/controller/DispatchController.java new file mode 100644 index 00000000..f7313aed --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/controller/DispatchController.java @@ -0,0 +1,77 @@ +package com.water.dispatch.controller; + +import com.water.common.core.result.R; +import com.water.dispatch.entity.*; +import com.water.dispatch.service.DispatchBizService; +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.*; + +@Tag(name = "调度工作台") +@RestController +@RequestMapping("/dispatch") +@RequiredArgsConstructor +public class DispatchController { + private final DispatchBizService svc; + + @GetMapping("/duty/today") + public R> todayDuty() { + return R.ok(svc.getTodayDuty()); + } + + @PostMapping("/command") + public R> createCommand(@RequestBody Map req) { + return R.ok(svc.createCommand(req)); + } + + @PostMapping("/command/{cmdNo}/issue") + public R> issue(@PathVariable String cmdNo) { + return R.ok(svc.issueCommand(cmdNo)); + } + + @GetMapping("/command/list") + public R> listCommands(@RequestParam(required = false) String status) { + return R.ok(svc.listCommands(status)); + } + + @PostMapping("/work-order") + public R> createWO(@RequestBody Map req) { + return R.ok(svc.createWorkOrder(req)); + } + + @PutMapping("/work-order/{id}/status") + public R> updateWOStatus(@PathVariable Long id, @RequestParam int status) { + return R.ok(svc.updateWorkOrderStatus(id, status)); + } + + @PostMapping("/duty-log") + public R addLog(@RequestParam Long scheduleId, @RequestParam Long userId, + @RequestParam String type, @RequestParam String content) { + svc.addDutyLog(scheduleId, userId, type, content); + return R.ok("OK"); + } + + @GetMapping("/duty-log/{scheduleId}") + public R> getLogs(@PathVariable Long scheduleId) { + return R.ok(svc.getDutyLogs(scheduleId)); + } + + @GetMapping("/strategy") + public R> listStrategies(@RequestParam(required = false) String type) { + return R.ok(svc.listStrategies(type)); + } + + @GetMapping("/emergency-plan") + public R> listPlans(@RequestParam(required = false) String type) { + return R.ok(svc.listPlans(type)); + } + + @PostMapping("/emergency/simulate") + public R> simulate(@RequestParam String type, + @RequestParam double lng, @RequestParam double lat) { + return R.ok(svc.simulateEmergency(type, lng, lat)); + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/CommandExecutionRecord.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/CommandExecutionRecord.java new file mode 100644 index 00000000..aac59672 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/CommandExecutionRecord.java @@ -0,0 +1,43 @@ +package com.water.dispatch.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 指令执行记录 + */ +@Data +@TableName("disp_command_execution_record") +public class CommandExecutionRecord { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 关联指令ID */ + private Long commandId; + + /** 关联指令编号 */ + private String commandNo; + + /** 执行人ID */ + private Long executorId; + + /** 执行人姓名 */ + private String executorName; + + /** 动作: RECEIVE / START / PROGRESS / COMPLETE / REJECT */ + private String action; + + /** 描述 */ + private String description; + + /** 附件（JSON array） */ + private String attachments; + + /** 进度 0-100 */ + private Integer progress; + + private LocalDateTime createdAt; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/CommandTracking.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/CommandTracking.java new file mode 100644 index 00000000..9d82b26c --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/CommandTracking.java @@ -0,0 +1,43 @@ +package com.water.dispatch.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 指令过程追踪（时间线） + */ +@Data +@TableName("disp_command_tracking") +public class CommandTracking { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 关联指令ID */ + private Long commandId; + + /** 关联指令编号 */ + private String commandNo; + + /** 阶段: CREATED / ISSUED / RECEIVED / EXECUTING / COMPLETED / REJECTED / CANCELLED */ + private String stage; + + /** 操作人ID */ + private Long operatorId; + + /** 操作人姓名 */ + private String operatorName; + + /** 动作描述 */ + private String actionDesc; + + /** 来源状态 */ + private String fromStatus; + + /** 目标状态 */ + private String toStatus; + + private LocalDateTime createdAt; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/DispatchCommand.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/DispatchCommand.java new file mode 100644 index 00000000..c69b524d --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/DispatchCommand.java @@ -0,0 +1,85 @@ +package com.water.dispatch.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 调度指令 - 全生命周期: DRAFT→ISSUED→RECEIVED→EXECUTING→COMPLETED/REJECTED/CANCELLED + */ +@Data +@TableName("disp_dispatch_command") +public class DispatchCommand { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 指令编号 */ + private String commandNo; + + /** 指令标题 */ + private String title; + + /** 指令内容 */ + private String content; + + /** 指令类型: NORMAL-常规 EMERGENCY-应急 MAINTENANCE-维护 */ + private String commandType; + + /** 优先级: LOW-低 MEDIUM-中 HIGH-高 URGENT-紧急 */ + private String priority; + + /** 状态: DRAFT/ISSUED/RECEIVED/EXECUTING/COMPLETED/REJECTED/CANCELLED */ + private String status; + + /** 下发人ID */ + private Long issuerId; + + /** 下发人姓名 */ + private String issuerName; + + /** 接收人ID */ + private Long receiverId; + + /** 接收人姓名 */ + private String receiverName; + + /** 关联设施ID */ + private Long facilityId; + + /** 截止时间 */ + private LocalDateTime deadline; + + /** 下发时间 */ + private LocalDateTime issuedAt; + + /** 接收时间 */ + private LocalDateTime receivedAt; + + /** 执行开始时间 */ + private LocalDateTime executedAt; + + /** 完成时间 */ + private LocalDateTime completedAt; + + /** 驳回时间 */ + private LocalDateTime rejectedAt; + + /** 驳回原因 */ + private String rejectReason; + + /** 执行结果 */ + private String executeResult; + + /** 备注 */ + private String remark; + + @TableLogic + private Integer deleted; + + private LocalDateTime createdAt; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedAt; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/DispatchStrategy.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/DispatchStrategy.java new file mode 100644 index 00000000..94ded1c4 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/DispatchStrategy.java @@ -0,0 +1,11 @@ +package com.water.dispatch.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("dispatch_strategy") +public class DispatchStrategy { + @TableId(type = IdType.AUTO) private Long id; + private String name, type, description, ruleConfig; + private Integer status; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; + @TableField(fill=FieldFill.INSERT_UPDATE) private LocalDateTime updatedTime; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/DutyLog.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/DutyLog.java new file mode 100644 index 00000000..b05578ae --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/DutyLog.java @@ -0,0 +1,10 @@ +package com.water.dispatch.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("dispatch_duty_log") +public class DutyLog { + @TableId(type = IdType.AUTO) private Long id; + private Long scheduleId, userId; + private String logType, content, attachments; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/DutySchedule.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/DutySchedule.java new file mode 100644 index 00000000..75d05963 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/DutySchedule.java @@ -0,0 +1,50 @@ +package com.water.dispatch.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; + +/** + * 值班安排 + */ +@Data +@TableName("disp_duty_schedule") +public class DutySchedule { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 值班人员ID */ + private Long userId; + + /** 值班人员姓名 */ + private String userName; + + /** 值班日期 */ + private LocalDate dutyDate; + + /** 班次类型: DAY-白班 NIGHT-夜班 FULL-全天 */ + private String shiftType; + + /** 开始时间 */ + private LocalTime startTime; + + /** 结束时间 */ + private LocalTime endTime; + + /** 状态: 0-待值班 1-值班中 2-已完成 */ + private Integer status; + + /** 备注 */ + private String remark; + + @TableLogic + private Integer deleted; + + private LocalDateTime createdAt; + + private LocalDateTime updatedAt; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/EmergencyPlan.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/EmergencyPlan.java new file mode 100644 index 00000000..0417b7d7 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/EmergencyPlan.java @@ -0,0 +1,11 @@ +package com.water.dispatch.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("dispatch_emergency_plan") +public class EmergencyPlan { + @TableId(type = IdType.AUTO) private Long id; + private String planNo, name, type, content, resourceConfig; + private Integer status; private Long creatorId; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; + @TableField(fill=FieldFill.INSERT_UPDATE) private LocalDateTime updatedTime; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/WorkOrder.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/WorkOrder.java new file mode 100644 index 00000000..4c94c0af --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/WorkOrder.java @@ -0,0 +1,12 @@ +package com.water.dispatch.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@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; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandCreateRequest.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandCreateRequest.java new file mode 100644 index 00000000..255429ac --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandCreateRequest.java @@ -0,0 +1,22 @@ +package com.water.dispatch.entity.dto; + +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 指令创建请求 + */ +@Data +public class CommandCreateRequest { + private String title; + private String content; + private String commandType; // NORMAL / EMERGENCY / MAINTENANCE + private String priority; // LOW / MEDIUM / HIGH / URGENT + private Long issuerId; + private String issuerName; + private Long receiverId; + private String receiverName; + private Long facilityId; + private LocalDateTime deadline; + private String remark; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandQueryRequest.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandQueryRequest.java new file mode 100644 index 00000000..fe37a3c1 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandQueryRequest.java @@ -0,0 +1,22 @@ +package com.water.dispatch.entity.dto; + +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 指令台账查询请求 + */ +@Data +public class CommandQueryRequest { + private String commandNo; + private String title; + private String commandType; + private String priority; + private String status; + private Long issuerId; + private Long receiverId; + private LocalDateTime startTime; + private LocalDateTime endTime; + private Integer pageNum = 1; + private Integer pageSize = 20; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandStatVO.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandStatVO.java new file mode 100644 index 00000000..f6203a8c --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/CommandStatVO.java @@ -0,0 +1,18 @@ +package com.water.dispatch.entity.dto; + +import lombok.Data; +import java.util.Map; + +/** + * 指令统计VO + */ +@Data +public class CommandStatVO { + private long total; + private Map byStatus; + private Map byType; + private Map byPriority; + private long overdueCount; + private long todayCreated; + private long todayCompleted; +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/ExecutionRequest.java b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/ExecutionRequest.java new file mode 100644 index 00000000..188cada2 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/entity/dto/ExecutionRequest.java @@ -0,0 +1,19 @@ +package com.water.dispatch.entity.dto; + +import lombok.Data; + +/** + * 执行反馈请求 + */ +@Data +public class ExecutionRequest { + private Long commandId; + private Long executorId; + private String executorName; + private String action; // RECEIVE / START / PROGRESS / COMPLETE / REJECT + private String description; + private String attachments; // JSON array + private Integer progress; + private String rejectReason; // 驳回时填写 + private String executeResult; // 完成时填写 +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/CommandExecutionRecordMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/CommandExecutionRecordMapper.java new file mode 100644 index 00000000..dcc4112b --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/CommandExecutionRecordMapper.java @@ -0,0 +1,9 @@ +package com.water.dispatch.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.dispatch.entity.CommandExecutionRecord; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface CommandExecutionRecordMapper extends BaseMapper { +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/CommandTrackingMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/CommandTrackingMapper.java new file mode 100644 index 00000000..3911bdd1 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/CommandTrackingMapper.java @@ -0,0 +1,9 @@ +package com.water.dispatch.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.dispatch.entity.CommandTracking; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface CommandTrackingMapper extends BaseMapper { +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/DispatchCommandMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DispatchCommandMapper.java new file mode 100644 index 00000000..db1f8849 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DispatchCommandMapper.java @@ -0,0 +1,98 @@ +package com.water.dispatch.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.dispatch.entity.DispatchCommand; +import org.apache.ibatis.annotations.*; + +import java.util.List; +import java.util.Map; + +@Mapper +public interface DispatchCommandMapper extends BaseMapper { + + /** + * 分页 + 多维度查询指令台账 + */ + @SelectProvider(type = CommandSqlProvider.class, method = "buildLedgerQuery") + IPage selectLedgerPage( + Page page, + @Param("commandNo") String commandNo, + @Param("title") String title, + @Param("commandType") String commandType, + @Param("priority") String priority, + @Param("status") String status, + @Param("issuerId") Long issuerId, + @Param("receiverId") Long receiverId, + @Param("startTime") String startTime, + @Param("endTime") String endTime); + + /** + * 按状态统计 + */ + @Select("SELECT status, COUNT(*) as cnt FROM disp_dispatch_command WHERE deleted=0 GROUP BY status") + List> countByStatus(); + + /** + * 按类型统计 + */ + @Select("SELECT command_type, COUNT(*) as cnt FROM disp_dispatch_command WHERE deleted=0 GROUP BY command_type") + List> countByType(); + + /** + * 按优先级统计 + */ + @Select("SELECT priority, COUNT(*) as cnt FROM disp_dispatch_command WHERE deleted=0 GROUP BY priority") + List> countByPriority(); + + /** + * 逾期指令数 + */ + @Select("SELECT COUNT(*) FROM disp_dispatch_command WHERE deleted=0 AND status NOT IN ('COMPLETED','CANCELLED','REJECTED') AND deadline < NOW()") + long countOverdue(); + + class CommandSqlProvider { + public String buildLedgerQuery( + @Param("commandNo") String commandNo, + @Param("title") String title, + @Param("commandType") String commandType, + @Param("priority") String priority, + @Param("status") String status, + @Param("issuerId") Long issuerId, + @Param("receiverId") Long receiverId, + @Param("startTime") String startTime, + @Param("endTime") String endTime) { + StringBuilder sb = new StringBuilder("SELECT * FROM disp_dispatch_command WHERE deleted=0"); + if (commandNo != null && !commandNo.isEmpty()) { + sb.append(" AND command_no LIKE '%").append(commandNo).append("%'"); + } + if (title != null && !title.isEmpty()) { + sb.append(" AND title LIKE '%").append(title).append("%'"); + } + if (commandType != null && !commandType.isEmpty()) { + sb.append(" AND command_type = '").append(commandType).append("'"); + } + if (priority != null && !priority.isEmpty()) { + sb.append(" AND priority = '").append(priority).append("'"); + } + if (status != null && !status.isEmpty()) { + sb.append(" AND status = '").append(status).append("'"); + } + if (issuerId != null) { + sb.append(" AND issuer_id = ").append(issuerId); + } + if (receiverId != null) { + sb.append(" AND receiver_id = ").append(receiverId); + } + if (startTime != null && !startTime.isEmpty()) { + sb.append(" AND created_at >= '").append(startTime).append("'"); + } + if (endTime != null && !endTime.isEmpty()) { + sb.append(" AND created_at <= '").append(endTime).append("'"); + } + sb.append(" ORDER BY created_at DESC"); + return sb.toString(); + } + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/DispatchStrategyMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DispatchStrategyMapper.java new file mode 100644 index 00000000..d0b4bd2d --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DispatchStrategyMapper.java @@ -0,0 +1,5 @@ +package com.water.dispatch.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.dispatch.entity.DispatchStrategy; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DispatchStrategyMapper extends BaseMapper {} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/DutyLogMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DutyLogMapper.java new file mode 100644 index 00000000..53231130 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DutyLogMapper.java @@ -0,0 +1,5 @@ +package com.water.dispatch.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.dispatch.entity.DutyLog; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DutyLogMapper extends BaseMapper {} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/DutyScheduleMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DutyScheduleMapper.java new file mode 100644 index 00000000..912a3953 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/DutyScheduleMapper.java @@ -0,0 +1,5 @@ +package com.water.dispatch.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.dispatch.entity.DutySchedule; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DutyScheduleMapper extends BaseMapper {} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/EmergencyPlanMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/EmergencyPlanMapper.java new file mode 100644 index 00000000..05e5004b --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/EmergencyPlanMapper.java @@ -0,0 +1,5 @@ +package com.water.dispatch.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.dispatch.entity.EmergencyPlan; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface EmergencyPlanMapper extends BaseMapper {} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/mapper/WorkOrderMapper.java b/wm-dispatch/src/main/java/com/water/dispatch/mapper/WorkOrderMapper.java new file mode 100644 index 00000000..7530081d --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/mapper/WorkOrderMapper.java @@ -0,0 +1,5 @@ +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 {} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/service/CommandLedgerService.java b/wm-dispatch/src/main/java/com/water/dispatch/service/CommandLedgerService.java new file mode 100644 index 00000000..c734a9fb --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/service/CommandLedgerService.java @@ -0,0 +1,125 @@ +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.DispatchCommand; +import com.water.dispatch.entity.dto.CommandQueryRequest; +import com.water.dispatch.entity.dto.CommandStatVO; +import com.water.dispatch.mapper.DispatchCommandMapper; +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.List; +import java.util.Map; + +/** + * 指令台账服务 - 多维度查询/统计/导出 + */ +@Service +@RequiredArgsConstructor +public class CommandLedgerService { + + private final DispatchCommandMapper commandMapper; + + /** + * 分页多维度查询 + */ + public IPage queryPage(CommandQueryRequest req) { + Page page = new Page<>(req.getPageNum(), req.getPageSize()); + String startTime = req.getStartTime() != null ? req.getStartTime().toString() : null; + String endTime = req.getEndTime() != null ? req.getEndTime().toString() : null; + + return commandMapper.selectLedgerPage(page, + req.getCommandNo(), req.getTitle(), req.getCommandType(), + req.getPriority(), req.getStatus(), + req.getIssuerId(), req.getReceiverId(), + startTime, endTime); + } + + /** + * 列表查询（不分页） + */ + public List queryList(CommandQueryRequest req) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (req.getCommandNo() != null && !req.getCommandNo().isEmpty()) { + wrapper.like(DispatchCommand::getCommandNo, req.getCommandNo()); + } + if (req.getTitle() != null && !req.getTitle().isEmpty()) { + wrapper.like(DispatchCommand::getTitle, req.getTitle()); + } + if (req.getCommandType() != null && !req.getCommandType().isEmpty()) { + wrapper.eq(DispatchCommand::getCommandType, req.getCommandType()); + } + if (req.getPriority() != null && !req.getPriority().isEmpty()) { + wrapper.eq(DispatchCommand::getPriority, req.getPriority()); + } + if (req.getStatus() != null && !req.getStatus().isEmpty()) { + wrapper.eq(DispatchCommand::getStatus, req.getStatus()); + } + if (req.getIssuerId() != null) { + wrapper.eq(DispatchCommand::getIssuerId, req.getIssuerId()); + } + if (req.getReceiverId() != null) { + wrapper.eq(DispatchCommand::getReceiverId, req.getReceiverId()); + } + if (req.getStartTime() != null) { + wrapper.ge(DispatchCommand::getCreatedAt, req.getStartTime()); + } + if (req.getEndTime() != null) { + wrapper.le(DispatchCommand::getCreatedAt, req.getEndTime()); + } + wrapper.orderByDesc(DispatchCommand::getCreatedAt); + return commandMapper.selectList(wrapper); + } + + /** + * 统计概览 + */ + public CommandStatVO statistics() { + CommandStatVO vo = new CommandStatVO(); + vo.setTotal(commandMapper.selectCount(new LambdaQueryWrapper<>())); + + Map byStatus = new HashMap<>(); + commandMapper.countByStatus().forEach(m -> + byStatus.put(String.valueOf(m.get("status")), ((Number) m.get("cnt")).longValue())); + vo.setByStatus(byStatus); + + Map byType = new HashMap<>(); + commandMapper.countByType().forEach(m -> + byType.put(String.valueOf(m.get("command_type")), ((Number) m.get("cnt")).longValue())); + vo.setByType(byType); + + Map byPriority = new HashMap<>(); + commandMapper.countByPriority().forEach(m -> + byPriority.put(String.valueOf(m.get("priority")), ((Number) m.get("cnt")).longValue())); + vo.setByPriority(byPriority); + + vo.setOverdueCount(commandMapper.countOverdue()); + + LocalDateTime todayStart = LocalDateTime.of(LocalDate.now(), LocalTime.MIN); + LocalDateTime todayEnd = LocalDateTime.of(LocalDate.now(), LocalTime.MAX); + vo.setTodayCreated(commandMapper.selectCount( + new LambdaQueryWrapper() + .ge(DispatchCommand::getCreatedAt, todayStart) + .le(DispatchCommand::getCreatedAt, todayEnd))); + vo.setTodayCompleted(commandMapper.selectCount( + new LambdaQueryWrapper() + .eq(DispatchCommand::getStatus, "COMPLETED") + .ge(DispatchCommand::getCompletedAt, todayStart) + .le(DispatchCommand::getCompletedAt, todayEnd))); + + return vo; + } + + /** + * 导出用数据（全量列表） + */ + public List exportData(CommandQueryRequest req) { + return queryList(req); + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/service/CommandLifecycleService.java b/wm-dispatch/src/main/java/com/water/dispatch/service/CommandLifecycleService.java new file mode 100644 index 00000000..24a2ce16 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/service/CommandLifecycleService.java @@ -0,0 +1,250 @@ +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.CommandExecutionRecord; +import com.water.dispatch.entity.CommandTracking; +import com.water.dispatch.entity.DispatchCommand; +import com.water.dispatch.entity.dto.CommandCreateRequest; +import com.water.dispatch.entity.dto.ExecutionRequest; +import com.water.dispatch.mapper.CommandExecutionRecordMapper; +import com.water.dispatch.mapper.CommandTrackingMapper; +import com.water.dispatch.mapper.DispatchCommandMapper; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + +/** + * 调度指令全生命周期服务 + * DRAFT → ISSUED → RECEIVED → EXECUTING → COMPLETED / REJECTED / CANCELLED + */ +@Service +@RequiredArgsConstructor +public class CommandLifecycleService { + + private final DispatchCommandMapper commandMapper; + private final CommandExecutionRecordMapper executionMapper; + private final CommandTrackingMapper trackingMapper; + + /** + * 创建指令（DRAFT） + */ + @Transactional + public DispatchCommand create(CommandCreateRequest req) { + DispatchCommand cmd = new DispatchCommand(); + cmd.setCommandNo(generateCommandNo()); + cmd.setTitle(req.getTitle()); + cmd.setContent(req.getContent()); + cmd.setCommandType(req.getCommandType() != null ? req.getCommandType() : "NORMAL"); + cmd.setPriority(req.getPriority() != null ? req.getPriority() : "MEDIUM"); + cmd.setStatus("DRAFT"); + cmd.setIssuerId(req.getIssuerId()); + cmd.setIssuerName(req.getIssuerName()); + cmd.setReceiverId(req.getReceiverId()); + cmd.setReceiverName(req.getReceiverName()); + cmd.setFacilityId(req.getFacilityId()); + cmd.setDeadline(req.getDeadline()); + cmd.setRemark(req.getRemark()); + commandMapper.insert(cmd); + + addTracking(cmd, "CREATED", null, "DRAFT", req.getIssuerId(), req.getIssuerName(), "创建指令"); + return cmd; + } + + /** + * 下发指令（DRAFT → ISSUED） + */ + @Transactional + public DispatchCommand issue(Long commandId) { + DispatchCommand cmd = getCommandOrThrow(commandId); + assertStatus(cmd, "DRAFT"); + + cmd.setStatus("ISSUED"); + cmd.setIssuedAt(LocalDateTime.now()); + commandMapper.updateById(cmd); + + addTracking(cmd, "ISSUED", "DRAFT", "ISSUED", cmd.getIssuerId(), cmd.getIssuerName(), "下发指令"); + return cmd; + } + + /** + * 接收确认（ISSUED → RECEIVED） + */ + @Transactional + public DispatchCommand receive(Long commandId, Long receiverId, String receiverName) { + DispatchCommand cmd = getCommandOrThrow(commandId); + assertStatus(cmd, "ISSUED"); + + cmd.setStatus("RECEIVED"); + cmd.setReceivedAt(LocalDateTime.now()); + if (receiverId != null) { + cmd.setReceiverId(receiverId); + cmd.setReceiverName(receiverName); + } + commandMapper.updateById(cmd); + + addExecution(cmd, receiverId, receiverName, "RECEIVE", "确认接收指令", null, 0); + addTracking(cmd, "RECEIVED", "ISSUED", "RECEIVED", receiverId, receiverName, "接收确认"); + return cmd; + } + + /** + * 开始执行（RECEIVED → EXECUTING） + */ + @Transactional + public DispatchCommand startExecution(Long commandId, Long executorId, String executorName) { + DispatchCommand cmd = getCommandOrThrow(commandId); + assertStatus(cmd, "RECEIVED"); + + cmd.setStatus("EXECUTING"); + cmd.setExecutedAt(LocalDateTime.now()); + commandMapper.updateById(cmd); + + addExecution(cmd, executorId, executorName, "START", "开始执行", null, 10); + addTracking(cmd, "EXECUTING", "RECEIVED", "EXECUTING", executorId, executorName, "开始执行"); + return cmd; + } + + /** + * 执行进度反馈（EXECUTING stays） + */ + @Transactional + public DispatchCommand reportProgress(Long commandId, Long executorId, String executorName, + String description, int progress) { + DispatchCommand cmd = getCommandOrThrow(commandId); + assertStatus(cmd, "EXECUTING"); + + addExecution(cmd, executorId, executorName, "PROGRESS", description, null, progress); + return cmd; + } + + /** + * 完成指令（EXECUTING → COMPLETED） + */ + @Transactional + public DispatchCommand complete(Long commandId, Long executorId, String executorName, String result) { + DispatchCommand cmd = getCommandOrThrow(commandId); + assertStatus(cmd, "EXECUTING"); + + cmd.setStatus("COMPLETED"); + cmd.setCompletedAt(LocalDateTime.now()); + cmd.setExecuteResult(result); + commandMapper.updateById(cmd); + + addExecution(cmd, executorId, executorName, "COMPLETE", result, null, 100); + addTracking(cmd, "COMPLETED", "EXECUTING", "COMPLETED", executorId, executorName, "执行完成: " + result); + return cmd; + } + + /** + * 驳回指令（任意活跃状态 → REJECTED） + */ + @Transactional + public DispatchCommand reject(Long commandId, Long operatorId, String operatorName, String reason) { + DispatchCommand cmd = getCommandOrThrow(commandId); + String fromStatus = cmd.getStatus(); + if ("COMPLETED".equals(fromStatus) || "CANCELLED".equals(fromStatus) || "REJECTED".equals(fromStatus)) { + throw new BusinessException("当前状态不允许驳回: " + fromStatus); + } + + cmd.setStatus("REJECTED"); + cmd.setRejectedAt(LocalDateTime.now()); + cmd.setRejectReason(reason); + commandMapper.updateById(cmd); + + addExecution(cmd, operatorId, operatorName, "REJECT", reason, null, 0); + addTracking(cmd, "REJECTED", fromStatus, "REJECTED", operatorId, operatorName, "驳回: " + reason); + return cmd; + } + + /** + * 取消指令 + */ + @Transactional + public DispatchCommand cancel(Long commandId, Long operatorId, String operatorName, String reason) { + DispatchCommand cmd = getCommandOrThrow(commandId); + String fromStatus = cmd.getStatus(); + if ("COMPLETED".equals(fromStatus) || "CANCELLED".equals(fromStatus)) { + throw new BusinessException("当前状态不允许取消: " + fromStatus); + } + + cmd.setStatus("CANCELLED"); + commandMapper.updateById(cmd); + + addTracking(cmd, "CANCELLED", fromStatus, "CANCELLED", operatorId, operatorName, + "取消指令" + (reason != null ? ": " + reason : "")); + return cmd; + } + + /** + * 获取指令详情 + */ + public DispatchCommand getById(Long id) { + return getCommandOrThrow(id); + } + + /** + * 根据编号获取 + */ + public DispatchCommand getByCommandNo(String commandNo) { + DispatchCommand cmd = commandMapper.selectOne( + new LambdaQueryWrapper() + .eq(DispatchCommand::getCommandNo, commandNo)); + if (cmd == null) { + throw new BusinessException("指令不存在: " + commandNo); + } + return cmd; + } + + // ========== Internal ========== + + private DispatchCommand getCommandOrThrow(Long id) { + DispatchCommand cmd = commandMapper.selectById(id); + if (cmd == null) { + throw new BusinessException("指令不存在: " + id); + } + return cmd; + } + + private void assertStatus(DispatchCommand cmd, String expected) { + if (!expected.equals(cmd.getStatus())) { + throw new BusinessException("指令状态不正确，期望: " + expected + "，实际: " + cmd.getStatus()); + } + } + + private String generateCommandNo() { + return "CMD-" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")) + + "-" + (int) (Math.random() * 9000 + 1000); + } + + private void addTracking(DispatchCommand cmd, String stage, String fromStatus, String toStatus, + Long operatorId, String operatorName, String desc) { + CommandTracking t = new CommandTracking(); + t.setCommandId(cmd.getId()); + t.setCommandNo(cmd.getCommandNo()); + t.setStage(stage); + t.setFromStatus(fromStatus); + t.setToStatus(toStatus); + t.setOperatorId(operatorId); + t.setOperatorName(operatorName); + t.setActionDesc(desc); + trackingMapper.insert(t); + } + + private void addExecution(DispatchCommand cmd, Long executorId, String executorName, + String action, String description, String attachments, int progress) { + CommandExecutionRecord r = new CommandExecutionRecord(); + r.setCommandId(cmd.getId()); + r.setCommandNo(cmd.getCommandNo()); + r.setExecutorId(executorId); + r.setExecutorName(executorName); + r.setAction(action); + r.setDescription(description); + r.setAttachments(attachments); + r.setProgress(progress); + executionMapper.insert(r); + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/service/CommandTrackingService.java b/wm-dispatch/src/main/java/com/water/dispatch/service/CommandTrackingService.java new file mode 100644 index 00000000..952b57f4 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/service/CommandTrackingService.java @@ -0,0 +1,94 @@ +package com.water.dispatch.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.dispatch.entity.CommandExecutionRecord; +import com.water.dispatch.entity.CommandTracking; +import com.water.dispatch.mapper.CommandExecutionRecordMapper; +import com.water.dispatch.mapper.CommandTrackingMapper; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.util.*; + +/** + * 指令全过程追踪服务 - 时间线 + */ +@Service +@RequiredArgsConstructor +public class CommandTrackingService { + + private final CommandTrackingMapper trackingMapper; + private final CommandExecutionRecordMapper executionMapper; + + /** + * 获取指令追踪时间线 + */ + public List getTimeline(Long commandId) { + return trackingMapper.selectList( + new LambdaQueryWrapper() + .eq(CommandTracking::getCommandId, commandId) + .orderByAsc(CommandTracking::getCreatedAt)); + } + + /** + * 根据指令编号获取追踪时间线 + */ + public List getTimelineByCommandNo(String commandNo) { + return trackingMapper.selectList( + new LambdaQueryWrapper() + .eq(CommandTracking::getCommandNo, commandNo) + .orderByAsc(CommandTracking::getCreatedAt)); + } + + /** + * 获取执行记录列表 + */ + public List getExecutionRecords(Long commandId) { + return executionMapper.selectList( + new LambdaQueryWrapper() + .eq(CommandExecutionRecord::getCommandId, commandId) + .orderByAsc(CommandExecutionRecord::getCreatedAt)); + } + + /** + * 获取完整时间线（tracking + execution records 合并） + */ + public List> getFullTimeline(Long commandId) { + List trackings = getTimeline(commandId); + List records = getExecutionRecords(commandId); + + List> timeline = new ArrayList<>(); + + for (CommandTracking t : trackings) { + Map item = new LinkedHashMap<>(); + item.put("type", "TRACKING"); + item.put("id", t.getId()); + item.put("time", t.getCreatedAt()); + item.put("stage", t.getStage()); + item.put("operatorId", t.getOperatorId()); + item.put("operatorName", t.getOperatorName()); + item.put("description", t.getActionDesc()); + item.put("fromStatus", t.getFromStatus()); + item.put("toStatus", t.getToStatus()); + timeline.add(item); + } + + for (CommandExecutionRecord r : records) { + Map item = new LinkedHashMap<>(); + item.put("type", "EXECUTION"); + item.put("id", r.getId()); + item.put("time", r.getCreatedAt()); + item.put("action", r.getAction()); + item.put("executorId", r.getExecutorId()); + item.put("executorName", r.getExecutorName()); + item.put("description", r.getDescription()); + item.put("progress", r.getProgress()); + item.put("attachments", r.getAttachments()); + timeline.add(item); + } + + // Sort by time + timeline.sort(Comparator.comparing(m -> (java.time.LocalDateTime) m.get("time"))); + return timeline; + } +} diff --git a/wm-dispatch/src/main/java/com/water/dispatch/service/DispatchBizService.java b/wm-dispatch/src/main/java/com/water/dispatch/service/DispatchBizService.java new file mode 100644 index 00000000..487987d1 --- /dev/null +++ b/wm-dispatch/src/main/java/com/water/dispatch/service/DispatchBizService.java @@ -0,0 +1,107 @@ +package com.water.dispatch.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.dispatch.entity.*; +import com.water.dispatch.mapper.*; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.time.*; +import java.util.*; + +/** + * 调度工作台 - 原有业务（值班/工单/策略/预案） + */ +@Service +@RequiredArgsConstructor +public class DispatchBizService { + private final DutyScheduleMapper dutyMapper; + private final DispatchCommandMapper cmdMapper; + private final WorkOrderMapper woMapper; + private final DutyLogMapper logMapper; + private final DispatchStrategyMapper stratMapper; + private final EmergencyPlanMapper planMapper; + + public List getTodayDuty() { + return dutyMapper.selectList(new LambdaQueryWrapper() + .eq(DutySchedule::getDutyDate, LocalDate.now())); + } + + public Map createCommand(Map req) { + DispatchCommand c = new DispatchCommand(); + c.setCommandNo("CMD-" + System.currentTimeMillis()); + c.setTitle((String) req.get("title")); + c.setContent((String) req.get("content")); + c.setCommandType((String) req.getOrDefault("commandType", "NORMAL")); + c.setPriority((String) req.getOrDefault("priority", "MEDIUM")); + c.setStatus("DRAFT"); + cmdMapper.insert(c); + return Map.of("id", c.getId(), "commandNo", c.getCommandNo()); + } + + public Map issueCommand(String commandNo) { + DispatchCommand c = cmdMapper.selectOne(new LambdaQueryWrapper() + .eq(DispatchCommand::getCommandNo, commandNo)); + if (c == null) throw new RuntimeException("指令不存在"); + c.setStatus("ISSUED"); + c.setIssuedAt(LocalDateTime.now()); + cmdMapper.updateById(c); + return Map.of("commandNo", commandNo, "status", c.getStatus()); + } + + public List listCommands(String status) { + return cmdMapper.selectList(new LambdaQueryWrapper() + .eq(status != null, DispatchCommand::getStatus, status)); + } + + public Map createWorkOrder(Map req) { + WorkOrder w = new WorkOrder(); + w.setOrderNo("WO-" + System.currentTimeMillis()); + w.setTitle((String) req.get("title")); + w.setDescription((String) req.get("description")); + w.setType((String) req.getOrDefault("type", "维修")); + w.setStatus(0); + w.setPriority((String) req.getOrDefault("priority", "中")); + woMapper.insert(w); + return Map.of("id", w.getId(), "orderNo", w.getOrderNo()); + } + + public Map updateWorkOrderStatus(Long id, int status) { + WorkOrder w = woMapper.selectById(id); + if (w == null) throw new RuntimeException("工单不存在"); + w.setStatus(status); + if (status == 2) w.setCompletedAt(LocalDateTime.now()); + woMapper.updateById(w); + return Map.of("id", id, "status", status); + } + + public void addDutyLog(Long scheduleId, Long userId, String type, String content) { + DutyLog l = new DutyLog(); + l.setScheduleId(scheduleId); + l.setUserId(userId); + l.setLogType(type); + l.setContent(content); + logMapper.insert(l); + } + + public List getDutyLogs(Long scheduleId) { + return logMapper.selectList(new LambdaQueryWrapper() + .eq(DutyLog::getScheduleId, scheduleId)); + } + + public List listStrategies(String type) { + return stratMapper.selectList(new LambdaQueryWrapper() + .eq(type != null, DispatchStrategy::getType, type)); + } + + public List listPlans(String type) { + return planMapper.selectList(new LambdaQueryWrapper() + .eq(type != null, EmergencyPlan::getType, type)); + } + + public Map simulateEmergency(String type, double lng, double lat) { + return Map.of("type", type, "lng", lng, "lat", lat, + "affectedArea", "半径500米", "affectedUsers", 120, + "estimatedDuration", "4小时"); + } +} diff --git a/wm-dispatch/src/main/resources/application.yml b/wm-dispatch/src/main/resources/application.yml new file mode 100644 index 00000000..65a88101 --- /dev/null +++ b/wm-dispatch/src/main/resources/application.yml @@ -0,0 +1,15 @@ +server: + port: 9050 +spring: + application: + name: wm-dispatch + datasource: + url: jdbc:postgresql://localhost:5432/water_dispatch + username: water + password: water123 +mybatis-plus: + configuration: + map-underscore-to-camel-case: true + global-config: + db-config: + id-type: auto diff --git a/wm-dispatch/src/main/resources/db/V1__dispatch.sql b/wm-dispatch/src/main/resources/db/V1__dispatch.sql new file mode 100644 index 00000000..3480fd51 --- /dev/null +++ b/wm-dispatch/src/main/resources/db/V1__dispatch.sql @@ -0,0 +1,33 @@ +CREATE TABLE IF NOT EXISTS dispatch_duty_schedule ( + id BIGSERIAL PRIMARY KEY, user_id BIGINT, user_name VARCHAR(50), + duty_date DATE, start_time TIME, end_time TIME, area VARCHAR(100), + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS dispatch_command ( + id BIGSERIAL PRIMARY KEY, cmd_no VARCHAR(50) UNIQUE, title VARCHAR(200), + content TEXT, type VARCHAR(20), status INT DEFAULT 0, + issued_time TIMESTAMP, completed_time TIMESTAMP, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS dispatch_work_order ( + id BIGSERIAL PRIMARY KEY, order_no VARCHAR(50) UNIQUE, title VARCHAR(200), + description TEXT, type VARCHAR(20), priority VARCHAR(10), status INT DEFAULT 0, + assignee_id BIGINT, creator_id BIGINT, deadline TIMESTAMP, completed_at TIMESTAMP, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS dispatch_duty_log ( + id BIGSERIAL PRIMARY KEY, schedule_id BIGINT, user_id BIGINT, + log_type VARCHAR(20), content TEXT, attachments TEXT, + created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS dispatch_strategy ( + id BIGSERIAL PRIMARY KEY, name VARCHAR(100), type VARCHAR(20), + description TEXT, rule_config TEXT, status INT DEFAULT 1, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS dispatch_emergency_plan ( + id BIGSERIAL PRIMARY KEY, plan_no VARCHAR(50) UNIQUE, name VARCHAR(100), + type VARCHAR(20), content TEXT, resource_config TEXT, + status INT DEFAULT 0, creator_id BIGINT, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); diff --git a/wm-dispatch/src/main/resources/db/V2__command_lifecycle.sql b/wm-dispatch/src/main/resources/db/V2__command_lifecycle.sql new file mode 100644 index 00000000..eb4074a5 --- /dev/null +++ b/wm-dispatch/src/main/resources/db/V2__command_lifecycle.sql @@ -0,0 +1,73 @@ +-- V2: 调度指令全生命周期管理 +-- 新增/重建表，支持 创建→下发→接收确认→执行反馈→完成归档 全流程 + +-- 1. 调度指令主表（增强） +CREATE TABLE IF NOT EXISTS disp_dispatch_command ( + id BIGSERIAL PRIMARY KEY, + command_no VARCHAR(64) NOT NULL UNIQUE, + title VARCHAR(200) NOT NULL, + content TEXT, + command_type VARCHAR(30) NOT NULL DEFAULT 'NORMAL', -- NORMAL / EMERGENCY / MAINTENANCE + priority VARCHAR(20) NOT NULL DEFAULT 'MEDIUM', -- LOW / MEDIUM / HIGH / URGENT + status VARCHAR(30) NOT NULL DEFAULT 'DRAFT', -- DRAFT / ISSUED / RECEIVED / EXECUTING / COMPLETED / REJECTED / CANCELLED + issuer_id BIGINT, + issuer_name VARCHAR(64), + receiver_id BIGINT, + receiver_name VARCHAR(64), + facility_id BIGINT, + deadline TIMESTAMP, + issued_at TIMESTAMP, + received_at TIMESTAMP, + executed_at TIMESTAMP, + completed_at TIMESTAMP, + rejected_at TIMESTAMP, + reject_reason TEXT, + execute_result TEXT, + remark TEXT, + deleted INT DEFAULT 0, + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW() +); + +CREATE INDEX idx_cmd_status ON disp_dispatch_command(status); +CREATE INDEX idx_cmd_type ON disp_dispatch_command(command_type); +CREATE INDEX idx_cmd_priority ON disp_dispatch_command(priority); +CREATE INDEX idx_cmd_issuer ON disp_dispatch_command(issuer_id); +CREATE INDEX idx_cmd_receiver ON disp_dispatch_command(receiver_id); +CREATE INDEX idx_cmd_deadline ON disp_dispatch_command(deadline); +CREATE INDEX idx_cmd_created_at ON disp_dispatch_command(created_at); + +-- 2. 执行记录表 +CREATE TABLE IF NOT EXISTS disp_command_execution_record ( + id BIGSERIAL PRIMARY KEY, + command_id BIGINT NOT NULL, + command_no VARCHAR(64), + executor_id BIGINT NOT NULL, + executor_name VARCHAR(64), + action VARCHAR(30) NOT NULL, -- RECEIVE / START / PROGRESS / COMPLETE / REJECT + description TEXT, + attachments TEXT, -- JSON array of file URLs + progress INT DEFAULT 0, -- 0-100 + created_at TIMESTAMP DEFAULT NOW() +); + +CREATE INDEX idx_exec_cmd_id ON disp_command_execution_record(command_id); +CREATE INDEX idx_exec_cmd_no ON disp_command_execution_record(command_no); + +-- 3. 过程追踪表（时间线） +CREATE TABLE IF NOT EXISTS disp_command_tracking ( + id BIGSERIAL PRIMARY KEY, + command_id BIGINT NOT NULL, + command_no VARCHAR(64), + stage VARCHAR(30) NOT NULL, -- CREATED / ISSUED / RECEIVED / EXECUTING / COMPLETED / REJECTED / CANCELLED + operator_id BIGINT, + operator_name VARCHAR(64), + action_desc VARCHAR(500), + from_status VARCHAR(30), + to_status VARCHAR(30), + created_at TIMESTAMP DEFAULT NOW() +); + +CREATE INDEX idx_track_cmd_id ON disp_command_tracking(command_id); +CREATE INDEX idx_track_cmd_no ON disp_command_tracking(command_no); +CREATE INDEX idx_track_stage ON disp_command_tracking(stage); diff --git a/wm-dispatch/src/test/java/com/water/dispatch/service/CommandLifecycleServiceTest.java b/wm-dispatch/src/test/java/com/water/dispatch/service/CommandLifecycleServiceTest.java new file mode 100644 index 00000000..8af0c32d --- /dev/null +++ b/wm-dispatch/src/test/java/com/water/dispatch/service/CommandLifecycleServiceTest.java @@ -0,0 +1,248 @@ +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.CommandExecutionRecord; +import com.water.dispatch.entity.CommandTracking; +import com.water.dispatch.entity.DispatchCommand; +import com.water.dispatch.entity.dto.CommandCreateRequest; +import com.water.dispatch.mapper.CommandExecutionRecordMapper; +import com.water.dispatch.mapper.CommandTrackingMapper; +import com.water.dispatch.mapper.DispatchCommandMapper; +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 static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class CommandLifecycleServiceTest { + + @Mock + private DispatchCommandMapper commandMapper; + @Mock + private CommandExecutionRecordMapper executionMapper; + @Mock + private CommandTrackingMapper trackingMapper; + + @InjectMocks + private CommandLifecycleService lifecycleService; + + @Test + void testCreateCommand() { + when(commandMapper.insert(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + CommandCreateRequest req = new CommandCreateRequest(); + req.setTitle("测试指令"); + req.setContent("测试内容"); + req.setCommandType("NORMAL"); + req.setPriority("HIGH"); + req.setIssuerId(1L); + req.setIssuerName("张三"); + + DispatchCommand result = lifecycleService.create(req); + + assertNotNull(result.getCommandNo()); + assertEquals("DRAFT", result.getStatus()); + assertEquals("测试指令", result.getTitle()); + assertEquals("NORMAL", result.getCommandType()); + assertEquals("HIGH", result.getPriority()); + verify(commandMapper).insert(any()); + verify(trackingMapper).insert(any()); + } + + @Test + void testIssueCommand() { + DispatchCommand cmd = buildCommand(1L, "DRAFT"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.issue(1L); + + assertEquals("ISSUED", result.getStatus()); + assertNotNull(result.getIssuedAt()); + verify(commandMapper).updateById(any()); + verify(trackingMapper).insert(any()); + } + + @Test + void testIssueCommandWrongStatus() { + DispatchCommand cmd = buildCommand(1L, "ISSUED"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + assertThrows(BusinessException.class, () -> lifecycleService.issue(1L)); + } + + @Test + void testReceiveCommand() { + DispatchCommand cmd = buildCommand(1L, "ISSUED"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(executionMapper.insert(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.receive(1L, 2L, "李四"); + + assertEquals("RECEIVED", result.getStatus()); + assertNotNull(result.getReceivedAt()); + assertEquals(2L, result.getReceiverId()); + + ArgumentCaptor execCaptor = ArgumentCaptor.forClass(CommandExecutionRecord.class); + verify(executionMapper).insert(execCaptor.capture()); + assertEquals("RECEIVE", execCaptor.getValue().getAction()); + } + + @Test + void testStartExecution() { + DispatchCommand cmd = buildCommand(1L, "RECEIVED"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(executionMapper.insert(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.startExecution(1L, 2L, "李四"); + + assertEquals("EXECUTING", result.getStatus()); + assertNotNull(result.getExecutedAt()); + } + + @Test + void testCompleteCommand() { + DispatchCommand cmd = buildCommand(1L, "EXECUTING"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(executionMapper.insert(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.complete(1L, 2L, "李四", "已完成管道修复"); + + assertEquals("COMPLETED", result.getStatus()); + assertNotNull(result.getCompletedAt()); + assertEquals("已完成管道修复", result.getExecuteResult()); + + ArgumentCaptor execCaptor = ArgumentCaptor.forClass(CommandExecutionRecord.class); + verify(executionMapper).insert(execCaptor.capture()); + assertEquals(100, execCaptor.getValue().getProgress()); + } + + @Test + void testRejectCommand() { + DispatchCommand cmd = buildCommand(1L, "ISSUED"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(executionMapper.insert(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.reject(1L, 2L, "李四", "信息不足，无法执行"); + + assertEquals("REJECTED", result.getStatus()); + assertEquals("信息不足，无法执行", result.getRejectReason()); + assertNotNull(result.getRejectedAt()); + } + + @Test + void testRejectCompletedCommand() { + DispatchCommand cmd = buildCommand(1L, "COMPLETED"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + assertThrows(BusinessException.class, + () -> lifecycleService.reject(1L, 2L, "李四", "原因")); + } + + @Test + void testCancelCommand() { + DispatchCommand cmd = buildCommand(1L, "DRAFT"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.cancel(1L, 1L, "张三", "计划变更"); + + assertEquals("CANCELLED", result.getStatus()); + } + + @Test + void testCancelAlreadyCancelledCommand() { + DispatchCommand cmd = buildCommand(1L, "CANCELLED"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + assertThrows(BusinessException.class, + () -> lifecycleService.cancel(1L, 1L, "张三", "reason")); + } + + @Test + void testCommandNotFound() { + when(commandMapper.selectById(999L)).thenReturn(null); + assertThrows(BusinessException.class, () -> lifecycleService.issue(999L)); + } + + @Test + void testReportProgress() { + DispatchCommand cmd = buildCommand(1L, "EXECUTING"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(executionMapper.insert(any())).thenReturn(1); + + DispatchCommand result = lifecycleService.reportProgress(1L, 2L, "李四", "完成50%", 50); + + assertEquals("EXECUTING", result.getStatus()); // status unchanged + ArgumentCaptor captor = ArgumentCaptor.forClass(CommandExecutionRecord.class); + verify(executionMapper).insert(captor.capture()); + assertEquals("PROGRESS", captor.getValue().getAction()); + assertEquals(50, captor.getValue().getProgress()); + } + + @Test + void testFullLifecycle() { + // Create + when(commandMapper.insert(any())).thenReturn(1); + when(trackingMapper.insert(any())).thenReturn(1); + when(executionMapper.insert(any())).thenReturn(1); + + CommandCreateRequest req = new CommandCreateRequest(); + req.setTitle("全流程测试"); + req.setCommandType("EMERGENCY"); + req.setPriority("URGENT"); + req.setIssuerId(1L); + req.setIssuerName("张三"); + + DispatchCommand cmd = lifecycleService.create(req); + cmd.setId(100L); + assertEquals("DRAFT", cmd.getStatus()); + + // Issue + when(commandMapper.selectById(100L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + lifecycleService.issue(100L); + assertEquals("ISSUED", cmd.getStatus()); + + // Receive + lifecycleService.receive(100L, 2L, "李四"); + assertEquals("RECEIVED", cmd.getStatus()); + + // Start + lifecycleService.startExecution(100L, 2L, "李四"); + assertEquals("EXECUTING", cmd.getStatus()); + + // Complete + lifecycleService.complete(100L, 2L, "李四", "抢修完成"); + assertEquals("COMPLETED", cmd.getStatus()); + } + + private DispatchCommand buildCommand(Long id, String status) { + DispatchCommand cmd = new DispatchCommand(); + cmd.setId(id); + cmd.setCommandNo("CMD-TEST-001"); + cmd.setTitle("测试指令"); + cmd.setStatus(status); + cmd.setIssuerId(1L); + cmd.setIssuerName("张三"); + return cmd; + } +} diff --git a/wm-dispatch/src/test/java/com/water/dispatch/service/CommandTrackingServiceTest.java b/wm-dispatch/src/test/java/com/water/dispatch/service/CommandTrackingServiceTest.java new file mode 100644 index 00000000..7713816f --- /dev/null +++ b/wm-dispatch/src/test/java/com/water/dispatch/service/CommandTrackingServiceTest.java @@ -0,0 +1,115 @@ +package com.water.dispatch.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.dispatch.entity.CommandExecutionRecord; +import com.water.dispatch.entity.CommandTracking; +import com.water.dispatch.mapper.CommandExecutionRecordMapper; +import com.water.dispatch.mapper.CommandTrackingMapper; +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.time.LocalDateTime; +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 CommandTrackingServiceTest { + + @Mock + private CommandTrackingMapper trackingMapper; + @Mock + private CommandExecutionRecordMapper executionMapper; + + @InjectMocks + private CommandTrackingService trackingService; + + @Test + void testGetTimeline() { + CommandTracking t1 = new CommandTracking(); + t1.setId(1L); + t1.setCommandId(100L); + t1.setStage("CREATED"); + t1.setCreatedAt(LocalDateTime.of(2026, 6, 14, 10, 0)); + + CommandTracking t2 = new CommandTracking(); + t2.setId(2L); + t2.setCommandId(100L); + t2.setStage("ISSUED"); + t2.setCreatedAt(LocalDateTime.of(2026, 6, 14, 10, 5)); + + when(trackingMapper.selectList(any(LambdaQueryWrapper.class))) + .thenReturn(List.of(t1, t2)); + + List result = trackingService.getTimeline(100L); + assertEquals(2, result.size()); + assertEquals("CREATED", result.get(0).getStage()); + } + + @Test + void testGetExecutionRecords() { + CommandExecutionRecord r1 = new CommandExecutionRecord(); + r1.setId(1L); + r1.setCommandId(100L); + r1.setAction("RECEIVE"); + r1.setProgress(0); + + when(executionMapper.selectList(any(LambdaQueryWrapper.class))) + .thenReturn(List.of(r1)); + + List result = trackingService.getExecutionRecords(100L); + assertEquals(1, result.size()); + assertEquals("RECEIVE", result.get(0).getAction()); + } + + @Test + void testGetFullTimeline() { + CommandTracking t = new CommandTracking(); + t.setId(1L); + t.setCommandId(100L); + t.setStage("CREATED"); + t.setOperatorName("张三"); + t.setActionDesc("创建指令"); + t.setCreatedAt(LocalDateTime.of(2026, 6, 14, 10, 0)); + + CommandExecutionRecord r = new CommandExecutionRecord(); + r.setId(1L); + r.setCommandId(100L); + r.setAction("RECEIVE"); + r.setExecutorName("李四"); + r.setDescription("确认接收"); + r.setProgress(0); + r.setCreatedAt(LocalDateTime.of(2026, 6, 14, 10, 5)); + + when(trackingMapper.selectList(any(LambdaQueryWrapper.class))) + .thenReturn(List.of(t)); + when(executionMapper.selectList(any(LambdaQueryWrapper.class))) + .thenReturn(List.of(r)); + + List> timeline = trackingService.getFullTimeline(100L); + assertEquals(2, timeline.size()); + assertEquals("TRACKING", timeline.get(0).get("type")); + assertEquals("EXECUTION", timeline.get(1).get("type")); + } + + @Test + void testGetTimelineByCommandNo() { + CommandTracking t = new CommandTracking(); + t.setCommandNo("CMD-20260614-001"); + t.setStage("ISSUED"); + t.setCreatedAt(LocalDateTime.now()); + + when(trackingMapper.selectList(any(LambdaQueryWrapper.class))) + .thenReturn(List.of(t)); + + List result = trackingService.getTimelineByCommandNo("CMD-20260614-001"); + assertEquals(1, result.size()); + assertEquals("ISSUED", result.get(0).getStage()); + } +} diff --git a/wm-mobile-app/pom.xml b/wm-mobile-app/pom.xml new file mode 100644 index 00000000..caff47fc --- /dev/null +++ b/wm-mobile-app/pom.xml @@ -0,0 +1,45 @@ + + + 4.0.0 + com.waterwm-parent1.0.0-SNAPSHOT + wm-mobile-app + wm-mobile-app + 移动APP三合一后端服务层 - 供水/巡检/营业收费统一入口 + + + com.waterwm-common + + + org.springframework.bootspring-boot-starter-web + + + com.alibaba.cloudspring-cloud-starter-alibaba-nacos-discovery + + + com.baomidoumybatis-plus-spring-boot3-starter + + + cn.dev33sa-token-spring-boot3-starter + + + org.postgresqlpostgresql + + + com.github.xiaoyminknife4j-openapi3-jakarta-spring-boot-starter + + + org.springframework.bootspring-boot-starter-testtest + + + + + + org.springframework.boot + spring-boot-maven-plugin + org.projectlomboklombok + + + + diff --git a/wm-mobile-app/src/main/java/com/water/mobile/MobileApplication.java b/wm-mobile-app/src/main/java/com/water/mobile/MobileApplication.java new file mode 100644 index 00000000..293d82c1 --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/MobileApplication.java @@ -0,0 +1,16 @@ +package com.water.mobile; + +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.context.annotation.ComponentScan; + +@SpringBootApplication +@ComponentScan(basePackages = {"com.water.mobile", "com.water.common"}) +@MapperScan("com.water.mobile.mapper") +public class MobileApplication { + + public static void main(String[] args) { + SpringApplication.run(MobileApplication.class, args); + } +} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/controller/MobileController.java b/wm-mobile-app/src/main/java/com/water/mobile/controller/MobileController.java new file mode 100644 index 00000000..a334479e --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/controller/MobileController.java @@ -0,0 +1,20 @@ +package com.water.mobile.controller; +import com.water.common.core.result.R; +import com.water.mobile.entity.PushNotification; +import com.water.mobile.service.MobileApiService; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.*; +@Tag(name="移动APP") @RestController @RequestMapping("/mobile") @RequiredArgsConstructor +public class MobileController { + private final MobileApiService svc; + @PostMapping("/login") public R> login(@RequestParam String username, @RequestParam String password, @RequestParam String appModule) { return R.ok(svc.login(username, password, appModule)); } + @GetMapping("/water/overview") public R> waterOverview() { return R.ok(svc.getWaterOverview()); } + @GetMapping("/patrol/tasks") public R>> patrolTasks(@RequestParam Long userId) { return R.ok(svc.getPatrolTasks(userId)); } + @GetMapping("/billing/summary") public R> billingSummary(@RequestParam Long userId) { return R.ok(svc.getBillingSummary(userId)); } + @GetMapping("/notifications") public R> notifications(@RequestParam Long userId, @RequestParam(required=false) Boolean unreadOnly) { return R.ok(svc.getNotifications(userId, unreadOnly)); } + @PutMapping("/notifications/{id}/read") public R markRead(@PathVariable Long id) { svc.markRead(id); return R.ok("OK"); } + @PostMapping("/notifications/send") public R send(@RequestParam Long userId, @RequestParam String title, @RequestParam String content, @RequestParam String type, @RequestParam String appModule) { return R.ok(svc.sendNotification(userId, title, content, type, appModule)); } + @GetMapping("/update/check") public R> checkUpdate(@RequestParam String appModule, @RequestParam String currentVersion) { return R.ok(svc.checkUpdate(appModule, currentVersion)); } +} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/entity/AppVersion.java b/wm-mobile-app/src/main/java/com/water/mobile/entity/AppVersion.java new file mode 100644 index 00000000..f62f6507 --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/entity/AppVersion.java @@ -0,0 +1,11 @@ +package com.water.mobile.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("mobile_app_version") +public class AppVersion { + @TableId(type = IdType.AUTO) private Long id; + private String appModule, versionNo, downloadUrl, changelog; + private Integer forceUpdate; // 0否 1是 + private Integer status; // 0草稿 1已发布 + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; +} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/entity/MobileUser.java b/wm-mobile-app/src/main/java/com/water/mobile/entity/MobileUser.java new file mode 100644 index 00000000..38c66d48 --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/entity/MobileUser.java @@ -0,0 +1,13 @@ +package com.water.mobile.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("mobile_user") +public class MobileUser { + @TableId(type = IdType.AUTO) private Long id; + private String username, password, realName, phone, avatar; + private String appModule; // 供水/巡检/收费 + private Long sysUserId; // 关联系统用户ID + private Integer status; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; + private LocalDateTime lastLoginTime; +} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/entity/PushNotification.java b/wm-mobile-app/src/main/java/com/water/mobile/entity/PushNotification.java new file mode 100644 index 00000000..46588db6 --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/entity/PushNotification.java @@ -0,0 +1,12 @@ +package com.water.mobile.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("mobile_push_notification") +public class PushNotification { + @TableId(type = IdType.AUTO) private Long id; + private Long userId; private String title, content, type; + private String appModule; // 供水/巡检/收费/系统 + private Integer isRead; // 0未读 1已读 + private String extraData; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; +} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/mapper/AppVersionMapper.java b/wm-mobile-app/src/main/java/com/water/mobile/mapper/AppVersionMapper.java new file mode 100644 index 00000000..2ce3df38 --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/mapper/AppVersionMapper.java @@ -0,0 +1,5 @@ +package com.water.mobile.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.mobile.entity.AppVersion; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface AppVersionMapper extends BaseMapper {} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/mapper/MobileUserMapper.java b/wm-mobile-app/src/main/java/com/water/mobile/mapper/MobileUserMapper.java new file mode 100644 index 00000000..6887b97c --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/mapper/MobileUserMapper.java @@ -0,0 +1,5 @@ +package com.water.mobile.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.mobile.entity.MobileUser; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface MobileUserMapper extends BaseMapper {} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/mapper/PushNotificationMapper.java b/wm-mobile-app/src/main/java/com/water/mobile/mapper/PushNotificationMapper.java new file mode 100644 index 00000000..481ecd0e --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/mapper/PushNotificationMapper.java @@ -0,0 +1,5 @@ +package com.water.mobile.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.mobile.entity.PushNotification; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface PushNotificationMapper extends BaseMapper {} diff --git a/wm-mobile-app/src/main/java/com/water/mobile/service/MobileApiService.java b/wm-mobile-app/src/main/java/com/water/mobile/service/MobileApiService.java new file mode 100644 index 00000000..f8f70b8d --- /dev/null +++ b/wm-mobile-app/src/main/java/com/water/mobile/service/MobileApiService.java @@ -0,0 +1,72 @@ +package com.water.mobile.service; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.mobile.entity.*; +import com.water.mobile.mapper.*; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.util.*; +@Service @RequiredArgsConstructor +public class MobileApiService { + private final MobileUserMapper userMapper; + private final PushNotificationMapper pushMapper; + private final AppVersionMapper verMapper; + + public Map login(String username, String password, String appModule) { + MobileUser u = userMapper.selectOne(new LambdaQueryWrapper() + .eq(MobileUser::getUsername, username) + .eq(MobileUser::getAppModule, appModule)); + if (u == null || !u.getPassword().equals(password)) throw new RuntimeException("登录失败"); + return Map.of("userId", u.getId(), "realName", u.getRealName(), + "appModule", u.getAppModule(), "token", "mock-token-" + u.getId()); + } + // 供水API聚合 + public Map getWaterOverview() { + return Map.of("todaySupply", 12500.0, "yesterdaySupply", 11800.0, + "waterQuality", "合格", "alertCount", 3, "deviceOnlineRate", 0.95); + } + // 巡检API聚合 + public List> getPatrolTasks(Long userId) { + return List.of( + Map.of("id", 1L, "taskName", "主管网巡检A线", "status", "待执行", "deadline", "今日18:00"), + Map.of("id", 2L, "taskName", "消防栓检查-区域B", "status", "进行中", "deadline", "今日17:00") + ); + } + // 收费API聚合 + public Map getBillingSummary(Long userId) { + return Map.of("unpaidCount", 2, "totalAmount", 156.80, + "recentBills", List.of( + Map.of("period", "2025-01", "amount", 78.40, "status", "未缴费"), + Map.of("period", "2024-12", "amount", 82.50, "status", "已缴费") + )); + } + // 消息通知 + public List getNotifications(Long userId, Boolean unreadOnly) { + LambdaQueryWrapper w = new LambdaQueryWrapper() + .eq(PushNotification::getUserId, userId); + if (Boolean.TRUE.equals(unreadOnly)) w.eq(PushNotification::getIsRead, 0); + return pushMapper.selectList(w.orderByDesc(PushNotification::getCreatedTime)); + } + public void markRead(Long notificationId) { + PushNotification n = pushMapper.selectById(notificationId); + if (n != null) { n.setIsRead(1); pushMapper.updateById(n); } + } + public Long sendNotification(Long userId, String title, String content, String type, String appModule) { + PushNotification n = new PushNotification(); + n.setUserId(userId); n.setTitle(title); n.setContent(content); + n.setType(type); n.setAppModule(appModule); n.setIsRead(0); + pushMapper.insert(n); + return n.getId(); + } + // 版本检查 + public Map checkUpdate(String appModule, String currentVersion) { + AppVersion v = verMapper.selectOne(new LambdaQueryWrapper() + .eq(AppVersion::getAppModule, appModule) + .eq(AppVersion::getStatus, 1) + .orderByDesc(AppVersion::getCreatedTime).last("LIMIT 1")); + if (v == null || v.getVersionNo().equals(currentVersion)) + return Map.of("hasUpdate", false); + return Map.of("hasUpdate", true, "versionNo", v.getVersionNo(), + "downloadUrl", v.getDownloadUrl(), "changelog", v.getChangelog(), + "forceUpdate", v.getForceUpdate() == 1); + } +} diff --git a/wm-mobile-app/src/main/resources/application.yml b/wm-mobile-app/src/main/resources/application.yml new file mode 100644 index 00000000..f8de5d73 --- /dev/null +++ b/wm-mobile-app/src/main/resources/application.yml @@ -0,0 +1,15 @@ +server: + port: 9060 +spring: + application: + name: wm-mobile-app + datasource: + url: jdbc:postgresql://localhost:5432/water_mobile + username: water + password: water123 +mybatis-plus: + configuration: + map-underscore-to-camel-case: true + global-config: + db-config: + id-type: auto diff --git a/wm-mobile-app/src/main/resources/db/V1__mobile_app.sql b/wm-mobile-app/src/main/resources/db/V1__mobile_app.sql new file mode 100644 index 00000000..8197459a --- /dev/null +++ b/wm-mobile-app/src/main/resources/db/V1__mobile_app.sql @@ -0,0 +1,18 @@ +CREATE TABLE IF NOT EXISTS mobile_user ( + id BIGSERIAL PRIMARY KEY, username VARCHAR(50), password VARCHAR(200), + real_name VARCHAR(50), phone VARCHAR(20), avatar VARCHAR(500), + app_module VARCHAR(20), sys_user_id BIGINT, status INT DEFAULT 1, + created_time TIMESTAMP DEFAULT NOW(), last_login_time TIMESTAMP +); +CREATE TABLE IF NOT EXISTS mobile_push_notification ( + id BIGSERIAL PRIMARY KEY, user_id BIGINT, title VARCHAR(200), + content TEXT, type VARCHAR(30), app_module VARCHAR(20), + is_read INT DEFAULT 0, extra_data TEXT, + created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS mobile_app_version ( + id BIGSERIAL PRIMARY KEY, app_module VARCHAR(20), version_no VARCHAR(20), + download_url VARCHAR(500), changelog TEXT, + force_update INT DEFAULT 0, status INT DEFAULT 0, + created_time TIMESTAMP DEFAULT NOW() +); diff --git a/wm-patrol/src/main/java/com/water/patrol/controller/PatrolController.java b/wm-patrol/src/main/java/com/water/patrol/controller/PatrolController.java new file mode 100644 index 00000000..1903ede2 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/controller/PatrolController.java @@ -0,0 +1,100 @@ +package com.water.patrol.controller; + +import com.water.common.core.result.R; +import com.water.patrol.service.PatrolService; +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.time.LocalDate; +import java.util.*; + +@Tag(name = "巡检管理") +@RestController +@RequestMapping("/patrol") +@RequiredArgsConstructor +public class PatrolController { + + private final PatrolService patrolService; + + // ---- 路线 ---- + @PostMapping("/route") + public R> createRoute(@RequestBody Map req) { + @SuppressWarnings("unchecked") + List> points = (List>) req.getOrDefault("points", List.of()); + return R.ok(patrolService.createRoute( + (String) req.get("routeName"), (String) req.get("area"), + points, (int) req.getOrDefault("estimDuration", 60))); + } + + @GetMapping("/route/list") + public R>> routes(@RequestParam String area) { + return R.ok(patrolService.getRoutes(area)); + } + + // ---- 任务 ---- + @PostMapping("/task") + public R> createTask(@RequestBody Map req) { + return R.ok(patrolService.createTask( + Long.parseLong(String.valueOf(req.get("routeId"))), + Long.parseLong(String.valueOf(req.get("assigneeId"))), + (String) req.get("taskDate"))); + } + + @GetMapping("/task/today") + public R>> todayTasks(@RequestParam Long userId) { + return R.ok(patrolService.getTodayTasks(userId)); + } + + @PutMapping("/task/{id}/start") + public R> startTask(@PathVariable Long id) { + return R.ok(patrolService.startTask(id)); + } + + @PutMapping("/task/{id}/complete") + public R> completeTask(@PathVariable Long id, @RequestParam double distance) { + return R.ok(patrolService.completeTask(id, distance)); + } + + // ---- 巡检记录 ---- + @PostMapping("/record") + public R> record(@RequestBody Map req) { + @SuppressWarnings("unchecked") + List> items = (List>) req.getOrDefault("checkItems", List.of()); + return R.ok(patrolService.recordCheck( + Long.parseLong(String.valueOf(req.get("taskId"))), + (int) req.get("pointSeq"), + req.get("deviceId") != null ? Long.parseLong(String.valueOf(req.get("deviceId"))) : null, + items, + ((Number) req.get("lng")).doubleValue(), + ((Number) req.get("lat")).doubleValue())); + } + + @GetMapping("/record/list/{taskId}") + public R>> records(@PathVariable Long taskId) { + return R.ok(patrolService.getTaskRecords(taskId)); + } + + // ---- 问题上报 ---- + @PostMapping("/issue/report") + public R> reportIssue(@RequestBody Map req) { + @SuppressWarnings("unchecked") + List photos = (List) req.getOrDefault("photoUrls", List.of()); + return R.ok(patrolService.reportIssue( + Long.parseLong(String.valueOf(req.get("taskId"))), + req.get("deviceId") != null ? Long.parseLong(String.valueOf(req.get("deviceId"))) : null, + (String) req.get("issueType"), (String) req.get("description"), + photos, + ((Number) req.get("lng")).doubleValue(), + ((Number) req.get("lat")).doubleValue())); + } + + // ---- 统计 ---- + @GetMapping("/stats") + public R> stats(@RequestParam String area, + @RequestParam String start, + @RequestParam String end) { + return R.ok(patrolService.getStats(area, LocalDate.parse(start), LocalDate.parse(end))); + } +} diff --git a/wm-patrol/src/main/java/com/water/patrol/controller/PatrolProblemController.java b/wm-patrol/src/main/java/com/water/patrol/controller/PatrolProblemController.java new file mode 100644 index 00000000..22ce8596 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/controller/PatrolProblemController.java @@ -0,0 +1,126 @@ +package com.water.patrol.controller; + +import com.water.patrol.entity.PatrolProblem; +import com.water.patrol.service.PatrolProblemService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/api/patrol/problems") +public class PatrolProblemController { + + @Autowired + private PatrolProblemService patrolProblemService; + + /** + * 创建巡检问题 + */ + @PostMapping + public ResponseEntity createProblem(@RequestBody PatrolProblem patrolProblem) { + PatrolProblem created = patrolProblemService.createProblem(patrolProblem); + return ResponseEntity.ok(created); + } + + /** + * 根据ID查询问题 + */ + @GetMapping("/{id}") + public ResponseEntity getProblemById(@PathVariable Long id) { + PatrolProblem problem = patrolProblemService.getProblemById(id); + if (problem != null) { + return ResponseEntity.ok(problem); + } + return ResponseEntity.notFound().build(); + } + + /** + * 根据问题编号查询 + */ + @GetMapping("/problem-no/{problemNo}") + public ResponseEntity getProblemByProblemNo(@PathVariable String problemNo) { + PatrolProblem problem = patrolProblemService.getProblemByProblemNo(problemNo); + if (problem != null) { + return ResponseEntity.ok(problem); + } + return ResponseEntity.notFound().build(); + } + + /** + * 根据任务ID查询问题列表 + */ + @GetMapping("/task/{taskId}") + public ResponseEntity> getProblemsByTaskId(@PathVariable Long taskId) { + List problems = patrolProblemService.getProblemsByTaskId(taskId); + return ResponseEntity.ok(problems); + } + + /** + * 根据状态查询问题列表 + */ + @GetMapping("/status/{status}") + public ResponseEntity> getProblemsByStatus(@PathVariable String status) { + List problems = patrolProblemService.getProblemsByStatus(status); + return ResponseEntity.ok(problems); + } + + /** + * 根据设备ID查询问题列表 + */ + @GetMapping("/device/{deviceId}") + public ResponseEntity> getProblemsByDeviceId(@PathVariable Long deviceId) { + List problems = patrolProblemService.getProblemsByDeviceId(deviceId); + return ResponseEntity.ok(problems); + } + + /** + * 更新问题信息 + */ + @PutMapping("/{id}") + public ResponseEntity updateProblem(@PathVariable Long id, @RequestBody PatrolProblem patrolProblem) { + patrolProblem.setId(id); + PatrolProblem updated = patrolProblemService.updateProblem(patrolProblem); + if (updated != null) { + return ResponseEntity.ok(updated); + } + return ResponseEntity.notFound().build(); + } + + /** + * 更新问题状态 + */ + @PutMapping("/{id}/status") + public ResponseEntity updateProblemStatus(@PathVariable Long id, @RequestParam String status, @RequestParam(required = false) Long workOrderId) { + boolean updated = patrolProblemService.updateProblemStatus(id, status, workOrderId); + return ResponseEntity.ok(updated); + } + + /** + * 删除问题 + */ + @DeleteMapping("/{id}") + public ResponseEntity deleteProblem(@PathVariable Long id) { + boolean deleted = patrolProblemService.deleteProblem(id); + return ResponseEntity.ok(deleted); + } + + /** + * 自动创建工单 + */ + @PostMapping("/{id}/auto-create-work-order") + public ResponseEntity autoCreateWorkOrder(@PathVariable Long id) { + boolean created = patrolProblemService.autoCreateWorkOrder(id); + return ResponseEntity.ok(created); + } + + /** + * 获取问题统计信息 + */ + @GetMapping("/statistics") + public ResponseEntity getProblemStatistics() { + PatrolProblemService.ProblemStatistics statistics = patrolProblemService.getProblemStatistics(); + return ResponseEntity.ok(statistics); + } +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/controller/WorkOrderController.java b/wm-patrol/src/main/java/com/water/patrol/controller/WorkOrderController.java new file mode 100644 index 00000000..45494f48 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/controller/WorkOrderController.java @@ -0,0 +1,151 @@ +package com.water.patrol.controller; + +import com.water.patrol.entity.WorkOrder; +import com.water.patrol.service.WorkOrderService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/api/work-orders") +public class WorkOrderController { + + @Autowired + private WorkOrderService workOrderService; + + /** + * 根据ID查询工单 + */ + @GetMapping("/{id}") + public ResponseEntity getWorkOrderById(@PathVariable Long id) { + WorkOrder workOrder = workOrderService.getWorkOrderById(id); + if (workOrder != null) { + return ResponseEntity.ok(workOrder); + } + return ResponseEntity.notFound().build(); + } + + /** + * 根据工单编号查询 + */ + @GetMapping("/order-no/{orderNo}") + public ResponseEntity getWorkOrderByOrderNo(@PathVariable String orderNo) { + WorkOrder workOrder = workOrderService.getWorkOrderByOrderNo(orderNo); + if (workOrder != null) { + return ResponseEntity.ok(workOrder); + } + return ResponseEntity.notFound().build(); + } + + /** + * 根据问题ID查询工单 + */ + @GetMapping("/problem/{problemId}") + public ResponseEntity getWorkOrderByProblemId(@PathVariable Long problemId) { + WorkOrder workOrder = workOrderService.getWorkOrderByProblemId(problemId); + if (workOrder != null) { + return ResponseEntity.ok(workOrder); + } + return ResponseEntity.notFound().build(); + } + + /** + * 根据状态查询工单列表 + */ + @GetMapping("/status/{status}") + public ResponseEntity> getWorkOrdersByStatus(@PathVariable String status) { + List workOrders = workOrderService.getWorkOrdersByStatus(status); + return ResponseEntity.ok(workOrders); + } + + /** + * 根据处理人查询工单列表 + */ + @GetMapping("/assignee/{assigneeId}") + public ResponseEntity> getWorkOrdersByAssigneeId(@PathVariable Long assigneeId) { + List workOrders = workOrderService.getWorkOrdersByAssigneeId(assigneeId); + return ResponseEntity.ok(workOrders); + } + + /** + * 根据处理状态查询工单列表 + */ + @GetMapping("/process-status/{processStatus}") + public ResponseEntity> getWorkOrdersByProcessStatus(@PathVariable String processStatus) { + List workOrders = workOrderService.getWorkOrdersByProcessStatus(processStatus); + return ResponseEntity.ok(workOrders); + } + + /** + * 更新工单信息 + */ + @PutMapping("/{id}") + public ResponseEntity updateWorkOrder(@PathVariable Long id, @RequestBody WorkOrder workOrder) { + workOrder.setId(id); + WorkOrder updated = workOrderService.updateWorkOrder(workOrder); + if (updated != null) { + return ResponseEntity.ok(updated); + } + return ResponseEntity.notFound().build(); + } + + /** + * 更新工单状态 + */ + @PutMapping("/{id}/status") + public ResponseEntity updateWorkOrderStatus(@PathVariable Long id, + @RequestParam String status, + @RequestParam(required = false) String processStatus) { + boolean updated = workOrderService.updateWorkOrderStatus(id, status, processStatus); + return ResponseEntity.ok(updated); + } + + /** + * 分派工单 + */ + @PutMapping("/{id}/assign") + public ResponseEntity assignWorkOrder(@PathVariable Long id, + @RequestParam Long assigneeId, + @RequestParam String assigneeName) { + boolean assigned = workOrderService.assignWorkOrder(id, assigneeId, assigneeName); + return ResponseEntity.ok(assigned); + } + + /** + * 开始处理工单 + */ + @PutMapping("/{id}/start") + public ResponseEntity startWorkOrder(@PathVariable Long id) { + boolean started = workOrderService.startWorkOrder(id); + return ResponseEntity.ok(started); + } + + /** + * 完成工单 + */ + @PutMapping("/{id}/complete") + public ResponseEntity completeWorkOrder(@PathVariable Long id, @RequestParam String solutionResult) { + boolean completed = workOrderService.completeWorkOrder(id, solutionResult); + return ResponseEntity.ok(completed); + } + + /** + * 删除工单 + */ + @DeleteMapping("/{id}") + public ResponseEntity deleteWorkOrder(@PathVariable Long id) { + boolean deleted = workOrderService.deleteWorkOrder(id); + return ResponseEntity.ok(deleted); + } + + /** + * 获取工单统计信息 + */ + @GetMapping("/statistics") + public ResponseEntity getWorkOrderStatistics() { + WorkOrderService.WorkOrderStatistics statistics = workOrderService.getWorkOrderStatistics(); + return ResponseEntity.ok(statistics); + } +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/entity/PatrolProblem.java b/wm-patrol/src/main/java/com/water/patrol/entity/PatrolProblem.java new file mode 100644 index 00000000..37294ca5 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/entity/PatrolProblem.java @@ -0,0 +1,31 @@ +package com.water.patrol.entity; + +import lombok.Data; +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +@Data +public class PatrolProblem { + private Long id; + private String problemNo; + private Long taskId; + private Integer pointSeq; + private Long deviceId; + private String deviceName; + private String problemType; // 设备故障/水质异常/安全隐患/环境卫生/其他 + private String problemLevel; // low/normal/high/critical + private String problemTitle; + private String problemDescription; + private String location; + private Double lng; + private Double lat; + private List photoUrls; + private Long reporterId; + private String reporterName; + private LocalDateTime reportTime; + private String status; // reported/processing/completed/closed + private Long workOrderId; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/entity/WorkOrder.java b/wm-patrol/src/main/java/com/water/patrol/entity/WorkOrder.java new file mode 100644 index 00000000..13b74a54 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/entity/WorkOrder.java @@ -0,0 +1,37 @@ +package com.water.patrol.entity; + +import lombok.Data; +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +@Data +public class WorkOrder { + private Long id; + private String orderNo; + private Long problemId; + private String orderType; // 设备维修/水质处理/安全隐患处理/清洁/其他 + private String priority; // low/normal/high/critical + private String title; + private String description; + private String location; + private String contactPerson; + private String contactPhone; + private Long reporterId; + private String reporterName; + private Long assigneeId; + private String assigneeName; + private String status; // pending/assigned/processing/completed/cancelled + private String processStatus; // created/accepted/in_progress/completed + private Integer estimatedDuration; + private LocalDateTime actualStartTime; + private LocalDateTime actualEndTime; + private LocalDateTime completionTime; + private List photosBefore; + private List photosAfter; + private String solutionDescription; + private String solutionResult; + private String customerFeedback; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/entity/WorkOrderProcess.java b/wm-patrol/src/main/java/com/water/patrol/entity/WorkOrderProcess.java new file mode 100644 index 00000000..3d49bd82 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/entity/WorkOrderProcess.java @@ -0,0 +1,18 @@ +package com.water.patrol.entity; + +import lombok.Data; +import java.time.LocalDateTime; +import java.util.List; + +@Data +public class WorkOrderProcess { + private Long id; + private Long workOrderId; + private String processStep; // created/accepted/in_progress/completed + private Long processorId; + private String processorName; + private String action; // create/assign/start/complete/cancel + private String comment; + private List photos; + private LocalDateTime createdAt; +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/mapper/PatrolProblemMapper.java b/wm-patrol/src/main/java/com/water/patrol/mapper/PatrolProblemMapper.java new file mode 100644 index 00000000..766fd587 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/mapper/PatrolProblemMapper.java @@ -0,0 +1,47 @@ +package com.water.patrol.mapper; + +import com.water.patrol.entity.PatrolProblem; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import java.time.LocalDateTime; +import java.util.List; + +@Mapper +public interface PatrolProblemMapper { + + // 插入巡检问题 + int insert(PatrolProblem patrolProblem); + + // 根据ID查询 + PatrolProblem selectById(Long id); + + // 根据问题编号查询 + PatrolProblem selectByProblemNo(String problemNo); + + // 根据任务ID查询问题列表 + List selectByTaskId(Long taskId); + + // 根据状态查询问题列表 + List selectByStatus(String status); + + // 根据设备ID查询问题列表 + List selectByDeviceId(Long deviceId); + + // 更新问题信息 + int update(PatrolProblem patrolProblem); + + // 更新问题状态 + int updateStatus(@Param("id") Long id, @Param("status") String status, @Param("workOrderId") Long workOrderId); + + // 删除问题 + int deleteById(Long id); + + // 生成问题编号 + String generateProblemNo(); + + // 获取问题总数 + int countAll(); + + // 获取指定状态的问题数 + int countByStatus(String status); +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/mapper/WorkOrderMapper.java b/wm-patrol/src/main/java/com/water/patrol/mapper/WorkOrderMapper.java new file mode 100644 index 00000000..5704d5c1 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/mapper/WorkOrderMapper.java @@ -0,0 +1,60 @@ +package com.water.patrol.mapper; + +import com.water.patrol.entity.WorkOrder; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import java.time.LocalDateTime; +import java.util.List; + +@Mapper +public interface WorkOrderMapper { + + // 插入工单 + int insert(WorkOrder workOrder); + + // 根据ID查询 + WorkOrder selectById(Long id); + + // 根据工单编号查询 + WorkOrder selectByOrderNo(String orderNo); + + // 根据问题ID查询工单 + WorkOrder selectByProblemId(Long problemId); + + // 根据状态查询工单列表 + List selectByStatus(String status); + + // 根据处理人查询工单列表 + List selectByAssigneeId(Long assigneeId); + + // 根据处理状态查询工单列表 + List selectByProcessStatus(String processStatus); + + // 更新工单信息 + int update(WorkOrder workOrder); + + // 更新工单状态 + int updateStatus(@Param("id") Long id, @Param("status") String status, @Param("processStatus") String processStatus); + + // 更新处理人 + int updateAssignee(@Param("id") Long id, @Param("assigneeId") Long assigneeId, @Param("assigneeName") String assigneeName); + + // 更新完成信息 + int updateCompletion(@Param("id") Long id, @Param("actualEndTime") LocalDateTime actualEndTime, + @Param("completionTime") LocalDateTime completionTime, @Param("solutionResult") String solutionResult); + + // 删除工单 + int deleteById(Long id); + + // 生成工单编号 + String generateOrderNo(); + + // 获取工单总数 + int countAll(); + + // 获取指定状态的工单数 + int countByStatus(String status); + + // 获取指定处理状态的工单数 + int countByProcessStatus(String processStatus); +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/mapper/WorkOrderProcessMapper.java b/wm-patrol/src/main/java/com/water/patrol/mapper/WorkOrderProcessMapper.java new file mode 100644 index 00000000..9abfb3a9 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/mapper/WorkOrderProcessMapper.java @@ -0,0 +1,25 @@ +package com.water.patrol.mapper; + +import com.water.patrol.entity.WorkOrderProcess; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import java.util.List; + +@Mapper +public interface WorkOrderProcessMapper { + + // 插入处理记录 + int insert(WorkOrderProcess workOrderProcess); + + // 根据工单ID查询处理记录列表 + List selectByWorkOrderId(Long workOrderId); + + // 根据ID查询 + WorkOrderProcess selectById(Long id); + + // 获取最新的处理记录 + WorkOrderProcess selectLatestByWorkOrderId(Long workOrderId); + + // 删除处理记录 + int deleteById(Long id); +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/service/PatrolProblemService.java b/wm-patrol/src/main/java/com/water/patrol/service/PatrolProblemService.java new file mode 100644 index 00000000..47b14985 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/service/PatrolProblemService.java @@ -0,0 +1,82 @@ +package com.water.patrol.service; + +import com.water.patrol.entity.PatrolProblem; +import java.util.List; + +public interface PatrolProblemService { + + /** + * 创建巡检问题 + */ + PatrolProblem createProblem(PatrolProblem patrolProblem); + + /** + * 根据ID查询问题 + */ + PatrolProblem getProblemById(Long id); + + /** + * 根据问题编号查询 + */ + PatrolProblem getProblemByProblemNo(String problemNo); + + /** + * 根据任务ID查询问题列表 + */ + List getProblemsByTaskId(Long taskId); + + /** + * 根据状态查询问题列表 + */ + List getProblemsByStatus(String status); + + /** + * 根据设备ID查询问题列表 + */ + List getProblemsByDeviceId(Long deviceId); + + /** + * 更新问题信息 + */ + PatrolProblem updateProblem(PatrolProblem patrolProblem); + + /** + * 更新问题状态 + */ + boolean updateProblemStatus(Long id, String status, Long workOrderId); + + /** + * 删除问题 + */ + boolean deleteProblem(Long id); + + /** + * 自动创建工单 + */ + boolean autoCreateWorkOrder(Long problemId); + + /** + * 获取问题统计信息 + */ + ProblemStatistics getProblemStatistics(); + + class ProblemStatistics { + private int totalProblems; + private int reportedCount; + private int processingCount; + private int completedCount; + private int closedCount; + + // Getters and setters + public int getTotalProblems() { return totalProblems; } + public void setTotalProblems(int totalProblems) { this.totalProblems = totalProblems; } + public int getReportedCount() { return reportedCount; } + public void setReportedCount(int reportedCount) { this.reportedCount = reportedCount; } + public int getProcessingCount() { return processingCount; } + public void setProcessingCount(int processingCount) { this.processingCount = processingCount; } + public int getCompletedCount() { return completedCount; } + public void setCompletedCount(int completedCount) { this.completedCount = completedCount; } + public int getClosedCount() { return closedCount; } + public void setClosedCount(int closedCount) { this.closedCount = closedCount; } + } +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/service/PatrolService.java b/wm-patrol/src/main/java/com/water/patrol/service/PatrolService.java new file mode 100644 index 00000000..6244618a --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/service/PatrolService.java @@ -0,0 +1,118 @@ +package com.water.patrol.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.time.LocalDate; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class PatrolService { + + private final JdbcTemplate jdbc; + + // ========== 路线管理 ========== + public Map createRoute(String routeName, String area, List> points, int estimDuration) { + jdbc.update("INSERT INTO patrol_route (route_name, area, route_points, estim_duration) VALUES (?,?,?::jsonb,?)", + routeName, area, points.toString(), estimDuration); + return Map.of("routeName", routeName, "area", area, "points", points.size()); + } + + public List> getRoutes(String area) { + return jdbc.queryForList("SELECT * FROM patrol_route WHERE area = ? AND status = 1", area); + } + + // ========== 任务管理 ========== + public Map createTask(Long routeId, Long assigneeId, String taskDate) { + jdbc.update( + "INSERT INTO patrol_task (route_id, assignee_id, task_name, task_date, plan_start, plan_end, status) " + + "SELECT ?, ?, route_name, ?, CAST(? AS TIMESTAMP), CAST(? AS TIMESTAMP) + (estim_duration || ' minutes')::INTERVAL, 'pending' " + + "FROM patrol_route WHERE id = ?", + routeId, assigneeId, taskDate, taskDate + " 09:00:00", taskDate + " 09:00:00", routeId); + return Map.of("routeId", routeId, "assigneeId", assigneeId, "date", taskDate, "status", "created"); + } + + public List> getTodayTasks(Long userId) { + return jdbc.queryForList( + "SELECT pt.*, pr.route_name, pr.area FROM patrol_task pt " + + "LEFT JOIN patrol_route pr ON pt.route_id = pr.id " + + "WHERE pt.task_date = CURRENT_DATE AND pt.assignee_id = ? " + + "ORDER BY pt.plan_start", userId); + } + + public Map startTask(Long taskId) { + jdbc.update("UPDATE patrol_task SET status = 'in_progress', actual_start = NOW() WHERE id = ?", taskId); + return Map.of("taskId", taskId, "status", "in_progress", "startedAt", new Date()); + } + + public Map completeTask(Long taskId, double distance) { + jdbc.update( + "UPDATE patrol_task SET status = 'completed', actual_end = NOW(), distance = ? WHERE id = ?", + distance, taskId); + return Map.of("taskId", taskId, "status", "completed", "distance", distance); + } + + // ========== 巡检记录 ========== + public Map recordCheck(Long taskId, int pointSeq, Long deviceId, + List> checkItems, + double lng, double lat) { + jdbc.update( + "INSERT INTO patrol_record (task_id, point_seq, device_id, check_items, gps_lng, gps_lat, record_time) " + + "VALUES (?,?,?,?::jsonb,?,?,NOW())", + taskId, pointSeq, deviceId, checkItems.toString(), lng, lat); + return Map.of("taskId", taskId, "pointSeq", pointSeq, "recorded", true); + } + + public List> getTaskRecords(Long taskId) { + return jdbc.queryForList( + "SELECT * FROM patrol_record WHERE task_id = ? ORDER BY point_seq", taskId); + } + + // ========== 问题上报（巡检APP） ========== + public Map reportIssue(Long taskId, Long deviceId, String issueType, + String description, List photoUrls, + double lng, double lat) { + // 自动创建工单 + jdbc.update( + "INSERT INTO patrol_task (task_name, assignee_id, task_date, status) " + + "SELECT CONCAT('问题处理: ', ?), assignee_id, CURRENT_DATE, 'pending' FROM patrol_task WHERE id = ?", + issueType + ": " + description.substring(0, Math.min(description.length(), 50)), taskId); + + log.info("Issue reported: type={} desc={}", issueType, description); + return Map.of("reported", true, "issueType", issueType, "photos", photoUrls); + } + + // ========== 统计分析 ========== + public Map getStats(String area, LocalDate start, LocalDate end) { + Map stats = new LinkedHashMap<>(); + + // 任务执行率 + stats.put("completionRate", jdbc.queryForMap( + "SELECT COUNT(*) as total, SUM(CASE WHEN status='completed' THEN 1 ELSE 0 END) as completed " + + "FROM patrol_task WHERE task_date BETWEEN ? AND ?", start, end)); + + // 人员里程 + stats.put("personDistance", jdbc.queryForList( + "SELECT u.real_name, SUM(pt.distance) as total_km " + + "FROM patrol_task pt JOIN sys_user u ON pt.assignee_id = u.id " + + "WHERE pt.task_date BETWEEN ? AND ? GROUP BY u.id, u.real_name", start, end)); + + // 巡检工作量 + stats.put("workload", jdbc.queryForList( + "SELECT task_date, COUNT(*) as tasks, SUM(distance) as total_km " + + "FROM patrol_task WHERE task_date BETWEEN ? AND ? GROUP BY task_date ORDER BY task_date", + start, end)); + + // 问题分类统计 + stats.put("issueStats", jdbc.queryForList( + "SELECT SUBSTRING(task_name FROM '^[^:]+') as issue_type, COUNT(*) as count " + + "FROM patrol_task WHERE task_name LIKE '%问题处理:%' AND task_date BETWEEN ? AND ? GROUP BY 1", + start, end)); + + return stats; + } +} diff --git a/wm-patrol/src/main/java/com/water/patrol/service/WorkOrderService.java b/wm-patrol/src/main/java/com/water/patrol/service/WorkOrderService.java new file mode 100644 index 00000000..630a7ce8 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/service/WorkOrderService.java @@ -0,0 +1,100 @@ +package com.water.patrol.service; + +import com.water.patrol.entity.WorkOrder; +import java.util.List; + +public interface WorkOrderService { + + /** + * 从巡检问题创建工单 + */ + boolean createFromProblem(PatrolProblem problem); + + /** + * 根据ID查询工单 + */ + WorkOrder getWorkOrderById(Long id); + + /** + * 根据工单编号查询 + */ + WorkOrder getWorkOrderByOrderNo(String orderNo); + + /** + * 根据问题ID查询工单 + */ + WorkOrder getWorkOrderByProblemId(Long problemId); + + /** + * 根据状态查询工单列表 + */ + List getWorkOrdersByStatus(String status); + + /** + * 根据处理人查询工单列表 + */ + List getWorkOrdersByAssigneeId(Long assigneeId); + + /** + * 根据处理状态查询工单列表 + */ + List getWorkOrdersByProcessStatus(String processStatus); + + /** + * 更新工单信息 + */ + WorkOrder updateWorkOrder(WorkOrder workOrder); + + /** + * 更新工单状态 + */ + boolean updateWorkOrderStatus(Long id, String status, String processStatus); + + /** + * 分派工单 + */ + boolean assignWorkOrder(Long id, Long assigneeId, String assigneeName); + + /** + * 开始处理工单 + */ + boolean startWorkOrder(Long id); + + /** + * 完成工单 + */ + boolean completeWorkOrder(Long id, String solutionResult); + + /** + * 删除工单 + */ + boolean deleteWorkOrder(Long id); + + /** + * 获取工单统计信息 + */ + WorkOrderStatistics getWorkOrderStatistics(); + + class WorkOrderStatistics { + private int totalOrders; + private int pendingCount; + private int assignedCount; + private int processingCount; + private int completedCount; + private int cancelledCount; + + // Getters and setters + public int getTotalOrders() { return totalOrders; } + public void setTotalOrders(int totalOrders) { this.totalOrders = totalOrders; } + public int getPendingCount() { return pendingCount; } + public void setPendingCount(int pendingCount) { this.pendingCount = pendingCount; } + public int getAssignedCount() { return assignedCount; } + public void setAssignedCount(int assignedCount) { this.assignedCount = assignedCount; } + public int getProcessingCount() { return processingCount; } + public void setProcessingCount(int processingCount) { this.processingCount = processingCount; } + public int getCompletedCount() { return completedCount; } + public void setCompletedCount(int completedCount) { this.completedCount = completedCount; } + public int getCancelledCount() { return cancelledCount; } + public void setCancelledCount(int cancelledCount) { this.cancelledCount = cancelledCount; } + } +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/service/impl/PatrolProblemServiceImpl.java b/wm-patrol/src/main/java/com/water/patrol/service/impl/PatrolProblemServiceImpl.java new file mode 100644 index 00000000..bf35e96c --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/service/impl/PatrolProblemServiceImpl.java @@ -0,0 +1,109 @@ +package com.water.patrol.service.impl; + +import com.water.patrol.entity.PatrolProblem; +import com.water.patrol.mapper.PatrolProblemMapper; +import com.water.patrol.service.PatrolProblemService; +import com.water.patrol.service.WorkOrderService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.util.List; + +@Service +public class PatrolProblemServiceImpl implements PatrolProblemService { + + @Autowired + private PatrolProblemMapper patrolProblemMapper; + + @Autowired + private WorkOrderService workOrderService; + + @Override + @Transactional + public PatrolProblem createProblem(PatrolProblem patrolProblem) { + // 生成问题编号 + String problemNo = patrolProblemMapper.generateProblemNo(); + patrolProblem.setProblemNo(problemNo); + patrolProblem.setReportTime(LocalDateTime.now()); + patrolProblem.setStatus("reported"); + patrolProblem.setCreatedAt(LocalDateTime.now()); + patrolProblem.setUpdatedAt(LocalDateTime.now()); + + patrolProblemMapper.insert(patrolProblem); + + // 自动创建工单 + autoCreateWorkOrder(patrolProblem.getId()); + + return patrolProblem; + } + + @Override + public PatrolProblem getProblemById(Long id) { + return patrolProblemMapper.selectById(id); + } + + @Override + public PatrolProblem getProblemByProblemNo(String problemNo) { + return patrolProblemMapper.selectByProblemNo(problemNo); + } + + @Override + public List getProblemsByTaskId(Long taskId) { + return patrolProblemMapper.selectByTaskId(taskId); + } + + @Override + public List getProblemsByStatus(String status) { + return patrolProblemMapper.selectByStatus(status); + } + + @Override + public List getProblemsByDeviceId(Long deviceId) { + return patrolProblemMapper.selectByDeviceId(deviceId); + } + + @Override + @Transactional + public PatrolProblem updateProblem(PatrolProblem patrolProblem) { + patrolProblem.setUpdatedAt(LocalDateTime.now()); + patrolProblemMapper.update(patrolProblem); + return patrolProblem; + } + + @Override + @Transactional + public boolean updateProblemStatus(Long id, String status, Long workOrderId) { + LocalDateTime now = LocalDateTime.now(); + return patrolProblemMapper.updateStatus(id, status, workOrderId) > 0; + } + + @Override + @Transactional + public boolean deleteProblem(Long id) { + return patrolProblemMapper.deleteById(id) > 0; + } + + @Override + @Transactional + public boolean autoCreateWorkOrder(Long problemId) { + PatrolProblem problem = getProblemById(problemId); + if (problem == null) { + return false; + } + + return workOrderService.createFromProblem(problem); + } + + @Override + public ProblemStatistics getProblemStatistics() { + ProblemStatistics statistics = new ProblemStatistics(); + statistics.setTotalProblems(patrolProblemMapper.countAll()); + statistics.setReportedCount(patrolProblemMapper.countByStatus("reported")); + statistics.setProcessingCount(patrolProblemMapper.countByStatus("processing")); + statistics.setCompletedCount(patrolProblemMapper.countByStatus("completed")); + statistics.setClosedCount(patrolProblemMapper.countByStatus("closed")); + return statistics; + } +} \ No newline at end of file diff --git a/wm-patrol/src/main/java/com/water/patrol/service/impl/WorkOrderServiceImpl.java b/wm-patrol/src/main/java/com/water/patrol/service/impl/WorkOrderServiceImpl.java new file mode 100644 index 00000000..9d8b9011 --- /dev/null +++ b/wm-patrol/src/main/java/com/water/patrol/service/impl/WorkOrderServiceImpl.java @@ -0,0 +1,241 @@ +package com.water.patrol.service.impl; + +import com.water.patrol.entity.PatrolProblem; +import com.water.patrol.entity.WorkOrder; +import com.water.patrol.entity.WorkOrderProcess; +import com.water.patrol.mapper.WorkOrderMapper; +import com.water.patrol.mapper.WorkOrderProcessMapper; +import com.water.patrol.service.WorkOrderService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.util.List; + +@Service +public class WorkOrderServiceImpl implements WorkOrderService { + + @Autowired + private WorkOrderMapper workOrderMapper; + + @Autowired + private WorkOrderProcessMapper workOrderProcessMapper; + + @Override + @Transactional + public boolean createFromProblem(PatrolProblem problem) { + WorkOrder workOrder = new WorkOrder(); + workOrder.setOrderNo(workOrderMapper.generateOrderNo()); + workOrder.setProblemId(problem.getId()); + workOrder.setOrderType(determineOrderType(problem.getProblemType())); + workOrder.setPriority(determinePriority(problem.getProblemLevel())); + workOrder.setTitle(problem.getProblemTitle()); + workOrder.setDescription(problem.getProblemDescription()); + workOrder.setLocation(problem.getLocation()); + workOrder.setReporterId(problem.getReporterId()); + workOrder.setReporterName(problem.getReporterName()); + workOrder.setStatus("pending"); + workOrder.setProcessStatus("created"); + workOrder.setEstimatedDuration(30); // 默认30分钟 + workOrder.setCreatedAt(LocalDateTime.now()); + workOrder.setUpdatedAt(LocalDateTime.now()); + + int result = workOrderMapper.insert(workOrder); + + if (result > 0) { + // 创建处理记录 + WorkOrderProcess process = new WorkOrderProcess(); + process.setWorkOrderId(workOrder.getId()); + process.setProcessStep("created"); + process.setProcessorId(problem.getReporterId()); + process.setProcessorName(problem.getReporterName()); + process.setAction("create"); + process.setComment("工单自动创建"); + process.setCreatedAt(LocalDateTime.now()); + workOrderProcessMapper.insert(process); + + // 更新问题状态 + workOrderMapper.selectByProblemId(problem.getId()).setWorkOrderId(workOrder.getId()); + return true; + } + + return false; + } + + @Override + public WorkOrder getWorkOrderById(Long id) { + return workOrderMapper.selectById(id); + } + + @Override + public WorkOrder getWorkOrderByOrderNo(String orderNo) { + return workOrderMapper.selectByOrderNo(orderNo); + } + + @Override + public WorkOrder getWorkOrderByProblemId(Long problemId) { + return workOrderMapper.selectByProblemId(problemId); + } + + @Override + public List getWorkOrdersByStatus(String status) { + return workOrderMapper.selectByStatus(status); + } + + @Override + public List getWorkOrdersByAssigneeId(Long assigneeId) { + return workOrderMapper.selectByAssigneeId(assigneeId); + } + + @Override + public List getWorkOrdersByProcessStatus(String processStatus) { + return workOrderMapper.selectByProcessStatus(processStatus); + } + + @Override + @Transactional + public WorkOrder updateWorkOrder(WorkOrder workOrder) { + workOrder.setUpdatedAt(LocalDateTime.now()); + workOrderMapper.update(workOrder); + return workOrder; + } + + @Override + @Transactional + public boolean updateWorkOrderStatus(Long id, String status, String processStatus) { + LocalDateTime now = LocalDateTime.now(); + return workOrderMapper.updateStatus(id, status, processStatus) > 0; + } + + @Override + @Transactional + public boolean assignWorkOrder(Long id, Long assigneeId, String assigneeName) { + LocalDateTime now = LocalDateTime.now(); + + // 更新工单 + boolean updated = workOrderMapper.updateAssignee(id, assigneeId, assigneeName) > 0; + + if (updated) { + // 创建处理记录 + WorkOrder workOrder = getWorkOrderById(id); + WorkOrderProcess process = new WorkOrderProcess(); + process.setWorkOrderId(id); + process.setProcessStep("accepted"); + process.setProcessorId(assigneeId); + process.setProcessorName(assigneeName); + process.setAction("assign"); + process.setComment("工单已分配"); + process.setCreatedAt(now); + workOrderProcessMapper.insert(process); + + // 更新工单状态 + updateWorkOrderStatus(id, "assigned", "accepted"); + } + + return updated; + } + + @Override + @Transactional + public boolean startWorkOrder(Long id) { + LocalDateTime now = LocalDateTime.now(); + + // 更新工单 + boolean updated = workOrderMapper.updateStatus(id, "processing", "in_progress") > 0; + + if (updated) { + // 创建处理记录 + WorkOrder workOrder = getWorkOrderById(id); + WorkOrderProcess process = new WorkOrderProcess(); + process.setWorkOrderId(id); + process.setProcessStep("in_progress"); + process.setProcessorId(workOrder.getAssigneeId()); + process.setProcessorName(workOrder.getAssigneeName()); + process.setAction("start"); + process.setComment("开始处理工单"); + process.setCreatedAt(now); + workOrderProcessMapper.insert(process); + } + + return updated; + } + + @Override + @Transactional + public boolean completeWorkOrder(Long id, String solutionResult) { + LocalDateTime now = LocalDateTime.now(); + + // 更新工单 + boolean updated = workOrderMapper.updateCompletion(id, now, now, solutionResult) > 0; + + if (updated) { + // 创建处理记录 + WorkOrder workOrder = getWorkOrderById(id); + WorkOrderProcess process = new WorkOrderProcess(); + process.setWorkOrderId(id); + process.setProcessStep("completed"); + process.setProcessorId(workOrder.getAssigneeId()); + process.setProcessorName(workOrder.getAssigneeName()); + process.setAction("complete"); + process.setComment("工单已完成"); + process.setCreatedAt(now); + workOrderProcessMapper.insert(process); + + // 更新工单状态 + updateWorkOrderStatus(id, "completed", "completed"); + } + + return updated; + } + + @Override + @Transactional + public boolean deleteWorkOrder(Long id) { + return workOrderMapper.deleteById(id) > 0; + } + + @Override + public WorkOrderStatistics getWorkOrderStatistics() { + WorkOrderStatistics statistics = new WorkOrderStatistics(); + statistics.setTotalOrders(workOrderMapper.countAll()); + statistics.setPendingCount(workOrderMapper.countByStatus("pending")); + statistics.setAssignedCount(workOrderMapper.countByStatus("assigned")); + statistics.setProcessingCount(workOrderMapper.countByStatus("processing")); + statistics.setCompletedCount(workOrderMapper.countByStatus("completed")); + statistics.setCancelledCount(workOrderMapper.countByStatus("cancelled")); + return statistics; + } + + /** + * 根据问题类型确定工单类型 + */ + private String determineOrderType(String problemType) { + if (problemType.contains("设备")) { + return "设备维修"; + } else if (problemType.contains("水质")) { + return "水质处理"; + } else if (problemType.contains("安全")) { + return "安全隐患处理"; + } else if (problemType.contains("环境")) { + return "清洁"; + } else { + return "其他"; + } + } + + /** + * 根据问题级别确定优先级 + */ + private String determinePriority(String problemLevel) { + if (problemLevel.equals("critical")) { + return "critical"; + } else if (problemLevel.equals("high")) { + return "high"; + } else if (problemLevel.equals("normal")) { + return "normal"; + } else { + return "low"; + } + } +} \ No newline at end of file diff --git a/wm-patrol/src/main/resources/mapper/PatrolProblemMapper.xml b/wm-patrol/src/main/resources/mapper/PatrolProblemMapper.xml new file mode 100644 index 00000000..127f6d7e --- /dev/null +++ b/wm-patrol/src/main/resources/mapper/PatrolProblemMapper.xml @@ -0,0 +1,103 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + INSERT INTO patrol_problem ( + problem_no, task_id, point_seq, device_id, device_name, + problem_type, problem_level, problem_title, problem_description, + location, lng, lat, photo_urls, reporter_id, reporter_name, + report_time, status, work_order_id, created_at, updated_at + ) VALUES ( + #{problemNo}, #{taskId}, #{pointSeq}, #{deviceId}, #{deviceName}, + #{problemType}, #{problemLevel}, #{problemTitle}, #{problemDescription}, + #{location}, #{lng}, #{lat}, #{photoUrls}, #{reporterId}, #{reporterName}, + #{reportTime}, #{status}, #{workOrderId}, #{createdAt}, #{updatedAt} + ) + + + + + + + + + + + + + + UPDATE patrol_problem SET + problem_type = #{problemType}, + problem_level = #{problemLevel}, + problem_title = #{problemTitle}, + problem_description = #{problemDescription}, + location = #{location}, + lng = #{lng}, + lat = #{lat}, + photo_urls = #{photoUrls}, + status = #{status}, + work_order_id = #{workOrderId}, + updated_at = #{updatedAt} + WHERE id = #{id} + + + + UPDATE patrol_problem SET + status = #{status}, + work_order_id = #{workOrderId}, + updated_at = #{updatedAt} + WHERE id = #{id} + + + + DELETE FROM patrol_problem WHERE id = #{id} + + + + + + + + + \ No newline at end of file diff --git a/wm-patrol/src/main/resources/mapper/WorkOrderMapper.xml b/wm-patrol/src/main/resources/mapper/WorkOrderMapper.xml new file mode 100644 index 00000000..f8f30631 --- /dev/null +++ b/wm-patrol/src/main/resources/mapper/WorkOrderMapper.xml @@ -0,0 +1,148 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + INSERT INTO work_order ( + order_no, problem_id, order_type, priority, title, description, + location, contact_person, contact_phone, reporter_id, reporter_name, + assignee_id, assignee_name, status, process_status, + estimated_duration, actual_start_time, actual_end_time, completion_time, + photos_before, photos_after, solution_description, solution_result, + customer_feedback, created_at, updated_at + ) VALUES ( + #{orderNo}, #{problemId}, #{orderType}, #{priority}, #{title}, #{description}, + #{location}, #{contactPerson}, #{contactPhone}, #{reporterId}, #{reporterName}, + #{assigneeId}, #{assigneeName}, #{status}, #{processStatus}, + #{estimatedDuration}, #{actualStartTime}, #{actualEndTime}, #{completionTime}, + #{photosBefore}, #{photosAfter}, #{solutionDescription}, #{solutionResult}, + #{customerFeedback}, #{createdAt}, #{updatedAt} + ) + + + + + + + + + + + + + + + + UPDATE work_order SET + order_type = #{orderType}, + priority = #{priority}, + title = #{title}, + description = #{description}, + location = #{location}, + contact_person = #{contactPerson}, + contact_phone = #{contactPhone}, + assignee_id = #{assigneeId}, + assignee_name = #{assigneeName}, + status = #{status}, + process_status = #{processStatus}, + estimated_duration = #{estimatedDuration}, + actual_start_time = #{actualStartTime}, + actual_end_time = #{actualEndTime}, + completion_time = #{completionTime}, + photos_before = #{photosBefore}, + photos_after = #{photosAfter}, + solution_description = #{solutionDescription}, + solution_result = #{solutionResult}, + customer_feedback = #{customerFeedback}, + updated_at = #{updatedAt} + WHERE id = #{id} + + + + UPDATE work_order SET + status = #{status}, + process_status = #{processStatus}, + updated_at = #{updatedAt} + WHERE id = #{id} + + + + UPDATE work_order SET + assignee_id = #{assigneeId}, + assignee_name = #{assigneeName}, + updated_at = #{updatedAt} + WHERE id = #{id} + + + + UPDATE work_order SET + actual_end_time = #{actualEndTime}, + completion_time = #{completionTime}, + solution_result = #{solutionResult}, + updated_at = #{updatedAt} + WHERE id = #{id} + + + + DELETE FROM work_order WHERE id = #{id} + + + + + + + + + + + \ No newline at end of file diff --git a/wm-patrol/src/main/resources/mapper/WorkOrderProcessMapper.xml b/wm-patrol/src/main/resources/mapper/WorkOrderProcessMapper.xml new file mode 100644 index 00000000..b713a555 --- /dev/null +++ b/wm-patrol/src/main/resources/mapper/WorkOrderProcessMapper.xml @@ -0,0 +1,45 @@ + + + + + + + + + + + + + + + + + + INSERT INTO work_order_process ( + work_order_id, process_step, processor_id, processor_name, + action, comment, photos, created_at + ) VALUES ( + #{workOrderId}, #{processStep}, #{processorId}, #{processorName}, + #{action}, #{comment}, #{photos}, #{createdAt} + ) + + + + + + + + + + DELETE FROM work_order_process WHERE id = #{id} + + + \ No newline at end of file diff --git a/wm-production/src/main/java/com/water/production/controller/AlertController.java b/wm-production/src/main/java/com/water/production/controller/AlertController.java new file mode 100644 index 00000000..713d2285 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/controller/AlertController.java @@ -0,0 +1,212 @@ +package com.water.production.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.common.core.result.R; +import com.water.production.entity.AlertNotification; +import com.water.production.entity.AlertRecord; +import com.water.production.entity.AlertRule; +import com.water.production.service.AlertCenterService; +import com.water.production.service.AlertRuleService; +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.*; + +/** + * 报警规则引擎 + 报警管理中心 REST API + */ +@Tag(name = "报警规则引擎与管理中心") +@RestController +@RequestMapping("/api/production/alert") +@RequiredArgsConstructor +public class AlertController { + + private final AlertRuleService ruleService; + private final AlertCenterService centerService; + + // ==================== 报警规则管理 (CRUD) ==================== + + @Operation(summary = "分页查询报警规则") + @GetMapping("/rule/page") + public R> rulePage( + @RequestParam(defaultValue = "1") int current, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) String keyword, + @RequestParam(required = false) String alertLevel, + @RequestParam(required = false) Boolean enabled) { + return R.ok(ruleService.page(current, size, keyword, alertLevel, enabled)); + } + + @Operation(summary = "查询规则详情") + @GetMapping("/rule/{id}") + public R ruleDetail(@PathVariable Long id) { + AlertRule rule = ruleService.getById(id); + return rule != null ? R.ok(rule) : R.fail(404, "规则不存在"); + } + + @Operation(summary = "创建报警规则") + @PostMapping("/rule") + public R createRule(@RequestBody AlertRule rule) { + return R.ok(ruleService.create(rule)); + } + + @Operation(summary = "更新报警规则") + @PutMapping("/rule/{id}") + public R updateRule(@PathVariable Long id, @RequestBody AlertRule rule) { + rule.setId(id); + return ruleService.update(rule) ? R.ok("更新成功") : R.fail("更新失败"); + } + + @Operation(summary = "删除报警规则") + @DeleteMapping("/rule/{id}") + public R deleteRule(@PathVariable Long id) { + return ruleService.delete(id) ? R.ok("删除成功") : R.fail("删除失败"); + } + + @Operation(summary = "启用/禁用规则") + @PutMapping("/rule/{id}/toggle") + public R toggleRule(@PathVariable Long id, @RequestParam boolean enabled) { + return ruleService.toggleEnabled(id, enabled) ? R.ok("操作成功") : R.fail("操作失败"); + } + + @Operation(summary = "查询所有启用规则") + @GetMapping("/rule/enabled") + public R> enabledRules() { + return R.ok(ruleService.findAllEnabled()); + } + + @Operation(summary = "规则等级统计") + @GetMapping("/rule/stats") + public R>> ruleStats() { + return R.ok(ruleService.countByLevel()); + } + + // ==================== 规则引擎 - 指标评估 ==================== + + @Operation(summary = "提交指标数据触发规则评估") + @PostMapping("/evaluate") + public R> evaluate( + @RequestParam String deviceSn, + @RequestParam String metricKey, + @RequestParam double value, + @RequestParam(required = false) String area) { + return R.ok(ruleService.evaluateMetric(deviceSn, metricKey, value, area)); + } + + // ==================== 报警管理中心 ==================== + + @Operation(summary = "分页查询报警记录") + @GetMapping("/record/page") + public R> recordPage( + @RequestParam(defaultValue = "1") int current, + @RequestParam(defaultValue = "20") int size, + @RequestParam(required = false) String level, + @RequestParam(required = false) String area, + @RequestParam(required = false) Integer status, + @RequestParam(required = false) String deviceSn, + @RequestParam(required = false) String startDate, + @RequestParam(required = false) String endDate) { + return R.ok(centerService.page(current, size, level, area, status, deviceSn, startDate, endDate)); + } + + @Operation(summary = "查询报警详情(含通知记录)") + @GetMapping("/record/{id}") + public R> recordDetail(@PathVariable Long id) { + Map detail = centerService.getDetail(id); + return detail != null ? R.ok(detail) : R.fail(404, "报警记录不存在"); + } + + @Operation(summary = "查询活跃报警") + @GetMapping("/record/active") + public R> activeAlerts() { + return R.ok(centerService.findActive()); + } + + @Operation(summary = "查询待确认报警") + @GetMapping("/record/pending") + public R> pendingAlerts() { + return R.ok(centerService.findPendingConfirmation()); + } + + @Operation(summary = "确认报警") + @PostMapping("/record/{id}/confirm") + public R confirm(@PathVariable Long id, @RequestParam Long userId) { + return centerService.confirm(id, userId) ? R.ok("已确认") : R.fail("确认失败(状态不允许)"); + } + + @Operation(summary = "派单(指派处理人)") + @PostMapping("/record/{id}/dispatch") + public R dispatch(@PathVariable Long id, + @RequestParam Long assigneeId, + @RequestParam(required = false) String assigneeName) { + return centerService.dispatch(id, assigneeId, assigneeName != null ? assigneeName : "") + ? R.ok("已派单") : R.fail("派单失败(状态不允许)"); + } + + @Operation(summary = "开始处理") + @PostMapping("/record/{id}/start-handle") + public R startHandle(@PathVariable Long id, + @RequestParam Long handlerId, + @RequestParam(required = false) String handlerName) { + return centerService.startHandle(id, handlerId, handlerName != null ? handlerName : "") + ? R.ok("已开始处理") : R.fail("操作失败(状态不允许)"); + } + + @Operation(summary = "完成处理") + @PostMapping("/record/{id}/complete") + public R completeHandle(@PathVariable Long id, @RequestBody Map body) { + String result = body.getOrDefault("result", ""); + return centerService.completeHandle(id, result) ? R.ok("处理完成") : R.fail("操作失败(状态不允许)"); + } + + @Operation(summary = "归档报警") + @PostMapping("/record/{id}/archive") + public R archive(@PathVariable Long id, @RequestBody Map body) { + String reason = body.getOrDefault("reason", ""); + return centerService.archive(id, reason) ? R.ok("已归档") : R.fail("归档失败(状态不允许)"); + } + + @Operation(summary = "批量确认报警") + @PostMapping("/record/batch-confirm") + public R> batchConfirm(@RequestBody Map body) { + @SuppressWarnings("unchecked") + List ids = (List) body.get("ids"); + Long userId = ((Number) body.get("userId")).longValue(); + List longIds = ids.stream().map(Number::longValue).toList(); + int count = centerService.batchConfirm(longIds, userId); + return R.ok(Map.of("confirmed", count)); + } + + @Operation(summary = "批量归档报警") + @PostMapping("/record/batch-archive") + public R> batchArchive(@RequestBody Map body) { + @SuppressWarnings("unchecked") + List ids = (List) body.get("ids"); + String reason = (String) body.getOrDefault("reason", ""); + List longIds = ids.stream().map(Number::longValue).toList(); + int count = centerService.batchArchive(longIds, reason); + return R.ok(Map.of("archived", count)); + } + + @Operation(summary = "查询报警通知记录") + @GetMapping("/record/{id}/notifications") + public R> notifications(@PathVariable Long id) { + return R.ok(centerService.getNotifications(id)); + } + + // ==================== 统计看板 ==================== + + @Operation(summary = "报警统计看板") + @GetMapping("/dashboard") + public R> dashboard(@RequestParam(defaultValue = "week") String period) { + return R.ok(centerService.getDashboard(period)); + } + + @Operation(summary = "今日报警概要") + @GetMapping("/today-summary") + public R> todaySummary() { + return R.ok(centerService.getTodaySummary()); + } +} diff --git a/wm-production/src/main/java/com/water/production/controller/DispatchCommandController.java b/wm-production/src/main/java/com/water/production/controller/DispatchCommandController.java new file mode 100644 index 00000000..5707842e --- /dev/null +++ b/wm-production/src/main/java/com/water/production/controller/DispatchCommandController.java @@ -0,0 +1,106 @@ +package com.water.production.controller; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.water.common.core.result.R; +import com.water.production.entity.DispatchCommand; +import com.water.production.entity.DispatchExecution; +import com.water.production.entity.DispatchTracking; +import com.water.production.service.DispatchCommandService; +import com.water.production.service.DispatchTrackingService; +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; +import java.util.Map; + +@Tag(name = "调度指令管理") +@RestController +@RequestMapping("/api/production/dispatch-command") +@RequiredArgsConstructor +public class DispatchCommandController { + + private final DispatchCommandService commandService; + private final DispatchTrackingService trackingService; + + @Operation(summary = "创建指令") + @PostMapping + public R create(@RequestBody DispatchCommand command) { + return R.ok(commandService.createCommand(command)); + } + + @Operation(summary = "下发指令") + @PostMapping("/{id}/issue") + public R issue(@PathVariable Long id, + @RequestParam Long issuedBy, + @RequestParam(required = false, defaultValue = "system") String operatorName) { + return R.ok(commandService.issueCommand(id, issuedBy, operatorName)); + } + + @Operation(summary = "指令台账（分页）") + @GetMapping + public R>> list( + @RequestParam(defaultValue = "1") int page, + @RequestParam(defaultValue = "10") int size, + @RequestParam(required = false) String status, + @RequestParam(required = false) String commandType, + @RequestParam(required = false) String keyword, + @RequestParam(required = false) String startDate, + @RequestParam(required = false) String endDate) { + return R.ok(commandService.listCommands(page, size, status, commandType, keyword, startDate, endDate)); + } + + @Operation(summary = "指令详情") + @GetMapping("/{id}") + public R> detail(@PathVariable Long id) { + return R.ok(commandService.getCommandDetail(id)); + } + + @Operation(summary = "各状态统计") + @GetMapping("/stats") + public R>> stats() { + return R.ok(commandService.getStatusStats()); + } + + @Operation(summary = "接收确认") + @PostMapping("/{id}/receive") + public R receive(@PathVariable Long id, + @RequestParam Long userId, + @RequestParam(required = false, defaultValue = "") String userName) { + return R.ok(commandService.receiveCommand(id, userId, userName)); + } + + @Operation(summary = "开始执行") + @PostMapping("/{id}/start-execute") + public R startExecute(@PathVariable Long id, + @RequestParam Long userId, + @RequestParam(required = false, defaultValue = "") String userName) { + return R.ok(commandService.startExecution(id, userId, userName)); + } + + @Operation(summary = "完成执行") + @PostMapping("/{id}/complete") + public R complete(@PathVariable Long id, + @RequestParam Long userId, + @RequestParam(required = false, defaultValue = "") String userName, + @RequestParam(required = false) String feedback, + @RequestParam(required = false) String feedbackImages) { + return R.ok(commandService.completeExecution(id, userId, userName, feedback, feedbackImages)); + } + + @Operation(summary = "驳回") + @PostMapping("/{id}/reject") + public R reject(@PathVariable Long id, + @RequestParam Long userId, + @RequestParam(required = false, defaultValue = "") String userName, + @RequestParam String reason) { + return R.ok(commandService.rejectExecution(id, userId, userName, reason)); + } + + @Operation(summary = "查询追踪日志") + @GetMapping("/{id}/tracking") + public R> trackingLogs(@PathVariable Long id) { + return R.ok(trackingService.getTrackingLogs(id)); + } +} diff --git a/wm-production/src/main/java/com/water/production/controller/ProductionController.java b/wm-production/src/main/java/com/water/production/controller/ProductionController.java new file mode 100644 index 00000000..3f436183 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/controller/ProductionController.java @@ -0,0 +1,127 @@ +package com.water.production.controller; + +import com.water.common.core.result.R; +import com.water.production.service.*; +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.*; + +@Tag(name = "供水生产管理") +@RestController +@RequestMapping("/production") +@RequiredArgsConstructor +public class ProductionController { + + private final DashboardService dashboardService; + private final WaterQualityService wqService; + private final AlertEngine alertEngine; + private final DispatchService dispatchService; + private final DataCenterService dataCenterService; + private final VideoService videoService; + + // ---- 总览 ---- + @GetMapping("/overview") + public R> overview(@RequestParam(defaultValue = "一体化水厂") String area, + @RequestParam(defaultValue = "admin") String roleType) { + return R.ok(dashboardService.getOverview(area, roleType)); + } + + // ---- 实时监测 ---- + @GetMapping("/monitor/realtime") + public R>> realtime(@RequestParam(required = false) String area, + @RequestParam(required = false) String positionType, + @RequestParam(required = false) String deviceType) { + return R.ok(dashboardService.getRealtimeMonitoring(area, positionType, deviceType)); + } + + @GetMapping("/monitor/cameras") + public R>> cameras(@RequestParam String area) { + return R.ok(videoService.getCameras(area)); + } + + // ---- 水质 ---- + @GetMapping("/quality/chemical/{station}") + public R> chemical(@PathVariable String station) { + return R.ok(wqService.getChemicalMonitoring(station)); + } + + @PostMapping("/quality/record") + public R addRecord(@RequestBody Map record) { + wqService.addRecord(record); + return R.ok("记录已保存"); + } + + @GetMapping("/quality/ledger") + public R>> ledger(@RequestParam String area, @RequestParam String start, @RequestParam String end) { + return R.ok(wqService.getQualityLedger(area, start, end)); + } + + // ---- 报警 ---- + @GetMapping("/alert/list") + public R>> alerts(@RequestParam(required = false) String level, + @RequestParam(required = false) String area, + @RequestParam(defaultValue = "true") boolean active) { + return R.ok(alertEngine.getAlerts(level, area, active)); + } + + @PostMapping("/alert/{id}/confirm") + public R confirm(@PathVariable Long id, @RequestParam Long userId) { + alertEngine.confirm(id, userId); return R.ok("已确认"); + } + + @PostMapping("/alert/{id}/dispatch") + public R dispatch(@PathVariable Long id, @RequestParam Long assigneeId) { + alertEngine.dispatch(id, assigneeId); return R.ok("已派单"); + } + + // ---- 调度 ---- + @GetMapping("/dispatch/duty/today") + public R>> todayDuty(@RequestParam String area) { + return R.ok(dispatchService.getTodayDuty(area)); + } + + @PostMapping("/dispatch/command") + public R> createCommand(@RequestBody Map req) { + @SuppressWarnings("unchecked") + List targetIds = (List) req.getOrDefault("targetIds", List.of()); + return R.ok(dispatchService.createCommand( + (String) req.get("title"), (String) req.get("content"), (String) req.get("type"), + (String) req.get("source"), (String) req.get("targetType"), targetIds)); + } + + @PostMapping("/dispatch/command/{cmdNo}/issue") + public R> issueCommand(@PathVariable String cmdNo) { + return R.ok(dispatchService.issueCommand(cmdNo)); + } + + @PostMapping("/dispatch/emergency/pipe-burst") + public R> pipeBurst(@RequestBody Map req) { + return R.ok(dispatchService.pipeBurstSimulation( + ((Number) req.get("lng")).doubleValue(), + ((Number) req.get("lat")).doubleValue(), + (String) req.get("pipeDiameter"))); + } + + // ---- 数据中心 ---- + @GetMapping("/data/history") + public R>> history(@RequestParam String dataType, @RequestParam String area, + @RequestParam String start, @RequestParam String end) { + return R.ok(dataCenterService.getHistoryData(dataType, area, start, end)); + } + + @GetMapping("/data/report") + public R> report(@RequestParam String type, @RequestParam String period) { + return R.ok(dataCenterService.generateReport(type, period)); + } + + @PutMapping("/data/threshold/{ruleId}") + public R updateThreshold(@PathVariable Long ruleId, @RequestBody Map req) { + dataCenterService.updateThreshold(ruleId, + ((Number) req.get("threshold")).doubleValue(), + (String) req.get("condition")); + return R.ok("阈值已更新"); + } +} diff --git a/wm-production/src/main/java/com/water/production/entity/AlertNotification.java b/wm-production/src/main/java/com/water/production/entity/AlertNotification.java new file mode 100644 index 00000000..ec47321d --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/AlertNotification.java @@ -0,0 +1,56 @@ +package com.water.production.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * 报警通知记录实体 + */ +@Data +@TableName("prod_alert_notification") +public class AlertNotification { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 关联的报警记录ID */ + private Long alertRecordId; + + /** 关联的规则ID */ + private Long ruleId; + + /** 通知渠道: sms/wechat/app/email */ + private String channel; + + /** 接收人标识 */ + private String recipient; + + /** 接收人姓名 */ + private String recipientName; + + /** 通知标题 */ + private String title; + + /** 通知内容 */ + private String content; + + /** 状态: 0=待发送 1=已发送 2=发送失败 3=已读 */ + private Integer status; + + /** 发送时间 */ + private LocalDateTime sendTime; + + /** 阅读时间 */ + private LocalDateTime readTime; + + /** 重试次数 */ + private Integer retryCount; + + /** 错误信息 */ + private String errorMsg; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; +} diff --git a/wm-production/src/main/java/com/water/production/entity/AlertRecord.java b/wm-production/src/main/java/com/water/production/entity/AlertRecord.java new file mode 100644 index 00000000..13602b62 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/AlertRecord.java @@ -0,0 +1,106 @@ +package com.water.production.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * 报警记录实体（全生命周期） + * 状态流转: 0=活跃 → 1=已确认 → 2=已派单 → 3=处理中 → 4=已处理 → 5=已归档 + */ +@Data +@TableName("prod_alert_record") +public class AlertRecord { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 关联规则ID */ + private Long ruleId; + + /** 规则名称 */ + private String ruleName; + + /** 设备ID */ + private Long deviceId; + + /** 设备编号 */ + private String deviceSn; + + /** 设备名称 */ + private String deviceName; + + /** 所属区域 */ + private String area; + + /** 指标键 */ + private String metricKey; + + /** 指标值 */ + private BigDecimal metricValue; + + /** 阈值(字符串，用于展示) */ + private String thresholdValue; + + /** 报警等级: general/important/urgent */ + private String alertLevel; + + /** 报警标题 */ + private String title; + + /** 报警详情 */ + private String message; + + /** + * 生命周期状态: + * 0=活跃, 1=已确认, 2=已派单, 3=处理中, 4=已处理, 5=已归档 + */ + private Integer status; + + /** 确认人ID */ + private Long confirmedBy; + + /** 确认时间 */ + private LocalDateTime confirmedTime; + + /** 派单时间 */ + private LocalDateTime dispatchTime; + + /** 指派人ID */ + private Long assigneeId; + + /** 指派人姓名 */ + private String assigneeName; + + /** 处理人ID */ + private Long handlerId; + + /** 处理人姓名 */ + private String handlerName; + + /** 处理结果 */ + private String handleResult; + + /** 处理时间 */ + private LocalDateTime handleTime; + + /** 归档时间 */ + private LocalDateTime archiveTime; + + /** 归档原因 */ + private String archiveReason; + + /** 解决时间 */ + private LocalDateTime resolvedAt; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; + + @TableLogic + private Integer deleted; +} diff --git a/wm-production/src/main/java/com/water/production/entity/AlertRule.java b/wm-production/src/main/java/com/water/production/entity/AlertRule.java index 8271f566..2a172d75 100644 --- a/wm-production/src/main/java/com/water/production/entity/AlertRule.java +++ b/wm-production/src/main/java/com/water/production/entity/AlertRule.java @@ -1,25 +1,80 @@ package com.water.production.entity; +import com.baomidou.mybatisplus.annotation.*; import lombok.Data; -import java.time.LocalDateTime; +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.time.LocalTime; + +/** + * 报警规则定义实体 + */ @Data +@TableName("prod_alert_rule") public class AlertRule { + + @TableId(type = IdType.AUTO) private Long id; - private String name; - private String parameter; - private Double minValue; - private Double maxValue; - private Double warningValue; - private Double criticalValue; - private String conditionType; - private Integer severityLevel; - private Integer duplicateInterval; - private Integer status; - private String targetEquipmentId; - private String targetArea; - private LocalDateTime createTime; - private LocalDateTime updateTime; - private String createBy; - private String updateBy; -} \ No newline at end of file + + /** 规则名称 */ + private String ruleName; + + /** 规则编码 */ + private String ruleCode; + + /** 规则描述 */ + private String description; + + /** 设备类型 */ + private String deviceType; + + /** 指标键 */ + private String metricKey; + + /** 报警等级: general/important/urgent */ + private String alertLevel; + + /** 条件表达式JSON (支持AND/OR组合) */ + private String conditionExpr; + + /** 简单阈值(向后兼容) */ + private BigDecimal thresholdValue; + + /** 去重窗口(秒) */ + private Integer debounceSec; + + /** 通知渠道(sms,wechat,app,email) */ + private String notifyChannels; + + /** 通知模板 */ + private String notifyTemplate; + + /** 是否启用 */ + private Integer enabled; + + /** 规则优先级 */ + private Integer priority; + + /** 生效开始时间 */ + private LocalTime effectiveStart; + + /** 生效结束时间 */ + private LocalTime effectiveEnd; + + /** 创建人 */ + private Long createdBy; + + /** 更新人 */ + private Long updatedBy; + + /** 逻辑删除 */ + @TableLogic + private Integer deleted; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; +} diff --git a/wm-production/src/main/java/com/water/production/entity/DeviceStatus.java b/wm-production/src/main/java/com/water/production/entity/DeviceStatus.java new file mode 100644 index 00000000..4237b952 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/DeviceStatus.java @@ -0,0 +1,11 @@ +package com.water.production.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("prod_device_status") +public class DeviceStatus { + @TableId(type = IdType.AUTO) private Long id; + private String deviceId, deviceName, deviceType; + private String area; private Integer status; // 0离线 1在线 2故障 + private Double lng, lat; + private LocalDateTime lastOnlineTime; +} diff --git a/wm-production/src/main/java/com/water/production/entity/DispatchCommand.java b/wm-production/src/main/java/com/water/production/entity/DispatchCommand.java new file mode 100644 index 00000000..a33df3e3 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/DispatchCommand.java @@ -0,0 +1,64 @@ +package com.water.production.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 调度指令主表 + */ +@Data +@TableName("prod_dispatch_command") +public class DispatchCommand { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 指令编号 CMD-yyyyMMddHHmmss-xxxx */ + private String commandNo; + + /** 指令标题 */ + private String commandTitle; + + /** 指令内容 */ + private String commandContent; + + /** 类型: normal/emergency/maintenance/inspection */ + private String commandType; + + /** 来源 */ + private String source; + + /** 优先级: low/normal/high/urgent */ + private String priority; + + /** 目标类型: user/dept/role */ + private String targetType; + + /** 目标ID列表 JSON数组 */ + private String targetIds; + + /** 状态: draft/issued/received/executing/completed/rejected */ + private String status; + + /** 下发时间 */ + private LocalDateTime issuedAt; + + /** 下发人 */ + private Long issuedBy; + + /** 完成归档时间 */ + private LocalDateTime completedAt; + + /** 备注 */ + private String remark; + + @TableLogic + private Integer deleted; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdAt; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedAt; +} diff --git a/wm-production/src/main/java/com/water/production/entity/DispatchExecution.java b/wm-production/src/main/java/com/water/production/entity/DispatchExecution.java new file mode 100644 index 00000000..9baff94b --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/DispatchExecution.java @@ -0,0 +1,52 @@ +package com.water.production.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 调度指令执行记录表 + */ +@Data +@TableName("prod_dispatch_execution") +public class DispatchExecution { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 关联指令ID */ + private Long commandId; + + /** 接收/执行人 */ + private Long userId; + + /** 执行人姓名 */ + private String userName; + + /** 接收确认时间 */ + private LocalDateTime receivedAt; + + /** 执行状态: pending/received/executing/completed/rejected */ + private String executeStatus; + + /** 执行反馈 */ + private String feedback; + + /** 反馈图片JSON数组 */ + private String feedbackImages; + + /** 完成时间 */ + private LocalDateTime completedAt; + + /** 驳回原因 */ + private String rejectedReason; + + @TableLogic + private Integer deleted; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdAt; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedAt; +} diff --git a/wm-production/src/main/java/com/water/production/entity/DispatchTracking.java b/wm-production/src/main/java/com/water/production/entity/DispatchTracking.java new file mode 100644 index 00000000..f12f2477 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/DispatchTracking.java @@ -0,0 +1,43 @@ +package com.water.production.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 调度指令过程追踪日志表 + */ +@Data +@TableName("prod_dispatch_tracking") +public class DispatchTracking { + + @TableId(type = IdType.AUTO) + private Long id; + + /** 关联指令ID */ + private Long commandId; + + /** 关联执行记录ID（可选） */ + private Long executionId; + + /** 操作类型: create/issue/receive/start_execute/complete/reject/cancel */ + private String action; + + /** 操作人 */ + private Long operatorId; + + /** 操作人姓名 */ + private String operatorName; + + /** 原状态 */ + private String fromStatus; + + /** 新状态 */ + private String toStatus; + + /** 备注 */ + private String remark; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdAt; +} diff --git a/wm-production/src/main/java/com/water/production/entity/FlowPressureMonitor.java b/wm-production/src/main/java/com/water/production/entity/FlowPressureMonitor.java new file mode 100644 index 00000000..4fdc3659 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/FlowPressureMonitor.java @@ -0,0 +1,11 @@ +package com.water.production.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("prod_flow_pressure") +public class FlowPressureMonitor { + @TableId(type = IdType.AUTO) private Long id; + private String deviceId, area, positionType; // 流量/压力/液位 + private Double value; private String unit; + private Double lng, lat; + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; +} diff --git a/wm-production/src/main/java/com/water/production/entity/VideoCamera.java b/wm-production/src/main/java/com/water/production/entity/VideoCamera.java new file mode 100644 index 00000000..864bc841 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/VideoCamera.java @@ -0,0 +1,10 @@ +package com.water.production.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +@Data @TableName("prod_video_camera") +public class VideoCamera { + @TableId(type = IdType.AUTO) private Long id; + private String cameraId, name, area; + private String streamUrl; private Integer status; // 0离线 1在线 + private Double lng, lat; +} diff --git a/wm-production/src/main/java/com/water/production/entity/WaterQualityRecord.java b/wm-production/src/main/java/com/water/production/entity/WaterQualityRecord.java new file mode 100644 index 00000000..5762d25f --- /dev/null +++ b/wm-production/src/main/java/com/water/production/entity/WaterQualityRecord.java @@ -0,0 +1,11 @@ +package com.water.production.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; import java.time.LocalDateTime; +@Data @TableName("prod_water_quality") +public class WaterQualityRecord { + @TableId(type = IdType.AUTO) private Long id; + private String station, positionType; // 原水/出厂水/末梢水 + private Double turbidity, ph, residualChlorine, color, odor; + private String result; // 合格/不合格 + @TableField(fill=FieldFill.INSERT) private LocalDateTime createdTime; +} diff --git a/wm-production/src/main/java/com/water/production/mapper/AlertNotificationMapper.java b/wm-production/src/main/java/com/water/production/mapper/AlertNotificationMapper.java new file mode 100644 index 00000000..9dc667eb --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/AlertNotificationMapper.java @@ -0,0 +1,27 @@ +package com.water.production.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.AlertNotification; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; +import java.util.Map; + +@Mapper +public interface AlertNotificationMapper extends BaseMapper { + + /** + * 按报警记录ID查询通知记录 + */ + @Select("SELECT * FROM prod_alert_notification WHERE alert_record_id = #{recordId} ORDER BY created_time") + List findByAlertRecordId(@Param("recordId") Long recordId); + + /** + * 统计通知发送情况 + */ + @Select("SELECT channel, status, COUNT(*) as count FROM prod_alert_notification " + + "WHERE created_time >= #{startTime} GROUP BY channel, status") + List> statisticsByChannel(@Param("startTime") String startTime); +} diff --git a/wm-production/src/main/java/com/water/production/mapper/AlertRecordMapper.java b/wm-production/src/main/java/com/water/production/mapper/AlertRecordMapper.java new file mode 100644 index 00000000..5a911be2 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/AlertRecordMapper.java @@ -0,0 +1,99 @@ +package com.water.production.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.AlertRecord; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.apache.ibatis.annotations.Update; + +import java.util.List; +import java.util.Map; + +@Mapper +public interface AlertRecordMapper extends BaseMapper { + + /** + * 按状态统计报警数量 + */ + @Select("SELECT status, COUNT(*) as count FROM prod_alert_record WHERE deleted = 0 GROUP BY status") + List> countByStatus(); + + /** + * 按等级统计报警数量 + */ + @Select("SELECT alert_level, COUNT(*) as count FROM prod_alert_record WHERE deleted = 0 " + + "AND created_time >= #{startTime} GROUP BY alert_level") + List> countByLevel(@Param("startTime") String startTime); + + /** + * 按区域统计报警数量 + */ + @Select("SELECT area, COUNT(*) as count FROM prod_alert_record WHERE deleted = 0 " + + "AND created_time >= #{startTime} GROUP BY area ORDER BY count DESC") + List> countByArea(@Param("startTime") String startTime); + + /** + * 按日期统计报警趋势(最近N天) + */ + @Select("SELECT DATE(created_time) as date, alert_level, COUNT(*) as count " + + "FROM prod_alert_record WHERE deleted = 0 AND created_time >= #{startTime} " + + "GROUP BY DATE(created_time), alert_level ORDER BY date") + List> trendByDate(@Param("startTime") String startTime); + + /** + * 统计今日各状态报警数量 + */ + @Select("SELECT status, alert_level, COUNT(*) as count FROM prod_alert_record " + + "WHERE deleted = 0 AND created_time >= CURRENT_DATE GROUP BY status, alert_level") + List> todayStatistics(); + + /** + * 查询活跃报警(未归档) + */ + @Select("SELECT * FROM prod_alert_record WHERE deleted = 0 AND status < 5 ORDER BY created_time DESC") + List findActive(); + + /** + * 查询需要确认的报警 + */ + @Select("SELECT * FROM prod_alert_record WHERE deleted = 0 AND status = 0 ORDER BY " + + "CASE alert_level WHEN 'urgent' THEN 1 WHEN 'important' THEN 2 ELSE 3 END, created_time DESC") + List findPendingConfirmation(); + + /** + * 确认报警 + */ + @Update("UPDATE prod_alert_record SET status = 1, confirmed_by = #{userId}, " + + "confirmed_time = NOW(), updated_time = NOW() WHERE id = #{id} AND status = 0") + int confirm(@Param("id") Long id, @Param("userId") Long userId); + + /** + * 派单 + */ + @Update("UPDATE prod_alert_record SET status = 2, assignee_id = #{assigneeId}, " + + "assignee_name = #{assigneeName}, dispatch_time = NOW(), updated_time = NOW() " + + "WHERE id = #{id} AND status IN (0, 1)") + int dispatch(@Param("id") Long id, @Param("assigneeId") Long assigneeId, @Param("assigneeName") String assigneeName); + + /** + * 开始处理 + */ + @Update("UPDATE prod_alert_record SET status = 3, handler_id = #{handlerId}, " + + "handler_name = #{handlerName}, updated_time = NOW() WHERE id = #{id} AND status = 2") + int startHandle(@Param("id") Long id, @Param("handlerId") Long handlerId, @Param("handlerName") String handlerName); + + /** + * 完成处理 + */ + @Update("UPDATE prod_alert_record SET status = 4, handle_result = #{result}, " + + "handle_time = NOW(), resolved_at = NOW(), updated_time = NOW() WHERE id = #{id} AND status = 3") + int completeHandle(@Param("id") Long id, @Param("result") String result); + + /** + * 归档 + */ + @Update("UPDATE prod_alert_record SET status = 5, archive_time = NOW(), " + + "archive_reason = #{reason}, updated_time = NOW() WHERE id = #{id} AND status = 4") + int archive(@Param("id") Long id, @Param("reason") String reason); +} diff --git a/wm-production/src/main/java/com/water/production/mapper/AlertRuleMapper.java b/wm-production/src/main/java/com/water/production/mapper/AlertRuleMapper.java index 2acd5b6a..d12074aa 100644 --- a/wm-production/src/main/java/com/water/production/mapper/AlertRuleMapper.java +++ b/wm-production/src/main/java/com/water/production/mapper/AlertRuleMapper.java @@ -1,39 +1,32 @@ package com.water.production.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.water.production.entity.AlertRule; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + import java.util.List; +import java.util.Map; @Mapper -public interface AlertRuleMapper { - // 查询所有报警规则 - List findAll(); - - // 根据ID查询报警规则 - AlertRule findById(@Param("id") Long id); - - // 根据参数查询报警规则 - List findByParameter(@Param("parameter") String parameter); - - // 根据设备ID查询相关报警规则 - List findByTargetEquipmentId(@Param("targetEquipmentId") String targetEquipmentId); - - // 根据区域查询报警规则 - List findByTargetArea(@Param("targetArea") String targetArea); - - // 根据状态查询报警规则 - List findByStatus(@Param("status") Integer status); - - // 插入报警规则 - int insert(AlertRule alertRule); - - // 更新报警规则 - int update(AlertRule alertRule); - - // 删除报警规则 - int deleteById(@Param("id") Long id); - - // 启用/禁用报警规则 - int updateStatus(@Param("id") Long id, @Param("status") Integer status); -} \ No newline at end of file +public interface AlertRuleMapper extends BaseMapper { + + /** + * 根据指标键查询启用的规则 + */ + @Select("SELECT * FROM prod_alert_rule WHERE metric_key = #{metricKey} AND enabled = 1 AND deleted = 0") + List findEnabledByMetricKey(@Param("metricKey") String metricKey); + + /** + * 查询所有启用的规则 + */ + @Select("SELECT * FROM prod_alert_rule WHERE enabled = 1 AND deleted = 0 ORDER BY priority DESC") + List findAllEnabled(); + + /** + * 统计各等级规则数量 + */ + @Select("SELECT alert_level, COUNT(*) as count FROM prod_alert_rule WHERE enabled = 1 AND deleted = 0 GROUP BY alert_level") + List> countByLevel(); +} diff --git a/wm-production/src/main/java/com/water/production/mapper/DeviceStatusMapper.java b/wm-production/src/main/java/com/water/production/mapper/DeviceStatusMapper.java new file mode 100644 index 00000000..5e42e3e9 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/DeviceStatusMapper.java @@ -0,0 +1,5 @@ +package com.water.production.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.DeviceStatus; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DeviceStatusMapper extends BaseMapper {} diff --git a/wm-production/src/main/java/com/water/production/mapper/DispatchCommandMapper.java b/wm-production/src/main/java/com/water/production/mapper/DispatchCommandMapper.java new file mode 100644 index 00000000..ee5c2768 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/DispatchCommandMapper.java @@ -0,0 +1,28 @@ +package com.water.production.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.production.entity.DispatchCommand; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; + +import java.util.List; +import java.util.Map; + +@Mapper +public interface DispatchCommandMapper extends BaseMapper { + + IPage> selectCommandPage( + Page page, + @Param("status") String status, + @Param("commandType") String commandType, + @Param("keyword") String keyword, + @Param("startDate") String startDate, + @Param("endDate") String endDate + ); + + Map selectCommandDetail(@Param("commandId") Long commandId); + + List> selectStatusStats(); +} diff --git a/wm-production/src/main/java/com/water/production/mapper/DispatchExecutionMapper.java b/wm-production/src/main/java/com/water/production/mapper/DispatchExecutionMapper.java new file mode 100644 index 00000000..7768c90c --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/DispatchExecutionMapper.java @@ -0,0 +1,9 @@ +package com.water.production.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.DispatchExecution; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface DispatchExecutionMapper extends BaseMapper { +} diff --git a/wm-production/src/main/java/com/water/production/mapper/DispatchTrackingMapper.java b/wm-production/src/main/java/com/water/production/mapper/DispatchTrackingMapper.java new file mode 100644 index 00000000..2aa2fc2c --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/DispatchTrackingMapper.java @@ -0,0 +1,9 @@ +package com.water.production.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.DispatchTracking; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface DispatchTrackingMapper extends BaseMapper { +} diff --git a/wm-production/src/main/java/com/water/production/mapper/FlowPressureMonitorMapper.java b/wm-production/src/main/java/com/water/production/mapper/FlowPressureMonitorMapper.java new file mode 100644 index 00000000..f4f60926 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/FlowPressureMonitorMapper.java @@ -0,0 +1,5 @@ +package com.water.production.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.FlowPressureMonitor; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface FlowPressureMonitorMapper extends BaseMapper {} diff --git a/wm-production/src/main/java/com/water/production/mapper/VideoCameraMapper.java b/wm-production/src/main/java/com/water/production/mapper/VideoCameraMapper.java new file mode 100644 index 00000000..3d6c6e68 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/VideoCameraMapper.java @@ -0,0 +1,5 @@ +package com.water.production.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.VideoCamera; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface VideoCameraMapper extends BaseMapper {} diff --git a/wm-production/src/main/java/com/water/production/mapper/WaterQualityRecordMapper.java b/wm-production/src/main/java/com/water/production/mapper/WaterQualityRecordMapper.java new file mode 100644 index 00000000..5fa5344e --- /dev/null +++ b/wm-production/src/main/java/com/water/production/mapper/WaterQualityRecordMapper.java @@ -0,0 +1,5 @@ +package com.water.production.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.production.entity.WaterQualityRecord; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface WaterQualityRecordMapper extends BaseMapper {} diff --git a/wm-production/src/main/java/com/water/production/service/AlertCenterService.java b/wm-production/src/main/java/com/water/production/service/AlertCenterService.java new file mode 100644 index 00000000..0be0b753 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/AlertCenterService.java @@ -0,0 +1,309 @@ +package com.water.production.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.water.production.entity.AlertNotification; +import com.water.production.entity.AlertRecord; +import com.water.production.mapper.AlertNotificationMapper; +import com.water.production.mapper.AlertRecordMapper; +import com.water.production.mapper.AlertRuleMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; + +/** + * 报警管理中心服务 - 报警全生命周期管理 + 统计看板 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class AlertCenterService { + + private final AlertRecordMapper recordMapper; + private final AlertNotificationMapper notificationMapper; + private final AlertRuleMapper ruleMapper; + + private static final DateTimeFormatter DATE_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + + // ==================== 报警列表与详情 ==================== + + /** + * 分页查询报警列表 (支持多条件筛选) + */ + public Page page(int current, int size, String level, String area, + Integer status, String deviceSn, + String startDate, String endDate) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (level != null && !level.isEmpty()) wrapper.eq(AlertRecord::getAlertLevel, level); + if (area != null && !area.isEmpty()) wrapper.eq(AlertRecord::getArea, area); + if (status != null) wrapper.eq(AlertRecord::getStatus, status); + if (deviceSn != null && !deviceSn.isEmpty()) wrapper.like(AlertRecord::getDeviceSn, deviceSn); + if (startDate != null && !startDate.isEmpty()) { + wrapper.ge(AlertRecord::getCreatedTime, LocalDate.parse(startDate, DATE_FMT).atStartOfDay()); + } + if (endDate != null && !endDate.isEmpty()) { + wrapper.le(AlertRecord::getCreatedTime, LocalDate.parse(endDate, DATE_FMT).plusDays(1).atStartOfDay()); + } + wrapper.orderByDesc(AlertRecord::getCreatedTime); + return recordMapper.selectPage(new Page<>(current, size), wrapper); + } + + /** + * 查询报警详情 (含通知记录) + */ + public Map getDetail(Long id) { + AlertRecord record = recordMapper.selectById(id); + if (record == null) return null; + + Map detail = new LinkedHashMap<>(); + detail.put("record", record); + detail.put("notifications", notificationMapper.findByAlertRecordId(id)); + detail.put("statusLabel", statusLabel(record.getStatus())); + detail.put("levelLabel", levelLabel(record.getAlertLevel())); + return detail; + } + + /** + * 查询活跃报警 + */ + public List findActive() { + return recordMapper.findActive(); + } + + /** + * 查询待确认报警 + */ + public List findPendingConfirmation() { + return recordMapper.findPendingConfirmation(); + } + + // ==================== 生命周期操作 ==================== + + /** + * 确认报警 + */ + @Transactional + public boolean confirm(Long id, Long userId) { + int rows = recordMapper.confirm(id, userId); + if (rows > 0) { + log.info("Alert confirmed: id={}, userId={}", id, userId); + } + return rows > 0; + } + + /** + * 派单(指派给处理人) + */ + @Transactional + public boolean dispatch(Long id, Long assigneeId, String assigneeName) { + int rows = recordMapper.dispatch(id, assigneeId, assigneeName); + if (rows > 0) { + log.info("Alert dispatched: id={}, assignee={}", id, assigneeName); + // 可选: 创建巡检任务 + createPatrolTask(id, assigneeId); + } + return rows > 0; + } + + /** + * 开始处理 + */ + @Transactional + public boolean startHandle(Long id, Long handlerId, String handlerName) { + int rows = recordMapper.startHandle(id, handlerId, handlerName); + if (rows > 0) { + log.info("Alert handling started: id={}, handler={}", id, handlerName); + } + return rows > 0; + } + + /** + * 完成处理 + */ + @Transactional + public boolean completeHandle(Long id, String result) { + int rows = recordMapper.completeHandle(id, result); + if (rows > 0) { + log.info("Alert handled: id={}", id); + } + return rows > 0; + } + + /** + * 归档 + */ + @Transactional + public boolean archive(Long id, String reason) { + int rows = recordMapper.archive(id, reason); + if (rows > 0) { + log.info("Alert archived: id={}", id); + } + return rows > 0; + } + + /** + * 批量确认 + */ + @Transactional + public int batchConfirm(List ids, Long userId) { + int count = 0; + for (Long id : ids) { + count += recordMapper.confirm(id, userId); + } + return count; + } + + /** + * 批量归档 + */ + @Transactional + public int batchArchive(List ids, String reason) { + int count = 0; + for (Long id : ids) { + count += recordMapper.archive(id, reason); + } + return count; + } + + // ==================== 统计看板 ==================== + + /** + * 获取统计看板数据 + */ + public Map getDashboard(String period) { + Map dashboard = new LinkedHashMap<>(); + + // 计算起始时间 + String startTime = calculateStartTime(period); + + // 总览数据 + dashboard.put("totalByStatus", recordMapper.countByStatus()); + dashboard.put("totalByLevel", recordMapper.countByLevel(startTime)); + dashboard.put("totalByArea", recordMapper.countByArea(startTime)); + dashboard.put("trend", recordMapper.trendByDate(startTime)); + dashboard.put("today", recordMapper.todayStatistics()); + + // 规则统计 + dashboard.put("ruleStats", ruleMapper.countByLevel()); + + // 通知统计 + dashboard.put("notificationStats", notificationMapper.statisticsByChannel(startTime)); + + // 汇总数值 + dashboard.put("summary", buildSummary(startTime)); + + dashboard.put("period", period); + dashboard.put("generatedAt", LocalDateTime.now()); + + return dashboard; + } + + /** + * 获取今日报警概要 + */ + public Map getTodaySummary() { + Map summary = new LinkedHashMap<>(); + List> todayStats = recordMapper.todayStatistics(); + + long totalToday = 0; + long activeCount = 0; + long confirmedCount = 0; + long handledCount = 0; + + for (Map row : todayStats) { + long count = ((Number) row.get("count")).longValue(); + int status = ((Number) row.get("status")).intValue(); + totalToday += count; + if (status == 0) activeCount += count; + else if (status == 1) confirmedCount += count; + else if (status >= 4) handledCount += count; + } + + summary.put("totalToday", totalToday); + summary.put("active", activeCount); + summary.put("confirmed", confirmedCount); + summary.put("handled", handledCount); + summary.put("pending", totalToday - handledCount); + summary.put("detail", todayStats); + return summary; + } + + // ==================== 通知记录查询 ==================== + + /** + * 查询报警关联的通知记录 + */ + public List getNotifications(Long alertRecordId) { + return notificationMapper.findByAlertRecordId(alertRecordId); + } + + // ==================== 内部方法 ==================== + + private String calculateStartTime(String period) { + LocalDate now = LocalDate.now(); + LocalDate start = switch (period != null ? period : "week") { + case "day" -> now.minusDays(1); + case "week" -> now.minusWeeks(1); + case "month" -> now.minusMonths(1); + case "quarter" -> now.minusMonths(3); + case "year" -> now.minusYears(1); + default -> now.minusWeeks(1); + }; + return start.format(DATE_FMT); + } + + private Map buildSummary(String startTime) { + Map summary = new LinkedHashMap<>(); + // 总报警数 + LambdaQueryWrapper totalWrapper = new LambdaQueryWrapper<>(); + totalWrapper.ge(AlertRecord::getCreatedTime, LocalDate.parse(startTime, DATE_FMT).atStartOfDay()); + long total = recordMapper.selectCount(totalWrapper); + summary.put("total", total); + + // 活跃报警数 + LambdaQueryWrapper activeWrapper = new LambdaQueryWrapper<>(); + activeWrapper.lt(AlertRecord::getStatus, 5) + .ge(AlertRecord::getCreatedTime, LocalDate.parse(startTime, DATE_FMT).atStartOfDay()); + summary.put("active", recordMapper.selectCount(activeWrapper)); + + // 紧急报警数 + LambdaQueryWrapper urgentWrapper = new LambdaQueryWrapper<>(); + urgentWrapper.eq(AlertRecord::getAlertLevel, "urgent") + .ge(AlertRecord::getCreatedTime, LocalDate.parse(startTime, DATE_FMT).atStartOfDay()); + summary.put("urgent", recordMapper.selectCount(urgentWrapper)); + + return summary; + } + + private void createPatrolTask(Long alertId, Long assigneeId) { + // 可选集成: 创建巡检任务关联报警 + log.info("Patrol task creation for alert {} assigned to user {}", alertId, assigneeId); + } + + private String statusLabel(Integer status) { + return switch (status) { + case 0 -> "活跃"; + case 1 -> "已确认"; + case 2 -> "已派单"; + case 3 -> "处理中"; + case 4 -> "已处理"; + case 5 -> "已归档"; + default -> "未知"; + }; + } + + private String levelLabel(String level) { + return switch (level) { + case "urgent" -> "紧急"; + case "important" -> "重要"; + case "general" -> "一般"; + default -> level; + }; + } +} diff --git a/wm-production/src/main/java/com/water/production/service/AlertEngine.java b/wm-production/src/main/java/com/water/production/service/AlertEngine.java new file mode 100644 index 00000000..a6563146 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/AlertEngine.java @@ -0,0 +1,87 @@ +package com.water.production.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.time.Instant; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +@Slf4j +@Service +@RequiredArgsConstructor +public class AlertEngine { + + private final JdbcTemplate jdbc; + private final Map lastAlertTime = new ConcurrentHashMap<>(); + + /** 检查指标是否触发报警 */ + public void checkMetric(String deviceSn, String metricKey, double value, String area) { + List> rules = jdbc.queryForList( + "SELECT * FROM alert_rule WHERE metric_key = ? AND enabled = 1", metricKey); + + for (Map rule : rules) { + try { + String condition = (String) rule.get("condition_expr"); + double threshold = ((Number) rule.get("threshold_value")).doubleValue(); + String level = (String) rule.get("alert_level"); + int debounce = ((Number) rule.get("debounce_sec")).intValue(); + + boolean triggered = false; + if (condition.startsWith(">")) triggered = value > threshold; + else if (condition.startsWith("<")) triggered = value < threshold; + else if (condition.startsWith(">=")) triggered = value >= threshold; + else if (condition.startsWith("<=")) triggered = value <= threshold; + + if (!triggered) continue; + + // 去重检查 + String dedupKey = deviceSn + ":" + metricKey + ":" + level; + long now = Instant.now().getEpochSecond(); + Long last = lastAlertTime.get(dedupKey); + if (last != null && (now - last) < debounce) continue; + lastAlertTime.put(dedupKey, now); + + // 创建报警事件 + Long ruleId = ((Number) rule.get("id")).longValue(); + String message = String.format("%s %s: %.2f %s 阈值 %.2f", + deviceSn, metricKey, value, condition, threshold); + + jdbc.update( + "INSERT INTO alert_event (rule_id, device_sn, area, metric_key, metric_value, threshold_value, alert_level, title, message) " + + "VALUES (?,?,?,?,?,?,?,?,?)", + ruleId, deviceSn, area, metricKey, value, String.valueOf(threshold), level, + "[" + level + "] " + metricKey + "异常", message); + + log.info("Alert triggered: {} level={}", dedupKey, level); + } catch (Exception e) { + log.error("CheckMetric error: {}", e.getMessage()); + } + } + } + + /** 确认报警 */ + public void confirm(Long alertId, Long userId) { + jdbc.update("UPDATE alert_event SET confirmed_by = ?, confirmed_at = NOW() WHERE id = ?", userId, alertId); + } + + /** 派单 */ + public void dispatch(Long alertId, Long assigneeId) { + jdbc.update("UPDATE alert_event SET dispatched = 1 WHERE id = ?", alertId); + jdbc.update("INSERT INTO patrol_task (task_name, assignee_id, task_date, status) " + + "SELECT CONCAT('报警处理: ', title), ?, CURRENT_DATE, 'pending' FROM alert_event WHERE id = ?", + assigneeId, alertId); + } + + /** 报警列表 */ + public List> getAlerts(String level, String area, boolean onlyActive) { + StringBuilder sql = new StringBuilder("SELECT * FROM alert_event WHERE 1=1"); + if (level != null) sql.append(" AND alert_level = '").append(level).append("'"); + if (area != null) sql.append(" AND area = '").append(area).append("'"); + if (onlyActive) sql.append(" AND resolved_at IS NULL"); + sql.append(" ORDER BY created_at DESC LIMIT 100"); + return jdbc.queryForList(sql.toString()); + } +} diff --git a/wm-production/src/main/java/com/water/production/service/AlertRuleService.java b/wm-production/src/main/java/com/water/production/service/AlertRuleService.java index 478fb148..b6ef5fe4 100644 --- a/wm-production/src/main/java/com/water/production/service/AlertRuleService.java +++ b/wm-production/src/main/java/com/water/production/service/AlertRuleService.java @@ -1,39 +1,292 @@ package com.water.production.service; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.water.production.entity.AlertNotification; +import com.water.production.entity.AlertRecord; import com.water.production.entity.AlertRule; -import java.util.List; +import com.water.production.mapper.AlertNotificationMapper; +import com.water.production.mapper.AlertRecordMapper; +import com.water.production.mapper.AlertRuleMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; -public interface AlertRuleService { - // 查询所有报警规则 - List getAllAlertRules(); - - // 根据ID获取报警规则 - AlertRule getAlertRuleById(Long id); - - // 根据参数获取报警规则 - List getAlertRulesByParameter(String parameter); - - // 根据设备获取报警规则 - List getAlertRulesByEquipment(String equipmentId); - - // 根据区域获取报警规则 - List getAlertRulesByArea(String area); - - // 创建报警规则 - AlertRule createAlertRule(AlertRule alertRule); - - // 更新报警规则 - AlertRule updateAlertRule(AlertRule alertRule); - - // 删除报警规则 - boolean deleteAlertRule(Long id); - - // 启用报警规则 - boolean enableAlertRule(Long id); - - // 禁用报警规则 - boolean disableAlertRule(Long id); - - // 验证报警规则 - boolean validateAlertRule(AlertRule alertRule); -} \ No newline at end of file +import java.math.BigDecimal; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +/** + * 报警规则服务 - CRUD + 规则评估引擎(支持AND/OR组合条件) + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class AlertRuleService { + + private final AlertRuleMapper ruleMapper; + private final AlertRecordMapper recordMapper; + private final AlertNotificationMapper notificationMapper; + private final ObjectMapper objectMapper; + + /** 去重缓存: key -> 上次触发时间戳(秒) */ + private final Map lastTriggerTime = new ConcurrentHashMap<>(); + + // ==================== CRUD ==================== + + /** + * 分页查询规则 + */ + public Page page(int current, int size, String keyword, String alertLevel, Boolean enabled) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (keyword != null && !keyword.isEmpty()) { + wrapper.and(w -> w.like(AlertRule::getRuleName, keyword) + .or().like(AlertRule::getRuleCode, keyword) + .or().like(AlertRule::getMetricKey, keyword)); + } + if (alertLevel != null) wrapper.eq(AlertRule::getAlertLevel, alertLevel); + if (enabled != null) wrapper.eq(AlertRule::getEnabled, enabled ? 1 : 0); + wrapper.orderByDesc(AlertRule::getPriority).orderByDesc(AlertRule::getCreatedTime); + return ruleMapper.selectPage(new Page<>(current, size), wrapper); + } + + /** + * 根据ID查询规则详情 + */ + public AlertRule getById(Long id) { + return ruleMapper.selectById(id); + } + + /** + * 创建规则 + */ + @Transactional + public AlertRule create(AlertRule rule) { + rule.setCreatedTime(LocalDateTime.now()); + rule.setUpdatedTime(LocalDateTime.now()); + rule.setDeleted(0); + if (rule.getDebounceSec() == null) rule.setDebounceSec(300); + if (rule.getPriority() == null) rule.setPriority(0); + if (rule.getEnabled() == null) rule.setEnabled(1); + ruleMapper.insert(rule); + return rule; + } + + /** + * 更新规则 + */ + @Transactional + public boolean update(AlertRule rule) { + rule.setUpdatedTime(LocalDateTime.now()); + return ruleMapper.updateById(rule) > 0; + } + + /** + * 删除规则(逻辑删除) + */ + @Transactional + public boolean delete(Long id) { + return ruleMapper.deleteById(id) > 0; + } + + /** + * 启用/禁用规则 + */ + @Transactional + public boolean toggleEnabled(Long id, boolean enabled) { + AlertRule rule = new AlertRule(); + rule.setId(id); + rule.setEnabled(enabled ? 1 : 0); + rule.setUpdatedTime(LocalDateTime.now()); + return ruleMapper.updateById(rule) > 0; + } + + /** + * 查询所有启用的规则 + */ + public List findAllEnabled() { + return ruleMapper.findAllEnabled(); + } + + /** + * 统计各等级规则数量 + */ + public List> countByLevel() { + return ruleMapper.countByLevel(); + } + + // ==================== 规则评估引擎 ==================== + + /** + * 评估指标值是否触发报警 (核心引擎) + */ + @Transactional + public List evaluateMetric(String deviceSn, String metricKey, double value, String area) { + List rules = ruleMapper.findEnabledByMetricKey(metricKey); + List triggeredRecords = new ArrayList<>(); + + for (AlertRule rule : rules) { + try { + if (!isWithinEffectiveTime(rule)) continue; + boolean triggered = evaluateCondition(rule.getConditionExpr(), metricKey, value); + if (!triggered) continue; + + String dedupKey = deviceSn + ":" + metricKey + ":" + rule.getAlertLevel(); + long now = Instant.now().getEpochSecond(); + Long lastTime = lastTriggerTime.get(dedupKey); + if (lastTime != null && (now - lastTime) < rule.getDebounceSec()) continue; + lastTriggerTime.put(dedupKey, now); + + AlertRecord record = createAlertRecord(rule, deviceSn, metricKey, value, area); + recordMapper.insert(record); + triggeredRecords.add(record); + sendNotifications(rule, record); + + log.info("Alert triggered: rule={} device={} metric={} value={} level={}", + rule.getRuleName(), deviceSn, metricKey, value, rule.getAlertLevel()); + } catch (Exception e) { + log.error("Evaluate rule error [{}]: {}", rule.getRuleCode(), e.getMessage(), e); + } + } + return triggeredRecords; + } + + public boolean evaluateCondition(String conditionExpr, String metricKey, double value) { + if (conditionExpr == null || conditionExpr.isEmpty()) return false; + try { + JsonNode root = objectMapper.readTree(conditionExpr); + if (root.has("op") && root.has("conditions")) { + return evaluateCompositeCondition(root, metricKey, value); + } + return evaluateSimpleCondition(root, metricKey, value); + } catch (Exception e) { + log.error("Parse condition expression error: {}", conditionExpr, e); + return false; + } + } + + private boolean evaluateCompositeCondition(JsonNode root, String metricKey, double value) { + String op = root.get("op").asText().toUpperCase(); + JsonNode conditions = root.get("conditions"); + if (conditions == null || !conditions.isArray()) return false; + + if ("AND".equals(op)) { + for (JsonNode condition : conditions) { + if (!evaluateSimpleCondition(condition, metricKey, value)) return false; + } + return true; + } else if ("OR".equals(op)) { + for (JsonNode condition : conditions) { + if (evaluateSimpleCondition(condition, metricKey, value)) return true; + } + return false; + } + return false; + } + + private boolean evaluateSimpleCondition(JsonNode condition, String metricKey, double value) { + String condMetric = condition.has("metric") ? condition.get("metric").asText() : metricKey; + if (!condMetric.equals(metricKey)) return false; + + String operator = condition.get("operator").asText(); + double threshold = condition.get("threshold").asDouble(); + + return switch (operator) { + case ">" -> value > threshold; + case ">=" -> value >= threshold; + case "<" -> value < threshold; + case "<=" -> value <= threshold; + case "==" -> Math.abs(value - threshold) < 0.0001; + case "!=" -> Math.abs(value - threshold) >= 0.0001; + default -> false; + }; + } + + private boolean isWithinEffectiveTime(AlertRule rule) { + if (rule.getEffectiveStart() == null || rule.getEffectiveEnd() == null) return true; + LocalTime now = LocalTime.now(); + if (rule.getEffectiveStart().isBefore(rule.getEffectiveEnd())) { + return !now.isBefore(rule.getEffectiveStart()) && !now.isAfter(rule.getEffectiveEnd()); + } else { + return !now.isBefore(rule.getEffectiveStart()) || !now.isAfter(rule.getEffectiveEnd()); + } + } + + private AlertRecord createAlertRecord(AlertRule rule, String deviceSn, String metricKey, double value, String area) { + AlertRecord record = new AlertRecord(); + record.setRuleId(rule.getId()); + record.setRuleName(rule.getRuleName()); + record.setDeviceSn(deviceSn); + record.setArea(area); + record.setMetricKey(metricKey); + record.setMetricValue(BigDecimal.valueOf(value)); + record.setThresholdValue(rule.getThresholdValue() != null ? rule.getThresholdValue().toPlainString() : ""); + record.setAlertLevel(rule.getAlertLevel()); + record.setTitle(String.format("[%s] %s - %s", levelLabel(rule.getAlertLevel()), rule.getRuleName(), deviceSn)); + record.setMessage(buildAlertMessage(rule, deviceSn, metricKey, value)); + record.setStatus(0); + record.setCreatedTime(LocalDateTime.now()); + record.setUpdatedTime(LocalDateTime.now()); + record.setDeleted(0); + return record; + } + + private String buildAlertMessage(AlertRule rule, String deviceSn, String metricKey, double value) { + return String.format("设备 %s 指标 %s 当前值 %.4f，触发规则: %s (等级: %s)\n规则描述: %s", + deviceSn, metricKey, value, rule.getRuleName(), + levelLabel(rule.getAlertLevel()), + rule.getDescription() != null ? rule.getDescription() : "无"); + } + + private void sendNotifications(AlertRule rule, AlertRecord record) { + String channels = rule.getNotifyChannels(); + if (channels == null || channels.isEmpty()) return; + + for (String channel : channels.split(",")) { + channel = channel.trim(); + if (channel.isEmpty()) continue; + + AlertNotification notification = new AlertNotification(); + notification.setAlertRecordId(record.getId()); + notification.setRuleId(rule.getId()); + notification.setChannel(channel); + notification.setRecipient("system"); + notification.setTitle(record.getTitle()); + notification.setContent(record.getMessage()); + notification.setStatus(0); + notification.setCreatedTime(LocalDateTime.now()); + notificationMapper.insert(notification); + + try { + doSendNotification(channel, notification); + notification.setStatus(1); + notification.setSendTime(LocalDateTime.now()); + } catch (Exception e) { + notification.setStatus(2); + notification.setErrorMsg(e.getMessage()); + log.error("Send notification error: channel={} record={}", channel, record.getId(), e); + } + notificationMapper.updateById(notification); + } + } + + private void doSendNotification(String channel, AlertNotification notification) { + log.info("Sending alert notification: channel={}, title={}, recipient={}", + channel, notification.getTitle(), notification.getRecipient()); + } + + private String levelLabel(String level) { + return switch (level) { + case "urgent" -> "紧急"; + case "important" -> "重要"; + case "general" -> "一般"; + default -> level; + }; + } +} diff --git a/wm-production/src/main/java/com/water/production/service/DashboardService.java b/wm-production/src/main/java/com/water/production/service/DashboardService.java new file mode 100644 index 00000000..051a6fb8 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/DashboardService.java @@ -0,0 +1,61 @@ +package com.water.production.service; + +import lombok.RequiredArgsConstructor; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Service +@RequiredArgsConstructor +public class DashboardService { + + private final JdbcTemplate jdbc; + + /** 获取供水总览数据（按角色自动定位区域） */ + public Map getOverview(String area, String roleType) { + Map overview = new LinkedHashMap<>(); + + // 今日进出水量（从时序库聚合） + try { + Map flow = jdbc.queryForMap( + "SELECT COALESCE(SUM(CASE WHEN metric_key='inflow' THEN metric_value ELSE 0 END),0) AS inflow, " + + "COALESCE(SUM(CASE WHEN metric_key='outflow' THEN metric_value ELSE 0 END),0) AS outflow " + + "FROM iot_telemetry WHERE ts >= CURRENT_DATE AND area = ?", area); + overview.put("todayInflow", flow.get("inflow")); + overview.put("todayOutflow", flow.get("outflow")); + } catch (Exception e) { overview.put("todayInflow", 0); overview.put("todayOutflow", 0); } + + // 昨日供水量 + overview.put("yesterdaySupply", jdbc.queryForObject( + "SELECT COALESCE(SUM(consumption),0) FROM rev_reading WHERE reading_date = CURRENT_DATE - 1", Double.class)); + + // 实时报警数 + overview.put("activeAlerts", jdbc.queryForObject( + "SELECT COUNT(*) FROM alert_event WHERE confirmed_by IS NULL AND created_at >= CURRENT_DATE", Long.class)); + + // 设备运行概况 + overview.put("deviceStats", jdbc.queryForList( + "SELECT status, COUNT(*) as count FROM iot_device WHERE area = ? GROUP BY status", area)); + + // 能耗药耗 + overview.put("energy", Map.of("power_kwh", 1250.5, "pump_runtime_h", 18.2)); + overview.put("chemical", Map.of("coagulant_kg", 45.0, "disinfectant_kg", 12.5)); + + overview.put("area", area); + overview.put("timestamp", System.currentTimeMillis()); + return overview; + } + + /** 实时监测列表（多维度筛选） */ + public List> getRealtimeMonitoring(String area, String positionType, String deviceType) { + StringBuilder sql = new StringBuilder( + "SELECT id, device_sn, device_name, device_type, position_type, area, status, last_report_time," + + "ST_X(geom) as lng, ST_Y(geom) as lat FROM iot_device WHERE 1=1"); + if (area != null) sql.append(" AND area = '").append(area).append("'"); + if (positionType != null) sql.append(" AND position_type = '").append(positionType).append("'"); + if (deviceType != null) sql.append(" AND device_type = '").append(deviceType).append("'"); + sql.append(" ORDER BY last_report_time DESC LIMIT 100"); + return jdbc.queryForList(sql.toString()); + } +} diff --git a/wm-production/src/main/java/com/water/production/service/DataCenterService.java b/wm-production/src/main/java/com/water/production/service/DataCenterService.java new file mode 100644 index 00000000..9bae7ddf --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/DataCenterService.java @@ -0,0 +1,66 @@ +package com.water.production.service; + +import lombok.RequiredArgsConstructor; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Service +@RequiredArgsConstructor +public class DataCenterService { + + private final JdbcTemplate jdbc; + + /** 历史数据查看（多类型） */ + public List> getHistoryData(String dataType, String area, String startTime, String endTime) { + String table = switch (dataType) { + case "water_flow" -> "rev_reading"; + case "water_quality" -> "water_quality_record"; + case "alerts" -> "alert_event"; + default -> "iot_telemetry"; + }; + return jdbc.queryForList( + "SELECT * FROM " + table + " WHERE (area = ? OR ? IS NULL) AND created_at BETWEEN ? AND ? LIMIT 500", + area, area, startTime, endTime); + } + + /** 报表生成 */ + public Map generateReport(String reportType, String period) { + Map report = new LinkedHashMap<>(); + report.put("reportType", reportType); + report.put("period", period); + report.put("generatedAt", new Date()); + + switch (reportType) { + case "water_volume" -> report.put("data", jdbc.queryForList( + "SELECT area, SUM(consumption) as total FROM rev_reading WHERE reading_period = ? GROUP BY area", period)); + case "water_quality" -> report.put("data", jdbc.queryForList( + "SELECT area, AVG(turbidity) as avg_turbidity, AVG(ph) as avg_ph, " + + "AVG(residual_chlorine) as avg_cl, COUNT(*) as tests, " + + "SUM(CASE WHEN is_qualified=1 THEN 1 ELSE 0 END)*100.0/NULLIF(COUNT(*),0) as pass_rate " + + "FROM water_quality_record WHERE to_char(test_date,'YYYY-MM') = ? GROUP BY area", period)); + case "alert" -> report.put("data", jdbc.queryForList( + "SELECT alert_level, area, COUNT(*) as count FROM alert_event WHERE to_char(created_at,'YYYY-MM') = ? GROUP BY alert_level, area", period)); + } + return report; + } + + /** 阈值管理 */ + public List> getThresholds() { + return jdbc.queryForList("SELECT * FROM alert_rule WHERE enabled = 1 ORDER BY device_type, metric_key"); + } + + public void updateThreshold(Long ruleId, double newThreshold, String newCondition) { + jdbc.update("UPDATE alert_rule SET threshold_value = ?, condition_expr = ? WHERE id = ?", + newThreshold, newCondition, ruleId); + } + + /** 信息发布 */ + public void publishInfo(String type, String title, String content) { + jdbc.update( + "INSERT INTO sys_dict_data (dict_type_id, dict_label, dict_value) " + + "SELECT id, ?, ? FROM sys_dict_type WHERE dict_key = ?", + title, content, "info_release_" + type); + } +} diff --git a/wm-production/src/main/java/com/water/production/service/DispatchCommandService.java b/wm-production/src/main/java/com/water/production/service/DispatchCommandService.java new file mode 100644 index 00000000..82936773 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/DispatchCommandService.java @@ -0,0 +1,228 @@ +package com.water.production.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.common.core.exception.BusinessException; +import com.water.production.entity.DispatchCommand; +import com.water.production.entity.DispatchExecution; +import com.water.production.entity.DispatchTracking; +import com.water.production.mapper.DispatchCommandMapper; +import com.water.production.mapper.DispatchExecutionMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class DispatchCommandService { + + private final DispatchCommandMapper commandMapper; + private final DispatchExecutionMapper executionMapper; + private final DispatchTrackingService trackingService; + + private static final Map> STATE_TRANSITIONS = new LinkedHashMap<>(); + static { + STATE_TRANSITIONS.put("draft", Set.of("issued")); + STATE_TRANSITIONS.put("issued", Set.of("received", "rejected")); + STATE_TRANSITIONS.put("received", Set.of("executing", "rejected")); + STATE_TRANSITIONS.put("executing", Set.of("completed", "rejected")); + STATE_TRANSITIONS.put("completed", Set.of()); + STATE_TRANSITIONS.put("rejected", Set.of()); + } + + @Transactional + public DispatchCommand createCommand(DispatchCommand command) { + String cmdNo = "CMD-" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")) + + "-" + String.format("%04d", new Random().nextInt(10000)); + command.setCommandNo(cmdNo); + command.setStatus("draft"); + commandMapper.insert(command); + trackingService.log(command.getId(), null, "create", null, null, "draft", "创建指令"); + log.info("创建调度指令: {}", cmdNo); + return command; + } + + @Transactional + public DispatchCommand issueCommand(Long commandId, Long issuedBy, String operatorName) { + DispatchCommand cmd = getCommandOrThrow(commandId); + validateTransition(cmd.getStatus(), "issued"); + cmd.setStatus("issued"); + cmd.setIssuedAt(LocalDateTime.now()); + cmd.setIssuedBy(issuedBy); + commandMapper.updateById(cmd); + createExecutionRecords(cmd); + trackingService.log(commandId, null, "issue", issuedBy, operatorName, "draft", "issued", "指令下发"); + log.info("下发调度指令: {}", cmd.getCommandNo()); + return cmd; + } + + @Transactional + public DispatchExecution receiveCommand(Long commandId, Long userId, String userName) { + DispatchCommand cmd = getCommandOrThrow(commandId); + validateTransition(cmd.getStatus(), "received"); + DispatchExecution exec = getExecutionOrThrow(commandId, userId); + if (!Objects.equals(exec.getExecuteStatus(), "pending")) { + throw new BusinessException("该执行记录状态不允许接收确认"); + } + exec.setExecuteStatus("received"); + exec.setReceivedAt(LocalDateTime.now()); + executionMapper.updateById(exec); + if (allExecutionsInStatus(commandId, "received")) { + cmd.setStatus("received"); + commandMapper.updateById(cmd); + } + trackingService.log(commandId, exec.getId(), "receive", userId, userName, "pending", "received", "接收确认"); + return exec; + } + + @Transactional + public DispatchExecution startExecution(Long commandId, Long userId, String userName) { + DispatchCommand cmd = getCommandOrThrow(commandId); + validateTransition(cmd.getStatus(), "executing"); + DispatchExecution exec = getExecutionOrThrow(commandId, userId); + if (!Objects.equals(exec.getExecuteStatus(), "received")) { + throw new BusinessException("必须先接收确认才能开始执行"); + } + exec.setExecuteStatus("executing"); + executionMapper.updateById(exec); + if (Objects.equals(cmd.getStatus(), "received")) { + cmd.setStatus("executing"); + commandMapper.updateById(cmd); + } + trackingService.log(commandId, exec.getId(), "start_execute", userId, userName, "received", "executing", "开始执行"); + return exec; + } + + @Transactional + public DispatchExecution completeExecution(Long commandId, Long userId, String userName, + String feedback, String feedbackImages) { + DispatchCommand cmd = getCommandOrThrow(commandId); + validateTransition(cmd.getStatus(), "completed"); + DispatchExecution exec = getExecutionOrThrow(commandId, userId); + if (!Objects.equals(exec.getExecuteStatus(), "executing")) { + throw new BusinessException("只有执行中状态才能完成"); + } + exec.setExecuteStatus("completed"); + exec.setFeedback(feedback); + exec.setFeedbackImages(feedbackImages); + exec.setCompletedAt(LocalDateTime.now()); + executionMapper.updateById(exec); + if (allExecutionsFinal(commandId)) { + cmd.setStatus("completed"); + cmd.setCompletedAt(LocalDateTime.now()); + commandMapper.updateById(cmd); + trackingService.log(commandId, null, "complete", userId, userName, "executing", "completed", "全部执行完成，归档"); + } + trackingService.log(commandId, exec.getId(), "complete", userId, userName, "executing", "completed", "执行完成"); + return exec; + } + + @Transactional + public DispatchExecution rejectExecution(Long commandId, Long userId, String userName, String reason) { + DispatchCommand cmd = getCommandOrThrow(commandId); + DispatchExecution exec = getExecutionOrThrow(commandId, userId); + String prevStatus = exec.getExecuteStatus(); + if (Objects.equals(prevStatus, "completed") || Objects.equals(prevStatus, "rejected")) { + throw new BusinessException("当前状态不允许驳回"); + } + exec.setExecuteStatus("rejected"); + exec.setRejectedReason(reason); + exec.setCompletedAt(LocalDateTime.now()); + executionMapper.updateById(exec); + if (allExecutionsFinal(commandId)) { + cmd.setStatus("rejected"); + commandMapper.updateById(cmd); + trackingService.log(commandId, null, "reject", userId, userName, cmd.getStatus(), "rejected", "全部驳回/终止"); + } + trackingService.log(commandId, exec.getId(), "reject", userId, userName, prevStatus, "rejected", "驳回原因: " + reason); + return exec; + } + + public IPage> listCommands(int page, int size, String status, String commandType, + String keyword, String startDate, String endDate) { + return commandMapper.selectCommandPage(new Page<>(page, size), status, commandType, keyword, startDate, endDate); + } + + public Map getCommandDetail(Long commandId) { + Map detail = commandMapper.selectCommandDetail(commandId); + if (detail == null) { + throw new BusinessException("指令不存在"); + } + detail.put("trackingLogs", trackingService.getTrackingLogs(commandId)); + return detail; + } + + public List> getStatusStats() { + return commandMapper.selectStatusStats(); + } + + private DispatchCommand getCommandOrThrow(Long commandId) { + DispatchCommand cmd = commandMapper.selectById(commandId); + if (cmd == null) throw new BusinessException("指令不存在"); + return cmd; + } + + private DispatchExecution getExecutionOrThrow(Long commandId, Long userId) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DispatchExecution::getCommandId, commandId) + .eq(DispatchExecution::getUserId, userId); + DispatchExecution exec = executionMapper.selectOne(wrapper); + if (exec == null) throw new BusinessException("执行记录不存在"); + return exec; + } + + private void validateTransition(String currentStatus, String targetStatus) { + Set allowed = STATE_TRANSITIONS.get(currentStatus); + if (allowed == null || !allowed.contains(targetStatus)) { + throw new BusinessException("状态流转不合法: " + currentStatus + " -> " + targetStatus); + } + } + + private void createExecutionRecords(DispatchCommand cmd) { + if (cmd.getTargetIds() == null || cmd.getTargetIds().isBlank()) return; + String cleaned = cmd.getTargetIds().replaceAll("[\\[\\]\"]", ""); + for (String idStr : cleaned.split(",")) { + String trimmed = idStr.trim(); + if (trimmed.isEmpty()) continue; + try { + Long userId = Long.parseLong(trimmed); + DispatchExecution exec = new DispatchExecution(); + exec.setCommandId(cmd.getId()); + exec.setUserId(userId); + exec.setExecuteStatus("pending"); + executionMapper.insert(exec); + } catch (NumberFormatException e) { + log.warn("跳过无效目标ID: {}", trimmed); + } + } + } + + private boolean allExecutionsInStatus(Long commandId, String status) { + LambdaQueryWrapper w1 = new LambdaQueryWrapper<>(); + w1.eq(DispatchExecution::getCommandId, commandId); + Long total = executionMapper.selectCount(w1); + LambdaQueryWrapper w2 = new LambdaQueryWrapper<>(); + w2.eq(DispatchExecution::getCommandId, commandId) + .eq(DispatchExecution::getExecuteStatus, status); + Long count = executionMapper.selectCount(w2); + return total > 0 && total.equals(count); + } + + private boolean allExecutionsFinal(Long commandId) { + LambdaQueryWrapper w1 = new LambdaQueryWrapper<>(); + w1.eq(DispatchExecution::getCommandId, commandId); + Long total = executionMapper.selectCount(w1); + LambdaQueryWrapper w2 = new LambdaQueryWrapper<>(); + w2.eq(DispatchExecution::getCommandId, commandId) + .in(DispatchExecution::getExecuteStatus, "completed", "rejected"); + Long finalCount = executionMapper.selectCount(w2); + return total > 0 && total.equals(finalCount); + } +} diff --git a/wm-production/src/main/java/com/water/production/service/DispatchService.java b/wm-production/src/main/java/com/water/production/service/DispatchService.java new file mode 100644 index 00000000..7627b328 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/DispatchService.java @@ -0,0 +1,100 @@ +package com.water.production.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.time.LocalDate; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class DispatchService { + + private final JdbcTemplate jdbc; + + // ========== 值班管理 ========== + public List> getTodayDuty(String area) { + return jdbc.queryForList( + "SELECT dr.*, u.real_name, u.phone, ds.shift_type " + + "FROM duty_record dr JOIN sys_user u ON dr.user_id = u.id " + + "JOIN duty_schedule ds ON dr.schedule_id = ds.id " + + "WHERE dr.duty_date = CURRENT_DATE AND ds.status = 1"); + } + + public Map startDuty(Long userId) { + jdbc.update("UPDATE duty_record SET status = 'on_duty', on_duty_at = NOW() WHERE user_id = ? AND duty_date = CURRENT_DATE", userId); + return Map.of("status", "on_duty", "startedAt", new Date()); + } + + public Map endDuty(Long userId, String handoverRemark) { + jdbc.update( + "UPDATE duty_record SET status = 'off_duty', off_duty_at = NOW(), handover_remark = ? WHERE user_id = ? AND duty_date = CURRENT_DATE", + handoverRemark, userId); + return Map.of("status", "off_duty"); + } + + // ========== 调度指令 ========== + public Map createCommand(String title, String content, String type, String source, String targetType, List targetIds) { + String cmdNo = "CMD-" + System.currentTimeMillis(); + jdbc.update( + "INSERT INTO dispatch_command (command_no, command_type, command_title, command_content, source, target_type, target_ids, status) " + + "VALUES (?,?,?,?,?,?,?::jsonb,'draft')", + cmdNo, type, title, content, source, targetType, targetIds.toString()); + log.info("Command created: {} type={}", cmdNo, type); + return Map.of("commandNo", cmdNo, "status", "draft"); + } + + public Map issueCommand(String cmdNo) { + jdbc.update("UPDATE dispatch_command SET status = 'issued', issued_at = NOW() WHERE command_no = ?", cmdNo); + // 记录日志 + jdbc.update("INSERT INTO dispatch_log (command_id, action) SELECT id, 'issue' FROM dispatch_command WHERE command_no = ?", cmdNo); + return Map.of("commandNo", cmdNo, "status", "issued"); + } + + public Map trackCommand(String cmdNo) { + return jdbc.queryForMap("SELECT * FROM dispatch_command WHERE command_no = ?", cmdNo); + } + + public List> getCommandLog(String cmdNo) { + return jdbc.queryForList( + "SELECT dl.* FROM dispatch_log dl JOIN dispatch_command dc ON dl.command_id = dc.id WHERE dc.command_no = ? ORDER BY dl.created_at", + cmdNo); + } + + // ========== 应急调度推演 ========== + public Map pipeBurstSimulation(double lng, double lat, String pipeDiameter) { + // 爆管模拟：影响区域分析 + Map result = new LinkedHashMap<>(); + result.put("scenario", "爆管"); + result.put("location", Map.of("lng", lng, "lat", lat)); + result.put("pipeDiameter", pipeDiameter); + result.put("affectedArea", "半径500m"); + result.put("affectedCustomers", 230); + result.put("suggestedActions", List.of( + "关闭上游阀门 V-001, V-002", + "启动应急供水方案 B", + "通知受影响用户（短信+公告）", + "调度抢修队出发" + )); + result.put("estimatedRecoveryHours", 4); + return result; + } + + public Map waterQualityIncident(String area, String pollutant) { + Map result = new LinkedHashMap<>(); + result.put("scenario", "水质异常"); + result.put("area", area); + result.put("pollutant", pollutant); + result.put("suggestedActions", List.of( + "立即停止该片区供水", + "启动备用水源", + "水质采样送检", + "向下游水厂发出预警" + )); + result.put("riskLevel", "critical"); + return result; + } +} diff --git a/wm-production/src/main/java/com/water/production/service/DispatchTrackingService.java b/wm-production/src/main/java/com/water/production/service/DispatchTrackingService.java new file mode 100644 index 00000000..3d2423fe --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/DispatchTrackingService.java @@ -0,0 +1,53 @@ +package com.water.production.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.production.entity.DispatchTracking; +import com.water.production.mapper.DispatchTrackingMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Slf4j +@Service +@RequiredArgsConstructor +public class DispatchTrackingService { + + private final DispatchTrackingMapper trackingMapper; + + public void log(Long commandId, Long executionId, String action, + Long operatorId, String operatorName, + String fromStatus, String toStatus, String remark) { + DispatchTracking tracking = new DispatchTracking(); + tracking.setCommandId(commandId); + tracking.setExecutionId(executionId); + tracking.setAction(action); + tracking.setOperatorId(operatorId); + tracking.setOperatorName(operatorName); + tracking.setFromStatus(fromStatus); + tracking.setToStatus(toStatus); + tracking.setRemark(remark); + trackingMapper.insert(tracking); + } + + public void log(Long commandId, Long executionId, String action, + Long operatorId, String operatorName, + String toStatus, String remark) { + log(commandId, executionId, action, operatorId, operatorName, null, toStatus, remark); + } + + public List getTrackingLogs(Long commandId) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DispatchTracking::getCommandId, commandId) + .orderByAsc(DispatchTracking::getCreatedAt); + return trackingMapper.selectList(wrapper); + } + + public List getExecutionTrackingLogs(Long executionId) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(DispatchTracking::getExecutionId, executionId) + .orderByAsc(DispatchTracking::getCreatedAt); + return trackingMapper.selectList(wrapper); + } +} diff --git a/wm-production/src/main/java/com/water/production/service/VideoService.java b/wm-production/src/main/java/com/water/production/service/VideoService.java new file mode 100644 index 00000000..6098038f --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/VideoService.java @@ -0,0 +1,34 @@ +package com.water.production.service; + +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Slf4j +@Service +public class VideoService { + + /** 获取所有视频监控点位 */ + public List> getCameras(String area) { + // Mock: 返回预设视频点位 + List> cameras = new ArrayList<>(); + cameras.add(Map.of("id", 1, "name", "一体化水厂-沉淀池", "rtsp", "rtsp://192.168.1.100/stream1", "area", "一体化水厂", "status", "online")); + cameras.add(Map.of("id", 2, "name", "查村调压站-入口", "rtsp", "rtsp://192.168.1.101/stream1", "area", "八家户片区", "status", "online")); + cameras.add(Map.of("id", 3, "name", "精芒片区-管网节点1", "rtsp", "rtsp://192.168.1.102/stream1", "area", "精芒片区", "status", "online")); + return cameras; + } + + /** AI 人员闯入检测 */ + public Map detectIntrusion(String cameraId, byte[] frameData) { + // Mock: YOLOv8 推理 (实际调用模型服务) + double probability = Math.random(); + boolean intruder = probability > 0.85; + if (intruder) { + log.warn("Intrusion detected on camera {} (prob={})", cameraId, String.format("%.2f", probability)); + return Map.of("cameraId", cameraId, "intruder", true, "confidence", probability, + "alert", "检测到人员闯入", "timestamp", System.currentTimeMillis()); + } + return Map.of("cameraId", cameraId, "intruder", false, "confidence", probability); + } +} diff --git a/wm-production/src/main/java/com/water/production/service/WaterQualityService.java b/wm-production/src/main/java/com/water/production/service/WaterQualityService.java new file mode 100644 index 00000000..6c0f1027 --- /dev/null +++ b/wm-production/src/main/java/com/water/production/service/WaterQualityService.java @@ -0,0 +1,61 @@ +package com.water.production.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class WaterQualityService { + + private final JdbcTemplate jdbc; + + /** 药剂投加监控：全工艺参数 */ + public Map getChemicalMonitoring(String stationName) { + Map data = new LinkedHashMap<>(); + data.put("station", stationName); + // 混凝 + data.put("inflowTurbidity", Map.of("value", 12.5, "unit", "NTU", "status", "normal")); + data.put("coagulantRate", Map.of("value", 25.3, "unit", "mg/L", "status", "normal")); + // 沉淀 + data.put("sedimentationLevel", Map.of("value", 3.2, "unit", "m", "status", "normal")); + data.put("sedimentationTurbidity", Map.of("value", 3.1, "unit", "NTU", "status", "normal")); + // 过滤 + data.put("filterLevel", Map.of("value", 2.5, "unit", "m", "status", "normal")); + data.put("filterHeadLoss", Map.of("value", 0.8, "unit", "m", "status", "normal")); + // 消毒 + data.put("disinfectantRate", Map.of("value", 2.0, "unit", "mg/L", "status", "normal")); + data.put("residualChlorine", Map.of("value", 0.5, "unit", "mg/L", "status", "normal")); + data.put("outflowTurbidity", Map.of("value", 0.3, "unit", "NTU", "status", "normal")); + return data; + } + + /** 人工检测点位规划 */ + public List> getManualTestPoints(String area) { + return jdbc.queryForList( + "SELECT DISTINCT test_point, point_type, lng, lat FROM water_quality_record WHERE area = ? AND test_type = 'manual' ORDER BY test_point", + area); + } + + /** 水质数据台账 */ + public List> getQualityLedger(String area, String startDate, String endDate) { + return jdbc.queryForList( + "SELECT * FROM water_quality_record WHERE area = ? AND test_date BETWEEN ? AND ? ORDER BY test_date DESC LIMIT 200", + area, startDate, endDate); + } + + /** 添加检测记录 */ + public void addRecord(Map record) { + jdbc.update( + "INSERT INTO water_quality_record (test_type, test_point, point_type, area, test_date, test_time, tester, turbidity, ph, residual_chlorine, is_qualified) " + + "VALUES (?,?,?,?,?,?,?,?,?,?,?)", + record.get("testType"), record.get("testPoint"), record.get("pointType"), record.get("area"), + record.get("testDate"), record.get("testTime"), record.get("tester"), + record.get("turbidity"), record.get("ph"), record.get("residualChlorine"), + record.get("isQualified")); + } +} diff --git a/wm-production/src/main/resources/db/V1__production_monitor.sql b/wm-production/src/main/resources/db/V1__production_monitor.sql new file mode 100644 index 00000000..d4465002 --- /dev/null +++ b/wm-production/src/main/resources/db/V1__production_monitor.sql @@ -0,0 +1,30 @@ +CREATE TABLE IF NOT EXISTS prod_water_quality ( + id BIGSERIAL PRIMARY KEY, station VARCHAR(100), position_type VARCHAR(20), + turbidity DOUBLE PRECISION, ph DOUBLE PRECISION, + residual_chlorine DOUBLE PRECISION, color DOUBLE PRECISION, odor DOUBLE PRECISION, + result VARCHAR(20), created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS prod_flow_pressure ( + id BIGSERIAL PRIMARY KEY, device_id VARCHAR(50), area VARCHAR(50), + position_type VARCHAR(20), value DOUBLE PRECISION, unit VARCHAR(20), + lng DOUBLE PRECISION, lat DOUBLE PRECISION, + created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS prod_device_status ( + id BIGSERIAL PRIMARY KEY, device_id VARCHAR(50), device_name VARCHAR(100), + device_type VARCHAR(30), area VARCHAR(50), status INT DEFAULT 0, + lng DOUBLE PRECISION, lat DOUBLE PRECISION, + last_online_time TIMESTAMP +); +CREATE TABLE IF NOT EXISTS prod_alert_record ( + id BIGSERIAL PRIMARY KEY, device_id VARCHAR(50), area VARCHAR(50), + level VARCHAR(10), alert_type VARCHAR(30), description TEXT, + status INT DEFAULT 0, confirmed_by BIGINT, handled_by BIGINT, + created_time TIMESTAMP DEFAULT NOW(), + confirmed_time TIMESTAMP, handled_time TIMESTAMP +); +CREATE TABLE IF NOT EXISTS prod_video_camera ( + id BIGSERIAL PRIMARY KEY, camera_id VARCHAR(50), name VARCHAR(100), + area VARCHAR(50), stream_url VARCHAR(500), status INT DEFAULT 0, + lng DOUBLE PRECISION, lat DOUBLE PRECISION +); diff --git a/wm-production/src/main/resources/db/V_dispatch_command.sql b/wm-production/src/main/resources/db/V_dispatch_command.sql new file mode 100644 index 00000000..c759c630 --- /dev/null +++ b/wm-production/src/main/resources/db/V_dispatch_command.sql @@ -0,0 +1,57 @@ +-- 调度指令管理模块 DDL + +CREATE TABLE IF NOT EXISTS prod_dispatch_command ( + id BIGSERIAL PRIMARY KEY, + command_no VARCHAR(64) NOT NULL UNIQUE, + command_title VARCHAR(200) NOT NULL, + command_content TEXT NOT NULL, + command_type VARCHAR(32) NOT NULL, + source VARCHAR(100), + priority VARCHAR(16) DEFAULT 'normal', + target_type VARCHAR(32), + target_ids TEXT, + status VARCHAR(32) NOT NULL DEFAULT 'draft', + issued_at TIMESTAMP, + issued_by BIGINT, + completed_at TIMESTAMP, + remark TEXT, + deleted INTEGER DEFAULT 0, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS prod_dispatch_execution ( + id BIGSERIAL PRIMARY KEY, + command_id BIGINT NOT NULL, + user_id BIGINT NOT NULL, + user_name VARCHAR(64), + received_at TIMESTAMP, + execute_status VARCHAR(32) DEFAULT 'pending', + feedback TEXT, + feedback_images TEXT, + completed_at TIMESTAMP, + rejected_reason TEXT, + deleted INTEGER DEFAULT 0, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS prod_dispatch_tracking ( + id BIGSERIAL PRIMARY KEY, + command_id BIGINT NOT NULL, + execution_id BIGINT, + action VARCHAR(32) NOT NULL, + operator_id BIGINT, + operator_name VARCHAR(64), + from_status VARCHAR(32), + to_status VARCHAR(32), + remark TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE INDEX IF NOT EXISTS idx_cmd_status ON prod_dispatch_command(status); +CREATE INDEX IF NOT EXISTS idx_cmd_type ON prod_dispatch_command(command_type); +CREATE INDEX IF NOT EXISTS idx_cmd_created ON prod_dispatch_command(created_at); +CREATE INDEX IF NOT EXISTS idx_exec_cmd ON prod_dispatch_execution(command_id); +CREATE INDEX IF NOT EXISTS idx_exec_user ON prod_dispatch_execution(user_id); +CREATE INDEX IF NOT EXISTS idx_track_cmd ON prod_dispatch_tracking(command_id); diff --git a/wm-production/src/main/resources/mapper/DispatchCommandMapper.xml b/wm-production/src/main/resources/mapper/DispatchCommandMapper.xml new file mode 100644 index 00000000..8905e310 --- /dev/null +++ b/wm-production/src/main/resources/mapper/DispatchCommandMapper.xml @@ -0,0 +1,44 @@ + + + + + + + + + + + diff --git a/wm-production/src/test/java/com/water/production/service/AlertCenterServiceTest.java b/wm-production/src/test/java/com/water/production/service/AlertCenterServiceTest.java new file mode 100644 index 00000000..ec6e73ad --- /dev/null +++ b/wm-production/src/test/java/com/water/production/service/AlertCenterServiceTest.java @@ -0,0 +1,159 @@ +package com.water.production.service; + +import com.water.production.entity.AlertRecord; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * AlertCenterService 报警管理中心单元测试 + * 测试状态流转、标签映射等核心逻辑 + */ +class AlertCenterServiceTest { + + @Test + @DisplayName("测试报警状态标签映射") + void testStatusLabelMapping() { + // 通过反射或构造测试状态标签的正确性 + AlertRecord record = new AlertRecord(); + + // 测试所有状态值 + record.setStatus(0); + assertEquals(0, record.getStatus()); + + record.setStatus(1); + assertEquals(1, record.getStatus()); + + record.setStatus(2); + assertEquals(2, record.getStatus()); + + record.setStatus(3); + assertEquals(3, record.getStatus()); + + record.setStatus(4); + assertEquals(4, record.getStatus()); + + record.setStatus(5); + assertEquals(5, record.getStatus()); + } + + @Test + @DisplayName("测试报警等级标签") + void testAlertLevelValues() { + AlertRecord record = new AlertRecord(); + + record.setAlertLevel("general"); + assertEquals("general", record.getAlertLevel()); + + record.setAlertLevel("important"); + assertEquals("important", record.getAlertLevel()); + + record.setAlertLevel("urgent"); + assertEquals("urgent", record.getAlertLevel()); + } + + @Test + @DisplayName("测试报警记录生命周期字段完整性") + void testAlertRecordLifecycleFields() { + AlertRecord record = new AlertRecord(); + record.setId(1L); + record.setRuleId(100L); + record.setRuleName("管网压力过高报警"); + record.setDeviceSn("DEV-001"); + record.setArea("城东片区"); + record.setMetricKey("pressure"); + record.setAlertLevel("urgent"); + record.setTitle("[紧急] 管网压力过高报警 - DEV-001"); + record.setMessage("设备 DEV-001 指标 pressure 当前值 0.95"); + record.setStatus(0); + record.setConfirmedBy(null); + record.setConfirmedTime(null); + + // 验证初始状态 + assertEquals(0, record.getStatus()); + assertNull(record.getConfirmedBy()); + assertNull(record.getAssigneeId()); + assertNull(record.getHandlerId()); + assertNull(record.getHandleResult()); + assertNull(record.getArchiveReason()); + + // 模拟确认 + record.setStatus(1); + record.setConfirmedBy(10L); + assertEquals(1, record.getStatus()); + assertEquals(10L, record.getConfirmedBy()); + + // 模拟派单 + record.setStatus(2); + record.setAssigneeId(20L); + record.setAssigneeName("张三"); + assertEquals(2, record.getStatus()); + assertEquals("张三", record.getAssigneeName()); + + // 模拟处理中 + record.setStatus(3); + record.setHandlerId(20L); + record.setHandlerName("张三"); + assertEquals(3, record.getStatus()); + + // 模拟完成处理 + record.setStatus(4); + record.setHandleResult("已更换压力传感器，恢复正常"); + assertEquals(4, record.getStatus()); + assertNotNull(record.getHandleResult()); + + // 模拟归档 + record.setStatus(5); + record.setArchiveReason("处理完毕，确认无误"); + assertEquals(5, record.getStatus()); + assertNotNull(record.getArchiveReason()); + } + + @Test + @DisplayName("测试条件表达式JSON结构验证") + void testConditionExpressionStructure() { + // 验证AND条件JSON + String andExpr = "{\"op\":\"AND\",\"conditions\":[" + + "{\"metric\":\"pressure\",\"operator\":\">\",\"threshold\":0.8}," + + "{\"metric\":\"pressure\",\"operator\":\"<\",\"threshold\":1.5}" + + "]}"; + assertTrue(andExpr.contains("\"op\":\"AND\"")); + assertTrue(andExpr.contains("\"conditions\"")); + + // 验证OR条件JSON + String orExpr = "{\"op\":\"OR\",\"conditions\":[" + + "{\"metric\":\"flow\",\"operator\":\">\",\"threshold\":100}," + + "{\"metric\":\"flow\",\"operator\":\"<\",\"threshold\":5}" + + "]}"; + assertTrue(orExpr.contains("\"op\":\"OR\"")); + } + + @Test + @DisplayName("测试报警标题格式化") + void testAlertTitleFormat() { + String level = "urgent"; + String ruleName = "管网压力过高报警"; + String deviceSn = "DEV-001"; + + String levelLabel = switch (level) { + case "urgent" -> "紧急"; + case "important" -> "重要"; + case "general" -> "一般"; + default -> level; + }; + + String title = String.format("[%s] %s - %s", levelLabel, ruleName, deviceSn); + assertEquals("[紧急] 管网压力过高报警 - DEV-001", title); + + // 测试一般等级 + levelLabel = switch ("general") { + case "urgent" -> "紧急"; + case "important" -> "重要"; + case "general" -> "一般"; + default -> "general"; + }; + title = String.format("[%s] %s - %s", levelLabel, "余氯偏低报警", "DEV-002"); + assertEquals("[一般] 余氯偏低报警 - DEV-002", title); + } +} diff --git a/wm-production/src/test/java/com/water/production/service/AlertRuleServiceTest.java b/wm-production/src/test/java/com/water/production/service/AlertRuleServiceTest.java new file mode 100644 index 00000000..1ca914f0 --- /dev/null +++ b/wm-production/src/test/java/com/water/production/service/AlertRuleServiceTest.java @@ -0,0 +1,143 @@ +package com.water.production.service; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * AlertRuleService 规则评估引擎单元测试 + * 测试条件表达式解析(AND/OR组合)、阈值触发、多级别报警 + */ +class AlertRuleServiceTest { + + private AlertRuleService ruleService; + private ObjectMapper objectMapper; + + @BeforeEach + void setUp() { + objectMapper = new ObjectMapper(); + ruleService = new AlertRuleService(null, null, null, objectMapper); + } + + @Test + @DisplayName("测试简单大于条件 - 触发报警") + void testSimpleGreaterThan_triggered() { + String expr = "{\"metric\":\"pressure\",\"operator\":\">\",\"threshold\":0.8}"; + assertTrue(ruleService.evaluateCondition(expr, "pressure", 0.9)); + } + + @Test + @DisplayName("测试简单大于条件 - 未触发") + void testSimpleGreaterThan_notTriggered() { + String expr = "{\"metric\":\"pressure\",\"operator\":\">\",\"threshold\":0.8}"; + assertFalse(ruleService.evaluateCondition(expr, "pressure", 0.7)); + } + + @Test + @DisplayName("测试简单小于条件 - 触发报警") + void testSimpleLessThan_triggered() { + String expr = "{\"metric\":\"residual_chlorine\",\"operator\":\"<\",\"threshold\":0.1}"; + assertTrue(ruleService.evaluateCondition(expr, "residual_chlorine", 0.05)); + } + + @Test + @DisplayName("测试AND组合条件 - 全部满足时触发") + void testAndCondition_allMet() { + String expr = "{\"op\":\"AND\",\"conditions\":[" + + "{\"metric\":\"pressure\",\"operator\":\">\",\"threshold\":0.8}," + + "{\"metric\":\"pressure\",\"operator\":\"<\",\"threshold\":1.5}" + + "]}"; + assertTrue(ruleService.evaluateCondition(expr, "pressure", 1.0)); + } + + @Test + @DisplayName("测试AND组合条件 - 部分不满足时不触发") + void testAndCondition_partialMet() { + String expr = "{\"op\":\"AND\",\"conditions\":[" + + "{\"metric\":\"pressure\",\"operator\":\">\",\"threshold\":0.8}," + + "{\"metric\":\"pressure\",\"operator\":\"<\",\"threshold\":0.9}" + + "]}"; + assertFalse(ruleService.evaluateCondition(expr, "pressure", 1.0)); + } + + @Test + @DisplayName("测试OR组合条件 - 任一满足即触发") + void testOrCondition_oneMet() { + String expr = "{\"op\":\"OR\",\"conditions\":[" + + "{\"metric\":\"flow\",\"operator\":\">\",\"threshold\":100}," + + "{\"metric\":\"flow\",\"operator\":\"<\",\"threshold\":5}" + + "]}"; + // flow=3 < 5, 满足第二个条件 + assertTrue(ruleService.evaluateCondition(expr, "flow", 3.0)); + // flow=150 > 100, 满足第一个条件 + assertTrue(ruleService.evaluateCondition(expr, "flow", 150.0)); + } + + @Test + @DisplayName("测试OR组合条件 - 全不满足时不触发") + void testOrCondition_noneMet() { + String expr = "{\"op\":\"OR\",\"conditions\":[" + + "{\"metric\":\"flow\",\"operator\":\">\",\"threshold\":100}," + + "{\"metric\":\"flow\",\"operator\":\"<\",\"threshold\":5}" + + "]}"; + // flow=50, 不满足任何条件 + assertFalse(ruleService.evaluateCondition(expr, "flow", 50.0)); + } + + @Test + @DisplayName("测试不同指标键不匹配 - 不触发") + void testMetricKeyMismatch() { + String expr = "{\"metric\":\"pressure\",\"operator\":\">\",\"threshold\":0.8}"; + // 条件检查pressure, 但实际metric是temperature + assertFalse(ruleService.evaluateCondition(expr, "temperature", 50.0)); + } + + @Test + @DisplayName("测试等于条件") + void testEqualsCondition() { + String expr = "{\"metric\":\"ph\",\"operator\":\"==\",\"threshold\":7.0}"; + assertTrue(ruleService.evaluateCondition(expr, "ph", 7.0)); + assertFalse(ruleService.evaluateCondition(expr, "ph", 7.1)); + } + + @Test + @DisplayName("测试大于等于和小于等于条件") + void testGreaterEqualAndLessEqual() { + String exprGte = "{\"metric\":\"pressure\",\"operator\":\">=\",\"threshold\":0.8}"; + assertTrue(ruleService.evaluateCondition(exprGte, "pressure", 0.8)); + assertTrue(ruleService.evaluateCondition(exprGte, "pressure", 0.9)); + assertFalse(ruleService.evaluateCondition(exprGte, "pressure", 0.79)); + + String exprLte = "{\"metric\":\"pressure\",\"operator\":\"<=\",\"threshold\":0.2}"; + assertTrue(ruleService.evaluateCondition(exprLte, "pressure", 0.2)); + assertTrue(ruleService.evaluateCondition(exprLte, "pressure", 0.1)); + assertFalse(ruleService.evaluateCondition(exprLte, "pressure", 0.21)); + } + + @Test + @DisplayName("测试空表达式和无效表达式") + void testNullAndInvalidExpression() { + assertFalse(ruleService.evaluateCondition(null, "pressure", 0.9)); + assertFalse(ruleService.evaluateCondition("", "pressure", 0.9)); + assertFalse(ruleService.evaluateCondition("not-json", "pressure", 0.9)); + } + + @Test + @DisplayName("测试多级别报警 - general/important/urgent 条件分别触发") + void testMultiLevelAlerts() { + // 一般: 余氯 < 0.1 + String generalExpr = "{\"metric\":\"residual_chlorine\",\"operator\":\"<\",\"threshold\":0.1}"; + assertTrue(ruleService.evaluateCondition(generalExpr, "residual_chlorine", 0.05)); + + // 重要: 压力 < 0.2 + String importantExpr = "{\"metric\":\"pressure\",\"operator\":\"<\",\"threshold\":0.2}"; + assertTrue(ruleService.evaluateCondition(importantExpr, "pressure", 0.15)); + + // 紧急: 浊度 > 1.0 + String urgentExpr = "{\"metric\":\"turbidity\",\"operator\":\">\",\"threshold\":1.0}"; + assertTrue(ruleService.evaluateCondition(urgentExpr, "turbidity", 2.5)); + } +} diff --git a/wm-production/src/test/java/com/water/production/service/DispatchCommandServiceTest.java b/wm-production/src/test/java/com/water/production/service/DispatchCommandServiceTest.java new file mode 100644 index 00000000..9b4beec5 --- /dev/null +++ b/wm-production/src/test/java/com/water/production/service/DispatchCommandServiceTest.java @@ -0,0 +1,223 @@ +package com.water.production.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.production.entity.DispatchCommand; +import com.water.production.entity.DispatchExecution; +import com.water.production.mapper.DispatchCommandMapper; +import com.water.production.mapper.DispatchExecutionMapper; +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 static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class DispatchCommandServiceTest { + + @Mock + private DispatchCommandMapper commandMapper; + @Mock + private DispatchExecutionMapper executionMapper; + @Mock + private DispatchTrackingService trackingService; + + @InjectMocks + private DispatchCommandService commandService; + + @Test + void testCreateCommand() { + when(commandMapper.insert(any())).thenReturn(1); + + DispatchCommand cmd = new DispatchCommand(); + cmd.setCommandTitle("测试调度指令"); + cmd.setCommandContent("请检查A区域管网压力"); + cmd.setCommandType("normal"); + cmd.setPriority("high"); + cmd.setSource("手动"); + cmd.setTargetType("user"); + cmd.setTargetIds("[1,2]"); + + DispatchCommand result = commandService.createCommand(cmd); + + assertNotNull(result.getCommandNo()); + assertTrue(result.getCommandNo().startsWith("CMD-")); + assertEquals("draft", result.getStatus()); + assertEquals("测试调度指令", result.getCommandTitle()); + verify(commandMapper).insert(any()); + verify(trackingService).log(any(), isNull(), eq("create"), isNull(), isNull(), eq("draft"), any()); + } + + @Test + void testIssueCommand() { + DispatchCommand cmd = buildCommand("draft"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + when(executionMapper.insert(any())).thenReturn(1); + + DispatchCommand result = commandService.issueCommand(1L, 100L, "admin"); + + assertEquals("issued", result.getStatus()); + assertNotNull(result.getIssuedAt()); + assertEquals(100L, result.getIssuedBy()); + verify(executionMapper, times(2)).insert(any()); // 2 target users + verify(trackingService).log(eq(1L), isNull(), eq("issue"), eq(100L), eq("admin"), + eq("draft"), eq("issued"), any()); + } + + @Test + void testIssueCommand_invalidTransition() { + DispatchCommand cmd = buildCommand("issued"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + assertThrows(BusinessException.class, () -> { + commandService.issueCommand(1L, 100L, "admin"); + }); + } + + @Test + void testReceiveCommand() { + DispatchCommand cmd = buildCommand("issued"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + DispatchExecution exec = buildExecution("pending"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + when(executionMapper.updateById(any())).thenReturn(1); + when(executionMapper.selectCount(any(LambdaQueryWrapper.class))) + .thenReturn(2L) // total + .thenReturn(2L); // all received + + DispatchExecution result = commandService.receiveCommand(1L, 1L, "张三"); + + assertEquals("received", result.getExecuteStatus()); + assertNotNull(result.getReceivedAt()); + } + + @Test + void testStartExecution() { + DispatchCommand cmd = buildCommand("received"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + when(commandMapper.updateById(any())).thenReturn(1); + + DispatchExecution exec = buildExecution("received"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + when(executionMapper.updateById(any())).thenReturn(1); + + DispatchExecution result = commandService.startExecution(1L, 1L, "张三"); + + assertEquals("executing", result.getExecuteStatus()); + } + + @Test + void testStartExecution_wrongStatus() { + DispatchCommand cmd = buildCommand("received"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + DispatchExecution exec = buildExecution("pending"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + + assertThrows(BusinessException.class, () -> { + commandService.startExecution(1L, 1L, "张三"); + }); + } + + @Test + void testCompleteExecution() { + DispatchCommand cmd = buildCommand("executing"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + DispatchExecution exec = buildExecution("executing"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + when(executionMapper.updateById(any())).thenReturn(1); + when(executionMapper.selectCount(any(LambdaQueryWrapper.class))) + .thenReturn(1L) // total + .thenReturn(1L); // all final + + DispatchExecution result = commandService.completeExecution(1L, 1L, "张三", "已完成巡检", null); + + assertEquals("completed", result.getExecuteStatus()); + assertEquals("已完成巡检", result.getFeedback()); + assertNotNull(result.getCompletedAt()); + } + + @Test + void testCompleteExecution_wrongStatus() { + DispatchCommand cmd = buildCommand("executing"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + DispatchExecution exec = buildExecution("received"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + + assertThrows(BusinessException.class, () -> { + commandService.completeExecution(1L, 1L, "张三", "反馈", null); + }); + } + + @Test + void testRejectExecution() { + DispatchCommand cmd = buildCommand("issued"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + DispatchExecution exec = buildExecution("pending"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + when(executionMapper.updateById(any())).thenReturn(1); + when(executionMapper.selectCount(any(LambdaQueryWrapper.class))) + .thenReturn(1L) // total + .thenReturn(1L); // all final + + DispatchExecution result = commandService.rejectExecution(1L, 1L, "张三", "人手不足"); + + assertEquals("rejected", result.getExecuteStatus()); + assertEquals("人手不足", result.getRejectedReason()); + } + + @Test + void testRejectExecution_alreadyCompleted() { + DispatchCommand cmd = buildCommand("executing"); + when(commandMapper.selectById(1L)).thenReturn(cmd); + + DispatchExecution exec = buildExecution("completed"); + when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(exec); + + assertThrows(BusinessException.class, () -> { + commandService.rejectExecution(1L, 1L, "张三", "原因"); + }); + } + + @Test + void testCommandNotFound() { + when(commandMapper.selectById(999L)).thenReturn(null); + + assertThrows(BusinessException.class, () -> { + commandService.issueCommand(999L, 1L, "admin"); + }); + } + + // ==================== Helper ==================== + + private DispatchCommand buildCommand(String status) { + DispatchCommand cmd = new DispatchCommand(); + cmd.setId(1L); + cmd.setCommandNo("CMD-20260614150000-0001"); + cmd.setCommandTitle("测试指令"); + cmd.setCommandContent("测试内容"); + cmd.setCommandType("normal"); + cmd.setStatus(status); + cmd.setTargetIds("[1,2]"); + return cmd; + } + + private DispatchExecution buildExecution(String status) { + DispatchExecution exec = new DispatchExecution(); + exec.setId(1L); + exec.setCommandId(1L); + exec.setUserId(1L); + exec.setUserName("张三"); + exec.setExecuteStatus(status); + return exec; + } +} diff --git a/wm-production/src/test/java/com/water/production/service/DispatchTrackingServiceTest.java b/wm-production/src/test/java/com/water/production/service/DispatchTrackingServiceTest.java new file mode 100644 index 00000000..3f6d84be --- /dev/null +++ b/wm-production/src/test/java/com/water/production/service/DispatchTrackingServiceTest.java @@ -0,0 +1,97 @@ +package com.water.production.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.production.entity.DispatchTracking; +import com.water.production.mapper.DispatchTrackingMapper; +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 DispatchTrackingServiceTest { + + @Mock + private DispatchTrackingMapper trackingMapper; + + @InjectMocks + private DispatchTrackingService trackingService; + + @Test + void testLog() { + when(trackingMapper.insert(any())).thenReturn(1); + + trackingService.log(1L, null, "create", null, null, "draft", "创建指令"); + + ArgumentCaptor captor = ArgumentCaptor.forClass(DispatchTracking.class); + verify(trackingMapper).insert(captor.capture()); + + DispatchTracking saved = captor.getValue(); + assertEquals(1L, saved.getCommandId()); + assertNull(saved.getExecutionId()); + assertEquals("create", saved.getAction()); + assertEquals("draft", saved.getToStatus()); + assertEquals("创建指令", saved.getRemark()); + } + + @Test + void testLogWithExecution() { + when(trackingMapper.insert(any())).thenReturn(1); + + trackingService.log(1L, 5L, "receive", 10L, "张三", "pending", "received", "接收确认"); + + ArgumentCaptor captor = ArgumentCaptor.forClass(DispatchTracking.class); + verify(trackingMapper).insert(captor.capture()); + + DispatchTracking saved = captor.getValue(); + assertEquals(5L, saved.getExecutionId()); + assertEquals(10L, saved.getOperatorId()); + assertEquals("张三", saved.getOperatorName()); + assertEquals("pending", saved.getFromStatus()); + assertEquals("received", saved.getToStatus()); + } + + @Test + void testGetTrackingLogs() { + DispatchTracking t1 = new DispatchTracking(); + t1.setId(1L); + t1.setCommandId(1L); + t1.setAction("create"); + + DispatchTracking t2 = new DispatchTracking(); + t2.setId(2L); + t2.setCommandId(1L); + t2.setAction("issue"); + + when(trackingMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(List.of(t1, t2)); + + List logs = trackingService.getTrackingLogs(1L); + + assertEquals(2, logs.size()); + assertEquals("create", logs.get(0).getAction()); + assertEquals("issue", logs.get(1).getAction()); + } + + @Test + void testGetExecutionTrackingLogs() { + DispatchTracking t1 = new DispatchTracking(); + t1.setId(3L); + t1.setExecutionId(5L); + t1.setAction("receive"); + + when(trackingMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(List.of(t1)); + + List logs = trackingService.getExecutionTrackingLogs(5L); + + assertEquals(1, logs.size()); + assertEquals(5L, logs.get(0).getExecutionId()); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/controller/MeterWorkController.java b/wm-revenue/src/main/java/com/water/revenue/controller/MeterWorkController.java new file mode 100644 index 00000000..a3f791b1 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/controller/MeterWorkController.java @@ -0,0 +1,59 @@ +package com.water.revenue.controller; + +import com.water.common.core.result.R; +import com.water.revenue.service.RemoteReadingService; +import com.water.revenue.service.WorkOrderService; +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.*; + +@Tag(name = "远传集抄 & 工单") +@RestController +@RequestMapping("/revenue/ops") +@RequiredArgsConstructor +public class MeterWorkController { + + private final RemoteReadingService rrService; + private final WorkOrderService woService; + + // ---- 远传集抄 ---- + @PostMapping("/reading/batch/{area}") + public R> batchRead(@PathVariable String area) { + return R.ok(rrService.batchRead(area)); + } + + @GetMapping("/dma/analysis") + public R> dmaAnalysis(@RequestParam String area, @RequestParam String period) { + return R.ok(rrService.dmaAnalysis(area, period)); + } + + @GetMapping("/meter/large") + public R>> largeMeters() { + return R.ok(rrService.largeMeterMonitor()); + } + + // ---- 工单 ---- + @PostMapping("/work-order") + public R> createWO(@RequestBody Map req) { + return R.ok(woService.create( + (String) req.get("title"), (String) req.get("type"), (String) req.get("priority"), + 1L, "当前用户", (String) req.get("description"), (String) req.get("area"))); + } + + @PutMapping("/work-order/assign") + public R> assign(@RequestBody Map req) { + return R.ok(woService.assign( + (String) req.get("woNo"), Long.parseLong(String.valueOf(req.get("assigneeId"))), + (String) req.get("assigneeName"))); + } + + @PutMapping("/work-order/complete") + public R> complete(@RequestBody Map req) { + @SuppressWarnings("unchecked") + List photos = (List) req.getOrDefault("photos", List.of()); + return R.ok(woService.complete((String) req.get("woNo"), (String) req.get("result"), photos)); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/controller/RevenueController.java b/wm-revenue/src/main/java/com/water/revenue/controller/RevenueController.java new file mode 100644 index 00000000..f1ee58d2 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/controller/RevenueController.java @@ -0,0 +1,79 @@ +package com.water.revenue.controller; + +import com.water.common.core.result.R; +import com.water.revenue.service.*; +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.math.BigDecimal; +import java.util.*; + +@Tag(name = "营业收费") +@RestController +@RequestMapping("/revenue") +@RequiredArgsConstructor +public class RevenueController { + + private final RevenueBaseService baseService; + private final InstallService installService; + private final BillingService billingService; + private final MeterService meterService; + + // ---- 营收平台 ---- + @PostMapping("/auth/sso") + public R> ssoLogin(@RequestBody Map req) { + return R.ok(baseService.ssoLogin(req.get("username"), req.get("password"), req.get("appType"))); + } + + // ---- 报装管理 ---- + @PostMapping("/install/pre-apply") + public R> preApply(@RequestBody Map req) { + return R.ok(installService.preApply(req.get("name"), req.get("phone"), + req.get("area"), req.get("address"), req.get("customerType"), req.get("caliber"))); + } + + @GetMapping("/install/progress/{appNo}") + public R> progress(@PathVariable String appNo) { + return R.ok(installService.getProgress(appNo)); + } + + // ---- 营业收费 ---- + @PostMapping("/billing/generate") + public R> generateBill(@RequestParam Long readingId) { + return R.ok(billingService.generateBill(readingId)); + } + + @PostMapping("/billing/pay") + public R> pay(@RequestBody Map req) { + return R.ok(billingService.pay( + Long.parseLong(String.valueOf(req.get("billId"))), + (String) req.get("payMethod"), + (String) req.get("payChannel"), + new BigDecimal(String.valueOf(req.get("amount"))))); + } + + // ---- 表务管理 ---- + @PostMapping("/meter/stock-in") + public R stockIn(@RequestBody Map req) { + meterService.stockIn(req.get("meterNo"), req.get("caliber"), + req.get("meterType"), req.get("manufacturer"), Integer.parseInt(req.get("quantity"))); + return R.ok("入库成功"); + } + + @PostMapping("/meter/replace") + public R replace(@RequestBody Map req) { + meterService.replace( + Long.parseLong(String.valueOf(req.get("oldMeterId"))), + Long.parseLong(String.valueOf(req.get("newMeterId"))), + new BigDecimal(String.valueOf(req.get("oldReading"))), + (String) req.get("remark")); + return R.ok("换表成功"); + } + + @GetMapping("/meter/lifecycle/{meterId}") + public R>> lifecycle(@PathVariable Long meterId) { + return R.ok(meterService.getLifecycle(meterId)); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/controller/WechatController.java b/wm-revenue/src/main/java/com/water/revenue/controller/WechatController.java new file mode 100644 index 00000000..a2d0b0e3 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/controller/WechatController.java @@ -0,0 +1,65 @@ +package com.water.revenue.controller; + +import com.water.common.core.result.R; +import com.water.revenue.service.CustomerServiceCenter; +import com.water.revenue.service.WechatService; +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.math.BigDecimal; +import java.util.*; + +@Tag(name = "客服热线 & 微信网厅") +@RestController +@RequestMapping("/revenue/customer") +@RequiredArgsConstructor +public class WechatController { + + private final CustomerServiceCenter csc; + private final WechatService wechatService; + + // ---- 客服 ---- + @GetMapping("/bills/query") + public R>> queryBills(@RequestParam String phoneOrNo) { + return R.ok(csc.queryBills(phoneOrNo)); + } + + @GetMapping("/knowledge/search") + public R>> searchKnowledge(@RequestParam String keyword) { + return R.ok(csc.searchKnowledge(keyword)); + } + + @GetMapping("/notices/{type}") + public R>> notices(@PathVariable String type) { + return R.ok(csc.getNotices(type)); + } + + @GetMapping("/kpi") + public R> kpi() { return R.ok(csc.getKpi()); } + + // ---- 微信网厅 ---- + @PostMapping("/wechat/bind") + public R> bind(@RequestBody Map req) { + return R.ok(wechatService.bindUser(req.get("openId"), req.get("customerNo"), req.get("phone"))); + } + + @PostMapping("/wechat/pay/prepay") + public R> prepay(@RequestBody Map req) { + return R.ok(wechatService.wechatPayPrepay( + req.get("customerNo"), req.get("billPeriod"), + new BigDecimal(req.get("amount")))); + } + + @GetMapping("/wechat/ai-answer") + public R aiAnswer(@RequestParam String question) { + return R.ok(wechatService.aiAnswer(question)); + } + + @PostMapping("/wechat/notice/publish") + public R publishNotice(@RequestBody Map req) { + wechatService.publishNotice(req.get("type"), req.get("title"), req.get("content")); + return R.ok("公告已发布"); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/BillingService.java b/wm-revenue/src/main/java/com/water/revenue/service/BillingService.java new file mode 100644 index 00000000..514ad65e --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/BillingService.java @@ -0,0 +1,96 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.time.LocalDate; +import java.time.YearMonth; +import java.time.format.DateTimeFormatter; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class BillingService { + + private final JdbcTemplate jdbcTemplate; + + /** 根据抄表记录生成账单 */ + @Transactional + public Map generateBill(Long readingId) { + Map reading = jdbcTemplate.queryForMap( + "SELECT r.*, m.customer_id, m.caliber, c.customer_type FROM rev_reading r " + + "JOIN rev_meter m ON r.meter_id = m.id " + + "JOIN rev_customer c ON m.customer_id = c.id " + + "WHERE r.id = ?", readingId); + + BigDecimal consumption = (BigDecimal) reading.get("consumption"); + String customerType = (String) reading.get("customer_type"); + String period = (String) reading.get("reading_period"); + + // 查询阶梯水价 + List> prices = jdbcTemplate.queryForList( + "SELECT * FROM rev_water_price WHERE customer_type = ? AND effective_date <= CURRENT_DATE ORDER BY tier_no", + customerType); + + BigDecimal waterFee = BigDecimal.ZERO; + BigDecimal remaining = consumption; + + for (Map p : prices) { + BigDecimal rangeEnd = p.get("range_end") != null ? (BigDecimal) p.get("range_end") : BigDecimal.valueOf(99999); + BigDecimal price = (BigDecimal) p.get("water_price"); + BigDecimal tierUsage = remaining.min(rangeEnd); + waterFee = waterFee.add(tierUsage.multiply(price)); + remaining = remaining.subtract(tierUsage); + if (remaining.compareTo(BigDecimal.ZERO) <= 0) break; + } + + // 污水处理费（用水量的80%） + BigDecimal sewageFee = consumption.multiply(((BigDecimal) prices.get(0).getOrDefault("sewage_price", BigDecimal.ZERO))) + .multiply(BigDecimal.valueOf(0.8)); + + BigDecimal totalFee = waterFee.add(sewageFee); + String billNo = "BILL-" + System.currentTimeMillis(); + Date dueDate = java.sql.Date.valueOf(LocalDate.now().plusDays(30)); + + jdbcTemplate.update( + "INSERT INTO rev_bill (bill_no, customer_id, meter_id, reading_id, bill_period, prev_reading, curr_reading, consumption, water_fee, sewage_fee, total_fee, status, due_date) " + + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", + billNo, reading.get("customer_id"), reading.get("meter_id"), readingId, + period, reading.get("prev_reading"), reading.get("curr_reading"), + consumption, waterFee, sewageFee, totalFee, "pending", dueDate); + + log.info("Bill generated: {} total={}", billNo, totalFee); + return Map.of("billNo", billNo, "totalFee", totalFee, "waterFee", waterFee, "sewageFee", sewageFee); + } + + /** 缴费 */ + @Transactional + public Map pay(long billId, String payMethod, String payChannel, BigDecimal amount) { + String paymentNo = "PAY-" + System.currentTimeMillis(); + jdbcTemplate.update( + "INSERT INTO rev_payment (bill_id, customer_id, payment_no, amount, pay_method, pay_channel) " + + "SELECT ?, customer_id, ?, ?, ?, ? FROM rev_bill WHERE id = ?", + billId, paymentNo, amount, payMethod, payChannel, billId); + + jdbcTemplate.update( + "UPDATE rev_bill SET paid_fee = paid_fee + ?, status = CASE WHEN paid_fee >= total_fee THEN 'paid' ELSE 'partial' END, paid_at = NOW() WHERE id = ?", + amount, billId); + + return Map.of("paymentNo", paymentNo, "amount", amount, "status", "success"); + } + + /** 欠费统计 */ + public List> getOverdueBills(String area) { + return jdbcTemplate.queryForList( + "SELECT b.*, c.customer_name, c.phone FROM rev_bill b " + + "JOIN rev_customer c ON b.customer_id = c.id " + + "WHERE b.status IN ('pending','partial') AND c.area = ? AND b.due_date < CURRENT_DATE", + area); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/CustomerServiceCenter.java b/wm-revenue/src/main/java/com/water/revenue/service/CustomerServiceCenter.java new file mode 100644 index 00000000..031b9101 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/CustomerServiceCenter.java @@ -0,0 +1,52 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class CustomerServiceCenter { + + private final JdbcTemplate jdbcTemplate; + + /** 水费查询（语音/在线） */ + public List> queryBills(String phoneOrCustomerNo) { + return jdbcTemplate.queryForList( + "SELECT b.*, c.customer_name, c.phone FROM rev_bill b " + + "JOIN rev_customer c ON b.customer_id = c.id " + + "WHERE c.phone = ? OR c.customer_no = ? ORDER BY b.bill_period DESC LIMIT 12", + phoneOrCustomerNo, phoneOrCustomerNo); + } + + /** 知识库管理 */ + public List> searchKnowledge(String keyword) { + return jdbcTemplate.queryForList( + "SELECT dict_label, dict_value FROM sys_dict_data WHERE dict_type_id = " + + "(SELECT id FROM sys_dict_type WHERE dict_key = 'knowledge_base') " + + "AND dict_label LIKE ?", "%" + keyword + "%"); + } + + /** 公告板 */ + public List> getNotices(String noticeType) { + return jdbcTemplate.queryForList( + "SELECT dict_label, dict_value, created_at FROM sys_dict_data WHERE dict_type_id = " + + "(SELECT id FROM sys_dict_type WHERE dict_key = ?) ORDER BY created_at DESC LIMIT 10", + "notice_" + noticeType); // notice_water_stop, notice_water_quality, etc. + } + + /** KPI 指标 */ + public Map getKpi() { + return jdbcTemplate.queryForMap(""" + SELECT + (SELECT COUNT(*) FROM rev_bill WHERE status = 'pending' AND created_at > CURRENT_DATE - 30) AS pending_bills, + (SELECT COUNT(*) FROM rev_install WHERE status IN ('pre_apply','engineering')) AS pending_installs, + (SELECT ROUND(AVG(EXTRACT(EPOCH FROM (updated_at - created_at))/3600)::numeric, 2) + FROM rev_install WHERE status = 'completed' AND created_at > CURRENT_DATE - 30) AS avg_install_hours + """); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/InstallService.java b/wm-revenue/src/main/java/com/water/revenue/service/InstallService.java new file mode 100644 index 00000000..fedc7d36 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/InstallService.java @@ -0,0 +1,56 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.time.LocalDate; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class InstallService { + + private final JdbcTemplate jdbcTemplate; + + /** 预受理申请 */ + public Map preApply(String name, String phone, String area, String address, String customerType, String caliber) { + String appNo = "INS-" + System.currentTimeMillis(); + jdbcTemplate.update( + "INSERT INTO rev_install (application_no, applicant_name, applicant_phone, area, address, customer_type, caliber, status) VALUES (?,?,?,?,?,?,?,?)", + appNo, name, phone, area, address, customerType, caliber, "pre_apply"); + return Map.of("applicationNo", appNo, "status", "pre_apply"); + } + + /** 工程申请 */ + public Map engineeringApply(String appNo, Map engData) { + jdbcTemplate.update( + "UPDATE rev_install SET status = 'engineering', updated_at = NOW() WHERE application_no = ?", + appNo); + return Map.of("applicationNo", appNo, "status", "engineering"); + } + + /** 派单到施工 */ + public Map assignTask(String appNo, Long assigneeId) { + jdbcTemplate.update( + "UPDATE rev_install SET status = 'pending_review', updated_at = NOW() WHERE application_no = ?", + appNo); + return Map.of("applicationNo", appNo, "status", "pending_review", "assigneeId", assigneeId); + } + + /** 查询报装进度 */ + public Map getProgress(String appNo) { + return jdbcTemplate.queryForMap( + "SELECT application_no, applicant_name, applicant_phone, area, address, customer_type, caliber, status, created_at, updated_at FROM rev_install WHERE application_no = ?", + appNo); + } + + /** 报装统计报表 */ + public List> getStatsReport(String area, LocalDate start, LocalDate end) { + return jdbcTemplate.queryForList( + "SELECT area, customer_type, status, COUNT(*) as count FROM rev_install WHERE created_at BETWEEN ? AND ? GROUP BY area, customer_type, status", + start, end); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/MeterService.java b/wm-revenue/src/main/java/com/water/revenue/service/MeterService.java new file mode 100644 index 00000000..53f6ebf4 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/MeterService.java @@ -0,0 +1,74 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class MeterService { + + private final JdbcTemplate jdbcTemplate; + + /** 水表入库 */ + public void stockIn(String meterNo, String caliber, String meterType, String manufacturer, int quantity) { + for (int i = 0; i < quantity; i++) { + String no = meterNo + "-" + (i + 1); + jdbcTemplate.update( + "INSERT INTO rev_meter (meter_no, caliber, meter_type, manufacturer, status) VALUES (?,?,?,?,?)", + no, caliber, meterType, manufacturer, "warehouse"); + } + log.info("Meter stock in: {} x{}", meterNo, quantity); + } + + /** 水表出库安装 */ + @Transactional + public void install(Long meterId, Long customerId, String address, BigDecimal initialReading) { + jdbcTemplate.update( + "UPDATE rev_meter SET customer_id = ?, install_address = ?, initial_reading = ?, current_reading = ?, status = 'active', install_date = CURRENT_DATE WHERE id = ?", + customerId, address, initialReading, initialReading, meterId); + jdbcTemplate.update( + "INSERT INTO rev_meter_log (meter_id, operation_type, old_reading, new_reading, remark) VALUES (?,?,?,?,?)", + meterId, "install", BigDecimal.ZERO, initialReading, "新表安装"); + } + + /** 故障换表 */ + @Transactional + public void replace(Long oldMeterId, Long newMeterId, BigDecimal oldReading, String remark) { + // 旧表拆除 + jdbcTemplate.update("UPDATE rev_meter SET status = 'dismantled', current_reading = ? WHERE id = ?", oldReading, oldMeterId); + jdbcTemplate.update( + "INSERT INTO rev_meter_log (meter_id, operation_type, old_reading, remark) VALUES (?,?,?,?)", + oldMeterId, "dismantle", oldReading, remark); + + // 新表安装（继承客户信息） + Map oldMeter = jdbcTemplate.queryForMap("SELECT customer_id, install_address FROM rev_meter WHERE id = ?", oldMeterId); + jdbcTemplate.update( + "UPDATE rev_meter SET customer_id = ?, install_address = ?, status = 'active', install_date = CURRENT_DATE WHERE id = ?", + oldMeter.get("customer_id"), oldMeter.get("install_address"), newMeterId); + jdbcTemplate.update( + "INSERT INTO rev_meter_log (meter_id, operation_type, new_meter_no, remark) VALUES (?,?,?,?)", + newMeterId, "change", String.valueOf(newMeterId), "替换旧表 #" + oldMeterId); + } + + /** 水表报废 */ + public void scrap(Long meterId, String reason) { + jdbcTemplate.update("UPDATE rev_meter SET status = 'scrapped' WHERE id = ?", meterId); + jdbcTemplate.update( + "INSERT INTO rev_meter_log (meter_id, operation_type, remark) VALUES (?,?,?)", + meterId, "scrap", reason); + } + + /** 查询水表生命周期记录 */ + public List> getLifecycle(Long meterId) { + return jdbcTemplate.queryForList( + "SELECT * FROM rev_meter_log WHERE meter_id = ? ORDER BY created_at", + meterId); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/RemoteReadingService.java b/wm-revenue/src/main/java/com/water/revenue/service/RemoteReadingService.java new file mode 100644 index 00000000..6113705e --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/RemoteReadingService.java @@ -0,0 +1,78 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class RemoteReadingService { + + private final JdbcTemplate jdbcTemplate; + + /** 远传集抄：批量采集 */ + public Map batchRead(String area) { + List> meters = jdbcTemplate.queryForList( + "SELECT rm.id, rm.meter_no, rm.current_reading, i.device_sn " + + "FROM rev_meter rm LEFT JOIN iot_device i ON rm.device_id = i.id " + + "JOIN rev_customer c ON rm.customer_id = c.id " + + "WHERE rm.status = 'active' AND c.area = ?", area); + + int success = 0, failed = 0; + String period = java.time.YearMonth.now().format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM")); + + for (Map m : meters) { + try { + String deviceSn = (String) m.get("device_sn"); + // 从 IoT 平台获取实时读数（mock: 随机增量） + BigDecimal prev = m.get("current_reading") != null ? (BigDecimal) m.get("current_reading") : BigDecimal.ZERO; + BigDecimal curr = prev.add(BigDecimal.valueOf(new Random().nextDouble() * 50)); + BigDecimal consumption = curr.subtract(prev); + if (consumption.compareTo(BigDecimal.ZERO) < 0) consumption = BigDecimal.ZERO; + + jdbcTemplate.update( + "INSERT INTO rev_reading (meter_id, reading_date, reading_period, prev_reading, curr_reading, consumption, read_type) " + + "VALUES (?, CURRENT_DATE, ?, ?, ?, ?, 'remote')", + m.get("id"), period, prev, curr, consumption); + jdbcTemplate.update("UPDATE rev_meter SET current_reading = ? WHERE id = ?", curr, m.get("id")); + success++; + } catch (Exception e) { + failed++; + log.warn("Read failed for meter {}: {}", m.get("meter_no"), e.getMessage()); + } + } + log.info("Batch read: area={} success={} failed={}", area, success, failed); + return Map.of("area", area, "success", success, "failed", failed, "period", period); + } + + /** DMA 分区漏损分析 */ + public Map dmaAnalysis(String area, String dateStr) { + List> result = jdbcTemplate.queryForList( + "SELECT area, SUM(consumption) as total_consumption, COUNT(DISTINCT rm.id) as meter_count " + + "FROM rev_reading rr JOIN rev_meter rm ON rr.meter_id = rm.id " + + "JOIN rev_customer c ON rm.customer_id = c.id " + + "WHERE c.area = ? AND rr.reading_period = ? GROUP BY area", + area, dateStr); + + // 漏损率 = 1 - (售水量/供水量) + Map dma = new HashMap<>(result.isEmpty() ? Map.of() : result.get(0)); + dma.put("supplyEstimate", 1000); // TODO: 从水厂出水量获取 + dma.put("leakRate", "分析中"); + return dma; + } + + /** 大表监控 (DN80+) */ + public List> largeMeterMonitor() { + return jdbcTemplate.queryForList( + "SELECT rm.*, c.customer_name, c.area, i.device_sn, i.status as device_status " + + "FROM rev_meter rm JOIN rev_customer c ON rm.customer_id = c.id " + + "LEFT JOIN iot_device i ON rm.device_id = i.id " + + "WHERE rm.caliber IN ('DN80','DN100','DN150','DN200','DN300','DN400') AND rm.status = 'active'"); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/RevenueBaseService.java b/wm-revenue/src/main/java/com/water/revenue/service/RevenueBaseService.java new file mode 100644 index 00000000..39b5c4c2 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/RevenueBaseService.java @@ -0,0 +1,49 @@ +package com.water.revenue.service; + +import cn.dev33.satoken.secure.BCrypt; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class RevenueBaseService { + + private final JdbcTemplate jdbcTemplate; + + // ========== SSO 单点登录 ========== + public Map ssoLogin(String username, String password, String appType) { + // 从统一用户表验证 + Map user = jdbcTemplate.queryForMap( + "SELECT id, username, real_name, phone, status FROM sys_user WHERE username = ? AND status = 1", + username); + if (user == null) throw new RuntimeException("用户不存在"); + // 生成 SSO Token + String ssoToken = UUID.randomUUID().toString(); + jdbcTemplate.update( + "INSERT INTO sys_oper_log (user_id, username, module, operation, request_url) VALUES (?,?,?,?,?)", + user.get("id"), username, "revenue", "sso_login", "/revenue/auth/sso"); + user.put("ssoToken", ssoToken); + user.put("appType", appType); + return user; + } + + // ========== 应用接入管理 ========== + public void registerApp(String appName, String appKey, String appSecret, String redirectUri) { + jdbcTemplate.update( + "INSERT INTO sys_dict_data (dict_type_id, dict_label, dict_value) " + + "SELECT id, ?, ? FROM sys_dict_type WHERE dict_key = 'app_config'", + appName, appKey + ":" + appSecret + ":" + redirectUri); + } + + // ========== 运维审计 ========== + public void auditLog(Long userId, String action, String target, String detail) { + jdbcTemplate.update( + "INSERT INTO sys_oper_log (user_id, module, operation, request_url, request_params) VALUES (?,?,?,?,?)", + userId, "revenue_audit", action, target, detail); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/WechatService.java b/wm-revenue/src/main/java/com/water/revenue/service/WechatService.java new file mode 100644 index 00000000..e0e48f04 --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/WechatService.java @@ -0,0 +1,68 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.math.BigDecimal; +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class WechatService { + + private final JdbcTemplate jdbcTemplate; + + /** 微信用户绑定 */ + public Map bindUser(String wechatOpenId, String customerNo, String phone) { + jdbcTemplate.update( + "UPDATE rev_customer SET phone = COALESCE(phone, ?) WHERE customer_no = ?", + phone, customerNo); + // 存储微信绑定关系 + jdbcTemplate.update( + "INSERT INTO sys_dict_data (dict_type_id, dict_label, dict_value) " + + "SELECT id, ?, ? FROM sys_dict_type WHERE dict_key = 'wechat_bind' " + + "ON CONFLICT DO NOTHING", + wechatOpenId, customerNo); + return Map.of("openId", wechatOpenId, "customerNo", customerNo, "status", "bound"); + } + + /** 在线缴费（微信支付预下单） */ + public Map wechatPayPrepay(String customerNo, String billPeriod, BigDecimal amount) { + String orderNo = "WXPAY-" + System.currentTimeMillis(); + Map bill = jdbcTemplate.queryForMap( + "SELECT id, total_fee FROM rev_bill WHERE customer_id = " + + "(SELECT id FROM rev_customer WHERE customer_no = ?) AND bill_period = ? AND status IN ('pending','partial')", + customerNo, billPeriod); + // 微信支付统一下单（mock） + log.info("WeChat Pay prepay: order={} bill={} amount={}", orderNo, bill.get("id"), amount); + return Map.of("orderNo", orderNo, "prepayId", "wx" + orderNo, "amount", amount); + } + + /** AI 客服问答 */ + public String aiAnswer(String question) { + // 简易关键词匹配 + Map qa = new LinkedHashMap<>(); + qa.put("水费", "您可以发送户号查询水费账单，或通过在线缴费功能直接支付。"); + qa.put("停水", "请查看停水公告了解最新停水计划。如有紧急停水，请拨打客服热线。"); + qa.put("报装", "新装水表可通过网上营业厅-业务办理-报装申请提交，我们会安排现场踏勘。"); + qa.put("水质", "水质报告每月更新，详见水质公告。如发现水质异常请立即联系我们。"); + qa.put("发票", "缴费后可在电子发票中申请开具电子发票，发送到您的微信或邮箱。"); + qa.put("过户", "房屋买卖后请携带房产证和身份证前往营业厅办理过户手续。"); + + for (Map.Entry e : qa.entrySet()) { + if (question.contains(e.getKey())) return e.getValue(); + } + return "您好！我是智慧水务AI客服，您可以问我关于水费、报装、停水、水质、发票等问题。如需人工服务请转接客服热线。"; + } + + /** 后台公告管理 */ + public void publishNotice(String type, String title, String content) { + jdbcTemplate.update( + "INSERT INTO sys_dict_data (dict_type_id, dict_label, dict_value) " + + "SELECT id, ?, ? FROM sys_dict_type WHERE dict_key = ?", + title, content, "notice_" + type); + } +} diff --git a/wm-revenue/src/main/java/com/water/revenue/service/WorkOrderService.java b/wm-revenue/src/main/java/com/water/revenue/service/WorkOrderService.java new file mode 100644 index 00000000..9aa6672c --- /dev/null +++ b/wm-revenue/src/main/java/com/water/revenue/service/WorkOrderService.java @@ -0,0 +1,49 @@ +package com.water.revenue.service; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import java.util.*; + +@Slf4j +@Service +@RequiredArgsConstructor +public class WorkOrderService { + + private final JdbcTemplate jdbcTemplate; + + /** 创建工单 */ + public Map create(String title, String type, String priority, Long reporterId, + String reporterName, String description, String area) { + String woNo = "WO-" + System.currentTimeMillis(); + jdbcTemplate.update( + "INSERT INTO patrol_task (task_name, task_date, status) VALUES (?, CURRENT_DATE, 'pending')", + title + "[" + woNo + "]"); + log.info("WorkOrder created: {} type={} priority={}", woNo, type, priority); + return Map.of("woNo", woNo, "title", title, "status", "pending", "area", area); + } + + /** 工单分派 */ + public Map assign(String woNo, Long assigneeId, String assigneeName) { + jdbcTemplate.update( + "UPDATE patrol_task SET assignee_id = ?, status = 'in_progress' WHERE task_name LIKE ?", + assigneeId, "%" + woNo + "%"); + return Map.of("woNo", woNo, "assigneeId", assigneeId, "status", "assigned"); + } + + /** 工单处理完成 */ + public Map complete(String woNo, String result, List photoUrls) { + jdbcTemplate.update( + "UPDATE patrol_task SET status = 'completed', actual_end = NOW() WHERE task_name LIKE ?", + "%" + woNo + "%"); + return Map.of("woNo", woNo, "status", "completed", "photos", photoUrls); + } + + /** 工单统计 */ + public Map stats(String area) { + return jdbcTemplate.queryForMap( + "SELECT status, COUNT(*) as count FROM patrol_task WHERE task_date >= CURRENT_DATE - 30 GROUP BY status"); + } +} diff --git a/wm-system/pom.xml b/wm-system/pom.xml new file mode 100644 index 00000000..87ec4daf --- /dev/null +++ b/wm-system/pom.xml @@ -0,0 +1,50 @@ + + + 4.0.0 + + com.water + wm-parent + 1.0.0-SNAPSHOT + + wm-system + wm-system + 文档管理与系统管理模块 + + + + com.water + wm-common + + + org.springframework.boot + spring-boot-starter-web + + + com.baomidou + mybatis-plus-spring-boot3-starter + + + cn.dev33 + sa-token-spring-boot3-starter + + + org.postgresql + postgresql + + + io.minio + minio + + + org.springframework.boot + spring-boot-starter-validation + + + org.springframework.boot + spring-boot-starter-test + test + + + diff --git a/wm-system/src/main/java/com/water/system/SystemApplication.java b/wm-system/src/main/java/com/water/system/SystemApplication.java new file mode 100644 index 00000000..8abc344e --- /dev/null +++ b/wm-system/src/main/java/com/water/system/SystemApplication.java @@ -0,0 +1,13 @@ +package com.water.system; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.mybatis.spring.annotation.MapperScan; + +@SpringBootApplication(scanBasePackages = "com.water") +@MapperScan("com.water.system.mapper") +public class SystemApplication { + public static void main(String[] args) { + SpringApplication.run(SystemApplication.class, args); + } +} diff --git a/wm-system/src/main/java/com/water/system/controller/DepartmentController.java b/wm-system/src/main/java/com/water/system/controller/DepartmentController.java new file mode 100644 index 00000000..d8b28706 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/DepartmentController.java @@ -0,0 +1,59 @@ +package com.water.system.controller; + +import com.water.common.core.result.R; +import com.water.system.entity.SysDepartment; +import com.water.system.entity.dto.DeptRequest; +import com.water.system.service.DepartmentService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.List; + +@Tag(name = "部门管理") +@RestController +@RequestMapping("/api/system/dept") +@RequiredArgsConstructor +public class DepartmentController { + + private final DepartmentService departmentService; + + @Operation(summary = "获取部门树") + @GetMapping("/tree") + public R> tree() { + return R.ok(departmentService.getDeptTree()); + } + + @Operation(summary = "获取部门详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(departmentService.getDeptById(id)); + } + + @Operation(summary = "创建部门") + @PostMapping + public R create(@Valid @RequestBody DeptRequest request) { + return R.ok(departmentService.createDept(request)); + } + + @Operation(summary = "更新部门") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @RequestBody DeptRequest request) { + departmentService.updateDept(id, request); + return R.ok("OK"); + } + + @Operation(summary = "删除部门") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + departmentService.deleteDept(id); + return R.ok("OK"); + } + + @Operation(summary = "获取子部门列表") + @GetMapping("/{id}/children") + public R> getChildren(@PathVariable Long id) { + return R.ok(departmentService.getChildDepts(id)); + } +} diff --git a/wm-system/src/main/java/com/water/system/controller/DictionaryController.java b/wm-system/src/main/java/com/water/system/controller/DictionaryController.java new file mode 100644 index 00000000..60846122 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/DictionaryController.java @@ -0,0 +1,87 @@ +package com.water.system.controller; + +import com.water.common.core.result.R; +import com.water.system.entity.DataDictionary; +import com.water.system.entity.DataDictionaryItem; +import com.water.system.entity.dto.DictItemRequest; +import com.water.system.entity.dto.DictRequest; +import com.water.system.service.DictionaryService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.List; + +@Tag(name = "数据字典管理") +@RestController +@RequestMapping("/api/system/dict") +@RequiredArgsConstructor +public class DictionaryController { + + private final DictionaryService dictionaryService; + + @Operation(summary = "获取字典列表") + @GetMapping("/list") + public R> list(@RequestParam(required = false) String keyword) { + return R.ok(dictionaryService.listDictionaries(keyword)); + } + + @Operation(summary = "获取字典详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(dictionaryService.getDictionaryById(id)); + } + + @Operation(summary = "创建字典") + @PostMapping + public R create(@Valid @RequestBody DictRequest request) { + return R.ok(dictionaryService.createDictionary(request)); + } + + @Operation(summary = "更新字典") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @RequestBody DictRequest request) { + dictionaryService.updateDictionary(id, request); + return R.ok("OK"); + } + + @Operation(summary = "删除字典") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + dictionaryService.deleteDictionary(id); + return R.ok("OK"); + } + + @Operation(summary = "获取字典项列表(按字典ID)") + @GetMapping("/{dictId}/items") + public R> listItems(@PathVariable Long dictId) { + return R.ok(dictionaryService.listItemsByDictId(dictId)); + } + + @Operation(summary = "根据字典编码获取字典项") + @GetMapping("/code/{dictCode}/items") + public R> listItemsByCode(@PathVariable String dictCode) { + return R.ok(dictionaryService.listItemsByDictCode(dictCode)); + } + + @Operation(summary = "创建字典项") + @PostMapping("/item") + public R createItem(@Valid @RequestBody DictItemRequest request) { + return R.ok(dictionaryService.createItem(request)); + } + + @Operation(summary = "更新字典项") + @PutMapping("/item/{id}") + public R updateItem(@PathVariable Long id, @RequestBody DictItemRequest request) { + dictionaryService.updateItem(id, request); + return R.ok("OK"); + } + + @Operation(summary = "删除字典项") + @DeleteMapping("/item/{id}") + public R deleteItem(@PathVariable Long id) { + dictionaryService.deleteItem(id); + return R.ok("OK"); + } +} diff --git a/wm-system/src/main/java/com/water/system/controller/DocController.java b/wm-system/src/main/java/com/water/system/controller/DocController.java new file mode 100644 index 00000000..d899f370 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/DocController.java @@ -0,0 +1,19 @@ +package com.water.system.controller; +import com.water.common.core.result.R; +import com.water.system.entity.*; +import com.water.system.service.DocService; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.*; +@Tag(name="文档管理") @RestController @RequestMapping("/system/doc") @RequiredArgsConstructor +public class DocController { + private final DocService svc; + @GetMapping("/list") public R> list(@RequestParam(required=false) String categoryId, @RequestParam(required=false) String keyword) { return R.ok(svc.listDocs(categoryId, keyword)); } + @GetMapping("/{id}") public R get(@PathVariable Long id) { return R.ok(svc.getDoc(id)); } + @PostMapping public R create(@RequestBody Map req) { return R.ok(svc.createDoc(req)); } + @PutMapping("/{id}") public R update(@PathVariable Long id, @RequestBody Map req) { svc.updateDoc(id, req); return R.ok("OK"); } + @DeleteMapping("/{id}") public R delete(@PathVariable Long id) { svc.deleteDoc(id); return R.ok("OK"); } + @GetMapping("/category/list") public R> categories() { return R.ok(svc.listCategories()); } + @GetMapping("/{docId}/versions") public R> versions(@PathVariable Long docId) { return R.ok(svc.getVersions(docId)); } +} diff --git a/wm-system/src/main/java/com/water/system/controller/LogController.java b/wm-system/src/main/java/com/water/system/controller/LogController.java new file mode 100644 index 00000000..700328cb --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/LogController.java @@ -0,0 +1,32 @@ +package com.water.system.controller; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.water.common.core.result.R; +import com.water.system.entity.SysLog; +import com.water.system.entity.dto.LogQueryRequest; +import com.water.system.service.LogService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; + +@Tag(name = "日志管理") +@RestController +@RequestMapping("/api/system/log") +@RequiredArgsConstructor +public class LogController { + + private final LogService logService; + + @Operation(summary = "分页查询日志") + @GetMapping("/page") + public R> page(LogQueryRequest request) { + return R.ok(logService.pageLogs(request)); + } + + @Operation(summary = "获取日志详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(logService.getLogById(id)); + } +} diff --git a/wm-system/src/main/java/com/water/system/controller/RoleController.java b/wm-system/src/main/java/com/water/system/controller/RoleController.java new file mode 100644 index 00000000..be6a3e78 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/RoleController.java @@ -0,0 +1,66 @@ +package com.water.system.controller; + +import com.water.common.core.result.R; +import com.water.system.entity.SysRole; +import com.water.system.entity.dto.RoleRequest; +import com.water.system.service.RoleService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.List; + +@Tag(name = "角色管理") +@RestController +@RequestMapping("/api/system/role") +@RequiredArgsConstructor +public class RoleController { + + private final RoleService roleService; + + @Operation(summary = "获取角色列表") + @GetMapping("/list") + public R> list() { + return R.ok(roleService.listRoles()); + } + + @Operation(summary = "获取角色详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(roleService.getRoleById(id)); + } + + @Operation(summary = "创建角色") + @PostMapping + public R create(@Valid @RequestBody RoleRequest request) { + return R.ok(roleService.createRole(request)); + } + + @Operation(summary = "更新角色") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @Valid @RequestBody RoleRequest request) { + roleService.updateRole(id, request); + return R.ok("OK"); + } + + @Operation(summary = "删除角色") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + roleService.deleteRole(id); + return R.ok("OK"); + } + + @Operation(summary = "分配角色权限") + @PutMapping("/{id}/permissions") + public R assignPermissions(@PathVariable Long id, @RequestBody List permissions) { + roleService.assignPermissions(id, permissions); + return R.ok("OK"); + } + + @Operation(summary = "获取用户角色") + @GetMapping("/user/{userId}") + public R> getByUserId(@PathVariable Long userId) { + return R.ok(roleService.getRolesByUserId(userId)); + } +} diff --git a/wm-system/src/main/java/com/water/system/controller/SysController.java b/wm-system/src/main/java/com/water/system/controller/SysController.java new file mode 100644 index 00000000..3bfb7cb0 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/SysController.java @@ -0,0 +1,21 @@ +package com.water.system.controller; +import com.water.common.core.result.R; +import com.water.system.entity.*; +import com.water.system.service.SysService; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import java.util.*; +@Tag(name="系统管理") @RestController @RequestMapping("/system") @RequiredArgsConstructor +public class SysController { + private final SysService svc; + @GetMapping("/role/list") public R> roles() { return R.ok(svc.listRoles()); } + @PostMapping("/role") public R createRole(@RequestBody Map req) { return R.ok(svc.createRole(req)); } + @GetMapping("/user/list") public R> users(@RequestParam(required=false) Integer status) { return R.ok(svc.listUsers(status)); } + @PostMapping("/user") public R createUser(@RequestBody Map req) { return R.ok(svc.createUser(req)); } + @PutMapping("/user/{id}/status") public R updateUserStatus(@PathVariable Long id, @RequestParam int status) { svc.updateUserStatus(id, status); return R.ok("OK"); } + @GetMapping("/menu/list") public R> menus() { return R.ok(svc.listMenus()); } + @GetMapping("/dept/list") public R> depts() { return R.ok(svc.listDepts()); } + @PostMapping("/dept") public R createDept(@RequestBody Map req) { return R.ok(svc.createDept(req)); } + @GetMapping("/log/list") public R> logs(@RequestParam(required=false) String logType, @RequestParam(required=false) String username) { return R.ok(svc.listLogs(logType, username)); } +} diff --git a/wm-system/src/main/java/com/water/system/controller/UserController.java b/wm-system/src/main/java/com/water/system/controller/UserController.java new file mode 100644 index 00000000..fee339d3 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/controller/UserController.java @@ -0,0 +1,74 @@ +package com.water.system.controller; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.water.common.core.result.R; +import com.water.system.entity.SysUser; +import com.water.system.entity.dto.PasswordResetRequest; +import com.water.system.entity.dto.UserCreateRequest; +import com.water.system.entity.dto.UserUpdateRequest; +import com.water.system.service.UserService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; + +@Tag(name = "用户管理") +@RestController +@RequestMapping("/api/system/user") +@RequiredArgsConstructor +public class UserController { + + private final UserService userService; + + @Operation(summary = "分页查询用户列表") + @GetMapping("/page") + public R> page( + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + @RequestParam(required = false) String keyword, + @RequestParam(required = false) Integer status, + @RequestParam(required = false) Long deptId) { + return R.ok(userService.pageUsers(pageNum, pageSize, keyword, status, deptId)); + } + + @Operation(summary = "获取用户详情") + @GetMapping("/{id}") + public R getById(@PathVariable Long id) { + return R.ok(userService.getUserById(id)); + } + + @Operation(summary = "创建用户") + @PostMapping + public R create(@Valid @RequestBody UserCreateRequest request) { + return R.ok(userService.createUser(request)); + } + + @Operation(summary = "更新用户信息") + @PutMapping("/{id}") + public R update(@PathVariable Long id, @RequestBody UserUpdateRequest request) { + userService.updateUser(id, request); + return R.ok("OK"); + } + + @Operation(summary = "删除用户") + @DeleteMapping("/{id}") + public R delete(@PathVariable Long id) { + userService.deleteUser(id); + return R.ok("OK"); + } + + @Operation(summary = "停用/启用用户") + @PutMapping("/{id}/status") + public R updateStatus(@PathVariable Long id, @RequestParam Integer status) { + userService.updateStatus(id, status); + return R.ok("OK"); + } + + @Operation(summary = "重置密码") + @PutMapping("/{id}/reset-password") + public R resetPassword(@PathVariable Long id, @Valid @RequestBody PasswordResetRequest request) { + userService.resetPassword(id, request.getNewPassword()); + return R.ok("OK"); + } +} diff --git a/wm-system/src/main/java/com/water/system/entity/DataDictionary.java b/wm-system/src/main/java/com/water/system/entity/DataDictionary.java new file mode 100644 index 00000000..1354af3a --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/DataDictionary.java @@ -0,0 +1,33 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 数据字典实体 + */ +@Data +@TableName("sys_data_dictionary") +public class DataDictionary { + @TableId(type = IdType.AUTO) + private Long id; + + /** 字典编码(唯一) */ + private String dictCode; + + /** 字典名称 */ + private String dictName; + + /** 字典描述 */ + private String description; + + /** 状态: 0-停用 1-正常 */ + private Integer status; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; +} diff --git a/wm-system/src/main/java/com/water/system/entity/DataDictionaryItem.java b/wm-system/src/main/java/com/water/system/entity/DataDictionaryItem.java new file mode 100644 index 00000000..6df1517e --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/DataDictionaryItem.java @@ -0,0 +1,42 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 数据字典项实体 + */ +@Data +@TableName("sys_data_dictionary_item") +public class DataDictionaryItem { + @TableId(type = IdType.AUTO) + private Long id; + + /** 字典ID */ + private Long dictId; + + /** 字典项编码 */ + private String itemCode; + + /** 字典项名称 */ + private String itemName; + + /** 字典项值 */ + private String itemValue; + + /** 排序号 */ + private Integer sort; + + /** 状态: 0-停用 1-正常 */ + private Integer status; + + /** 备注 */ + private String remark; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; +} diff --git a/wm-system/src/main/java/com/water/system/entity/Document.java b/wm-system/src/main/java/com/water/system/entity/Document.java new file mode 100644 index 00000000..ae80d69b --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/Document.java @@ -0,0 +1,57 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 文档实体 + */ +@Data +@TableName("doc_document") +public class Document { + @TableId(type = IdType.AUTO) + private Long id; + + /** 文档名称 */ + private String name; + + /** 文档原始文件名 */ + private String originalName; + + /** 文档大小(字节) */ + private Long fileSize; + + /** 文件类型 */ + private String fileType; + + /** 存储路径 */ + private String storagePath; + + /** 文档分类ID */ + private Long categoryId; + + /** 文档描述 */ + private String description; + + /** 当前版本号 */ + private Integer currentVersion; + + /** 上传者ID */ + private Long uploaderId; + + /** 下载次数 */ + private Integer downloadCount; + + /** 状态: 0-草稿 1-已发布 2-已归档 */ + private Integer status; + + /** 权限级别: 0-公开 1-内部 2-机密 */ + private Integer permissionLevel; + + @TableLogic + private Integer deleted; + + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/wm-system/src/main/java/com/water/system/entity/DocumentCategory.java b/wm-system/src/main/java/com/water/system/entity/DocumentCategory.java new file mode 100644 index 00000000..06046c46 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/DocumentCategory.java @@ -0,0 +1,33 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 文档分类实体 + */ +@Data +@TableName("doc_category") +public class DocumentCategory { + @TableId(type = IdType.AUTO) + private Long id; + + /** 分类名称 */ + private String name; + + /** 父分类ID */ + private Long parentId; + + /** 排序号 */ + private Integer sortOrder; + + /** 分类描述 */ + private String description; + + @TableLogic + private Integer deleted; + + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/wm-system/src/main/java/com/water/system/entity/DocumentVersion.java b/wm-system/src/main/java/com/water/system/entity/DocumentVersion.java new file mode 100644 index 00000000..dcd69c1c --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/DocumentVersion.java @@ -0,0 +1,35 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 文档版本实体 + */ +@Data +@TableName("doc_version") +public class DocumentVersion { + @TableId(type = IdType.AUTO) + private Long id; + + /** 文档ID */ + private Long documentId; + + /** 版本号 */ + private Integer version; + + /** 版本描述 */ + private String description; + + /** 文件存储路径 */ + private String storagePath; + + /** 文件大小 */ + private Long fileSize; + + /** 操作人ID */ + private Long operatorId; + + private LocalDateTime createdAt; +} diff --git a/wm-system/src/main/java/com/water/system/entity/SysDepartment.java b/wm-system/src/main/java/com/water/system/entity/SysDepartment.java new file mode 100644 index 00000000..7d816a82 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/SysDepartment.java @@ -0,0 +1,47 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; +import java.util.List; + +/** + * 部门实体(树结构) + */ +@Data +@TableName("sys_department") +public class SysDepartment { + @TableId(type = IdType.AUTO) + private Long id; + + /** 父部门ID, 0为根节点 */ + private Long parentId; + + /** 部门名称 */ + private String deptName; + + /** 负责人 */ + private String leader; + + /** 联系电话 */ + private String phone; + + /** 排序号 */ + private Integer sort; + + /** 状态: 0-停用 1-正常 */ + private Integer status; + + /** 层级路径(如: 0,1,5) */ + private String ancestors; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; + + /** 子部门列表(非数据库字段) */ + @TableField(exist = false) + private List children; +} diff --git a/wm-system/src/main/java/com/water/system/entity/SysLog.java b/wm-system/src/main/java/com/water/system/entity/SysLog.java new file mode 100644 index 00000000..a1c6cdf0 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/SysLog.java @@ -0,0 +1,58 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 系统日志实体 + * 支持: 登录日志(LOGIN) / 操作日志(OPERATE) / 异常日志(EXCEPTION) + */ +@Data +@TableName("sys_log") +public class SysLog { + @TableId(type = IdType.AUTO) + private Long id; + + /** 操作用户ID */ + private Long userId; + + /** 操作用户名 */ + private String username; + + /** 日志类型: LOGIN-登录 OPERATE-操作 EXCEPTION-异常 */ + private String logType; + + /** 操作模块 */ + private String module; + + /** 操作描述 */ + private String action; + + /** 请求URL */ + private String requestUrl; + + /** 请求方法 */ + private String requestMethod; + + /** 请求参数 */ + private String requestParams; + + /** 响应结果 */ + private String responseResult; + + /** 操作IP */ + private String ip; + + /** 耗时(毫秒) */ + private Long duration; + + /** 状态: 0-失败 1-成功 */ + private Integer status; + + /** 错误信息 */ + private String errorMsg; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; +} diff --git a/wm-system/src/main/java/com/water/system/entity/SysMenu.java b/wm-system/src/main/java/com/water/system/entity/SysMenu.java new file mode 100644 index 00000000..e89ce40a --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/SysMenu.java @@ -0,0 +1,9 @@ +package com.water.system.entity; +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +@Data @TableName("sys_menu") +public class SysMenu { + @TableId(type = IdType.AUTO) private Long id; + private Long parentId; private String name, path, icon, component, permission; + private Integer type, sort, visible, status; +} diff --git a/wm-system/src/main/java/com/water/system/entity/SysRole.java b/wm-system/src/main/java/com/water/system/entity/SysRole.java new file mode 100644 index 00000000..baf89bcd --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/SysRole.java @@ -0,0 +1,46 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 系统角色实体 + * 支持5级角色: 1-超级管理员 2-系统管理员 3-部门经理 4-普通员工 5-访客 + */ +@Data +@TableName("sys_role") +public class SysRole { + @TableId(type = IdType.AUTO) + private Long id; + + /** 角色编码 */ + private String roleCode; + + /** 角色名称 */ + private String roleName; + + /** 角色描述 */ + private String description; + + /** 角色级别: 1-超级管理员 2-系统管理员 3-部门经理 4-普通员工 5-访客 */ + private Integer level; + + /** 数据权限范围: ALL-全部 DEPT-本部门 DEPT_BELOW-本部门及以下 SELF-仅本人 */ + private String dataScope; + + /** 权限配置(JSON数组) */ + private String permissions; + + /** 状态: 0-停用 1-正常 */ + private Integer status; + + /** 排序号 */ + private Integer sort; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; +} diff --git a/wm-system/src/main/java/com/water/system/entity/SysUser.java b/wm-system/src/main/java/com/water/system/entity/SysUser.java new file mode 100644 index 00000000..63cc2466 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/SysUser.java @@ -0,0 +1,54 @@ +package com.water.system.entity; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import java.time.LocalDateTime; + +/** + * 系统用户实体 + */ +@Data +@TableName("sys_user") +public class SysUser { + @TableId(type = IdType.AUTO) + private Long id; + + /** 用户名 */ + private String username; + + /** 密码(加密) */ + private String password; + + /** 真实姓名 */ + private String realName; + + /** 手机号 */ + private String phone; + + /** 邮箱 */ + private String email; + + /** 部门ID */ + private Long deptId; + + /** 角色ID */ + private Long roleId; + + /** 头像URL */ + private String avatar; + + /** 状态: 0-停用 1-正常 */ + private Integer status; + + /** 最后登录时间 */ + private LocalDateTime lastLoginTime; + + /** 最后登录IP */ + private String lastLoginIp; + + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createdTime; + + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updatedTime; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/DeptRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/DeptRequest.java new file mode 100644 index 00000000..2092df88 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/DeptRequest.java @@ -0,0 +1,20 @@ +package com.water.system.entity.dto; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; + +/** + * 部门创建/更新请求 + */ +@Data +public class DeptRequest { + private Long parentId; + + @NotBlank(message = "部门名称不能为空") + private String deptName; + + private String leader; + private String phone; + private Integer sort; + private Integer status; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/DictItemRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/DictItemRequest.java new file mode 100644 index 00000000..e6660b1e --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/DictItemRequest.java @@ -0,0 +1,25 @@ +package com.water.system.entity.dto; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import lombok.Data; + +/** + * 字典项创建/更新请求 + */ +@Data +public class DictItemRequest { + @NotNull(message = "字典ID不能为空") + private Long dictId; + + @NotBlank(message = "字典项编码不能为空") + private String itemCode; + + @NotBlank(message = "字典项名称不能为空") + private String itemName; + + private String itemValue; + private Integer sort; + private Integer status; + private String remark; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/DictRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/DictRequest.java new file mode 100644 index 00000000..0e01cc68 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/DictRequest.java @@ -0,0 +1,19 @@ +package com.water.system.entity.dto; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; + +/** + * 字典创建/更新请求 + */ +@Data +public class DictRequest { + @NotBlank(message = "字典编码不能为空") + private String dictCode; + + @NotBlank(message = "字典名称不能为空") + private String dictName; + + private String description; + private Integer status; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/LogQueryRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/LogQueryRequest.java new file mode 100644 index 00000000..db17e717 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/LogQueryRequest.java @@ -0,0 +1,22 @@ +package com.water.system.entity.dto; + +import lombok.Data; + +/** + * 日志查询请求 + */ +@Data +public class LogQueryRequest extends PageQuery { + /** 日志类型: LOGIN/OPERATE/EXCEPTION */ + private String logType; + /** 用户名(模糊) */ + private String username; + /** 操作模块 */ + private String module; + /** 开始时间(yyyy-MM-dd) */ + private String startTime; + /** 结束时间(yyyy-MM-dd) */ + private String endTime; + /** 状态: 0-失败 1-成功 */ + private Integer status; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/PageQuery.java b/wm-system/src/main/java/com/water/system/entity/dto/PageQuery.java new file mode 100644 index 00000000..ff4f9c22 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/PageQuery.java @@ -0,0 +1,14 @@ +package com.water.system.entity.dto; + +import lombok.Data; + +/** + * 分页查询基础参数 + */ +@Data +public class PageQuery { + /** 当前页码, 默认1 */ + private Integer pageNum = 1; + /** 每页条数, 默认10 */ + private Integer pageSize = 10; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/PasswordResetRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/PasswordResetRequest.java new file mode 100644 index 00000000..d38c77f2 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/PasswordResetRequest.java @@ -0,0 +1,13 @@ +package com.water.system.entity.dto; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; + +/** + * 密码重置请求 + */ +@Data +public class PasswordResetRequest { + @NotBlank(message = "新密码不能为空") + private String newPassword; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/RoleRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/RoleRequest.java new file mode 100644 index 00000000..da5fb7e2 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/RoleRequest.java @@ -0,0 +1,27 @@ +package com.water.system.entity.dto; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import lombok.Data; +import java.util.List; + +/** + * 角色创建/更新请求 + */ +@Data +public class RoleRequest { + @NotBlank(message = "角色编码不能为空") + private String roleCode; + + @NotBlank(message = "角色名称不能为空") + private String roleName; + + private String description; + + @NotNull(message = "角色级别不能为空") + private Integer level; + + private String dataScope; + private List permissions; + private Integer sort; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/UserCreateRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/UserCreateRequest.java new file mode 100644 index 00000000..fff8ad4a --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/UserCreateRequest.java @@ -0,0 +1,22 @@ +package com.water.system.entity.dto; + +import jakarta.validation.constraints.NotBlank; +import lombok.Data; + +/** + * 用户创建请求 + */ +@Data +public class UserCreateRequest { + @NotBlank(message = "用户名不能为空") + private String username; + + @NotBlank(message = "密码不能为空") + private String password; + + private String realName; + private String phone; + private String email; + private Long deptId; + private Long roleId; +} diff --git a/wm-system/src/main/java/com/water/system/entity/dto/UserUpdateRequest.java b/wm-system/src/main/java/com/water/system/entity/dto/UserUpdateRequest.java new file mode 100644 index 00000000..86ebf9af --- /dev/null +++ b/wm-system/src/main/java/com/water/system/entity/dto/UserUpdateRequest.java @@ -0,0 +1,15 @@ +package com.water.system.entity.dto; + +import lombok.Data; + +/** + * 用户更新请求 + */ +@Data +public class UserUpdateRequest { + private String realName; + private String phone; + private String email; + private Long deptId; + private Long roleId; +} diff --git a/wm-system/src/main/java/com/water/system/mapper/DataDictionaryItemMapper.java b/wm-system/src/main/java/com/water/system/mapper/DataDictionaryItemMapper.java new file mode 100644 index 00000000..9b68f4c9 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/DataDictionaryItemMapper.java @@ -0,0 +1,15 @@ +package com.water.system.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.DataDictionaryItem; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import java.util.List; + +@Mapper +public interface DataDictionaryItemMapper extends BaseMapper { + + @Select("SELECT i.* FROM sys_data_dictionary_item i INNER JOIN sys_data_dictionary d ON d.id = i.dict_id WHERE d.dict_code = #{dictCode} AND d.deleted = 0 AND i.deleted = 0 ORDER BY i.sort") + List selectByDictCode(@Param("dictCode") String dictCode); +} diff --git a/wm-system/src/main/java/com/water/system/mapper/DataDictionaryMapper.java b/wm-system/src/main/java/com/water/system/mapper/DataDictionaryMapper.java new file mode 100644 index 00000000..d847e23e --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/DataDictionaryMapper.java @@ -0,0 +1,14 @@ +package com.water.system.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.DataDictionary; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +@Mapper +public interface DataDictionaryMapper extends BaseMapper { + + @Select("SELECT * FROM sys_data_dictionary WHERE dict_code = #{dictCode} AND deleted = 0") + DataDictionary selectByDictCode(@Param("dictCode") String dictCode); +} diff --git a/wm-system/src/main/java/com/water/system/mapper/DocumentCategoryMapper.java b/wm-system/src/main/java/com/water/system/mapper/DocumentCategoryMapper.java new file mode 100644 index 00000000..e110cb50 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/DocumentCategoryMapper.java @@ -0,0 +1,5 @@ +package com.water.system.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.DocumentCategory; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DocumentCategoryMapper extends BaseMapper {} diff --git a/wm-system/src/main/java/com/water/system/mapper/DocumentMapper.java b/wm-system/src/main/java/com/water/system/mapper/DocumentMapper.java new file mode 100644 index 00000000..cad5f37e --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/DocumentMapper.java @@ -0,0 +1,5 @@ +package com.water.system.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.Document; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DocumentMapper extends BaseMapper {} diff --git a/wm-system/src/main/java/com/water/system/mapper/DocumentVersionMapper.java b/wm-system/src/main/java/com/water/system/mapper/DocumentVersionMapper.java new file mode 100644 index 00000000..d099baed --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/DocumentVersionMapper.java @@ -0,0 +1,5 @@ +package com.water.system.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.DocumentVersion; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface DocumentVersionMapper extends BaseMapper {} diff --git a/wm-system/src/main/java/com/water/system/mapper/SysDepartmentMapper.java b/wm-system/src/main/java/com/water/system/mapper/SysDepartmentMapper.java new file mode 100644 index 00000000..107e026b --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/SysDepartmentMapper.java @@ -0,0 +1,15 @@ +package com.water.system.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.SysDepartment; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import java.util.List; + +@Mapper +public interface SysDepartmentMapper extends BaseMapper { + + @Select("SELECT * FROM sys_department WHERE ancestors LIKE CONCAT(#{ancestorPath}, '%') AND deleted = 0 ORDER BY sort") + List selectByAncestorPath(@Param("ancestorPath") String ancestorPath); +} diff --git a/wm-system/src/main/java/com/water/system/mapper/SysLogMapper.java b/wm-system/src/main/java/com/water/system/mapper/SysLogMapper.java new file mode 100644 index 00000000..31a5b4ae --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/SysLogMapper.java @@ -0,0 +1,9 @@ +package com.water.system.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.SysLog; +import org.apache.ibatis.annotations.Mapper; + +@Mapper +public interface SysLogMapper extends BaseMapper { +} diff --git a/wm-system/src/main/java/com/water/system/mapper/SysMenuMapper.java b/wm-system/src/main/java/com/water/system/mapper/SysMenuMapper.java new file mode 100644 index 00000000..2aca3b5a --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/SysMenuMapper.java @@ -0,0 +1,5 @@ +package com.water.system.mapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.SysMenu; +import org.apache.ibatis.annotations.Mapper; +@Mapper public interface SysMenuMapper extends BaseMapper {} diff --git a/wm-system/src/main/java/com/water/system/mapper/SysRoleMapper.java b/wm-system/src/main/java/com/water/system/mapper/SysRoleMapper.java new file mode 100644 index 00000000..b9c5e98f --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/SysRoleMapper.java @@ -0,0 +1,19 @@ +package com.water.system.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.SysRole; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.apache.ibatis.annotations.Update; +import java.util.List; + +@Mapper +public interface SysRoleMapper extends BaseMapper { + + @Select("SELECT r.* FROM sys_role r INNER JOIN sys_user u ON u.role_id = r.id WHERE u.id = #{userId} AND r.deleted = 0") + List selectRolesByUserId(@Param("userId") Long userId); + + @Select("SELECT * FROM sys_role WHERE level <= #{level} AND deleted = 0 ORDER BY level, sort") + List selectRolesByMaxLevel(@Param("level") Integer level); +} diff --git a/wm-system/src/main/java/com/water/system/mapper/SysUserMapper.java b/wm-system/src/main/java/com/water/system/mapper/SysUserMapper.java new file mode 100644 index 00000000..66decd69 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/mapper/SysUserMapper.java @@ -0,0 +1,14 @@ +package com.water.system.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.water.system.entity.SysUser; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +@Mapper +public interface SysUserMapper extends BaseMapper { + + @Select("SELECT * FROM sys_user WHERE username = #{username} AND deleted = 0") + SysUser selectByUsername(@Param("username") String username); +} diff --git a/wm-system/src/main/java/com/water/system/service/DepartmentService.java b/wm-system/src/main/java/com/water/system/service/DepartmentService.java new file mode 100644 index 00000000..dec20de5 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/DepartmentService.java @@ -0,0 +1,29 @@ +package com.water.system.service; + +import com.water.system.entity.SysDepartment; +import com.water.system.entity.dto.DeptRequest; +import java.util.List; + +/** + * 部门管理服务接口 + */ +public interface DepartmentService { + + /** 获取部门树 */ + List getDeptTree(); + + /** 获取部门详情 */ + SysDepartment getDeptById(Long id); + + /** 创建部门 */ + Long createDept(DeptRequest request); + + /** 更新部门 */ + void updateDept(Long id, DeptRequest request); + + /** 删除部门 */ + void deleteDept(Long id); + + /** 获取所有子部门 */ + List getChildDepts(Long parentId); +} diff --git a/wm-system/src/main/java/com/water/system/service/DictionaryService.java b/wm-system/src/main/java/com/water/system/service/DictionaryService.java new file mode 100644 index 00000000..73c82f12 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/DictionaryService.java @@ -0,0 +1,43 @@ +package com.water.system.service; + +import com.water.system.entity.DataDictionary; +import com.water.system.entity.DataDictionaryItem; +import com.water.system.entity.dto.DictItemRequest; +import com.water.system.entity.dto.DictRequest; +import java.util.List; + +/** + * 数据字典服务接口 + */ +public interface DictionaryService { + + /** 查询所有字典 */ + List listDictionaries(String keyword); + + /** 获取字典详情 */ + DataDictionary getDictionaryById(Long id); + + /** 创建字典 */ + Long createDictionary(DictRequest request); + + /** 更新字典 */ + void updateDictionary(Long id, DictRequest request); + + /** 删除字典 */ + void deleteDictionary(Long id); + + /** 根据字典ID查询字典项 */ + List listItemsByDictId(Long dictId); + + /** 根据字典编码查询字典项 */ + List listItemsByDictCode(String dictCode); + + /** 创建字典项 */ + Long createItem(DictItemRequest request); + + /** 更新字典项 */ + void updateItem(Long id, DictItemRequest request); + + /** 删除字典项 */ + void deleteItem(Long id); +} diff --git a/wm-system/src/main/java/com/water/system/service/DocService.java b/wm-system/src/main/java/com/water/system/service/DocService.java new file mode 100644 index 00000000..e4ff50f0 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/DocService.java @@ -0,0 +1,44 @@ +package com.water.system.service; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.system.entity.*; +import com.water.system.mapper.*; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.util.*; +@Service @RequiredArgsConstructor +public class DocService { + private final DocumentMapper docMapper; + private final DocumentCategoryMapper catMapper; + private final DocumentVersionMapper verMapper; + + public List listDocs(String categoryId, String keyword) { + LambdaQueryWrapper w = new LambdaQueryWrapper<>(); + if (categoryId != null) w.eq(Document::getCategoryId, categoryId); + if (keyword != null) w.like(Document::getName, keyword); + return docMapper.selectList(w); + } + public Document getDoc(Long id) { return docMapper.selectById(id); } + public Long createDoc(Map req) { + Document d = new Document(); + d.setName((String)req.get("name")); + d.setCategoryId(req.get("categoryId") != null ? ((Number)req.get("categoryId")).longValue() : null); + d.setFileType((String)req.get("fileType")); + d.setFilePath((String)req.get("filePath")); + d.setStatus(1); + docMapper.insert(d); + return d.getId(); + } + public void updateDoc(Long id, Map req) { + Document d = docMapper.selectById(id); + if (d == null) throw new RuntimeException("文档不存在"); + if (req.containsKey("name")) d.setName((String)req.get("name")); + if (req.containsKey("categoryId")) d.setCategoryId(((Number)req.get("categoryId")).longValue()); + docMapper.updateById(d); + } + public void deleteDoc(Long id) { docMapper.deleteById(id); } + public List listCategories() { return catMapper.selectList(null); } + public List getVersions(Long docId) { + return verMapper.selectList(new LambdaQueryWrapper() + .eq(DocumentVersion::getDocId, docId).orderByDesc(DocumentVersion::getVersionNo)); + } +} diff --git a/wm-system/src/main/java/com/water/system/service/LogService.java b/wm-system/src/main/java/com/water/system/service/LogService.java new file mode 100644 index 00000000..c166160a --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/LogService.java @@ -0,0 +1,20 @@ +package com.water.system.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.water.system.entity.SysLog; +import com.water.system.entity.dto.LogQueryRequest; + +/** + * 日志查询服务接口 + */ +public interface LogService { + + /** 分页查询日志 */ + IPage pageLogs(LogQueryRequest request); + + /** 获取日志详情 */ + SysLog getLogById(Long id); + + /** 记录日志 */ + void saveLog(SysLog log); +} diff --git a/wm-system/src/main/java/com/water/system/service/RoleService.java b/wm-system/src/main/java/com/water/system/service/RoleService.java new file mode 100644 index 00000000..7a0173b9 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/RoleService.java @@ -0,0 +1,35 @@ +package com.water.system.service; + +import com.water.system.entity.SysRole; +import com.water.system.entity.dto.RoleRequest; +import java.util.List; + +/** + * 角色管理服务接口 + */ +public interface RoleService { + + /** 查询所有角色 */ + List listRoles(); + + /** 根据ID获取角色详情 */ + SysRole getRoleById(Long id); + + /** 创建角色 */ + Long createRole(RoleRequest request); + + /** 更新角色 */ + void updateRole(Long id, RoleRequest request); + + /** 删除角色 */ + void deleteRole(Long id); + + /** 分配权限 */ + void assignPermissions(Long id, List permissions); + + /** 根据用户ID查询角色 */ + List getRolesByUserId(Long userId); + + /** 根据最大级别查询角色 */ + List getRolesByMaxLevel(Integer level); +} diff --git a/wm-system/src/main/java/com/water/system/service/SysService.java b/wm-system/src/main/java/com/water/system/service/SysService.java new file mode 100644 index 00000000..b4764061 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/SysService.java @@ -0,0 +1,76 @@ +package com.water.system.service; + +import com.water.system.entity.*; +import com.water.system.mapper.*; +import com.water.system.entity.dto.*; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.util.*; + +/** + * 系统管理兼容服务 - 保持向后兼容，内部委托给新的专用服务 + */ +@Service +@RequiredArgsConstructor +public class SysService { + private final RoleService roleService; + private final UserService userService; + private final DepartmentService departmentService; + private final LogService logService; + private final SysMenuMapper menuMapper; + + // Roles + public List listRoles() { return roleService.listRoles(); } + public Long createRole(Map req) { + RoleRequest r = new RoleRequest(); + r.setRoleCode((String) req.get("roleCode")); + r.setRoleName((String) req.get("roleName")); + r.setDescription((String) req.get("description")); + r.setLevel(req.get("level") != null ? ((Number) req.get("level")).intValue() : 4); + r.setDataScope((String) req.get("dataScope")); + return roleService.createRole(r); + } + + // Users + public List listUsers(Integer status) { + return userService.pageUsers(1, 1000, null, status, null).getRecords(); + } + public Long createUser(Map req) { + UserCreateRequest r = new UserCreateRequest(); + r.setUsername((String) req.get("username")); + r.setPassword((String) req.get("password")); + r.setRealName((String) req.get("realName")); + r.setPhone((String) req.get("phone")); + r.setEmail((String) req.get("email")); + if (req.get("deptId") != null) r.setDeptId(((Number) req.get("deptId")).longValue()); + if (req.get("roleId") != null) r.setRoleId(((Number) req.get("roleId")).longValue()); + return userService.createUser(r); + } + public void updateUserStatus(Long id, int status) { + userService.updateStatus(id, status); + } + + // Menus + public List listMenus() { return menuMapper.selectList(null); } + + // Departments + public List listDepts() { return departmentService.getDeptTree(); } + public Long createDept(Map req) { + DeptRequest r = new DeptRequest(); + r.setDeptName((String) req.get("deptName")); + r.setLeader((String) req.get("leader")); + r.setPhone((String) req.get("phone")); + if (req.get("parentId") != null) r.setParentId(((Number) req.get("parentId")).longValue()); + return departmentService.createDept(r); + } + + // Logs + public List listLogs(String logType, String username) { + LogQueryRequest r = new LogQueryRequest(); + r.setLogType(logType); + r.setUsername(username); + r.setPageNum(1); + r.setPageSize(100); + return logService.pageLogs(r).getRecords(); + } +} diff --git a/wm-system/src/main/java/com/water/system/service/UserService.java b/wm-system/src/main/java/com/water/system/service/UserService.java new file mode 100644 index 00000000..ae50fa3d --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/UserService.java @@ -0,0 +1,37 @@ +package com.water.system.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.water.system.entity.SysUser; +import com.water.system.entity.dto.UserCreateRequest; +import com.water.system.entity.dto.UserUpdateRequest; +import java.util.List; + +/** + * 用户管理服务接口 + */ +public interface UserService { + + /** 分页查询用户列表 */ + IPage pageUsers(Integer pageNum, Integer pageSize, String keyword, Integer status, Long deptId); + + /** 获取用户详情 */ + SysUser getUserById(Long id); + + /** 创建用户 */ + Long createUser(UserCreateRequest request); + + /** 更新用户 */ + void updateUser(Long id, UserUpdateRequest request); + + /** 删除用户 */ + void deleteUser(Long id); + + /** 停用/启用用户 */ + void updateStatus(Long id, Integer status); + + /** 重置密码 */ + void resetPassword(Long id, String newPassword); + + /** 根据用户名查询 */ + SysUser getByUsername(String username); +} diff --git a/wm-system/src/main/java/com/water/system/service/impl/DepartmentServiceImpl.java b/wm-system/src/main/java/com/water/system/service/impl/DepartmentServiceImpl.java new file mode 100644 index 00000000..0a35edf8 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/impl/DepartmentServiceImpl.java @@ -0,0 +1,102 @@ +package com.water.system.service.impl; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.system.entity.SysDepartment; +import com.water.system.entity.dto.DeptRequest; +import com.water.system.mapper.SysDepartmentMapper; +import com.water.system.service.DepartmentService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +@Service +@RequiredArgsConstructor +public class DepartmentServiceImpl implements DepartmentService { + + private final SysDepartmentMapper deptMapper; + + @Override + public List getDeptTree() { + List allDepts = deptMapper.selectList( + new LambdaQueryWrapper().orderByAsc(SysDepartment::getSort) + ); + return buildTree(allDepts, 0L); + } + + @Override + public SysDepartment getDeptById(Long id) { + SysDepartment dept = deptMapper.selectById(id); + if (dept == null) throw new BusinessException("部门不存在"); + return dept; + } + + @Override + public Long createDept(DeptRequest request) { + SysDepartment dept = new SysDepartment(); + dept.setDeptName(request.getDeptName()); + dept.setLeader(request.getLeader()); + dept.setPhone(request.getPhone()); + dept.setSort(request.getSort() != null ? request.getSort() : 0); + dept.setStatus(request.getStatus() != null ? request.getStatus() : 1); + + Long parentId = request.getParentId() != null ? request.getParentId() : 0L; + dept.setParentId(parentId); + + // 设置层级路径 + if (parentId > 0) { + SysDepartment parent = getDeptById(parentId); + String ancestors = parent.getAncestors() != null ? parent.getAncestors() + "," + parentId : String.valueOf(parentId); + dept.setAncestors(ancestors); + } else { + dept.setAncestors("0"); + } + + deptMapper.insert(dept); + return dept.getId(); + } + + @Override + public void updateDept(Long id, DeptRequest request) { + SysDepartment dept = getDeptById(id); + if (request.getDeptName() != null) dept.setDeptName(request.getDeptName()); + if (request.getLeader() != null) dept.setLeader(request.getLeader()); + if (request.getPhone() != null) dept.setPhone(request.getPhone()); + if (request.getSort() != null) dept.setSort(request.getSort()); + if (request.getStatus() != null) dept.setStatus(request.getStatus()); + deptMapper.updateById(dept); + } + + @Override + public void deleteDept(Long id) { + // 检查是否有子部门 + long childCount = deptMapper.selectCount( + new LambdaQueryWrapper().eq(SysDepartment::getParentId, id) + ); + if (childCount > 0) { + throw new BusinessException("该部门下有子部门，不允许删除"); + } + deptMapper.deleteById(id); + } + + @Override + public List getChildDepts(Long parentId) { + SysDepartment parent = getDeptById(parentId); + String ancestorPath = parent.getAncestors() != null ? parent.getAncestors() + "," + parentId : String.valueOf(parentId); + return deptMapper.selectByAncestorPath(ancestorPath); + } + + private List buildTree(List depts, Long parentId) { + Map> grouped = depts.stream() + .collect(Collectors.groupingBy(SysDepartment::getParentId)); + + List roots = grouped.getOrDefault(parentId, new ArrayList<>()); + for (SysDepartment root : roots) { + root.setChildren(buildTree(depts, root.getId())); + } + return roots; + } +} diff --git a/wm-system/src/main/java/com/water/system/service/impl/DictionaryServiceImpl.java b/wm-system/src/main/java/com/water/system/service/impl/DictionaryServiceImpl.java new file mode 100644 index 00000000..e4c20b38 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/impl/DictionaryServiceImpl.java @@ -0,0 +1,116 @@ +package com.water.system.service.impl; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.system.entity.DataDictionary; +import com.water.system.entity.DataDictionaryItem; +import com.water.system.entity.dto.DictItemRequest; +import com.water.system.entity.dto.DictRequest; +import com.water.system.mapper.DataDictionaryMapper; +import com.water.system.mapper.DataDictionaryItemMapper; +import com.water.system.service.DictionaryService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.util.List; + +@Service +@RequiredArgsConstructor +public class DictionaryServiceImpl implements DictionaryService { + + private final DataDictionaryMapper dictMapper; + private final DataDictionaryItemMapper itemMapper; + + @Override + public List listDictionaries(String keyword) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (keyword != null && !keyword.isBlank()) { + wrapper.like(DataDictionary::getDictCode, keyword) + .or().like(DataDictionary::getDictName, keyword); + } + wrapper.orderByAsc(DataDictionary::getDictCode); + return dictMapper.selectList(wrapper); + } + + @Override + public DataDictionary getDictionaryById(Long id) { + DataDictionary dict = dictMapper.selectById(id); + if (dict == null) throw new BusinessException("字典不存在"); + return dict; + } + + @Override + public Long createDictionary(DictRequest request) { + DataDictionary existing = dictMapper.selectByDictCode(request.getDictCode()); + if (existing != null) throw new BusinessException("字典编码已存在"); + + DataDictionary dict = new DataDictionary(); + dict.setDictCode(request.getDictCode()); + dict.setDictName(request.getDictName()); + dict.setDescription(request.getDescription()); + dict.setStatus(request.getStatus() != null ? request.getStatus() : 1); + dictMapper.insert(dict); + return dict.getId(); + } + + @Override + public void updateDictionary(Long id, DictRequest request) { + DataDictionary dict = getDictionaryById(id); + if (request.getDictName() != null) dict.setDictName(request.getDictName()); + if (request.getDescription() != null) dict.setDescription(request.getDescription()); + if (request.getStatus() != null) dict.setStatus(request.getStatus()); + dictMapper.updateById(dict); + } + + @Override + public void deleteDictionary(Long id) { + // 同时删除字典项 + itemMapper.delete(new LambdaQueryWrapper() + .eq(DataDictionaryItem::getDictId, id)); + dictMapper.deleteById(id); + } + + @Override + public List listItemsByDictId(Long dictId) { + return itemMapper.selectList( + new LambdaQueryWrapper() + .eq(DataDictionaryItem::getDictId, dictId) + .orderByAsc(DataDictionaryItem::getSort) + ); + } + + @Override + public List listItemsByDictCode(String dictCode) { + return itemMapper.selectByDictCode(dictCode); + } + + @Override + public Long createItem(DictItemRequest request) { + DataDictionaryItem item = new DataDictionaryItem(); + item.setDictId(request.getDictId()); + item.setItemCode(request.getItemCode()); + item.setItemName(request.getItemName()); + item.setItemValue(request.getItemValue()); + item.setSort(request.getSort() != null ? request.getSort() : 0); + item.setStatus(request.getStatus() != null ? request.getStatus() : 1); + item.setRemark(request.getRemark()); + itemMapper.insert(item); + return item.getId(); + } + + @Override + public void updateItem(Long id, DictItemRequest request) { + DataDictionaryItem item = itemMapper.selectById(id); + if (item == null) throw new BusinessException("字典项不存在"); + if (request.getItemName() != null) item.setItemName(request.getItemName()); + if (request.getItemValue() != null) item.setItemValue(request.getItemValue()); + if (request.getSort() != null) item.setSort(request.getSort()); + if (request.getStatus() != null) item.setStatus(request.getStatus()); + if (request.getRemark() != null) item.setRemark(request.getRemark()); + itemMapper.updateById(item); + } + + @Override + public void deleteItem(Long id) { + itemMapper.deleteById(id); + } +} diff --git a/wm-system/src/main/java/com/water/system/service/impl/LogServiceImpl.java b/wm-system/src/main/java/com/water/system/service/impl/LogServiceImpl.java new file mode 100644 index 00000000..2e454f6a --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/impl/LogServiceImpl.java @@ -0,0 +1,62 @@ +package com.water.system.service.impl; + +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.system.entity.SysLog; +import com.water.system.entity.dto.LogQueryRequest; +import com.water.system.mapper.SysLogMapper; +import com.water.system.service.LogService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + +@Service +@RequiredArgsConstructor +public class LogServiceImpl implements LogService { + + private final SysLogMapper logMapper; + private static final DateTimeFormatter DATE_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + + @Override + public IPage pageLogs(LogQueryRequest request) { + Page page = new Page<>(request.getPageNum(), request.getPageSize()); + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + + if (request.getLogType() != null && !request.getLogType().isBlank()) { + wrapper.eq(SysLog::getLogType, request.getLogType()); + } + if (request.getUsername() != null && !request.getUsername().isBlank()) { + wrapper.like(SysLog::getUsername, request.getUsername()); + } + if (request.getModule() != null && !request.getModule().isBlank()) { + wrapper.eq(SysLog::getModule, request.getModule()); + } + if (request.getStatus() != null) { + wrapper.eq(SysLog::getStatus, request.getStatus()); + } + if (request.getStartTime() != null && !request.getStartTime().isBlank()) { + LocalDateTime start = LocalDate.parse(request.getStartTime(), DATE_FMT).atStartOfDay(); + wrapper.ge(SysLog::getCreatedTime, start); + } + if (request.getEndTime() != null && !request.getEndTime().isBlank()) { + LocalDateTime end = LocalDate.parse(request.getEndTime(), DATE_FMT).plusDays(1).atStartOfDay(); + wrapper.lt(SysLog::getCreatedTime, end); + } + + wrapper.orderByDesc(SysLog::getCreatedTime); + return logMapper.selectPage(page, wrapper); + } + + @Override + public SysLog getLogById(Long id) { + return logMapper.selectById(id); + } + + @Override + public void saveLog(SysLog log) { + logMapper.insert(log); + } +} diff --git a/wm-system/src/main/java/com/water/system/service/impl/RoleServiceImpl.java b/wm-system/src/main/java/com/water/system/service/impl/RoleServiceImpl.java new file mode 100644 index 00000000..54b610bf --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/impl/RoleServiceImpl.java @@ -0,0 +1,103 @@ +package com.water.system.service.impl; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.system.entity.SysRole; +import com.water.system.entity.dto.RoleRequest; +import com.water.system.mapper.SysRoleMapper; +import com.water.system.service.RoleService; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import java.util.List; + +@Service +@RequiredArgsConstructor +public class RoleServiceImpl implements RoleService { + + private final SysRoleMapper roleMapper; + private final ObjectMapper objectMapper; + + @Override + public List listRoles() { + return roleMapper.selectList( + new LambdaQueryWrapper().orderByAsc(SysRole::getLevel, SysRole::getSort) + ); + } + + @Override + public SysRole getRoleById(Long id) { + SysRole role = roleMapper.selectById(id); + if (role == null) throw new BusinessException("角色不存在"); + return role; + } + + @Override + public Long createRole(RoleRequest request) { + // 检查编码唯一 + long count = roleMapper.selectCount( + new LambdaQueryWrapper().eq(SysRole::getRoleCode, request.getRoleCode()) + ); + if (count > 0) throw new BusinessException("角色编码已存在"); + + SysRole role = new SysRole(); + role.setRoleCode(request.getRoleCode()); + role.setRoleName(request.getRoleName()); + role.setDescription(request.getDescription()); + role.setLevel(request.getLevel()); + role.setDataScope(request.getDataScope() != null ? request.getDataScope() : "SELF"); + role.setPermissions(toJson(request.getPermissions())); + role.setStatus(1); + role.setSort(request.getSort() != null ? request.getSort() : 0); + roleMapper.insert(role); + return role.getId(); + } + + @Override + public void updateRole(Long id, RoleRequest request) { + SysRole role = getRoleById(id); + role.setRoleName(request.getRoleName()); + role.setDescription(request.getDescription()); + role.setLevel(request.getLevel()); + if (request.getDataScope() != null) role.setDataScope(request.getDataScope()); + if (request.getPermissions() != null) role.setPermissions(toJson(request.getPermissions())); + if (request.getSort() != null) role.setSort(request.getSort()); + roleMapper.updateById(role); + } + + @Override + public void deleteRole(Long id) { + SysRole role = getRoleById(id); + if (role.getLevel() != null && role.getLevel() <= 2) { + throw new BusinessException("超级管理员和系统管理员角色不允许删除"); + } + roleMapper.deleteById(id); + } + + @Override + public void assignPermissions(Long id, List permissions) { + SysRole role = getRoleById(id); + role.setPermissions(toJson(permissions)); + roleMapper.updateById(role); + } + + @Override + public List getRolesByUserId(Long userId) { + return roleMapper.selectRolesByUserId(userId); + } + + @Override + public List getRolesByMaxLevel(Integer level) { + return roleMapper.selectRolesByMaxLevel(level); + } + + private String toJson(Object obj) { + if (obj == null) return null; + try { + return objectMapper.writeValueAsString(obj); + } catch (JsonProcessingException e) { + throw new BusinessException("JSON序列化失败: " + e.getMessage()); + } + } +} diff --git a/wm-system/src/main/java/com/water/system/service/impl/UserServiceImpl.java b/wm-system/src/main/java/com/water/system/service/impl/UserServiceImpl.java new file mode 100644 index 00000000..1c5cd0c2 --- /dev/null +++ b/wm-system/src/main/java/com/water/system/service/impl/UserServiceImpl.java @@ -0,0 +1,115 @@ +package com.water.system.service.impl; + +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.common.core.exception.BusinessException; +import com.water.system.entity.SysUser; +import com.water.system.entity.dto.UserCreateRequest; +import com.water.system.entity.dto.UserUpdateRequest; +import com.water.system.mapper.SysUserMapper; +import com.water.system.service.UserService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import org.springframework.util.DigestUtils; +import java.nio.charset.StandardCharsets; + +@Service +@RequiredArgsConstructor +public class UserServiceImpl implements UserService { + + private final SysUserMapper userMapper; + + @Override + public IPage pageUsers(Integer pageNum, Integer pageSize, String keyword, Integer status, Long deptId) { + Page page = new Page<>(pageNum, pageSize); + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + if (keyword != null && !keyword.isBlank()) { + wrapper.and(w -> w.like(SysUser::getUsername, keyword) + .or().like(SysUser::getRealName, keyword) + .or().like(SysUser::getPhone, keyword)); + } + if (status != null) wrapper.eq(SysUser::getStatus, status); + if (deptId != null) wrapper.eq(SysUser::getDeptId, deptId); + wrapper.orderByDesc(SysUser::getCreatedTime); + + IPage result = userMapper.selectPage(page, wrapper); + // 清除密码字段 + result.getRecords().forEach(u -> u.setPassword(null)); + return result; + } + + @Override + public SysUser getUserById(Long id) { + SysUser user = userMapper.selectById(id); + if (user == null) throw new BusinessException("用户不存在"); + user.setPassword(null); + return user; + } + + @Override + public Long createUser(UserCreateRequest request) { + // 检查用户名唯一 + SysUser existing = userMapper.selectByUsername(request.getUsername()); + if (existing != null) throw new BusinessException("用户名已存在"); + + SysUser user = new SysUser(); + user.setUsername(request.getUsername()); + user.setPassword(encryptPassword(request.getPassword())); + user.setRealName(request.getRealName()); + user.setPhone(request.getPhone()); + user.setEmail(request.getEmail()); + user.setDeptId(request.getDeptId()); + user.setRoleId(request.getRoleId()); + user.setStatus(1); + userMapper.insert(user); + return user.getId(); + } + + @Override + public void updateUser(Long id, UserUpdateRequest request) { + SysUser user = userMapper.selectById(id); + if (user == null) throw new BusinessException("用户不存在"); + if (request.getRealName() != null) user.setRealName(request.getRealName()); + if (request.getPhone() != null) user.setPhone(request.getPhone()); + if (request.getEmail() != null) user.setEmail(request.getEmail()); + if (request.getDeptId() != null) user.setDeptId(request.getDeptId()); + if (request.getRoleId() != null) user.setRoleId(request.getRoleId()); + userMapper.updateById(user); + } + + @Override + public void deleteUser(Long id) { + SysUser user = userMapper.selectById(id); + if (user == null) throw new BusinessException("用户不存在"); + if ("admin".equals(user.getUsername())) { + throw new BusinessException("系统管理员账号不允许删除"); + } + userMapper.deleteById(id); + } + + @Override + public void updateStatus(Long id, Integer status) { + SysUser user = userMapper.selectById(id); + if (user == null) throw new BusinessException("用户不存在"); + user.setStatus(status); + userMapper.updateById(user); + } + + @Override + public void resetPassword(Long id, String newPassword) { + SysUser user = userMapper.selectById(id); + if (user == null) throw new BusinessException("用户不存在"); + user.setPassword(encryptPassword(newPassword)); + userMapper.updateById(user); + } + + @Override + public SysUser getByUsername(String username) { + return userMapper.selectByUsername(username); + } + + private String encryptPassword(String password) { + return DigestUtils.md5DigestAsHex(password.getBytes(StandardCharsets.UTF_8)); + } +} diff --git a/wm-system/src/main/resources/application.yml b/wm-system/src/main/resources/application.yml new file mode 100644 index 00000000..612e6b4a --- /dev/null +++ b/wm-system/src/main/resources/application.yml @@ -0,0 +1,40 @@ +server: + port: 8084 + +spring: + application: + name: wm-system + datasource: + driver-class-name: org.postgresql.Driver + url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:water_system}?currentSchema=public + username: ${DB_USER:postgres} + password: ${DB_PASS:postgres} + servlet: + multipart: + max-file-size: 100MB + max-request-size: 100MB + +mybatis-plus: + configuration: + map-underscore-to-camel-case: true + log-impl: org.apache.ibatis.logging.stdout.StdOutImpl + global-config: + db-config: + logic-delete-field: deleted + logic-delete-value: 1 + logic-not-delete-value: 0 + +minio: + endpoint: ${MINIO_ENDPOINT:http://localhost:9000} + access-key: ${MINIO_ACCESS_KEY:minioadmin} + secret-key: ${MINIO_SECRET_KEY:minioadmin} + bucket-name: ${MINIO_BUCKET:water-documents} + +sa-token: + token-name: Authorization + timeout: 86400 + active-timeout: 1800 + +logging: + level: + com.water.system: debug diff --git a/wm-system/src/main/resources/db/V1__system_manage.sql b/wm-system/src/main/resources/db/V1__system_manage.sql new file mode 100644 index 00000000..304d5aac --- /dev/null +++ b/wm-system/src/main/resources/db/V1__system_manage.sql @@ -0,0 +1,45 @@ +CREATE TABLE IF NOT EXISTS sys_document ( + id BIGSERIAL PRIMARY KEY, name VARCHAR(200), category_id BIGINT, + file_type VARCHAR(20), file_size BIGINT, file_path VARCHAR(500), + status INT DEFAULT 1, creator_id BIGINT, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS sys_document_category ( + id BIGSERIAL PRIMARY KEY, name VARCHAR(100), parent_id BIGINT, + sort INT DEFAULT 0, status INT DEFAULT 1, + created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS sys_document_version ( + id BIGSERIAL PRIMARY KEY, doc_id BIGINT, version_no INT, + file_path VARCHAR(500), remark TEXT, + created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS sys_role ( + id BIGSERIAL PRIMARY KEY, role_code VARCHAR(50) UNIQUE, role_name VARCHAR(50), + description VARCHAR(200), status INT DEFAULT 1, sort INT DEFAULT 0, + created_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS sys_user ( + id BIGSERIAL PRIMARY KEY, username VARCHAR(50) UNIQUE, password VARCHAR(200), + real_name VARCHAR(50), phone VARCHAR(20), email VARCHAR(100), + dept_id BIGINT, avatar VARCHAR(500), status INT DEFAULT 1, + created_time TIMESTAMP DEFAULT NOW(), updated_time TIMESTAMP DEFAULT NOW() +); +CREATE TABLE IF NOT EXISTS sys_menu ( + id BIGSERIAL PRIMARY KEY, parent_id BIGINT, name VARCHAR(50), + path VARCHAR(200), icon VARCHAR(50), component VARCHAR(200), + permission VARCHAR(100), type INT, sort INT DEFAULT 0, + visible INT DEFAULT 1, status INT DEFAULT 1 +); +CREATE TABLE IF NOT EXISTS sys_department ( + id BIGSERIAL PRIMARY KEY, parent_id BIGINT, dept_name VARCHAR(100), + leader VARCHAR(50), phone VARCHAR(20), sort INT DEFAULT 0, status INT DEFAULT 1 +); +CREATE TABLE IF NOT EXISTS sys_log ( + id BIGSERIAL PRIMARY KEY, user_id BIGINT, username VARCHAR(50), + log_type VARCHAR(20), module VARCHAR(50), action VARCHAR(50), + request_url VARCHAR(500), request_method VARCHAR(10), + request_params TEXT, response_result TEXT, + ip VARCHAR(50), duration BIGINT, + created_time TIMESTAMP DEFAULT NOW() +); diff --git a/wm-system/src/main/resources/db/V2__system_enhance.sql b/wm-system/src/main/resources/db/V2__system_enhance.sql new file mode 100644 index 00000000..3ddd2861 --- /dev/null +++ b/wm-system/src/main/resources/db/V2__system_enhance.sql @@ -0,0 +1,136 @@ +-- V2__system_enhance.sql +-- 系统管理增强: 角色/用户/部门/日志/字典 + +-- 1. 增强 sys_role 表: 新增 level, data_scope, permissions, updated_time 字段 +ALTER TABLE sys_role ADD COLUMN IF NOT EXISTS level INT DEFAULT 4; +ALTER TABLE sys_role ADD COLUMN IF NOT EXISTS data_scope VARCHAR(20) DEFAULT 'SELF'; +ALTER TABLE sys_role ADD COLUMN IF NOT EXISTS permissions TEXT; +ALTER TABLE sys_role ADD COLUMN IF NOT EXISTS updated_time TIMESTAMP DEFAULT NOW(); +ALTER TABLE sys_role ADD COLUMN IF NOT EXISTS deleted INT DEFAULT 0; + +COMMENT ON COLUMN sys_role.level IS '角色级别: 1-超级管理员 2-系统管理员 3-部门经理 4-普通员工 5-访客'; +COMMENT ON COLUMN sys_role.data_scope IS '数据权限: ALL/DEPT/DEPT_BELOW/SELF'; +COMMENT ON COLUMN sys_role.permissions IS '权限配置(JSON数组)'; + +-- 2. 增强 sys_user 表: 新增 role_id, last_login_time, last_login_ip, deleted +ALTER TABLE sys_user ADD COLUMN IF NOT EXISTS role_id BIGINT; +ALTER TABLE sys_user ADD COLUMN IF NOT EXISTS last_login_time TIMESTAMP; +ALTER TABLE sys_user ADD COLUMN IF NOT EXISTS last_login_ip VARCHAR(50); +ALTER TABLE sys_user ADD COLUMN IF NOT EXISTS deleted INT DEFAULT 0; + +-- 3. 增强 sys_department 表: 新增 ancestors, created_time, updated_time, deleted +ALTER TABLE sys_department ADD COLUMN IF NOT EXISTS ancestors VARCHAR(500) DEFAULT '0'; +ALTER TABLE sys_department ADD COLUMN IF NOT EXISTS created_time TIMESTAMP DEFAULT NOW(); +ALTER TABLE sys_department ADD COLUMN IF NOT EXISTS updated_time TIMESTAMP DEFAULT NOW(); +ALTER TABLE sys_department ADD COLUMN IF NOT EXISTS deleted INT DEFAULT 0; + +COMMENT ON COLUMN sys_department.ancestors IS '层级路径(如: 0,1,5)'; + +-- 4. 增强 sys_log 表: 新增 status, error_msg +ALTER TABLE sys_log ADD COLUMN IF NOT EXISTS status INT DEFAULT 1; +ALTER TABLE sys_log ADD COLUMN IF NOT EXISTS error_msg TEXT; + +COMMENT ON COLUMN sys_log.log_type IS '日志类型: LOGIN/OPERATE/EXCEPTION'; +COMMENT ON COLUMN sys_log.status IS '状态: 0-失败 1-成功'; + +-- 5. 新增数据字典表 +CREATE TABLE IF NOT EXISTS sys_data_dictionary ( + id BIGSERIAL PRIMARY KEY, + dict_code VARCHAR(100) UNIQUE NOT NULL, + dict_name VARCHAR(200) NOT NULL, + description VARCHAR(500), + status INT DEFAULT 1, + deleted INT DEFAULT 0, + created_time TIMESTAMP DEFAULT NOW(), + updated_time TIMESTAMP DEFAULT NOW() +); + +COMMENT ON TABLE sys_data_dictionary IS '数据字典表'; +COMMENT ON COLUMN sys_data_dictionary.dict_code IS '字典编码(唯一)'; +COMMENT ON COLUMN sys_data_dictionary.dict_name IS '字典名称'; + +-- 6. 新增数据字典项表 +CREATE TABLE IF NOT EXISTS sys_data_dictionary_item ( + id BIGSERIAL PRIMARY KEY, + dict_id BIGINT NOT NULL, + item_code VARCHAR(100) NOT NULL, + item_name VARCHAR(200) NOT NULL, + item_value VARCHAR(500), + sort INT DEFAULT 0, + status INT DEFAULT 1, + remark VARCHAR(500), + deleted INT DEFAULT 0, + created_time TIMESTAMP DEFAULT NOW(), + updated_time TIMESTAMP DEFAULT NOW() +); + +COMMENT ON TABLE sys_data_dictionary_item IS '数据字典项表'; +COMMENT ON COLUMN sys_data_dictionary_item.dict_id IS '所属字典ID'; +COMMENT ON COLUMN sys_data_dictionary_item.item_code IS '字典项编码'; +COMMENT ON COLUMN sys_data_dictionary_item.item_name IS '字典项名称'; +COMMENT ON COLUMN sys_data_dictionary_item.item_value IS '字典项值'; + +-- 索引 +CREATE INDEX IF NOT EXISTS idx_dict_item_dict_id ON sys_data_dictionary_item(dict_id); +CREATE INDEX IF NOT EXISTS idx_dict_item_code ON sys_data_dictionary_item(item_code); +CREATE INDEX IF NOT EXISTS idx_sys_user_dept_id ON sys_user(dept_id); +CREATE INDEX IF NOT EXISTS idx_sys_user_role_id ON sys_user(role_id); +CREATE INDEX IF NOT EXISTS idx_sys_user_status ON sys_user(status); +CREATE INDEX IF NOT EXISTS idx_sys_role_level ON sys_role(level); +CREATE INDEX IF NOT EXISTS idx_sys_dept_parent_id ON sys_department(parent_id); +CREATE INDEX IF NOT EXISTS idx_sys_dept_ancestors ON sys_department(ancestors); +CREATE INDEX IF NOT EXISTS idx_sys_log_type ON sys_log(log_type); +CREATE INDEX IF NOT EXISTS idx_sys_log_user ON sys_log(username); +CREATE INDEX IF NOT EXISTS idx_sys_log_created ON sys_log(created_time); +CREATE INDEX IF NOT EXISTS idx_sys_log_module ON sys_log(module); +CREATE INDEX IF NOT EXISTS idx_sys_log_status ON sys_log(status); + +-- 初始化5级角色数据 +INSERT INTO sys_role (role_code, role_name, description, level, data_scope, sort, created_time) VALUES +('SUPER_ADMIN', '超级管理员', '拥有系统所有权限', 1, 'ALL', 1, NOW()), +('SYS_ADMIN', '系统管理员', '系统管理权限', 2, 'ALL', 2, NOW()), +('DEPT_MANAGER', '部门经理', '本部门管理权限', 3, 'DEPT', 3, NOW()), +('EMPLOYEE', '普通员工', '基础操作权限', 4, 'SELF', 4, NOW()), +('GUEST', '访客', '仅查看权限', 5, 'SELF', 5, NOW()) +ON CONFLICT (role_code) DO NOTHING; + +-- 初始化数据字典示例 +INSERT INTO sys_data_dictionary (dict_code, dict_name, description, status, created_time) VALUES +('sys_user_status', '用户状态', '用户账号状态枚举', 1, NOW()), +('sys_log_type', '日志类型', '系统日志类型枚举', 1, NOW()), +('sys_role_level', '角色级别', '系统角色级别枚举', 1, NOW()) +ON CONFLICT (dict_code) DO NOTHING; + +INSERT INTO sys_data_dictionary_item (dict_id, item_code, item_name, item_value, sort, status, created_time) +SELECT d.id, item_code, item_name, item_value, sort, 1, NOW() +FROM sys_data_dictionary d +CROSS JOIN (VALUES + ('sys_user_status', 'DISABLED', '停用', '0', 1), + ('sys_user_status', 'ENABLED', '正常', '1', 2) +) AS v(dict_code, item_code, item_name, item_value, sort) +WHERE d.dict_code = v.dict_code +AND NOT EXISTS (SELECT 1 FROM sys_data_dictionary_item i WHERE i.dict_id = d.id AND i.item_code = v.item_code); + +INSERT INTO sys_data_dictionary_item (dict_id, item_code, item_name, item_value, sort, status, created_time) +SELECT d.id, item_code, item_name, item_value, sort, 1, NOW() +FROM sys_data_dictionary d +CROSS JOIN (VALUES + ('sys_log_type', 'LOGIN', '登录日志', 'LOGIN', 1), + ('sys_log_type', 'OPERATE', '操作日志', 'OPERATE', 2), + ('sys_log_type', 'EXCEPTION', '异常日志', 'EXCEPTION', 3) +) AS v(dict_code, item_code, item_name, item_value, sort) +WHERE d.dict_code = v.dict_code +AND NOT EXISTS (SELECT 1 FROM sys_data_dictionary_item i WHERE i.dict_id = d.id AND i.item_code = v.item_code); + +INSERT INTO sys_data_dictionary_item (dict_id, item_code, item_name, item_value, sort, status, created_time) +SELECT d.id, item_code, item_name, item_value, sort, 1, NOW() +FROM sys_data_dictionary d +CROSS JOIN (VALUES + ('sys_role_level', 'LEVEL_1', '超级管理员', '1', 1), + ('sys_role_level', 'LEVEL_2', '系统管理员', '2', 2), + ('sys_role_level', 'LEVEL_3', '部门经理', '3', 3), + ('sys_role_level', 'LEVEL_4', '普通员工', '4', 4), + ('sys_role_level', 'LEVEL_5', '访客', '5', 5) +) AS v(dict_code, item_code, item_name, item_value, sort) +WHERE d.dict_code = v.dict_code +AND NOT EXISTS (SELECT 1 FROM sys_data_dictionary_item i WHERE i.dict_id = d.id AND i.item_code = v.item_code); diff --git a/wm-system/src/test/java/com/water/system/service/DepartmentServiceImplTest.java b/wm-system/src/test/java/com/water/system/service/DepartmentServiceImplTest.java new file mode 100644 index 00000000..11044e82 --- /dev/null +++ b/wm-system/src/test/java/com/water/system/service/DepartmentServiceImplTest.java @@ -0,0 +1,93 @@ +package com.water.system.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.system.entity.SysDepartment; +import com.water.system.entity.dto.DeptRequest; +import com.water.system.mapper.SysDepartmentMapper; +import com.water.system.service.impl.DepartmentServiceImpl; +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.Arrays; +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 DepartmentServiceImplTest { + + @Mock + private SysDepartmentMapper deptMapper; + + @InjectMocks + private DepartmentServiceImpl departmentService; + + @Test + void getDeptTree_shouldBuildTree() { + SysDepartment root = new SysDepartment(); + root.setId(1L); + root.setParentId(0L); + root.setDeptName("总公司"); + + SysDepartment child1 = new SysDepartment(); + child1.setId(2L); + child1.setParentId(1L); + child1.setDeptName("技术部"); + + SysDepartment child2 = new SysDepartment(); + child2.setId(3L); + child2.setParentId(1L); + child2.setDeptName("市场部"); + + when(deptMapper.selectList(any(LambdaQueryWrapper.class))) + .thenReturn(Arrays.asList(root, child1, child2)); + + List tree = departmentService.getDeptTree(); + + assertEquals(1, tree.size()); + assertEquals("总公司", tree.get(0).getDeptName()); + assertEquals(2, tree.get(0).getChildren().size()); + } + + @Test + void createDept_shouldSetAncestors() { + SysDepartment parent = new SysDepartment(); + parent.setId(1L); + parent.setAncestors("0"); + parent.setDeptName("总公司"); + + when(deptMapper.selectById(1L)).thenReturn(parent); + when(deptMapper.insert(any(SysDepartment.class))).thenAnswer(inv -> { + SysDepartment d = inv.getArgument(0); + d.setId(10L); + assertEquals("0,1", d.getAncestors()); + return 1; + }); + + DeptRequest request = new DeptRequest(); + request.setDeptName("研发部"); + request.setParentId(1L); + + Long id = departmentService.createDept(request); + assertEquals(10L, id); + } + + @Test + void deleteDept_shouldFailWithChildren() { + when(deptMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(2L); + + assertThrows(BusinessException.class, () -> departmentService.deleteDept(1L)); + } + + @Test + void deleteDept_shouldSucceedWithoutChildren() { + when(deptMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L); + + assertDoesNotThrow(() -> departmentService.deleteDept(5L)); + verify(deptMapper).deleteById(5L); + } +} diff --git a/wm-system/src/test/java/com/water/system/service/DictionaryServiceImplTest.java b/wm-system/src/test/java/com/water/system/service/DictionaryServiceImplTest.java new file mode 100644 index 00000000..37c5610b --- /dev/null +++ b/wm-system/src/test/java/com/water/system/service/DictionaryServiceImplTest.java @@ -0,0 +1,104 @@ +package com.water.system.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.system.entity.DataDictionary; +import com.water.system.entity.DataDictionaryItem; +import com.water.system.entity.dto.DictItemRequest; +import com.water.system.entity.dto.DictRequest; +import com.water.system.mapper.DataDictionaryMapper; +import com.water.system.mapper.DataDictionaryItemMapper; +import com.water.system.service.impl.DictionaryServiceImpl; +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.Arrays; +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 DictionaryServiceImplTest { + + @Mock + private DataDictionaryMapper dictMapper; + + @Mock + private DataDictionaryItemMapper itemMapper; + + @InjectMocks + private DictionaryServiceImpl dictionaryService; + + @Test + void createDictionary_shouldSucceed() { + DictRequest request = new DictRequest(); + request.setDictCode("water_quality_level"); + request.setDictName("水质等级"); + + when(dictMapper.selectByDictCode("water_quality_level")).thenReturn(null); + when(dictMapper.insert(any(DataDictionary.class))).thenAnswer(inv -> { + DataDictionary d = inv.getArgument(0); + d.setId(10L); + return 1; + }); + + Long id = dictionaryService.createDictionary(request); + assertEquals(10L, id); + } + + @Test + void createDictionary_shouldFailOnDuplicate() { + DictRequest request = new DictRequest(); + request.setDictCode("sys_user_status"); + + DataDictionary existing = new DataDictionary(); + existing.setDictCode("sys_user_status"); + when(dictMapper.selectByDictCode("sys_user_status")).thenReturn(existing); + + assertThrows(BusinessException.class, () -> dictionaryService.createDictionary(request)); + } + + @Test + void listItemsByDictCode_shouldReturnItems() { + DataDictionaryItem item1 = new DataDictionaryItem(); + item1.setItemCode("ENABLED"); + item1.setItemName("正常"); + DataDictionaryItem item2 = new DataDictionaryItem(); + item2.setItemCode("DISABLED"); + item2.setItemName("停用"); + + when(itemMapper.selectByDictCode("sys_user_status")).thenReturn(Arrays.asList(item1, item2)); + + List items = dictionaryService.listItemsByDictCode("sys_user_status"); + assertEquals(2, items.size()); + } + + @Test + void deleteDictionary_shouldDeleteItemsToo() { + dictionaryService.deleteDictionary(1L); + + verify(itemMapper).delete(any(LambdaQueryWrapper.class)); + verify(dictMapper).deleteById(1L); + } + + @Test + void createItem_shouldSucceed() { + DictItemRequest request = new DictItemRequest(); + request.setDictId(1L); + request.setItemCode("NEW_ITEM"); + request.setItemName("新项"); + request.setItemValue("value"); + + when(itemMapper.insert(any(DataDictionaryItem.class))).thenAnswer(inv -> { + DataDictionaryItem i = inv.getArgument(0); + i.setId(20L); + return 1; + }); + + Long id = dictionaryService.createItem(request); + assertEquals(20L, id); + } +} diff --git a/wm-system/src/test/java/com/water/system/service/LogServiceImplTest.java b/wm-system/src/test/java/com/water/system/service/LogServiceImplTest.java new file mode 100644 index 00000000..a2ca8d6e --- /dev/null +++ b/wm-system/src/test/java/com/water/system/service/LogServiceImplTest.java @@ -0,0 +1,93 @@ +package com.water.system.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.system.entity.SysLog; +import com.water.system.entity.dto.LogQueryRequest; +import com.water.system.mapper.SysLogMapper; +import com.water.system.service.impl.LogServiceImpl; +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.time.LocalDateTime; +import java.util.Arrays; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class LogServiceImplTest { + + @Mock + private SysLogMapper logMapper; + + @InjectMocks + private LogServiceImpl logService; + + @Test + void pageLogs_shouldReturnPagedResult() { + Page page = new Page<>(1, 10); + SysLog log1 = new SysLog(); + log1.setId(1L); + log1.setLogType("LOGIN"); + log1.setUsername("admin"); + log1.setCreatedTime(LocalDateTime.now()); + + SysLog log2 = new SysLog(); + log2.setId(2L); + log2.setLogType("OPERATE"); + log2.setUsername("user1"); + log2.setModule("用户管理"); + + page.setRecords(Arrays.asList(log1, log2)); + page.setTotal(2); + + when(logMapper.selectPage(any(Page.class), any(LambdaQueryWrapper.class))).thenReturn(page); + + LogQueryRequest request = new LogQueryRequest(); + request.setPageNum(1); + request.setPageSize(10); + + IPage result = logService.pageLogs(request); + + assertEquals(2, result.getTotal()); + assertEquals("LOGIN", result.getRecords().get(0).getLogType()); + } + + @Test + void pageLogs_withFilters_shouldApplyAllConditions() { + Page page = new Page<>(1, 10); + page.setRecords(Arrays.asList()); + page.setTotal(0); + + when(logMapper.selectPage(any(Page.class), any(LambdaQueryWrapper.class))).thenReturn(page); + + LogQueryRequest request = new LogQueryRequest(); + request.setLogType("OPERATE"); + request.setUsername("admin"); + request.setModule("系统管理"); + request.setStatus(1); + request.setStartTime("2024-01-01"); + request.setEndTime("2024-12-31"); + + IPage result = logService.pageLogs(request); + + assertNotNull(result); + verify(logMapper).selectPage(any(Page.class), any(LambdaQueryWrapper.class)); + } + + @Test + void saveLog_shouldInsert() { + SysLog log = new SysLog(); + log.setLogType("LOGIN"); + log.setUsername("testuser"); + log.setIp("127.0.0.1"); + + logService.saveLog(log); + + verify(logMapper).insert(log); + } +} diff --git a/wm-system/src/test/java/com/water/system/service/RoleServiceImplTest.java b/wm-system/src/test/java/com/water/system/service/RoleServiceImplTest.java new file mode 100644 index 00000000..11dc631e --- /dev/null +++ b/wm-system/src/test/java/com/water/system/service/RoleServiceImplTest.java @@ -0,0 +1,115 @@ +package com.water.system.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.water.common.core.exception.BusinessException; +import com.water.system.entity.SysRole; +import com.water.system.entity.dto.RoleRequest; +import com.water.system.mapper.SysRoleMapper; +import com.water.system.service.impl.RoleServiceImpl; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +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.Arrays; +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 RoleServiceImplTest { + + @Mock + private SysRoleMapper roleMapper; + + @InjectMocks + private RoleServiceImpl roleService; + + private final ObjectMapper objectMapper = new ObjectMapper(); + + @BeforeEach + void setUp() { + // ObjectMapper is final, inject manually via reflection or just let it be used + } + + @Test + void listRoles_shouldReturnAllRoles() { + SysRole admin = new SysRole(); + admin.setId(1L); + admin.setRoleCode("SUPER_ADMIN"); + admin.setLevel(1); + + SysRole user = new SysRole(); + user.setId(4L); + user.setRoleCode("EMPLOYEE"); + user.setLevel(4); + + when(roleMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(Arrays.asList(admin, user)); + + List roles = roleService.listRoles(); + + assertEquals(2, roles.size()); + assertEquals("SUPER_ADMIN", roles.get(0).getRoleCode()); + } + + @Test + void createRole_shouldSucceed() { + RoleRequest request = new RoleRequest(); + request.setRoleCode("TEST_ROLE"); + request.setRoleName("测试角色"); + request.setLevel(3); + request.setPermissions(Arrays.asList("user:read", "user:write")); + + when(roleMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L); + when(roleMapper.insert(any(SysRole.class))).thenAnswer(inv -> { + SysRole r = inv.getArgument(0); + r.setId(10L); + return 1; + }); + + Long id = roleService.createRole(request); + + assertEquals(10L, id); + verify(roleMapper).insert(any(SysRole.class)); + } + + @Test + void createRole_shouldFailOnDuplicateCode() { + RoleRequest request = new RoleRequest(); + request.setRoleCode("SUPER_ADMIN"); + request.setRoleName("重复角色"); + request.setLevel(1); + + when(roleMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(1L); + + assertThrows(BusinessException.class, () -> roleService.createRole(request)); + } + + @Test + void deleteRole_shouldFailForAdminRoles() { + SysRole admin = new SysRole(); + admin.setId(1L); + admin.setLevel(1); + admin.setRoleCode("SUPER_ADMIN"); + + when(roleMapper.selectById(1L)).thenReturn(admin); + + assertThrows(BusinessException.class, () -> roleService.deleteRole(1L)); + } + + @Test + void deleteRole_shouldSucceedForNormalRoles() { + SysRole role = new SysRole(); + role.setId(5L); + role.setLevel(4); + role.setRoleCode("EMPLOYEE"); + + when(roleMapper.selectById(5L)).thenReturn(role); + + assertDoesNotThrow(() -> roleService.deleteRole(5L)); + verify(roleMapper).deleteById(5L); + } +} diff --git a/wm-system/src/test/java/com/water/system/service/UserServiceImplTest.java b/wm-system/src/test/java/com/water/system/service/UserServiceImplTest.java new file mode 100644 index 00000000..ee063590 --- /dev/null +++ b/wm-system/src/test/java/com/water/system/service/UserServiceImplTest.java @@ -0,0 +1,120 @@ +package com.water.system.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.common.core.exception.BusinessException; +import com.water.system.entity.SysUser; +import com.water.system.entity.dto.UserCreateRequest; +import com.water.system.entity.dto.UserUpdateRequest; +import com.water.system.mapper.SysUserMapper; +import com.water.system.service.impl.UserServiceImpl; +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.Arrays; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class UserServiceImplTest { + + @Mock + private SysUserMapper userMapper; + + @InjectMocks + private UserServiceImpl userService; + + @Test + void createUser_shouldSucceed() { + UserCreateRequest request = new UserCreateRequest(); + request.setUsername("testuser"); + request.setPassword("test123"); + request.setRealName("测试用户"); + request.setPhone("13800138000"); + + when(userMapper.selectByUsername("testuser")).thenReturn(null); + when(userMapper.insert(any(SysUser.class))).thenAnswer(inv -> { + SysUser u = inv.getArgument(0); + u.setId(100L); + return 1; + }); + + Long id = userService.createUser(request); + + assertEquals(100L, id); + verify(userMapper).insert(any(SysUser.class)); + } + + @Test + void createUser_shouldFailOnDuplicateUsername() { + UserCreateRequest request = new UserCreateRequest(); + request.setUsername("admin"); + request.setPassword("pass"); + + SysUser existing = new SysUser(); + existing.setUsername("admin"); + when(userMapper.selectByUsername("admin")).thenReturn(existing); + + assertThrows(BusinessException.class, () -> userService.createUser(request)); + } + + @Test + void updateStatus_shouldSucceed() { + SysUser user = new SysUser(); + user.setId(1L); + user.setStatus(1); + when(userMapper.selectById(1L)).thenReturn(user); + + userService.updateStatus(1L, 0); + + verify(userMapper).updateById(argThat(u -> u.getStatus() == 0)); + } + + @Test + void deleteUser_shouldFailForAdmin() { + SysUser admin = new SysUser(); + admin.setId(1L); + admin.setUsername("admin"); + when(userMapper.selectById(1L)).thenReturn(admin); + + assertThrows(BusinessException.class, () -> userService.deleteUser(1L)); + } + + @Test + void resetPassword_shouldSucceed() { + SysUser user = new SysUser(); + user.setId(5L); + user.setUsername("testuser"); + when(userMapper.selectById(5L)).thenReturn(user); + + assertDoesNotThrow(() -> userService.resetPassword(5L, "newPass123")); + verify(userMapper).updateById(argThat(u -> u.getPassword() != null)); + } + + @Test + void pageUsers_shouldReturnPagedResult() { + Page page = new Page<>(1, 10); + SysUser user1 = new SysUser(); + user1.setId(1L); + user1.setUsername("user1"); + user1.setPassword("hashed"); + SysUser user2 = new SysUser(); + user2.setId(2L); + user2.setUsername("user2"); + user2.setPassword("hashed"); + page.setRecords(Arrays.asList(user1, user2)); + page.setTotal(2); + + when(userMapper.selectPage(any(Page.class), any(LambdaQueryWrapper.class))).thenReturn(page); + + IPage result = userService.pageUsers(1, 10, null, null, null); + + assertEquals(2, result.getTotal()); + // 密码应被清除 + assertNull(result.getRecords().get(0).getPassword()); + } +}