feat(wm-revenue): #52 电子发票管理+应收应付账务+欠费催缴

- Entity: Invoice, Receivable, Payable, Reconciliation, CollectionRecord
- Mapper: 5个MyBatis-Plus Mapper接口
- Service: InvoiceService(开具/查询/推送/红冲), AccountService(应收/应付/对账/结转), CollectionService(催缴/通知/统计)
- Controller: InvoiceController(8端点), AccountController(12端点), CollectionController(8端点)
- DDL: V_invoice_account.sql(5张表+索引)
- Test: InvoiceAccountTest(16个测试用例)

db/postgresql/V_invoice_account.sql

@@ -0,0 +1,155 @@
+-- =============================================
+-- 智慧水务管理系统 - 电子发票 + 应收应付 + 催缴 DDL
+-- 版本: V_invoice_account
+-- =============================================
+
+-- 电子发票表
+CREATE TABLE IF NOT EXISTS rev_invoice (
+    id BIGSERIAL PRIMARY KEY,
+    invoice_no VARCHAR(30) UNIQUE NOT NULL,
+    invoice_type VARCHAR(20) NOT NULL DEFAULT 'electronic',  -- normal/special/electronic
+    customer_id BIGINT NOT NULL,
+    customer_name VARCHAR(100),
+    customer_tax_no VARCHAR(30),
+    amount DECIMAL(12,2) NOT NULL,
+    tax_rate DECIMAL(5,2) DEFAULT 6.00,
+    tax_amount DECIMAL(12,2) NOT NULL,
+    total_amount DECIMAL(12,2) NOT NULL,
+    content VARCHAR(500),
+    bill_id BIGINT,
+    status VARCHAR(20) NOT NULL DEFAULT 'draft',             -- draft/issued/sent/cancelled/red
+    issue_date DATE,
+    push_status VARCHAR(20) DEFAULT 'none',                  -- none/email/sms/both
+    push_time TIMESTAMP,
+    email VARCHAR(100),
+    phone VARCHAR(20),
+    cancel_reason VARCHAR(500),
+    original_invoice_id BIGINT,                              -- 红冲关联的原发票
+    operator_id BIGINT,
+    operator_name VARCHAR(50),
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_invoice IS '电子发票表';
+CREATE INDEX IF NOT EXISTS idx_invoice_customer ON rev_invoice(customer_id);
+CREATE INDEX IF NOT EXISTS idx_invoice_bill ON rev_invoice(bill_id);
+CREATE INDEX IF NOT EXISTS idx_invoice_status ON rev_invoice(status);
+CREATE INDEX IF NOT EXISTS idx_invoice_issue_date ON rev_invoice(issue_date);
+
+-- 应收账款表
+CREATE TABLE IF NOT EXISTS rev_receivable (
+    id BIGSERIAL PRIMARY KEY,
+    receivable_no VARCHAR(30) UNIQUE NOT NULL,
+    bill_period VARCHAR(10) NOT NULL,                        -- 2026-06
+    customer_id BIGINT NOT NULL,
+    customer_name VARCHAR(100),
+    amount DECIMAL(12,2) NOT NULL,
+    received_amount DECIMAL(12,2) DEFAULT 0,
+    unreceived_amount DECIMAL(12,2) NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'pending',           -- pending/partial/completed/overdue/cancelled
+    bill_id BIGINT,
+    due_date DATE,
+    overdue_days INT DEFAULT 0,
+    collection_count INT DEFAULT 0,
+    last_collection_time TIMESTAMP,
+    operator_id BIGINT,
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_receivable IS '应收账款表';
+CREATE INDEX IF NOT EXISTS idx_receivable_customer ON rev_receivable(customer_id);
+CREATE INDEX IF NOT EXISTS idx_receivable_period ON rev_receivable(bill_period);
+CREATE INDEX IF NOT EXISTS idx_receivable_status ON rev_receivable(status);
+CREATE INDEX IF NOT EXISTS idx_receivable_due_date ON rev_receivable(due_date);
+
+-- 应付账款表
+CREATE TABLE IF NOT EXISTS rev_payable (
+    id BIGSERIAL PRIMARY KEY,
+    payable_no VARCHAR(30) UNIQUE NOT NULL,
+    bill_period VARCHAR(10) NOT NULL,                        -- 2026-06
+    supplier_id BIGINT NOT NULL,
+    supplier_name VARCHAR(100),
+    amount DECIMAL(12,2) NOT NULL,
+    paid_amount DECIMAL(12,2) DEFAULT 0,
+    unpaid_amount DECIMAL(12,2) NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'pending',           -- pending/partial/completed/cancelled
+    expense_type VARCHAR(30),                                -- electricity/chemical/maintenance/equipment/other
+    due_date DATE,
+    invoice_no VARCHAR(50),
+    contract_no VARCHAR(50),
+    operator_id BIGINT,
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_payable IS '应付账款表';
+CREATE INDEX IF NOT EXISTS idx_payable_supplier ON rev_payable(supplier_id);
+CREATE INDEX IF NOT EXISTS idx_payable_period ON rev_payable(bill_period);
+CREATE INDEX IF NOT EXISTS idx_payable_status ON rev_payable(status);
+CREATE INDEX IF NOT EXISTS idx_payable_due_date ON rev_payable(due_date);
+
+-- 对账记录表
+CREATE TABLE IF NOT EXISTS rev_reconciliation (
+    id BIGSERIAL PRIMARY KEY,
+    reconciliation_no VARCHAR(30) UNIQUE NOT NULL,
+    bill_period VARCHAR(10) NOT NULL,
+    reconciliation_type VARCHAR(20) DEFAULT 'all',           -- receivable/payable/all
+    total_receivable DECIMAL(14,2) DEFAULT 0,
+    total_received DECIMAL(14,2) DEFAULT 0,
+    total_payable DECIMAL(14,2) DEFAULT 0,
+    total_paid DECIMAL(14,2) DEFAULT 0,
+    difference DECIMAL(14,2) DEFAULT 0,
+    status VARCHAR(20) NOT NULL DEFAULT 'draft',             -- draft/pending/approved/rejected/completed
+    start_date DATE,
+    end_date DATE,
+    exception_count INT DEFAULT 0,
+    exception_note TEXT,
+    auditor_id BIGINT,
+    auditor_name VARCHAR(50),
+    audit_time TIMESTAMP,
+    operator_id BIGINT,
+    operator_name VARCHAR(50),
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_reconciliation IS '对账记录表';
+CREATE INDEX IF NOT EXISTS idx_reconciliation_period ON rev_reconciliation(bill_period);
+CREATE INDEX IF NOT EXISTS idx_reconciliation_status ON rev_reconciliation(status);
+
+-- 催缴记录表
+CREATE TABLE IF NOT EXISTS rev_collection_record (
+    id BIGSERIAL PRIMARY KEY,
+    collection_no VARCHAR(30) UNIQUE NOT NULL,
+    customer_id BIGINT NOT NULL,
+    customer_name VARCHAR(100),
+    overdue_amount DECIMAL(12,2) NOT NULL,
+    overdue_days INT DEFAULT 0,
+    collection_type VARCHAR(20) NOT NULL,                    -- sms/phone/visit/letter
+    collection_result VARCHAR(20),                           -- success/promised/failed/unreachable/refused
+    contact_person VARCHAR(50),
+    contact_phone VARCHAR(20),
+    contact_email VARCHAR(100),
+    collection_time TIMESTAMP,
+    promised_date DATE,
+    collector_id BIGINT,
+    collector_name VARCHAR(50),
+    receivable_id BIGINT,
+    remark VARCHAR(500),
+    status VARCHAR(20) DEFAULT 'pending',                    -- pending/in_progress/completed/cancelled
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_collection_record IS '催缴记录表';
+CREATE INDEX IF NOT EXISTS idx_collection_customer ON rev_collection_record(customer_id);
+CREATE INDEX IF NOT EXISTS idx_collection_receivable ON rev_collection_record(receivable_id);
+CREATE INDEX IF NOT EXISTS idx_collection_status ON rev_collection_record(status);
+CREATE INDEX IF NOT EXISTS idx_collection_time ON rev_collection_record(collection_time);
+CREATE INDEX IF NOT EXISTS idx_collection_type ON rev_collection_record(collection_type);

wm-revenue/src/main/java/com/water/revenue/controller/AccountController.java

@@ -0,0 +1,161 @@
+package com.water.revenue.controller;
+
+import com.water.common.core.result.R;
+import com.water.revenue.entity.Payable;
+import com.water.revenue.entity.Receivable;
+import com.water.revenue.entity.Reconciliation;
+import com.water.revenue.service.AccountService;
+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.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应收应付账务管理接口
+ */
+@Tag(name = "应收应付账务管理")
+@RestController
+@RequestMapping("/api/revenue/account")
+@RequiredArgsConstructor
+public class AccountController {
+
+    private final AccountService accountService;
+
+    // ==================== 应收账款 ====================
+
+    @Operation(summary = "创建应收账款")
+    @PostMapping("/receivable")
+    public R<Receivable> createReceivable(@RequestBody Map<String, Object> req) {
+        Receivable receivable = accountService.createReceivable(
+                (String) req.get("billPeriod"),
+                Long.parseLong(String.valueOf(req.get("customerId"))),
+                (String) req.get("customerName"),
+                new BigDecimal(String.valueOf(req.get("amount"))),
+                req.get("billId") != null ? Long.parseLong(String.valueOf(req.get("billId"))) : null,
+                req.get("dueDate") != null ? LocalDate.parse((String) req.get("dueDate")) : null,
+                req.get("operatorId") != null ? Long.parseLong(String.valueOf(req.get("operatorId"))) : 1L,
+                (String) req.get("remark")
+        );
+        return R.ok(receivable);
+    }
+
+    @Operation(summary = "应收收款登记")
+    @PostMapping("/receivable/{id}/receive")
+    public R<Receivable> receivePayment(
+            @PathVariable Long id,
+            @RequestBody Map<String, Object> req) {
+        return R.ok(accountService.receivePayment(id, new BigDecimal(String.valueOf(req.get("amount")))));
+    }
+
+    @Operation(summary = "查询客户应收列表")
+    @GetMapping("/receivable/customer/{customerId}")
+    public R<List<Receivable>> listReceivableByCustomer(@PathVariable Long customerId) {
+        return R.ok(accountService.listReceivableByCustomer(customerId));
+    }
+
+    @Operation(summary = "按账期查询应收")
+    @GetMapping("/receivable/period/{billPeriod}")
+    public R<List<Receivable>> listReceivableByPeriod(@PathVariable String billPeriod) {
+        return R.ok(accountService.listReceivableByPeriod(billPeriod));
+    }
+
+    @Operation(summary = "查询逾期应收")
+    @GetMapping("/receivable/overdue")
+    public R<List<Receivable>> listOverdueReceivables() {
+        return R.ok(accountService.listOverdueReceivables());
+    }
+
+    // ==================== 应付账款 ====================
+
+    @Operation(summary = "创建应付账款")
+    @PostMapping("/payable")
+    public R<Payable> createPayable(@RequestBody Map<String, Object> req) {
+        Payable payable = accountService.createPayable(
+                (String) req.get("billPeriod"),
+                Long.parseLong(String.valueOf(req.get("supplierId"))),
+                (String) req.get("supplierName"),
+                new BigDecimal(String.valueOf(req.get("amount"))),
+                (String) req.get("expenseType"),
+                req.get("dueDate") != null ? LocalDate.parse((String) req.get("dueDate")) : null,
+                (String) req.get("invoiceNo"),
+                (String) req.get("contractNo"),
+                req.get("operatorId") != null ? Long.parseLong(String.valueOf(req.get("operatorId"))) : 1L,
+                (String) req.get("remark")
+        );
+        return R.ok(payable);
+    }
+
+    @Operation(summary = "应付付款登记")
+    @PostMapping("/payable/{id}/pay")
+    public R<Payable> makePayment(
+            @PathVariable Long id,
+            @RequestBody Map<String, Object> req) {
+        return R.ok(accountService.makePayment(id, new BigDecimal(String.valueOf(req.get("amount")))));
+    }
+
+    @Operation(summary = "按供应商查询应付")
+    @GetMapping("/payable/supplier/{supplierId}")
+    public R<List<Payable>> listPayableBySupplier(@PathVariable Long supplierId) {
+        return R.ok(accountService.listPayableBySupplier(supplierId));
+    }
+
+    @Operation(summary = "按账期查询应付")
+    @GetMapping("/payable/period/{billPeriod}")
+    public R<List<Payable>> listPayableByPeriod(@PathVariable String billPeriod) {
+        return R.ok(accountService.listPayableByPeriod(billPeriod));
+    }
+
+    // ==================== 对账与结转 ====================
+
+    @Operation(summary = "创建月度对账")
+    @PostMapping("/reconciliation")
+    public R<Reconciliation> createReconciliation(@RequestBody Map<String, Object> req) {
+        return R.ok(accountService.createReconciliation(
+                (String) req.get("billPeriod"),
+                (String) req.get("reconciliationType"),
+                req.get("operatorId") != null ? Long.parseLong(String.valueOf(req.get("operatorId"))) : 1L,
+                (String) req.getOrDefault("operatorName", "系统")
+        ));
+    }
+
+    @Operation(summary = "审核对账单")
+    @PostMapping("/reconciliation/{id}/audit")
+    public R<Reconciliation> auditReconciliation(
+            @PathVariable Long id,
+            @RequestBody Map<String, Object> req) {
+        return R.ok(accountService.auditReconciliation(
+                id,
+                Boolean.parseBoolean(String.valueOf(req.get("approved"))),
+                req.get("auditorId") != null ? Long.parseLong(String.valueOf(req.get("auditorId"))) : 1L,
+                (String) req.getOrDefault("auditorName", "审核员"),
+                (String) req.get("remark")
+        ));
+    }
+
+    @Operation(summary = "查询对账单列表")
+    @GetMapping("/reconciliation/list")
+    public R<List<Reconciliation>> listReconciliations(
+            @RequestParam(required = false) String billPeriod) {
+        return R.ok(accountService.listReconciliations(billPeriod));
+    }
+
+    @Operation(summary = "结转处理")
+    @PostMapping("/carry-forward")
+    public R<Map<String, Object>> carryForward(@RequestBody Map<String, Object> req) {
+        return R.ok(accountService.carryForward(
+                (String) req.get("billPeriod"),
+                req.get("operatorId") != null ? Long.parseLong(String.valueOf(req.get("operatorId"))) : 1L
+        ));
+    }
+
+    @Operation(summary = "应收应付汇总统计")
+    @GetMapping("/summary")
+    public R<Map<String, Object>> summary(@RequestParam String billPeriod) {
+        return R.ok(accountService.summary(billPeriod));
+    }
+}

wm-revenue/src/main/java/com/water/revenue/controller/CollectionController.java

@@ -0,0 +1,106 @@
+package com.water.revenue.controller;
+
+import com.water.common.core.result.R;
+import com.water.revenue.entity.CollectionRecord;
+import com.water.revenue.entity.Receivable;
+import com.water.revenue.service.CollectionService;
+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.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 欠费催缴管理接口
+ */
+@Tag(name = "欠费催缴管理")
+@RestController
+@RequestMapping("/api/revenue/collection")
+@RequiredArgsConstructor
+public class CollectionController {
+
+    private final CollectionService collectionService;
+
+    @Operation(summary = "查询欠费列表")
+    @GetMapping("/overdue")
+    public R<List<Receivable>> queryOverdueAccounts() {
+        return R.ok(collectionService.queryOverdueAccounts());
+    }
+
+    @Operation(summary = "查询客户欠费")
+    @GetMapping("/overdue/customer/{customerId}")
+    public R<List<Receivable>> queryCustomerOverdue(@PathVariable Long customerId) {
+        return R.ok(collectionService.queryCustomerOverdue(customerId));
+    }
+
+    @Operation(summary = "创建催缴记录")
+    @PostMapping("/record")
+    public R<CollectionRecord> createCollection(@RequestBody Map<String, Object> req) {
+        CollectionRecord record = collectionService.createCollection(
+                Long.parseLong(String.valueOf(req.get("customerId"))),
+                (String) req.get("customerName"),
+                new BigDecimal(String.valueOf(req.get("overdueAmount"))),
+                req.get("overdueDays") != null ? Integer.parseInt(String.valueOf(req.get("overdueDays"))) : null,
+                (String) req.get("collectionType"),
+                (String) req.get("contactPerson"),
+                (String) req.get("contactPhone"),
+                (String) req.get("contactEmail"),
+                req.get("receivableId") != null ? Long.parseLong(String.valueOf(req.get("receivableId"))) : null,
+                req.get("collectorId") != null ? Long.parseLong(String.valueOf(req.get("collectorId"))) : 1L,
+                (String) req.getOrDefault("collectorName", "系统"),
+                (String) req.get("remark")
+        );
+        return R.ok(record);
+    }
+
+    @Operation(summary = "发送催缴通知")
+    @PostMapping("/notify/{collectionId}")
+    public R<Map<String, Object>> sendNotification(@PathVariable Long collectionId) {
+        return R.ok(collectionService.sendNotification(collectionId));
+    }
+
+    @Operation(summary = "更新催缴结果")
+    @PutMapping("/record/{id}/result")
+    public R<CollectionRecord> updateResult(
+            @PathVariable Long id,
+            @RequestBody Map<String, Object> req) {
+        return R.ok(collectionService.updateResult(
+                id,
+                (String) req.get("collectionResult"),
+                req.get("promisedDate") != null ? LocalDate.parse((String) req.get("promisedDate")) : null,
+                (String) req.get("remark")
+        ));
+    }
+
+    @Operation(summary = "查询客户催缴记录")
+    @GetMapping("/record/customer/{customerId}")
+    public R<List<CollectionRecord>> listByCustomer(@PathVariable Long customerId) {
+        return R.ok(collectionService.listByCustomer(customerId));
+    }
+
+    @Operation(summary = "查询应收催缴记录")
+    @GetMapping("/record/receivable/{receivableId}")
+    public R<List<CollectionRecord>> listByReceivable(@PathVariable Long receivableId) {
+        return R.ok(collectionService.listByReceivable(receivableId));
+    }
+
+    @Operation(summary = "分页查询催缴记录")
+    @GetMapping("/record/list")
+    public R<List<CollectionRecord>> listRecords(
+            @RequestParam(required = false) String status,
+            @RequestParam(required = false) String collectionType,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        return R.ok(collectionService.listRecords(status, collectionType, page, size));
+    }
+
+    @Operation(summary = "催缴统计")
+    @GetMapping("/statistics")
+    public R<Map<String, Object>> statistics(@RequestParam(defaultValue = "30") Integer days) {
+        return R.ok(collectionService.statistics(days));
+    }
+}

wm-revenue/src/main/java/com/water/revenue/controller/InvoiceController.java

@@ -0,0 +1,103 @@
+package com.water.revenue.controller;
+
+import com.water.common.core.result.R;
+import com.water.revenue.entity.Invoice;
+import com.water.revenue.service.InvoiceService;
+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.List;
+import java.util.Map;
+
+/**
+ * 电子发票管理接口
+ */
+@Tag(name = "电子发票管理")
+@RestController
+@RequestMapping("/api/revenue/invoice")
+@RequiredArgsConstructor
+public class InvoiceController {
+
+    private final InvoiceService invoiceService;
+
+    @Operation(summary = "开具发票")
+    @PostMapping("/issue")
+    public R<Invoice> issueInvoice(@RequestBody Map<String, Object> req) {
+        Invoice invoice = invoiceService.issueInvoice(
+                Long.parseLong(String.valueOf(req.get("customerId"))),
+                (String) req.get("customerName"),
+                (String) req.get("customerTaxNo"),
+                new BigDecimal(String.valueOf(req.get("amount"))),
+                req.get("taxRate") != null ? new BigDecimal(String.valueOf(req.get("taxRate"))) : BigDecimal.valueOf(6),
+                (String) req.get("invoiceType"),
+                (String) req.get("content"),
+                req.get("billId") != null ? Long.parseLong(String.valueOf(req.get("billId"))) : null,
+                (String) req.get("email"),
+                (String) req.get("phone"),
+                req.get("operatorId") != null ? Long.parseLong(String.valueOf(req.get("operatorId"))) : 1L,
+                (String) req.getOrDefault("operatorName", "系统")
+        );
+        return R.ok(invoice);
+    }
+
+    @Operation(summary = "按发票号查询")
+    @GetMapping("/{invoiceNo}")
+    public R<Invoice> getByInvoiceNo(@PathVariable String invoiceNo) {
+        return R.ok(invoiceService.getByInvoiceNo(invoiceNo));
+    }
+
+    @Operation(summary = "查询客户发票列表")
+    @GetMapping("/customer/{customerId}")
+    public R<List<Invoice>> listByCustomer(@PathVariable Long customerId) {
+        return R.ok(invoiceService.listByCustomerId(customerId));
+    }
+
+    @Operation(summary = "按账单ID查询发票")
+    @GetMapping("/bill/{billId}")
+    public R<List<Invoice>> listByBill(@PathVariable Long billId) {
+        return R.ok(invoiceService.listByBillId(billId));
+    }
+
+    @Operation(summary = "分页查询发票")
+    @GetMapping("/list")
+    public R<List<Invoice>> list(
+            @RequestParam(required = false) String status,
+            @RequestParam(required = false) String invoiceType,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        return R.ok(invoiceService.listInvoices(status, invoiceType, page, size));
+    }
+
+    @Operation(summary = "推送发票")
+    @PostMapping("/push/{invoiceId}")
+    public R<Map<String, Object>> pushInvoice(
+            @PathVariable Long invoiceId,
+            @RequestParam(defaultValue = "email") String pushType) {
+        return R.ok(invoiceService.pushInvoice(invoiceId, pushType));
+    }
+
+    @Operation(summary = "红冲/作废发票")
+    @PostMapping("/red-flush/{invoiceId}")
+    public R<Invoice> redFlush(
+            @PathVariable Long invoiceId,
+            @RequestBody Map<String, Object> req) {
+        Invoice redInvoice = invoiceService.redFlush(
+                invoiceId,
+                (String) req.get("reason"),
+                req.get("operatorId") != null ? Long.parseLong(String.valueOf(req.get("operatorId"))) : 1L,
+                (String) req.getOrDefault("operatorName", "系统")
+        );
+        return R.ok(redInvoice);
+    }
+
+    @Operation(summary = "发票统计")
+    @GetMapping("/statistics")
+    public R<Map<String, Object>> statistics(
+            @RequestParam(required = false) String startDate,
+            @RequestParam(required = false) String endDate) {
+        return R.ok(invoiceService.statistics(startDate, endDate));
+    }
+}

wm-revenue/src/main/java/com/water/revenue/entity/CollectionRecord.java

@@ -0,0 +1,77 @@
+package com.water.revenue.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 欠费催缴记录实体
+ */
+@Data
+@TableName("rev_collection_record")
+public class CollectionRecord {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 催缴单号 */
+    private String collectionNo;
+
+    /** 客户ID */
+    private Long customerId;
+
+    /** 客户名称 */
+    private String customerName;
+
+    /** 欠费金额 */
+    private BigDecimal overdueAmount;
+
+    /** 逾期天数 */
+    private Integer overdueDays;
+
+    /** 催缴类型：sms-短信 phone-电话 visit-上门 letter-催缴函 */
+    private String collectionType;
+
+    /** 催缴结果：success-成功（已缴费） promised-承诺缴费 failed-失败 unreachable-无法联系 refused-拒缴 */
+    private String collectionResult;
+
+    /** 联系人 */
+    private String contactPerson;
+
+    /** 联系电话 */
+    private String contactPhone;
+
+    /** 联系邮箱 */
+    private String contactEmail;
+
+    /** 催缴时间 */
+    private LocalDateTime collectionTime;
+
+    /** 承诺缴费日期 */
+    private LocalDate promisedDate;
+
+    /** 催缴人ID */
+    private Long collectorId;
+
+    /** 催缴人名称 */
+    private String collectorName;
+
+    /** 应收单ID（关联应收账款） */
+    private Long receivableId;
+
+    /** 催缴备注 */
+    private String remark;
+
+    /** 状态：pending-待处理 in_progress-处理中 completed-已完成 cancelled-已取消 */
+    private String status;
+
+    @TableLogic
+    private Integer deleted;
+
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+}

wm-revenue/src/main/java/com/water/revenue/entity/Invoice.java

@@ -0,0 +1,92 @@
+package com.water.revenue.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 电子发票实体
+ */
+@Data
+@TableName("rev_invoice")
+public class Invoice {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 发票号码 */
+    private String invoiceNo;
+
+    /** 发票类型：normal-普通发票 special-专用发票 electronic-电子发票 */
+    private String invoiceType;
+
+    /** 客户ID */
+    private Long customerId;
+
+    /** 客户名称 */
+    private String customerName;
+
+    /** 客户税号 */
+    private String customerTaxNo;
+
+    /** 不含税金额 */
+    private BigDecimal amount;
+
+    /** 税率 */
+    private BigDecimal taxRate;
+
+    /** 税额 */
+    private BigDecimal taxAmount;
+
+    /** 含税总额 */
+    private BigDecimal totalAmount;
+
+    /** 发票内容描述 */
+    private String content;
+
+    /** 账单ID（关联水费账单） */
+    private Long billId;
+
+    /** 状态：draft-草稿 issued-已开具 sent-已推送 cancelled-已作废 red-已红冲 */
+    private String status;
+
+    /** 开票日期 */
+    private LocalDate issueDate;
+
+    /** 推送状态：none-未推送 email-邮件推送 sms-短信推送 both-邮件+短信 */
+    private String pushStatus;
+
+    /** 推送时间 */
+    private LocalDateTime pushTime;
+
+    /** 接收邮箱 */
+    private String email;
+
+    /** 接收手机号 */
+    private String phone;
+
+    /** 红冲原因 */
+    private String cancelReason;
+
+    /** 原发票ID（红冲时关联） */
+    private Long originalInvoiceId;
+
+    /** 操作人ID */
+    private Long operatorId;
+
+    /** 操作人名称 */
+    private String operatorName;
+
+    /** 备注 */
+    private String remark;
+
+    @TableLogic
+    private Integer deleted;
+
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+}

wm-revenue/src/main/java/com/water/revenue/entity/Payable.java

@@ -0,0 +1,68 @@
+package com.water.revenue.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 应付账款实体
+ */
+@Data
+@TableName("rev_payable")
+public class Payable {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 应付单号 */
+    private String payableNo;
+
+    /** 账期（如 2026-06） */
+    private String billPeriod;
+
+    /** 供应商ID */
+    private Long supplierId;
+
+    /** 供应商名称 */
+    private String supplierName;
+
+    /** 应付金额 */
+    private BigDecimal amount;
+
+    /** 已付金额 */
+    private BigDecimal paidAmount;
+
+    /** 未付金额 */
+    private BigDecimal unpaidAmount;
+
+    /** 状态：pending-待付款 partial-部分付款 completed-已付清 cancelled-已取消 */
+    private String status;
+
+    /** 费用类型：electricity-电费 chemical-药剂费 maintenance-维修费 equipment-设备费 other-其他 */
+    private String expenseType;
+
+    /** 到期日 */
+    private LocalDate dueDate;
+
+    /** 发票号 */
+    private String invoiceNo;
+
+    /** 合同编号 */
+    private String contractNo;
+
+    /** 操作人ID */
+    private Long operatorId;
+
+    /** 备注 */
+    private String remark;
+
+    @TableLogic
+    private Integer deleted;
+
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+}

wm-revenue/src/main/java/com/water/revenue/entity/Receivable.java

@@ -0,0 +1,71 @@
+package com.water.revenue.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 应收账款实体
+ */
+@Data
+@TableName("rev_receivable")
+public class Receivable {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 应收单号 */
+    private String receivableNo;
+
+    /** 账期（如 2026-06） */
+    private String billPeriod;
+
+    /** 客户ID */
+    private Long customerId;
+
+    /** 客户名称 */
+    private String customerName;
+
+    /** 应收金额 */
+    private BigDecimal amount;
+
+    /** 已收金额 */
+    private BigDecimal receivedAmount;
+
+    /** 未收金额 */
+    private BigDecimal unreceivedAmount;
+
+    /** 状态：pending-待收款 partial-部分收款 completed-已收清 overdue-逾期 cancelled-已取消 */
+    private String status;
+
+    /** 账单ID（关联水费账单） */
+    private Long billId;
+
+    /** 到期日 */
+    private LocalDate dueDate;
+
+    /** 逾期天数 */
+    private Integer overdueDays;
+
+    /** 催缴次数 */
+    private Integer collectionCount;
+
+    /** 最后催缴时间 */
+    private LocalDateTime lastCollectionTime;
+
+    /** 操作人ID */
+    private Long operatorId;
+
+    /** 备注 */
+    private String remark;
+
+    @TableLogic
+    private Integer deleted;
+
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+}

wm-revenue/src/main/java/com/water/revenue/entity/Reconciliation.java

@@ -0,0 +1,83 @@
+package com.water.revenue.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 对账记录实体
+ */
+@Data
+@TableName("rev_reconciliation")
+public class Reconciliation {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 对账单号 */
+    private String reconciliationNo;
+
+    /** 对账账期（如 2026-06） */
+    private String billPeriod;
+
+    /** 对账类型：receivable-应收对账 payable-应付对账 all-综合对账 */
+    private String reconciliationType;
+
+    /** 应收总额 */
+    private BigDecimal totalReceivable;
+
+    /** 实收总额 */
+    private BigDecimal totalReceived;
+
+    /** 应付总额 */
+    private BigDecimal totalPayable;
+
+    /** 实付总额 */
+    private BigDecimal totalPaid;
+
+    /** 差额 */
+    private BigDecimal difference;
+
+    /** 状态：draft-草稿 pending-待审核 approved-已审核 rejected-已驳回 completed-已完成 */
+    private String status;
+
+    /** 对账开始日期 */
+    private LocalDate startDate;
+
+    /** 对账结束日期 */
+    private LocalDate endDate;
+
+    /** 异常笔数 */
+    private Integer exceptionCount;
+
+    /** 异常说明 */
+    private String exceptionNote;
+
+    /** 审核人ID */
+    private Long auditorId;
+
+    /** 审核人名称 */
+    private String auditorName;
+
+    /** 审核时间 */
+    private LocalDateTime auditTime;
+
+    /** 操作人ID */
+    private Long operatorId;
+
+    /** 操作人名称 */
+    private String operatorName;
+
+    /** 备注 */
+    private String remark;
+
+    @TableLogic
+    private Integer deleted;
+
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+}

wm-revenue/src/main/java/com/water/revenue/mapper/CollectionRecordMapper.java

@@ -0,0 +1,27 @@
+package com.water.revenue.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.revenue.entity.CollectionRecord;
+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 CollectionRecordMapper extends BaseMapper<CollectionRecord> {
+
+    @Select("SELECT * FROM rev_collection_record WHERE customer_id = #{customerId} ORDER BY collection_time DESC")
+    List<CollectionRecord> selectByCustomerId(@Param("customerId") Long customerId);
+
+    @Select("SELECT * FROM rev_collection_record WHERE receivable_id = #{receivableId} ORDER BY collection_time DESC")
+    List<CollectionRecord> selectByReceivableId(@Param("receivableId") Long receivableId);
+
+    @Select("SELECT collection_type, COUNT(*) as count, SUM(CASE WHEN collection_result = 'success' THEN 1 ELSE 0 END) as success_count FROM rev_collection_record WHERE collection_time >= #{startTime} GROUP BY collection_type")
+    List<Map<String, Object>> selectStatistics(@Param("startTime") java.time.LocalDateTime startTime);
+
+    @Update("UPDATE rev_collection_record SET status = #{status}, collection_result = #{result} WHERE id = #{id}")
+    int updateResult(@Param("id") Long id, @Param("status") String status, @Param("result") String result);
+}

wm-revenue/src/main/java/com/water/revenue/mapper/InvoiceMapper.java

@@ -0,0 +1,26 @@
+package com.water.revenue.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.revenue.entity.Invoice;
+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 InvoiceMapper extends BaseMapper<Invoice> {
+
+    @Select("SELECT * FROM rev_invoice WHERE customer_id = #{customerId} AND status != 'cancelled' ORDER BY created_at DESC")
+    List<Invoice> selectByCustomerId(@Param("customerId") Long customerId);
+
+    @Select("SELECT * FROM rev_invoice WHERE invoice_no = #{invoiceNo} LIMIT 1")
+    Invoice selectByInvoiceNo(@Param("invoiceNo") String invoiceNo);
+
+    @Select("SELECT * FROM rev_invoice WHERE bill_id = #{billId} AND status NOT IN ('cancelled', 'red') ORDER BY created_at DESC")
+    List<Invoice> selectByBillId(@Param("billId") Long billId);
+
+    @Update("UPDATE rev_invoice SET status = #{status}, push_status = #{pushStatus}, push_time = NOW() WHERE id = #{id}")
+    int updatePushStatus(@Param("id") Long id, @Param("status") String status, @Param("pushStatus") String pushStatus);
+}

wm-revenue/src/main/java/com/water/revenue/mapper/PayableMapper.java

@@ -0,0 +1,24 @@
+package com.water.revenue.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.revenue.entity.Payable;
+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 PayableMapper extends BaseMapper<Payable> {
+
+    @Select("SELECT * FROM rev_payable WHERE supplier_id = #{supplierId} AND status NOT IN ('completed', 'cancelled') ORDER BY due_date ASC")
+    List<Payable> selectBySupplierId(@Param("supplierId") Long supplierId);
+
+    @Select("SELECT * FROM rev_payable WHERE bill_period = #{billPeriod} AND status NOT IN ('completed', 'cancelled') ORDER BY supplier_id")
+    List<Payable> selectByBillPeriod(@Param("billPeriod") String billPeriod);
+
+    @Update("UPDATE rev_payable SET paid_amount = #{paidAmount}, unpaid_amount = #{unpaidAmount}, status = #{status} WHERE id = #{id}")
+    int updateAmount(@Param("id") Long id, @Param("paidAmount") java.math.BigDecimal paidAmount,
+                     @Param("unpaidAmount") java.math.BigDecimal unpaidAmount, @Param("status") String status);
+}

wm-revenue/src/main/java/com/water/revenue/mapper/ReceivableMapper.java

@@ -0,0 +1,27 @@
+package com.water.revenue.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.revenue.entity.Receivable;
+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 ReceivableMapper extends BaseMapper<Receivable> {
+
+    @Select("SELECT * FROM rev_receivable WHERE customer_id = #{customerId} AND status NOT IN ('completed', 'cancelled') ORDER BY due_date ASC")
+    List<Receivable> selectOverdueByCustomerId(@Param("customerId") Long customerId);
+
+    @Select("SELECT * FROM rev_receivable WHERE bill_period = #{billPeriod} AND status NOT IN ('completed', 'cancelled') ORDER BY customer_id")
+    List<Receivable> selectByBillPeriod(@Param("billPeriod") String billPeriod);
+
+    @Select("SELECT * FROM rev_receivable WHERE status = 'overdue' ORDER BY overdue_days DESC")
+    List<Receivable> selectAllOverdue();
+
+    @Update("UPDATE rev_receivable SET received_amount = #{receivedAmount}, unreceived_amount = #{unreceivedAmount}, status = #{status} WHERE id = #{id}")
+    int updateAmount(@Param("id") Long id, @Param("receivedAmount") java.math.BigDecimal receivedAmount,
+                     @Param("unreceivedAmount") java.math.BigDecimal unreceivedAmount, @Param("status") String status);
+}

wm-revenue/src/main/java/com/water/revenue/mapper/ReconciliationMapper.java

@@ -0,0 +1,24 @@
+package com.water.revenue.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.revenue.entity.Reconciliation;
+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 ReconciliationMapper extends BaseMapper<Reconciliation> {
+
+    @Select("SELECT * FROM rev_reconciliation WHERE bill_period = #{billPeriod} ORDER BY created_at DESC")
+    List<Reconciliation> selectByBillPeriod(@Param("billPeriod") String billPeriod);
+
+    @Select("SELECT * FROM rev_reconciliation WHERE reconciliation_no = #{reconciliationNo} LIMIT 1")
+    Reconciliation selectByReconciliationNo(@Param("reconciliationNo") String reconciliationNo);
+
+    @Update("UPDATE rev_reconciliation SET status = #{status}, auditor_id = #{auditorId}, auditor_name = #{auditorName}, audit_time = NOW() WHERE id = #{id}")
+    int updateAuditStatus(@Param("id") Long id, @Param("status") String status,
+                          @Param("auditorId") Long auditorId, @Param("auditorName") String auditorName);
+}

wm-revenue/src/main/java/com/water/revenue/service/AccountService.java

@@ -0,0 +1,397 @@
+package com.water.revenue.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.common.core.exception.BusinessException;
+import com.water.revenue.entity.Payable;
+import com.water.revenue.entity.Receivable;
+import com.water.revenue.entity.Reconciliation;
+import com.water.revenue.mapper.PayableMapper;
+import com.water.revenue.mapper.ReceivableMapper;
+import com.water.revenue.mapper.ReconciliationMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * 应收应付账务服务
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class AccountService {
+
+    private final ReceivableMapper receivableMapper;
+    private final PayableMapper payableMapper;
+    private final ReconciliationMapper reconciliationMapper;
+
+    // ==================== 应收账款管理 ====================
+
+    /**
+     * 创建应收账款
+     */
+    @Transactional
+    public Receivable createReceivable(String billPeriod, Long customerId, String customerName,
+                                        BigDecimal amount, Long billId, LocalDate dueDate,
+                                        Long operatorId, String remark) {
+        if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new BusinessException("应收金额必须大于0");
+        }
+
+        Receivable receivable = new Receivable();
+        receivable.setReceivableNo(generateNo("RCV"));
+        receivable.setBillPeriod(billPeriod);
+        receivable.setCustomerId(customerId);
+        receivable.setCustomerName(customerName);
+        receivable.setAmount(amount);
+        receivable.setReceivedAmount(BigDecimal.ZERO);
+        receivable.setUnreceivedAmount(amount);
+        receivable.setStatus("pending");
+        receivable.setBillId(billId);
+        receivable.setDueDate(dueDate);
+        receivable.setOverdueDays(0);
+        receivable.setCollectionCount(0);
+        receivable.setOperatorId(operatorId);
+        receivable.setRemark(remark);
+        receivable.setDeleted(0);
+        receivable.setCreatedAt(LocalDateTime.now());
+        receivable.setUpdatedAt(LocalDateTime.now());
+
+        receivableMapper.insert(receivable);
+        log.info("Receivable created: {} amount={}", receivable.getReceivableNo(), amount);
+        return receivable;
+    }
+
+    /**
+     * 应收账款收款（登记收款）
+     */
+    @Transactional
+    public Receivable receivePayment(Long receivableId, BigDecimal receiveAmount) {
+        Receivable receivable = receivableMapper.selectById(receivableId);
+        if (receivable == null) {
+            throw new BusinessException("应收账款不存在");
+        }
+        if (receiveAmount == null || receiveAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new BusinessException("收款金额必须大于0");
+        }
+        if (receiveAmount.compareTo(receivable.getUnreceivedAmount()) > 0) {
+            throw new BusinessException("收款金额不能超过未收金额: " + receivable.getUnreceivedAmount());
+        }
+
+        BigDecimal newReceived = receivable.getReceivedAmount().add(receiveAmount);
+        BigDecimal newUnreceived = receivable.getUnreceivedAmount().subtract(receiveAmount);
+        String newStatus = newUnreceived.compareTo(BigDecimal.ZERO) <= 0 ? "completed" : "partial";
+
+        receivableMapper.updateAmount(receivableId, newReceived, newUnreceived, newStatus);
+        receivable.setReceivedAmount(newReceived);
+        receivable.setUnreceivedAmount(newUnreceived);
+        receivable.setStatus(newStatus);
+
+        log.info("Receivable payment received: {} amount={} status={}", receivable.getReceivableNo(), receiveAmount, newStatus);
+        return receivable;
+    }
+
+    /**
+     * 查询客户应收列表
+     */
+    public List<Receivable> listReceivableByCustomer(Long customerId) {
+        return receivableMapper.selectOverdueByCustomerId(customerId);
+    }
+
+    /**
+     * 按账期查询应收
+     */
+    public List<Receivable> listReceivableByPeriod(String billPeriod) {
+        return receivableMapper.selectByBillPeriod(billPeriod);
+    }
+
+    /**
+     * 查询逾期应收
+     */
+    public List<Receivable> listOverdueReceivables() {
+        return receivableMapper.selectAllOverdue();
+    }
+
+    // ==================== 应付账款管理 ====================
+
+    /**
+     * 创建应付账款
+     */
+    @Transactional
+    public Payable createPayable(String billPeriod, Long supplierId, String supplierName,
+                                  BigDecimal amount, String expenseType, LocalDate dueDate,
+                                  String invoiceNo, String contractNo, Long operatorId, String remark) {
+        if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new BusinessException("应付金额必须大于0");
+        }
+
+        Payable payable = new Payable();
+        payable.setPayableNo(generateNo("PAY"));
+        payable.setBillPeriod(billPeriod);
+        payable.setSupplierId(supplierId);
+        payable.setSupplierName(supplierName);
+        payable.setAmount(amount);
+        payable.setPaidAmount(BigDecimal.ZERO);
+        payable.setUnpaidAmount(amount);
+        payable.setStatus("pending");
+        payable.setExpenseType(expenseType);
+        payable.setDueDate(dueDate);
+        payable.setInvoiceNo(invoiceNo);
+        payable.setContractNo(contractNo);
+        payable.setOperatorId(operatorId);
+        payable.setRemark(remark);
+        payable.setDeleted(0);
+        payable.setCreatedAt(LocalDateTime.now());
+        payable.setUpdatedAt(LocalDateTime.now());
+
+        payableMapper.insert(payable);
+        log.info("Payable created: {} amount={}", payable.getPayableNo(), amount);
+        return payable;
+    }
+
+    /**
+     * 应付账款付款（登记付款）
+     */
+    @Transactional
+    public Payable makePayment(Long payableId, BigDecimal payAmount) {
+        Payable payable = payableMapper.selectById(payableId);
+        if (payable == null) {
+            throw new BusinessException("应付账款不存在");
+        }
+        if (payAmount == null || payAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new BusinessException("付款金额必须大于0");
+        }
+        if (payAmount.compareTo(payable.getUnpaidAmount()) > 0) {
+            throw new BusinessException("付款金额不能超过未付金额: " + payable.getUnpaidAmount());
+        }
+
+        BigDecimal newPaid = payable.getPaidAmount().add(payAmount);
+        BigDecimal newUnpaid = payable.getUnpaidAmount().subtract(payAmount);
+        String newStatus = newUnpaid.compareTo(BigDecimal.ZERO) <= 0 ? "completed" : "partial";
+
+        payableMapper.updateAmount(payableId, newPaid, newUnpaid, newStatus);
+        payable.setPaidAmount(newPaid);
+        payable.setUnpaidAmount(newUnpaid);
+        payable.setStatus(newStatus);
+
+        log.info("Payable payment made: {} amount={} status={}", payable.getPayableNo(), payAmount, newStatus);
+        return payable;
+    }
+
+    /**
+     * 按供应商查询应付
+     */
+    public List<Payable> listPayableBySupplier(Long supplierId) {
+        return payableMapper.selectBySupplierId(supplierId);
+    }
+
+    /**
+     * 按账期查询应付
+     */
+    public List<Payable> listPayableByPeriod(String billPeriod) {
+        return payableMapper.selectByBillPeriod(billPeriod);
+    }
+
+    // ==================== 月度对账 ====================
+
+    /**
+     * 创建月度对账
+     */
+    @Transactional
+    public Reconciliation createReconciliation(String billPeriod, String reconciliationType,
+                                                Long operatorId, String operatorName) {
+        Reconciliation reconciliation = new Reconciliation();
+        reconciliation.setReconciliationNo(generateNo("REC"));
+        reconciliation.setBillPeriod(billPeriod);
+        reconciliation.setReconciliationType(reconciliationType != null ? reconciliationType : "all");
+        reconciliation.setStatus("draft");
+
+        // 汇总应收
+        List<Receivable> receivables = receivableMapper.selectByBillPeriod(billPeriod);
+        BigDecimal totalReceivable = BigDecimal.ZERO;
+        BigDecimal totalReceived = BigDecimal.ZERO;
+        for (Receivable r : receivables) {
+            totalReceivable = totalReceivable.add(r.getAmount());
+            totalReceived = totalReceived.add(r.getReceivedAmount());
+        }
+        reconciliation.setTotalReceivable(totalReceivable);
+        reconciliation.setTotalReceived(totalReceived);
+
+        // 汇总应付
+        List<Payable> payables = payableMapper.selectByBillPeriod(billPeriod);
+        BigDecimal totalPayable = BigDecimal.ZERO;
+        BigDecimal totalPaid = BigDecimal.ZERO;
+        for (Payable p : payables) {
+            totalPayable = totalPayable.add(p.getAmount());
+            totalPaid = totalPaid.add(p.getPaidAmount());
+        }
+        reconciliation.setTotalPayable(totalPayable);
+        reconciliation.setTotalPaid(totalPaid);
+
+        // 差额 = (应收-实收) - (应付-实付)
+        BigDecimal difference = totalReceivable.subtract(totalReceived)
+                .subtract(totalPayable.subtract(totalPaid));
+        reconciliation.setDifference(difference);
+
+        reconciliation.setStartDate(LocalDate.parse(billPeriod + "-01"));
+        reconciliation.setEndDate(LocalDate.parse(billPeriod + "-01").plusMonths(1).minusDays(1));
+        reconciliation.setExceptionCount(0);
+        reconciliation.setOperatorId(operatorId);
+        reconciliation.setOperatorName(operatorName);
+        reconciliation.setDeleted(0);
+        reconciliation.setCreatedAt(LocalDateTime.now());
+        reconciliation.setUpdatedAt(LocalDateTime.now());
+
+        reconciliationMapper.insert(reconciliation);
+        log.info("Reconciliation created: {} period={}", reconciliation.getReconciliationNo(), billPeriod);
+        return reconciliation;
+    }
+
+    /**
+     * 审核对账单
+     */
+    @Transactional
+    public Reconciliation auditReconciliation(Long reconciliationId, boolean approved,
+                                               Long auditorId, String auditorName, String remark) {
+        Reconciliation reconciliation = reconciliationMapper.selectById(reconciliationId);
+        if (reconciliation == null) {
+            throw new BusinessException("对账单不存在");
+        }
+        if (!"pending".equals(reconciliation.getStatus()) && !"draft".equals(reconciliation.getStatus())) {
+            throw new BusinessException("对账单当前状态不允许审核: " + reconciliation.getStatus());
+        }
+
+        String newStatus = approved ? "approved" : "rejected";
+        reconciliationMapper.updateAuditStatus(reconciliationId, newStatus, auditorId, auditorName);
+        reconciliation.setStatus(newStatus);
+        reconciliation.setAuditorId(auditorId);
+        reconciliation.setAuditorName(auditorName);
+
+        if (remark != null) {
+            reconciliation.setRemark(remark);
+            reconciliation.setUpdatedAt(LocalDateTime.now());
+            reconciliationMapper.updateById(reconciliation);
+        }
+
+        log.info("Reconciliation audited: {} result={}", reconciliation.getReconciliationNo(), newStatus);
+        return reconciliation;
+    }
+
+    /**
+     * 查询对账单列表
+     */
+    public List<Reconciliation> listReconciliations(String billPeriod) {
+        if (billPeriod != null) {
+            return reconciliationMapper.selectByBillPeriod(billPeriod);
+        }
+        LambdaQueryWrapper<Reconciliation> wrapper = new LambdaQueryWrapper<>();
+        wrapper.orderByDesc(Reconciliation::getCreatedAt);
+        return reconciliationMapper.selectList(wrapper);
+    }
+
+    // ==================== 结转处理 ====================
+
+    /**
+     * 结转处理 - 将未结清的应收/应付结转到下一账期
+     */
+    @Transactional
+    public Map<String, Object> carryForward(String billPeriod, Long operatorId) {
+        String nextPeriod = calculateNextPeriod(billPeriod);
+
+        // 结转未结清的应收
+        List<Receivable> receivables = receivableMapper.selectByBillPeriod(billPeriod);
+        int carriedReceivable = 0;
+        for (Receivable r : receivables) {
+            if ("pending".equals(r.getStatus()) || "partial".equals(r.getStatus()) || "overdue".equals(r.getStatus())) {
+                createReceivable(nextPeriod, r.getCustomerId(), r.getCustomerName(),
+                        r.getUnreceivedAmount(), r.getBillId(),
+                        r.getDueDate() != null ? r.getDueDate().plusMonths(1) : null,
+                        operatorId, "从" + billPeriod + "结转");
+                carriedReceivable++;
+            }
+        }
+
+        // 结转未结清的应付
+        List<Payable> payables = payableMapper.selectByBillPeriod(billPeriod);
+        int carriedPayable = 0;
+        for (Payable p : payables) {
+            if ("pending".equals(p.getStatus()) || "partial".equals(p.getStatus())) {
+                createPayable(nextPeriod, p.getSupplierId(), p.getSupplierName(),
+                        p.getUnpaidAmount(), p.getExpenseType(),
+                        p.getDueDate() != null ? p.getDueDate().plusMonths(1) : null,
+                        p.getInvoiceNo(), p.getContractNo(),
+                        operatorId, "从" + billPeriod + "结转");
+                carriedPayable++;
+            }
+        }
+
+        log.info("Carry forward: {} -> {} receivables={} payables={}", billPeriod, nextPeriod, carriedReceivable, carriedPayable);
+        return Map.of(
+                "fromPeriod", billPeriod,
+                "toPeriod", nextPeriod,
+                "carriedReceivable", carriedReceivable,
+                "carriedPayable", carriedPayable
+        );
+    }
+
+    /**
+     * 应收应付汇总统计
+     */
+    public Map<String, Object> summary(String billPeriod) {
+        List<Receivable> receivables = receivableMapper.selectByBillPeriod(billPeriod);
+        List<Payable> payables = payableMapper.selectByBillPeriod(billPeriod);
+
+        BigDecimal totalReceivable = BigDecimal.ZERO;
+        BigDecimal totalReceived = BigDecimal.ZERO;
+        int overdueCount = 0;
+        for (Receivable r : receivables) {
+            totalReceivable = totalReceivable.add(r.getAmount());
+            totalReceived = totalReceived.add(r.getReceivedAmount());
+            if ("overdue".equals(r.getStatus())) overdueCount++;
+        }
+
+        BigDecimal totalPayable = BigDecimal.ZERO;
+        BigDecimal totalPaid = BigDecimal.ZERO;
+        for (Payable p : payables) {
+            totalPayable = totalPayable.add(p.getAmount());
+            totalPaid = totalPaid.add(p.getPaidAmount());
+        }
+
+        return Map.of(
+                "billPeriod", billPeriod,
+                "totalReceivable", totalReceivable,
+                "totalReceived", totalReceived,
+                "unreceivedAmount", totalReceivable.subtract(totalReceived),
+                "totalPayable", totalPayable,
+                "totalPaid", totalPaid,
+                "unpaidAmount", totalPayable.subtract(totalPaid),
+                "overdueCount", overdueCount,
+                "receivableCount", receivables.size(),
+                "payableCount", payables.size()
+        );
+    }
+
+    private String generateNo(String prefix) {
+        return prefix + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"))
+                + String.format("%06d", (int) (Math.random() * 999999));
+    }
+
+    private String calculateNextPeriod(String billPeriod) {
+        // billPeriod format: "2026-06"
+        String[] parts = billPeriod.split("-");
+        int year = Integer.parseInt(parts[0]);
+        int month = Integer.parseInt(parts[1]);
+        month++;
+        if (month > 12) {
+            month = 1;
+            year++;
+        }
+        return String.format("%04d-%02d", year, month);
+    }
+}

wm-revenue/src/main/java/com/water/revenue/service/CollectionService.java

@@ -0,0 +1,262 @@
+package com.water.revenue.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.common.core.exception.BusinessException;
+import com.water.revenue.entity.CollectionRecord;
+import com.water.revenue.entity.Receivable;
+import com.water.revenue.mapper.CollectionRecordMapper;
+import com.water.revenue.mapper.ReceivableMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * 欠费催缴服务
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class CollectionService {
+
+    private final CollectionRecordMapper collectionRecordMapper;
+    private final ReceivableMapper receivableMapper;
+
+    /**
+     * 查询欠费列表（逾期应收）
+     */
+    public List<Receivable> queryOverdueAccounts() {
+        return receivableMapper.selectAllOverdue();
+    }
+
+    /**
+     * 查询客户欠费
+     */
+    public List<Receivable> queryCustomerOverdue(Long customerId) {
+        return receivableMapper.selectOverdueByCustomerId(customerId);
+    }
+
+    /**
+     * 创建催缴记录
+     */
+    @Transactional
+    public CollectionRecord createCollection(Long customerId, String customerName,
+                                              BigDecimal overdueAmount, Integer overdueDays,
+                                              String collectionType, String contactPerson,
+                                              String contactPhone, String contactEmail,
+                                              Long receivableId, Long collectorId,
+                                              String collectorName, String remark) {
+        if (overdueAmount == null || overdueAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new BusinessException("欠费金额必须大于0");
+        }
+        if (collectionType == null || collectionType.isEmpty()) {
+            throw new BusinessException("催缴类型不能为空");
+        }
+
+        CollectionRecord record = new CollectionRecord();
+        record.setCollectionNo(generateCollectionNo());
+        record.setCustomerId(customerId);
+        record.setCustomerName(customerName);
+        record.setOverdueAmount(overdueAmount);
+        record.setOverdueDays(overdueDays != null ? overdueDays : 0);
+        record.setCollectionType(collectionType);
+        record.setCollectionResult(null);
+        record.setContactPerson(contactPerson);
+        record.setContactPhone(contactPhone);
+        record.setContactEmail(contactEmail);
+        record.setCollectionTime(LocalDateTime.now());
+        record.setCollectorId(collectorId);
+        record.setCollectorName(collectorName);
+        record.setReceivableId(receivableId);
+        record.setRemark(remark);
+        record.setStatus("pending");
+        record.setDeleted(0);
+        record.setCreatedAt(LocalDateTime.now());
+        record.setUpdatedAt(LocalDateTime.now());
+
+        collectionRecordMapper.insert(record);
+
+        // 更新应收账款的催缴次数
+        if (receivableId != null) {
+            Receivable receivable = receivableMapper.selectById(receivableId);
+            if (receivable != null) {
+                receivable.setCollectionCount(
+                        (receivable.getCollectionCount() != null ? receivable.getCollectionCount() : 0) + 1);
+                receivable.setLastCollectionTime(LocalDateTime.now());
+                receivableMapper.updateById(receivable);
+            }
+        }
+
+        log.info("Collection created: {} customer={} amount={}", record.getCollectionNo(), customerName, overdueAmount);
+        return record;
+    }
+
+    /**
+     * 发送催缴通知（模拟短信/电话/上门）
+     */
+    @Transactional
+    public Map<String, Object> sendNotification(Long collectionId) {
+        CollectionRecord record = collectionRecordMapper.selectById(collectionId);
+        if (record == null) {
+            throw new BusinessException("催缴记录不存在");
+        }
+
+        String notificationType = record.getCollectionType();
+        String message;
+
+        switch (notificationType) {
+            case "sms":
+                message = "短信催缴通知已发送至 " + record.getContactPhone() + "（模拟）";
+                break;
+            case "phone":
+                message = "电话催缴已拨打 " + record.getContactPhone() + "（模拟）";
+                break;
+            case "visit":
+                message = "上门催缴已安排，客户: " + record.getCustomerName() + "（模拟）";
+                break;
+            case "letter":
+                message = "催缴函已发送至 " + record.getContactEmail() + "（模拟）";
+                break;
+            default:
+                message = "催缴通知已发送（模拟）";
+        }
+
+        record.setStatus("in_progress");
+        record.setUpdatedAt(LocalDateTime.now());
+        collectionRecordMapper.updateById(record);
+
+        log.info("Collection notification sent: {} type={}", record.getCollectionNo(), notificationType);
+        return Map.of(
+                "collectionNo", record.getCollectionNo(),
+                "notificationType", notificationType,
+                "message", message
+        );
+    }
+
+    /**
+     * 更新催缴结果
+     */
+    @Transactional
+    public CollectionRecord updateResult(Long collectionId, String collectionResult,
+                                          LocalDate promisedDate, String remark) {
+        CollectionRecord record = collectionRecordMapper.selectById(collectionId);
+        if (record == null) {
+            throw new BusinessException("催缴记录不存在");
+        }
+
+        String newStatus;
+        switch (collectionResult) {
+            case "success":
+                newStatus = "completed";
+                break;
+            case "promised":
+                newStatus = "in_progress";
+                break;
+            default:
+                newStatus = record.getStatus();
+        }
+
+        collectionRecordMapper.updateResult(collectionId, newStatus, collectionResult);
+        record.setCollectionResult(collectionResult);
+        record.setStatus(newStatus);
+        if (promisedDate != null) {
+            record.setPromisedDate(promisedDate);
+        }
+        if (remark != null) {
+            record.setRemark(remark);
+        }
+        record.setUpdatedAt(LocalDateTime.now());
+        collectionRecordMapper.updateById(record);
+
+        log.info("Collection result updated: {} result={}", record.getCollectionNo(), collectionResult);
+        return record;
+    }
+
+    /**
+     * 查询客户的催缴记录
+     */
+    public List<CollectionRecord> listByCustomer(Long customerId) {
+        return collectionRecordMapper.selectByCustomerId(customerId);
+    }
+
+    /**
+     * 查询应收账款关联的催缴记录
+     */
+    public List<CollectionRecord> listByReceivable(Long receivableId) {
+        return collectionRecordMapper.selectByReceivableId(receivableId);
+    }
+
+    /**
+     * 分页查询催缴记录
+     */
+    public List<CollectionRecord> listRecords(String status, String collectionType, int page, int size) {
+        LambdaQueryWrapper<CollectionRecord> wrapper = new LambdaQueryWrapper<>();
+        if (status != null && !status.isEmpty()) {
+            wrapper.eq(CollectionRecord::getStatus, status);
+        }
+        if (collectionType != null && !collectionType.isEmpty()) {
+            wrapper.eq(CollectionRecord::getCollectionType, collectionType);
+        }
+        wrapper.orderByDesc(CollectionRecord::getCollectionTime);
+        wrapper.last("LIMIT " + size + " OFFSET " + ((page - 1) * size));
+        return collectionRecordMapper.selectList(wrapper);
+    }
+
+    /**
+     * 催缴统计
+     */
+    public Map<String, Object> statistics(Integer days) {
+        LocalDateTime startTime = LocalDateTime.now().minusDays(days != null ? days : 30);
+        List<Map<String, Object>> typeStats = collectionRecordMapper.selectStatistics(startTime);
+
+        LambdaQueryWrapper<CollectionRecord> wrapper = new LambdaQueryWrapper<>();
+        wrapper.ge(CollectionRecord::getCollectionTime, startTime);
+        List<CollectionRecord> allRecords = collectionRecordMapper.selectList(wrapper);
+
+        int totalCount = allRecords.size();
+        int successCount = 0;
+        int promisedCount = 0;
+        int failedCount = 0;
+        BigDecimal totalOverdue = BigDecimal.ZERO;
+        BigDecimal totalCollected = BigDecimal.ZERO;
+
+        for (CollectionRecord r : allRecords) {
+            totalOverdue = totalOverdue.add(r.getOverdueAmount());
+            if ("success".equals(r.getCollectionResult())) {
+                successCount++;
+                totalCollected = totalCollected.add(r.getOverdueAmount());
+            } else if ("promised".equals(r.getCollectionResult())) {
+                promisedCount++;
+            } else if ("failed".equals(r.getCollectionResult()) || "refused".equals(r.getCollectionResult())) {
+                failedCount++;
+            }
+        }
+
+        BigDecimal successRate = totalCount > 0
+                ? BigDecimal.valueOf(successCount).multiply(BigDecimal.valueOf(100)).divide(BigDecimal.valueOf(totalCount), 1, java.math.RoundingMode.HALF_UP)
+                : BigDecimal.ZERO;
+
+        return Map.of(
+                "period", days != null ? days : 30,
+                "totalCount", totalCount,
+                "successCount", successCount,
+                "promisedCount", promisedCount,
+                "failedCount", failedCount,
+                "successRate", successRate,
+                "totalOverdueAmount", totalOverdue,
+                "totalCollectedAmount", totalCollected,
+                "byType", typeStats
+        );
+    }
+
+    private String generateCollectionNo() {
+        return "CLT" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"))
+                + String.format("%06d", (int) (Math.random() * 999999));
+    }
+}

wm-revenue/src/main/java/com/water/revenue/service/InvoiceService.java

@@ -0,0 +1,232 @@
+package com.water.revenue.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.common.core.exception.BusinessException;
+import com.water.revenue.entity.Invoice;
+import com.water.revenue.mapper.InvoiceMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+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.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * 电子发票服务
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class InvoiceService {
+
+    private final InvoiceMapper invoiceMapper;
+
+    /**
+     * 开具发票（模拟）
+     */
+    @Transactional
+    public Invoice issueInvoice(Long customerId, String customerName, String customerTaxNo,
+                                 BigDecimal amount, BigDecimal taxRate, String invoiceType,
+                                 String content, Long billId, String email, String phone,
+                                 Long operatorId, String operatorName) {
+        if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new BusinessException("发票金额必须大于0");
+        }
+        if (customerId == null) {
+            throw new BusinessException("客户ID不能为空");
+        }
+
+        BigDecimal taxAmount = amount.multiply(taxRate).divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP);
+        BigDecimal totalAmount = amount.add(taxAmount);
+
+        Invoice invoice = new Invoice();
+        invoice.setInvoiceNo(generateInvoiceNo());
+        invoice.setInvoiceType(invoiceType != null ? invoiceType : "electronic");
+        invoice.setCustomerId(customerId);
+        invoice.setCustomerName(customerName);
+        invoice.setCustomerTaxNo(customerTaxNo);
+        invoice.setAmount(amount);
+        invoice.setTaxRate(taxRate);
+        invoice.setTaxAmount(taxAmount);
+        invoice.setTotalAmount(totalAmount);
+        invoice.setContent(content);
+        invoice.setBillId(billId);
+        invoice.setStatus("issued");
+        invoice.setIssueDate(LocalDate.now());
+        invoice.setPushStatus("none");
+        invoice.setEmail(email);
+        invoice.setPhone(phone);
+        invoice.setOperatorId(operatorId);
+        invoice.setOperatorName(operatorName);
+        invoice.setDeleted(0);
+        invoice.setCreatedAt(LocalDateTime.now());
+        invoice.setUpdatedAt(LocalDateTime.now());
+
+        invoiceMapper.insert(invoice);
+        log.info("Invoice issued: {} amount={} total={}", invoice.getInvoiceNo(), amount, totalAmount);
+        return invoice;
+    }
+
+    /**
+     * 查询发票（按发票号）
+     */
+    public Invoice getByInvoiceNo(String invoiceNo) {
+        Invoice invoice = invoiceMapper.selectByInvoiceNo(invoiceNo);
+        if (invoice == null) {
+            throw new BusinessException("发票不存在: " + invoiceNo);
+        }
+        return invoice;
+    }
+
+    /**
+     * 查询客户的发票列表
+     */
+    public List<Invoice> listByCustomerId(Long customerId) {
+        return invoiceMapper.selectByCustomerId(customerId);
+    }
+
+    /**
+     * 按账单ID查询发票
+     */
+    public List<Invoice> listByBillId(Long billId) {
+        return invoiceMapper.selectByBillId(billId);
+    }
+
+    /**
+     * 分页查询发票
+     */
+    public List<Invoice> listInvoices(String status, String invoiceType, int page, int size) {
+        LambdaQueryWrapper<Invoice> wrapper = new LambdaQueryWrapper<>();
+        if (status != null && !status.isEmpty()) {
+            wrapper.eq(Invoice::getStatus, status);
+        }
+        if (invoiceType != null && !invoiceType.isEmpty()) {
+            wrapper.eq(Invoice::getInvoiceType, invoiceType);
+        }
+        wrapper.orderByDesc(Invoice::getCreatedAt);
+        wrapper.last("LIMIT " + size + " OFFSET " + ((page - 1) * size));
+        return invoiceMapper.selectList(wrapper);
+    }
+
+    /**
+     * 推送发票（邮件/短信）
+     */
+    @Transactional
+    public Map<String, Object> pushInvoice(Long invoiceId, String pushType) {
+        Invoice invoice = invoiceMapper.selectById(invoiceId);
+        if (invoice == null) {
+            throw new BusinessException("发票不存在");
+        }
+        if (!"issued".equals(invoice.getStatus()) && !"sent".equals(invoice.getStatus())) {
+            throw new BusinessException("当前发票状态不允许推送: " + invoice.getStatus());
+        }
+
+        String pushStatus = pushType != null ? pushType : "email";
+        invoiceMapper.updatePushStatus(invoiceId, "sent", pushStatus);
+
+        log.info("Invoice pushed: {} via {}", invoice.getInvoiceNo(), pushStatus);
+        return Map.of(
+                "invoiceNo", invoice.getInvoiceNo(),
+                "pushStatus", pushStatus,
+                "pushTime", LocalDateTime.now().toString(),
+                "message", "发票推送成功（模拟）"
+        );
+    }
+
+    /**
+     * 红冲/作废发票
+     */
+    @Transactional
+    public Invoice redFlush(Long invoiceId, String reason, Long operatorId, String operatorName) {
+        Invoice invoice = invoiceMapper.selectById(invoiceId);
+        if (invoice == null) {
+            throw new BusinessException("发票不存在");
+        }
+        if ("cancelled".equals(invoice.getStatus()) || "red".equals(invoice.getStatus())) {
+            throw new BusinessException("发票已作废或已红冲");
+        }
+
+        // 更新原发票状态为红冲
+        invoice.setStatus("red");
+        invoice.setCancelReason(reason);
+        invoice.setUpdatedAt(LocalDateTime.now());
+        invoiceMapper.updateById(invoice);
+
+        // 创建红冲发票（金额为负）
+        Invoice redInvoice = new Invoice();
+        redInvoice.setInvoiceNo(generateInvoiceNo());
+        redInvoice.setInvoiceType(invoice.getInvoiceType());
+        redInvoice.setCustomerId(invoice.getCustomerId());
+        redInvoice.setCustomerName(invoice.getCustomerName());
+        redInvoice.setCustomerTaxNo(invoice.getCustomerTaxNo());
+        redInvoice.setAmount(invoice.getAmount().negate());
+        redInvoice.setTaxRate(invoice.getTaxRate());
+        redInvoice.setTaxAmount(invoice.getTaxAmount().negate());
+        redInvoice.setTotalAmount(invoice.getTotalAmount().negate());
+        redInvoice.setContent("红冲-" + invoice.getContent());
+        redInvoice.setBillId(invoice.getBillId());
+        redInvoice.setStatus("issued");
+        redInvoice.setIssueDate(LocalDate.now());
+        redInvoice.setPushStatus("none");
+        redInvoice.setOriginalInvoiceId(invoiceId);
+        redInvoice.setCancelReason(reason);
+        redInvoice.setOperatorId(operatorId);
+        redInvoice.setOperatorName(operatorName);
+        redInvoice.setDeleted(0);
+        redInvoice.setCreatedAt(LocalDateTime.now());
+        redInvoice.setUpdatedAt(LocalDateTime.now());
+
+        invoiceMapper.insert(redInvoice);
+        log.info("Invoice red-flushed: {} -> {}", invoice.getInvoiceNo(), redInvoice.getInvoiceNo());
+        return redInvoice;
+    }
+
+    /**
+     * 统计发票数据
+     */
+    public Map<String, Object> statistics(String startDate, String endDate) {
+        LambdaQueryWrapper<Invoice> wrapper = new LambdaQueryWrapper<>();
+        wrapper.ne(Invoice::getStatus, "cancelled");
+        if (startDate != null) {
+            wrapper.ge(Invoice::getIssueDate, LocalDate.parse(startDate));
+        }
+        if (endDate != null) {
+            wrapper.le(Invoice::getIssueDate, LocalDate.parse(endDate));
+        }
+        List<Invoice> invoices = invoiceMapper.selectList(wrapper);
+
+        BigDecimal totalAmount = BigDecimal.ZERO;
+        BigDecimal totalTax = BigDecimal.ZERO;
+        int issuedCount = 0;
+        int redCount = 0;
+
+        for (Invoice inv : invoices) {
+            if ("red".equals(inv.getStatus())) {
+                redCount++;
+            } else {
+                issuedCount++;
+                totalAmount = totalAmount.add(inv.getAmount());
+                totalTax = totalTax.add(inv.getTaxAmount());
+            }
+        }
+
+        return Map.of(
+                "totalCount", invoices.size(),
+                "issuedCount", issuedCount,
+                "redCount", redCount,
+                "totalAmount", totalAmount,
+                "totalTaxAmount", totalTax,
+                "totalWithTax", totalAmount.add(totalTax)
+        );
+    }
+
+    private String generateInvoiceNo() {
+        return "INV" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"))
+                + String.format("%06d", (int) (Math.random() * 999999));
+    }
+}

wm-revenue/src/main/resources/db/V_invoice_account.sql

@@ -0,0 +1,155 @@
+-- =============================================
+-- 智慧水务管理系统 - 电子发票 + 应收应付 + 催缴 DDL
+-- 版本: V_invoice_account
+-- =============================================
+
+-- 电子发票表
+CREATE TABLE IF NOT EXISTS rev_invoice (
+    id BIGSERIAL PRIMARY KEY,
+    invoice_no VARCHAR(30) UNIQUE NOT NULL,
+    invoice_type VARCHAR(20) NOT NULL DEFAULT 'electronic',  -- normal/special/electronic
+    customer_id BIGINT NOT NULL,
+    customer_name VARCHAR(100),
+    customer_tax_no VARCHAR(30),
+    amount DECIMAL(12,2) NOT NULL,
+    tax_rate DECIMAL(5,2) DEFAULT 6.00,
+    tax_amount DECIMAL(12,2) NOT NULL,
+    total_amount DECIMAL(12,2) NOT NULL,
+    content VARCHAR(500),
+    bill_id BIGINT,
+    status VARCHAR(20) NOT NULL DEFAULT 'draft',             -- draft/issued/sent/cancelled/red
+    issue_date DATE,
+    push_status VARCHAR(20) DEFAULT 'none',                  -- none/email/sms/both
+    push_time TIMESTAMP,
+    email VARCHAR(100),
+    phone VARCHAR(20),
+    cancel_reason VARCHAR(500),
+    original_invoice_id BIGINT,                              -- 红冲关联的原发票
+    operator_id BIGINT,
+    operator_name VARCHAR(50),
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_invoice IS '电子发票表';
+CREATE INDEX IF NOT EXISTS idx_invoice_customer ON rev_invoice(customer_id);
+CREATE INDEX IF NOT EXISTS idx_invoice_bill ON rev_invoice(bill_id);
+CREATE INDEX IF NOT EXISTS idx_invoice_status ON rev_invoice(status);
+CREATE INDEX IF NOT EXISTS idx_invoice_issue_date ON rev_invoice(issue_date);
+
+-- 应收账款表
+CREATE TABLE IF NOT EXISTS rev_receivable (
+    id BIGSERIAL PRIMARY KEY,
+    receivable_no VARCHAR(30) UNIQUE NOT NULL,
+    bill_period VARCHAR(10) NOT NULL,                        -- 2026-06
+    customer_id BIGINT NOT NULL,
+    customer_name VARCHAR(100),
+    amount DECIMAL(12,2) NOT NULL,
+    received_amount DECIMAL(12,2) DEFAULT 0,
+    unreceived_amount DECIMAL(12,2) NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'pending',           -- pending/partial/completed/overdue/cancelled
+    bill_id BIGINT,
+    due_date DATE,
+    overdue_days INT DEFAULT 0,
+    collection_count INT DEFAULT 0,
+    last_collection_time TIMESTAMP,
+    operator_id BIGINT,
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_receivable IS '应收账款表';
+CREATE INDEX IF NOT EXISTS idx_receivable_customer ON rev_receivable(customer_id);
+CREATE INDEX IF NOT EXISTS idx_receivable_period ON rev_receivable(bill_period);
+CREATE INDEX IF NOT EXISTS idx_receivable_status ON rev_receivable(status);
+CREATE INDEX IF NOT EXISTS idx_receivable_due_date ON rev_receivable(due_date);
+
+-- 应付账款表
+CREATE TABLE IF NOT EXISTS rev_payable (
+    id BIGSERIAL PRIMARY KEY,
+    payable_no VARCHAR(30) UNIQUE NOT NULL,
+    bill_period VARCHAR(10) NOT NULL,                        -- 2026-06
+    supplier_id BIGINT NOT NULL,
+    supplier_name VARCHAR(100),
+    amount DECIMAL(12,2) NOT NULL,
+    paid_amount DECIMAL(12,2) DEFAULT 0,
+    unpaid_amount DECIMAL(12,2) NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'pending',           -- pending/partial/completed/cancelled
+    expense_type VARCHAR(30),                                -- electricity/chemical/maintenance/equipment/other
+    due_date DATE,
+    invoice_no VARCHAR(50),
+    contract_no VARCHAR(50),
+    operator_id BIGINT,
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_payable IS '应付账款表';
+CREATE INDEX IF NOT EXISTS idx_payable_supplier ON rev_payable(supplier_id);
+CREATE INDEX IF NOT EXISTS idx_payable_period ON rev_payable(bill_period);
+CREATE INDEX IF NOT EXISTS idx_payable_status ON rev_payable(status);
+CREATE INDEX IF NOT EXISTS idx_payable_due_date ON rev_payable(due_date);
+
+-- 对账记录表
+CREATE TABLE IF NOT EXISTS rev_reconciliation (
+    id BIGSERIAL PRIMARY KEY,
+    reconciliation_no VARCHAR(30) UNIQUE NOT NULL,
+    bill_period VARCHAR(10) NOT NULL,
+    reconciliation_type VARCHAR(20) DEFAULT 'all',           -- receivable/payable/all
+    total_receivable DECIMAL(14,2) DEFAULT 0,
+    total_received DECIMAL(14,2) DEFAULT 0,
+    total_payable DECIMAL(14,2) DEFAULT 0,
+    total_paid DECIMAL(14,2) DEFAULT 0,
+    difference DECIMAL(14,2) DEFAULT 0,
+    status VARCHAR(20) NOT NULL DEFAULT 'draft',             -- draft/pending/approved/rejected/completed
+    start_date DATE,
+    end_date DATE,
+    exception_count INT DEFAULT 0,
+    exception_note TEXT,
+    auditor_id BIGINT,
+    auditor_name VARCHAR(50),
+    audit_time TIMESTAMP,
+    operator_id BIGINT,
+    operator_name VARCHAR(50),
+    remark VARCHAR(500),
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_reconciliation IS '对账记录表';
+CREATE INDEX IF NOT EXISTS idx_reconciliation_period ON rev_reconciliation(bill_period);
+CREATE INDEX IF NOT EXISTS idx_reconciliation_status ON rev_reconciliation(status);
+
+-- 催缴记录表
+CREATE TABLE IF NOT EXISTS rev_collection_record (
+    id BIGSERIAL PRIMARY KEY,
+    collection_no VARCHAR(30) UNIQUE NOT NULL,
+    customer_id BIGINT NOT NULL,
+    customer_name VARCHAR(100),
+    overdue_amount DECIMAL(12,2) NOT NULL,
+    overdue_days INT DEFAULT 0,
+    collection_type VARCHAR(20) NOT NULL,                    -- sms/phone/visit/letter
+    collection_result VARCHAR(20),                           -- success/promised/failed/unreachable/refused
+    contact_person VARCHAR(50),
+    contact_phone VARCHAR(20),
+    contact_email VARCHAR(100),
+    collection_time TIMESTAMP,
+    promised_date DATE,
+    collector_id BIGINT,
+    collector_name VARCHAR(50),
+    receivable_id BIGINT,
+    remark VARCHAR(500),
+    status VARCHAR(20) DEFAULT 'pending',                    -- pending/in_progress/completed/cancelled
+    deleted SMALLINT DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE rev_collection_record IS '催缴记录表';
+CREATE INDEX IF NOT EXISTS idx_collection_customer ON rev_collection_record(customer_id);
+CREATE INDEX IF NOT EXISTS idx_collection_receivable ON rev_collection_record(receivable_id);
+CREATE INDEX IF NOT EXISTS idx_collection_status ON rev_collection_record(status);
+CREATE INDEX IF NOT EXISTS idx_collection_time ON rev_collection_record(collection_time);
+CREATE INDEX IF NOT EXISTS idx_collection_type ON rev_collection_record(collection_type);

wm-revenue/src/test/java/com/water/revenue/InvoiceAccountTest.java

@@ -0,0 +1,380 @@
+package com.water.revenue;
+
+import com.water.common.core.exception.BusinessException;
+import com.water.revenue.entity.*;
+import com.water.revenue.mapper.*;
+import com.water.revenue.service.AccountService;
+import com.water.revenue.service.CollectionService;
+import com.water.revenue.service.InvoiceService;
+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 java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * 电子发票 + 应收应付 + 欠费催缴 综合测试
+ */
+@ExtendWith(MockitoExtension.class)
+class InvoiceAccountTest {
+
+    @Mock
+    private InvoiceMapper invoiceMapper;
+
+    @Mock
+    private ReceivableMapper receivableMapper;
+
+    @Mock
+    private PayableMapper payableMapper;
+
+    @Mock
+    private ReconciliationMapper reconciliationMapper;
+
+    @Mock
+    private CollectionRecordMapper collectionRecordMapper;
+
+    private InvoiceService invoiceService;
+    private AccountService accountService;
+    private CollectionService collectionService;
+
+    @BeforeEach
+    void setUp() {
+        invoiceService = new InvoiceService(invoiceMapper);
+        accountService = new AccountService(receivableMapper, payableMapper, reconciliationMapper);
+        collectionService = new CollectionService(collectionRecordMapper, receivableMapper);
+    }
+
+    // ==================== 发票服务测试 ====================
+
+    @Test
+    @DisplayName("开具发票 - 正常开票")
+    void testIssueInvoice() {
+        when(invoiceMapper.insert(any(Invoice.class))).thenAnswer(invocation -> {
+            Invoice inv = invocation.getArgument(0);
+            inv.setId(1L);
+            return 1;
+        });
+
+        Invoice invoice = invoiceService.issueInvoice(
+                1L, "测试客户", "TAX123456", new BigDecimal("1000.00"),
+                BigDecimal.valueOf(6), "electronic", "水费-202606",
+                100L, "test@example.com", "13800138000", 1L, "操作员");
+
+        assertNotNull(invoice);
+        assertNotNull(invoice.getInvoiceNo());
+        assertTrue(invoice.getInvoiceNo().startsWith("INV"));
+        assertEquals(new BigDecimal("1000.00"), invoice.getAmount());
+        assertEquals(new BigDecimal("60.00"), invoice.getTaxAmount());
+        assertEquals(new BigDecimal("1060.00"), invoice.getTotalAmount());
+        assertEquals("issued", invoice.getStatus());
+        assertEquals("none", invoice.getPushStatus());
+
+        verify(invoiceMapper, times(1)).insert(any(Invoice.class));
+    }
+
+    @Test
+    @DisplayName("开具发票 - 金额为0应抛异常")
+    void testIssueInvoiceZeroAmount() {
+        assertThrows(BusinessException.class, () ->
+                invoiceService.issueInvoice(1L, "客户", "TAX", BigDecimal.ZERO,
+                        BigDecimal.valueOf(6), "electronic", "水费", null, null, null, 1L, "操作员"));
+    }
+
+    @Test
+    @DisplayName("开具发票 - 客户ID为空应抛异常")
+    void testIssueInvoiceNullCustomer() {
+        assertThrows(BusinessException.class, () ->
+                invoiceService.issueInvoice(null, "客户", "TAX", new BigDecimal("100"),
+                        BigDecimal.valueOf(6), "electronic", "水费", null, null, null, 1L, "操作员"));
+    }
+
+    @Test
+    @DisplayName("推送发票 - 正常推送")
+    void testPushInvoice() {
+        Invoice invoice = new Invoice();
+        invoice.setId(1L);
+        invoice.setInvoiceNo("INV20260614000001");
+        invoice.setStatus("issued");
+
+        when(invoiceMapper.selectById(1L)).thenReturn(invoice);
+        when(invoiceMapper.updatePushStatus(anyLong(), anyString(), anyString())).thenReturn(1);
+
+        Map<String, Object> result = invoiceService.pushInvoice(1L, "email");
+
+        assertNotNull(result);
+        assertEquals("INV20260614000001", result.get("invoiceNo"));
+        assertEquals("email", result.get("pushStatus"));
+        verify(invoiceMapper, times(1)).updatePushStatus(1L, "sent", "email");
+    }
+
+    @Test
+    @DisplayName("红冲发票 - 正常红冲")
+    void testRedFlush() {
+        Invoice original = new Invoice();
+        original.setId(1L);
+        original.setInvoiceNo("INV20260614000001");
+        original.setInvoiceType("electronic");
+        original.setCustomerId(1L);
+        original.setCustomerName("测试客户");
+        original.setAmount(new BigDecimal("1000.00"));
+        original.setTaxRate(BigDecimal.valueOf(6));
+        original.setTaxAmount(new BigDecimal("60.00"));
+        original.setTotalAmount(new BigDecimal("1060.00"));
+        original.setStatus("issued");
+
+        when(invoiceMapper.selectById(1L)).thenReturn(original);
+        when(invoiceMapper.updateById(any(Invoice.class))).thenReturn(1);
+        when(invoiceMapper.insert(any(Invoice.class))).thenAnswer(inv -> {
+            Invoice inv = inv.getArgument(0);
+            inv.setId(2L);
+            return 1;
+        });
+
+        Invoice redInvoice = invoiceService.redFlush(1L, "开票有误", 1L, "操作员");
+
+        assertNotNull(redInvoice);
+        assertEquals(new BigDecimal("-1000.00"), redInvoice.getAmount());
+        assertEquals(new BigDecimal("-60.00"), redInvoice.getTaxAmount());
+        assertEquals(1L, redInvoice.getOriginalInvoiceId());
+        assertTrue(redInvoice.getContent().startsWith("红冲-"));
+        verify(invoiceMapper, times(1)).updateById(argThat(inv -> "red".equals(((Invoice) inv).getStatus())));
+    }
+
+    @Test
+    @DisplayName("红冲发票 - 已红冲的发票不能再红冲")
+    void testRedFlushAlreadyRed() {
+        Invoice invoice = new Invoice();
+        invoice.setId(1L);
+        invoice.setStatus("red");
+
+        when(invoiceMapper.selectById(1L)).thenReturn(invoice);
+
+        assertThrows(BusinessException.class, () ->
+                invoiceService.redFlush(1L, "重复红冲", 1L, "操作员"));
+    }
+
+    // ==================== 应收应付服务测试 ====================
+
+    @Test
+    @DisplayName("创建应收账款 - 正常创建")
+    void testCreateReceivable() {
+        when(receivableMapper.insert(any(Receivable.class))).thenAnswer(inv -> {
+            Receivable r = inv.getArgument(0);
+            r.setId(1L);
+            return 1;
+        });
+
+        Receivable receivable = accountService.createReceivable(
+                "2026-06", 1L, "客户A", new BigDecimal("5000.00"),
+                100L, LocalDate.now().plusDays(30), 1L, "水费应收");
+
+        assertNotNull(receivable);
+        assertTrue(receivable.getReceivableNo().startsWith("RCV"));
+        assertEquals("2026-06", receivable.getBillPeriod());
+        assertEquals(new BigDecimal("5000.00"), receivable.getAmount());
+        assertEquals(BigDecimal.ZERO, receivable.getReceivedAmount());
+        assertEquals(new BigDecimal("5000.00"), receivable.getUnreceivedAmount());
+        assertEquals("pending", receivable.getStatus());
+    }
+
+    @Test
+    @DisplayName("应收收款 - 部分收款")
+    void testReceivePayment() {
+        Receivable receivable = new Receivable();
+        receivable.setId(1L);
+        receivable.setReceivableNo("RCV20260614000001");
+        receivable.setAmount(new BigDecimal("5000.00"));
+        receivable.setReceivedAmount(new BigDecimal("0.00"));
+        receivable.setUnreceivedAmount(new BigDecimal("5000.00"));
+        receivable.setStatus("pending");
+
+        when(receivableMapper.selectById(1L)).thenReturn(receivable);
+        when(receivableMapper.updateAmount(eq(1L), any(BigDecimal.class), any(BigDecimal.class), anyString())).thenReturn(1);
+
+        Receivable result = accountService.receivePayment(1L, new BigDecimal("3000.00"));
+
+        assertEquals(new BigDecimal("3000.00"), result.getReceivedAmount());
+        assertEquals(new BigDecimal("2000.00"), result.getUnreceivedAmount());
+        assertEquals("partial", result.getStatus());
+    }
+
+    @Test
+    @DisplayName("应收收款 - 超额收款应抛异常")
+    void testReceivePaymentExceed() {
+        Receivable receivable = new Receivable();
+        receivable.setId(1L);
+        receivable.setUnreceivedAmount(new BigDecimal("2000.00"));
+
+        when(receivableMapper.selectById(1L)).thenReturn(receivable);
+
+        assertThrows(BusinessException.class, () ->
+                accountService.receivePayment(1L, new BigDecimal("3000.00")));
+    }
+
+    @Test
+    @DisplayName("创建应付账款 - 正常创建")
+    void testCreatePayable() {
+        when(payableMapper.insert(any(Payable.class))).thenAnswer(inv -> {
+            Payable p = inv.getArgument(0);
+            p.setId(1L);
+            return 1;
+        });
+
+        Payable payable = accountService.createPayable(
+                "2026-06", 10L, "电力公司", new BigDecimal("20000.00"),
+                "electricity", LocalDate.now().plusDays(15),
+                "INV-ELEC-001", "CT-2026-001", 1L, "6月电费");
+
+        assertNotNull(payable);
+        assertTrue(payable.getPayableNo().startsWith("PAY"));
+        assertEquals("electricity", payable.getExpenseType());
+        assertEquals(new BigDecimal("20000.00"), payable.getAmount());
+        assertEquals("pending", payable.getStatus());
+    }
+
+    @Test
+    @DisplayName("应付付款 - 全额付清")
+    void testMakePaymentFull() {
+        Payable payable = new Payable();
+        payable.setId(1L);
+        payable.setPayableNo("PAY20260614000001");
+        payable.setAmount(new BigDecimal("10000.00"));
+        payable.setPaidAmount(BigDecimal.ZERO);
+        payable.setUnpaidAmount(new BigDecimal("10000.00"));
+        payable.setStatus("pending");
+
+        when(payableMapper.selectById(1L)).thenReturn(payable);
+        when(payableMapper.updateAmount(eq(1L), any(BigDecimal.class), any(BigDecimal.class), anyString())).thenReturn(1);
+
+        Payable result = accountService.makePayment(1L, new BigDecimal("10000.00"));
+
+        assertEquals(new BigDecimal("10000.00"), result.getPaidAmount());
+        assertEquals(BigDecimal.ZERO, result.getUnpaidAmount());
+        assertEquals("completed", result.getStatus());
+    }
+
+    // ==================== 催缴服务测试 ====================
+
+    @Test
+    @DisplayName("创建催缴记录 - 短信催缴")
+    void testCreateCollection() {
+        when(collectionRecordMapper.insert(any(CollectionRecord.class))).thenAnswer(inv -> {
+            CollectionRecord r = inv.getArgument(0);
+            r.setId(1L);
+            return 1;
+        });
+
+        Receivable receivable = new Receivable();
+        receivable.setId(100L);
+        receivable.setCollectionCount(0);
+        when(receivableMapper.selectById(100L)).thenReturn(receivable);
+        when(receivableMapper.updateById(any(Receivable.class))).thenReturn(1);
+
+        CollectionRecord record = collectionService.createCollection(
+                1L, "欠费客户", new BigDecimal("3000.00"), 60,
+                "sms", "张三", "13800138000", "zhangsan@test.com",
+                100L, 1L, "催缴员", "首次催缴");
+
+        assertNotNull(record);
+        assertTrue(record.getCollectionNo().startsWith("CLT"));
+        assertEquals("sms", record.getCollectionType());
+        assertEquals("pending", record.getStatus());
+        assertEquals(60, record.getOverdueDays());
+
+        verify(receivableMapper, times(1)).updateById(argThat(r ->
+                ((Receivable) r).getCollectionCount() == 1));
+    }
+
+    @Test
+    @DisplayName("创建催缴记录 - 金额为0应抛异常")
+    void testCreateCollectionZeroAmount() {
+        assertThrows(BusinessException.class, () ->
+                collectionService.createCollection(
+                        1L, "客户", BigDecimal.ZERO, 30, "sms",
+                        "联系人", "138", null, null, 1L, "催缴员", null));
+    }
+
+    @Test
+    @DisplayName("发送催缴通知 - 短信通知")
+    void testSendNotification() {
+        CollectionRecord record = new CollectionRecord();
+        record.setId(1L);
+        record.setCollectionNo("CLT20260614000001");
+        record.setCollectionType("sms");
+        record.setContactPhone("13800138000");
+        record.setStatus("pending");
+
+        when(collectionRecordMapper.selectById(1L)).thenReturn(record);
+        when(collectionRecordMapper.updateById(any(CollectionRecord.class))).thenReturn(1);
+
+        Map<String, Object> result = collectionService.sendNotification(1L);
+
+        assertNotNull(result);
+        assertEquals("sms", result.get("notificationType"));
+        assertTrue(((String) result.get("message")).contains("短信"));
+        verify(collectionRecordMapper, times(1)).updateById(argThat(r ->
+                "in_progress".equals(((CollectionRecord) r).getStatus())));
+    }
+
+    @Test
+    @DisplayName("更新催缴结果 - 催缴成功")
+    void testUpdateResultSuccess() {
+        CollectionRecord record = new CollectionRecord();
+        record.setId(1L);
+        record.setCollectionNo("CLT20260614000001");
+        record.setStatus("in_progress");
+
+        when(collectionRecordMapper.selectById(1L)).thenReturn(record);
+        when(collectionRecordMapper.updateResult(eq(1L), anyString(), anyString())).thenReturn(1);
+        when(collectionRecordMapper.updateById(any(CollectionRecord.class))).thenReturn(1);
+
+        CollectionRecord result = collectionService.updateResult(
+                1L, "success", null, "客户已缴费");
+
+        assertEquals("success", result.getCollectionResult());
+        assertEquals("completed", result.getStatus());
+    }
+
+    @Test
+    @DisplayName("催缴统计 - 正常统计")
+    void testStatistics() {
+        CollectionRecord success = new CollectionRecord();
+        success.setCollectionResult("success");
+        success.setOverdueAmount(new BigDecimal("1000.00"));
+        success.setCollectionTime(LocalDateTime.now().minusDays(5));
+
+        CollectionRecord promised = new CollectionRecord();
+        promised.setCollectionResult("promised");
+        promised.setOverdueAmount(new BigDecimal("2000.00"));
+        promised.setCollectionTime(LocalDateTime.now().minusDays(3));
+
+        CollectionRecord failed = new CollectionRecord();
+        failed.setCollectionResult("failed");
+        failed.setOverdueAmount(new BigDecimal("500.00"));
+        failed.setCollectionTime(LocalDateTime.now().minusDays(1));
+
+        when(collectionRecordMapper.selectStatistics(any(LocalDateTime.class)))
+                .thenReturn(List.of(Map.of("collection_type", "sms", "count", 3L, "success_count", 1L)));
+        when(collectionRecordMapper.selectList(any())).thenReturn(List.of(success, promised, failed));
+
+        Map<String, Object> stats = collectionService.statistics(30);
+
+        assertNotNull(stats);
+        assertEquals(3, stats.get("totalCount"));
+        assertEquals(1, stats.get("successCount"));
+        assertEquals(1, stats.get("promisedCount"));
+        assertEquals(1, stats.get("failedCount"));
+        assertEquals(new BigDecimal("3500.00"), stats.get("totalOverdueAmount"));
+        assertEquals(new BigDecimal("1000.00"), stats.get("totalCollectedAmount"));
+    }
+}