迁移pro

liyong

2 天以前 1ca5584d7e3200a9af65a099bd26d3593e2ba702

 src/main/java/com/ruoyi/ai/tools/PurchaseAgentTools.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,643 @@
package com.ruoyi.ai.tools;

import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.ai.context.AiSessionUserContext;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.security.LoginUser;
import com.ruoyi.purchase.mapper.InvoicePurchaseMapper;
import com.ruoyi.purchase.mapper.PaymentRegistrationMapper;
import com.ruoyi.purchase.mapper.PurchaseLedgerMapper;
import com.ruoyi.purchase.mapper.PurchaseReturnOrdersMapper;
import com.ruoyi.purchase.pojo.InvoicePurchase;
import com.ruoyi.purchase.pojo.PaymentRegistration;
import com.ruoyi.purchase.pojo.PurchaseLedger;
import com.ruoyi.purchase.pojo.PurchaseReturnOrders;
import com.ruoyi.procurementrecord.mapper.InboundManagementMapper;
import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;
import com.ruoyi.procurementrecord.pojo.InboundManagement;
import com.ruoyi.procurementrecord.pojo.ProcurementRecordStorage;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
import com.ruoyi.sales.pojo.SalesLedgerProduct;
import dev.langchain4j.agent.tool.P;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolMemoryId;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Comparator;
import java.util.stream.Collectors;

@Component
public class PurchaseAgentTools {

    private static final DateTimeFormatter DATE_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final int DEFAULT_LIMIT = 10;
    private static final int MAX_LIMIT = 30;

    private final PurchaseLedgerMapper purchaseLedgerMapper;
    private final PaymentRegistrationMapper paymentRegistrationMapper;
    private final InvoicePurchaseMapper invoicePurchaseMapper;
    private final PurchaseReturnOrdersMapper purchaseReturnOrdersMapper;
    private final SalesLedgerProductMapper salesLedgerProductMapper;
    private final ProcurementRecordMapper procurementRecordMapper;
    private final InboundManagementMapper inboundManagementMapper;
    private final AiSessionUserContext aiSessionUserContext;

    public PurchaseAgentTools(PurchaseLedgerMapper purchaseLedgerMapper,
                              PaymentRegistrationMapper paymentRegistrationMapper,
                              InvoicePurchaseMapper invoicePurchaseMapper,
                              PurchaseReturnOrdersMapper purchaseReturnOrdersMapper,
                              SalesLedgerProductMapper salesLedgerProductMapper,
                              ProcurementRecordMapper procurementRecordMapper,
                              InboundManagementMapper inboundManagementMapper,
                              AiSessionUserContext aiSessionUserContext) {
        this.purchaseLedgerMapper = purchaseLedgerMapper;
        this.paymentRegistrationMapper = paymentRegistrationMapper;
        this.invoicePurchaseMapper = invoicePurchaseMapper;
        this.purchaseReturnOrdersMapper = purchaseReturnOrdersMapper;
        this.salesLedgerProductMapper = salesLedgerProductMapper;
        this.procurementRecordMapper = procurementRecordMapper;
        this.inboundManagementMapper = inboundManagementMapper;
        this.aiSessionUserContext = aiSessionUserContext;
    }

    @Tool(name = "查询采购台账列表", value = "按关键字和时间范围查询采购台账，支持返回最近N条")
    public String listPurchaseLedgers(@ToolMemoryId String memoryId,
                                      @P(value = "关键字，可匹配采购合同号/供应商/项目名", required = false) String keyword,
                                      @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                      @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                      @P(value = "返回条数，默认10，最大30", required = false) Integer limit) {
        LoginUser loginUser = currentLoginUser(memoryId);
        LocalDate start = parseLocalDate(startDate);
        LocalDate end = parseLocalDate(endDate);
        int finalLimit = normalizeLimit(limit);

        LambdaQueryWrapper<PurchaseLedger> wrapper = new LambdaQueryWrapper<>();
        applyTenantFilter(wrapper, loginUser.getTenantId(), PurchaseLedger::getTenantId);
        if (StringUtils.hasText(keyword)) {
            wrapper.and(w -> w.like(PurchaseLedger::getPurchaseContractNumber, keyword)
                    .or().like(PurchaseLedger::getSupplierName, keyword)
                    .or().like(PurchaseLedger::getProjectName, keyword));
        }
        if (start != null) {
            wrapper.ge(PurchaseLedger::getEntryDate, toDate(start));
        }
        if (end != null) {
            wrapper.lt(PurchaseLedger::getEntryDate, toExclusiveEndDate(end));
        }
        wrapper.orderByDesc(PurchaseLedger::getEntryDate, PurchaseLedger::getId).last("limit " + finalLimit);

        List<PurchaseLedger> rows = defaultList(purchaseLedgerMapper.selectList(wrapper));
        List<Map<String, Object>> items = rows.stream().map(this::toLedgerItem).collect(Collectors.toList());
        return jsonResponse(true, "purchase_ledger_list", "已返回采购台账列表",
                Map.of("count", items.size(), "limit", finalLimit, "keyword", safe(keyword)),
                Map.of("items", items), Map.of());
    }

    @Tool(name = "查询采购台账详情", value = "按采购台账ID查询详情")
    public String getPurchaseLedgerDetail(@ToolMemoryId String memoryId, @P("采购台账ID") Long ledgerId) {
        if (ledgerId == null) {
            return jsonResponse(false, "purchase_ledger_detail", "采购台账ID不能为空", Map.of(), Map.of(), Map.of());
        }
        LoginUser loginUser = currentLoginUser(memoryId);
        PurchaseLedger ledger = purchaseLedgerMapper.selectById(ledgerId);
        if (ledger == null || !tenantMatched(ledger.getTenantId(), loginUser.getTenantId())) {
            return jsonResponse(false, "purchase_ledger_detail", "未找到该采购台账或无权限访问", Map.of("ledgerId", ledgerId), Map.of(), Map.of());
        }
        return jsonResponse(true, "purchase_ledger_detail", "已返回采购台账详情",
                Map.of("ledgerId", ledgerId),
                Map.of("detail", toLedgerItem(ledger)),
                Map.of());
    }

    @Tool(name = "统计采购数据", value = "统计时间范围内采购合同数、合同金额、付款金额、发票金额、退货金额")
    public String getPurchaseStats(@ToolMemoryId String memoryId,
                                   @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                   @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                   @P(value = "时间范围描述，例如今年、本月、近30天", required = false) String timeRange) {
        LoginUser loginUser = currentLoginUser(memoryId);
        DateRange range = resolveDateRange(startDate, endDate, timeRange);

        List<PurchaseLedger> ledgers = queryLedgers(loginUser, range);
        List<PaymentRegistration> payments = queryPayments(loginUser, range);
        List<InvoicePurchase> invoices = queryInvoices(loginUser, range);
        List<PurchaseReturnOrders> returns = queryReturns(loginUser, range);

        BigDecimal contractAmount = ledgers.stream()
                .map(PurchaseLedger::getContractAmount)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal paymentAmount = payments.stream()
                .map(PaymentRegistration::getCurrentPaymentAmount)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal invoiceAmount = invoices.stream()
                .map(InvoicePurchase::getInvoiceAmount)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal returnAmount = returns.stream()
                .map(PurchaseReturnOrders::getTotalAmount)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);

        Map<String, Object> summary = new LinkedHashMap<>();
        summary.put("timeRange", range.label());
        summary.put("startDate", range.start().toString());
        summary.put("endDate", range.end().toString());
        summary.put("ledgerCount", ledgers.size());
        summary.put("paymentCount", payments.size());
        summary.put("invoiceCount", invoices.size());
        summary.put("returnCount", returns.size());
        summary.put("contractAmount", contractAmount);
        summary.put("paymentAmount", paymentAmount);
        summary.put("invoiceAmount", invoiceAmount);
        summary.put("returnAmount", returnAmount);

        return jsonResponse(true, "purchase_stats", "已返回采购统计数据", summary, Map.of(), Map.of());
    }

    @Tool(name = "采购物料金额排行", value = "按时间范围统计采购物料金额排行，可回答本月采购金额排名靠前的物料。")
    public String rankPurchaseMaterials(@ToolMemoryId String memoryId,
                                        @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                        @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                        @P(value = "时间范围描述，例如本月、近7天、近30天", required = false) String timeRange,
                                        @P(value = "返回条数，默认10，最大30", required = false) Integer limit) {
        LoginUser loginUser = currentLoginUser(memoryId);
        DateRange range = resolveDateRange(startDate, endDate, timeRange);
        List<Long> ledgerIds = queryLedgers(loginUser, range).stream()
                .map(PurchaseLedger::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        if (ledgerIds.isEmpty()) {
            return jsonResponse(true, "purchase_material_rank", "当前时间范围内没有采购物料数据。",
                    rangeSummary(range, 0), Map.of("items", List.of()), Map.of());
        }

        List<SalesLedgerProduct> products = defaultList(salesLedgerProductMapper.selectList(new LambdaQueryWrapper<SalesLedgerProduct>()
                .eq(SalesLedgerProduct::getType, 2)
                .in(SalesLedgerProduct::getSalesLedgerId, ledgerIds)));

        Map<String, MaterialRankItem> grouped = new LinkedHashMap<>();
        for (SalesLedgerProduct product : products) {
            String name = safe(product.getProductCategory());
            String model = safe(product.getSpecificationModel());
            String key = name + "|" + model;
            MaterialRankItem item = grouped.computeIfAbsent(key, ignored -> new MaterialRankItem(name, model, safe(product.getUnit())));
            item.quantity = item.quantity.add(defaultDecimal(product.getQuantity()));
            item.amount = item.amount.add(defaultDecimal(product.getTaxInclusiveTotalPrice()));
        }

        List<Map<String, Object>> items = grouped.values().stream()
                .sorted(Comparator.comparing((MaterialRankItem item) -> item.amount).reversed())
                .limit(normalizeLimit(limit))
                .map(MaterialRankItem::toMap)
                .collect(Collectors.toList());

        return jsonResponse(true, "purchase_material_rank", "已返回采购物料金额排行。",
                rangeSummary(range, items.size()), Map.of("items", items), Map.of());
    }

    @Tool(name = "查询未入库采购订单", value = "查询采购订单下仍有待入库数量的物料明细。")
    public String listUnstockedPurchaseOrders(@ToolMemoryId String memoryId,
                                              @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                              @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                              @P(value = "关键字，可匹配采购合同号/供应商/物料", required = false) String keyword,
                                              @P(value = "返回条数，默认10，最大30", required = false) Integer limit) {
        LoginUser loginUser = currentLoginUser(memoryId);
        DateRange range = resolveDateRange(startDate, endDate, null);
        List<PurchaseLedger> ledgers = queryLedgers(loginUser, range).stream()
                .filter(ledger -> matchLedgerKeyword(ledger, keyword))
                .collect(Collectors.toList());
        Map<Long, PurchaseLedger> ledgerMap = ledgers.stream()
                .filter(ledger -> ledger.getId() != null)
                .collect(Collectors.toMap(PurchaseLedger::getId, ledger -> ledger, (a, b) -> a, LinkedHashMap::new));
        if (ledgerMap.isEmpty()) {
            return jsonResponse(true, "purchase_unstocked_list", "未查询到符合条件的采购订单。",
                    rangeSummary(range, 0), Map.of("items", List.of()), Map.of());
        }

        List<SalesLedgerProduct> products = defaultList(salesLedgerProductMapper.selectList(new LambdaQueryWrapper<SalesLedgerProduct>()
                .eq(SalesLedgerProduct::getType, 2)
                .in(SalesLedgerProduct::getSalesLedgerId, ledgerMap.keySet())));

        List<Map<String, Object>> items = products.stream()
                .filter(product -> matchProductKeyword(product, keyword))
                .map(product -> toUnstockedItem(product, ledgerMap.get(product.getSalesLedgerId())))
                .filter(Objects::nonNull)
                .limit(normalizeLimit(limit))
                .collect(Collectors.toList());

        return jsonResponse(true, "purchase_unstocked_list", "已返回未入库采购订单。",
                rangeSummary(range, items.size()), Map.of("items", items), Map.of());
    }

    @Tool(name = "查询采购到货异常", value = "查询到货状态异常或备注包含异常信息的到货记录。")
    public String listArrivalExceptions(@ToolMemoryId String memoryId,
                                        @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                        @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                        @P(value = "时间范围描述，例如近7天、本月", required = false) String timeRange,
                                        @P(value = "返回条数，默认10，最大30", required = false) Integer limit) {
        LoginUser loginUser = currentLoginUser(memoryId);
        DateRange range = resolveDateRange(startDate, endDate, timeRange);
        LambdaQueryWrapper<InboundManagement> wrapper = new LambdaQueryWrapper<>();
        applyTenantFilter(wrapper, loginUser.getTenantId(), InboundManagement::getTenantId);
        wrapper.ge(InboundManagement::getArrivalTime, toDate(range.start()))
                .lt(InboundManagement::getArrivalTime, toExclusiveEndDate(range.end()))
                .and(w -> w.notLike(InboundManagement::getStatus, "正常")
                        .notLike(InboundManagement::getStatus, "完成")
                        .notLike(InboundManagement::getStatus, "已到货")
                        .or().like(InboundManagement::getStatus, "异常")
                        .or().like(InboundManagement::getRemark, "异常")
                        .or().like(InboundManagement::getRemark, "问题")
                        .or().like(InboundManagement::getRemark, "延迟")
                        .or().like(InboundManagement::getRemark, "短缺"));
        wrapper.orderByDesc(InboundManagement::getArrivalTime).last("limit " + normalizeLimit(limit));

        List<Map<String, Object>> items = defaultList(inboundManagementMapper.selectList(wrapper)).stream()
                .map(this::toArrivalItem)
                .collect(Collectors.toList());
        return jsonResponse(true, "purchase_arrival_exception_list", "已返回采购到货异常记录。",
                rangeSummary(range, items.size()), Map.of("items", items), Map.of());
    }

    @Tool(name = "查询待付款采购单", value = "查询合同金额大于已付款金额的采购单。")
    public String listPendingPaymentOrders(@ToolMemoryId String memoryId,
                                           @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                           @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                           @P(value = "关键字，可匹配采购合同号/供应商/项目名", required = false) String keyword,
                                           @P(value = "返回条数，默认10，最大30", required = false) Integer limit) {
        LoginUser loginUser = currentLoginUser(memoryId);
        DateRange range = resolveDateRange(startDate, endDate, null);
        List<Map<String, Object>> items = queryLedgers(loginUser, range).stream()
                .filter(ledger -> matchLedgerKeyword(ledger, keyword))
                .map(ledger -> toPendingPaymentItem(loginUser, ledger))
                .filter(Objects::nonNull)
                .sorted(Comparator.comparing(item -> (BigDecimal) item.get("pendingAmount"), Comparator.reverseOrder()))
                .limit(normalizeLimit(limit))
                .collect(Collectors.toList());
        return jsonResponse(true, "purchase_pending_payment_list", "已返回待付款采购单。",
                rangeSummary(range, items.size()), Map.of("items", items), Map.of());
    }

    @Tool(name = "查询采购退货情况", value = "按时间范围查询采购退货单列表和退货金额。")
    public String listPurchaseReturns(@ToolMemoryId String memoryId,
                                      @P(value = "开始日期 yyyy-MM-dd", required = false) String startDate,
                                      @P(value = "结束日期 yyyy-MM-dd", required = false) String endDate,
                                      @P(value = "关键字，可匹配退货单号/备注", required = false) String keyword,
                                      @P(value = "返回条数，默认10，最大30", required = false) Integer limit) {
        LoginUser loginUser = currentLoginUser(memoryId);
        DateRange range = resolveDateRange(startDate, endDate, null);
        LambdaQueryWrapper<PurchaseReturnOrders> wrapper = new LambdaQueryWrapper<>();
        applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), PurchaseReturnOrders::getDeptId);
        wrapper.ge(PurchaseReturnOrders::getPreparedAt, range.start())
                .le(PurchaseReturnOrders::getPreparedAt, range.end());
        if (StringUtils.hasText(keyword)) {
            wrapper.and(w -> w.like(PurchaseReturnOrders::getNo, keyword)
                    .or().like(PurchaseReturnOrders::getRemark, keyword)
                    .or().like(PurchaseReturnOrders::getReturnUserName, keyword));
        }
        wrapper.orderByDesc(PurchaseReturnOrders::getPreparedAt).last("limit " + normalizeLimit(limit));

        List<PurchaseReturnOrders> returns = defaultList(purchaseReturnOrdersMapper.selectList(wrapper));
        BigDecimal totalAmount = returns.stream()
                .map(PurchaseReturnOrders::getTotalAmount)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        Map<String, Object> summary = rangeSummary(range, returns.size());
        summary.put("returnAmount", totalAmount);

        return jsonResponse(true, "purchase_return_list", "已返回采购退货情况。",
                summary,
                Map.of("items", returns.stream().map(this::toReturnItem).collect(Collectors.toList())),
                Map.of());
    }

    private List<PurchaseLedger> queryLedgers(LoginUser loginUser, DateRange range) {
        LambdaQueryWrapper<PurchaseLedger> wrapper = new LambdaQueryWrapper<>();
        applyTenantFilter(wrapper, loginUser.getTenantId(), PurchaseLedger::getTenantId);
        wrapper.ge(PurchaseLedger::getEntryDate, toDate(range.start()))
                .lt(PurchaseLedger::getEntryDate, toExclusiveEndDate(range.end()));
        return defaultList(purchaseLedgerMapper.selectList(wrapper));
    }

    private Map<String, Object> rangeSummary(DateRange range, int count) {
        Map<String, Object> summary = new LinkedHashMap<>();
        summary.put("timeRange", range.label());
        summary.put("startDate", range.start().toString());
        summary.put("endDate", range.end().toString());
        summary.put("count", count);
        return summary;
    }

    private boolean matchLedgerKeyword(PurchaseLedger ledger, String keyword) {
        if (!StringUtils.hasText(keyword)) {
            return true;
        }
        String text = keyword.trim();
        return safe(ledger.getPurchaseContractNumber()).contains(text)
                || safe(ledger.getSupplierName()).contains(text)
                || safe(ledger.getProjectName()).contains(text);
    }

    private boolean matchProductKeyword(SalesLedgerProduct product, String keyword) {
        if (!StringUtils.hasText(keyword)) {
            return true;
        }
        String text = keyword.trim();
        return safe(product.getProductCategory()).contains(text)
                || safe(product.getSpecificationModel()).contains(text);
    }

    private Map<String, Object> toUnstockedItem(SalesLedgerProduct product, PurchaseLedger ledger) {
        if (product == null || ledger == null || product.getId() == null) {
            return null;
        }
        BigDecimal orderedQuantity = defaultDecimal(product.getQuantity());
        BigDecimal inboundQuantity = sumInboundQuantity(product.getId());
        BigDecimal pendingQuantity = orderedQuantity.subtract(inboundQuantity);
        if (pendingQuantity.compareTo(BigDecimal.ZERO) <= 0) {
            return null;
        }
        Map<String, Object> item = new LinkedHashMap<>();
        item.put("purchaseLedgerId", ledger.getId());
        item.put("purchaseContractNumber", safe(ledger.getPurchaseContractNumber()));
        item.put("supplierName", safe(ledger.getSupplierName()));
        item.put("productCategory", safe(product.getProductCategory()));
        item.put("specificationModel", safe(product.getSpecificationModel()));
        item.put("unit", safe(product.getUnit()));
        item.put("orderedQuantity", orderedQuantity);
        item.put("inboundQuantity", inboundQuantity);
        item.put("pendingInboundQuantity", pendingQuantity);
        item.put("entryDate", formatDate(ledger.getEntryDate()));
        return item;
    }

    private BigDecimal sumInboundQuantity(Long salesLedgerProductId) {
        List<ProcurementRecordStorage> records = defaultList(procurementRecordMapper.selectList(new LambdaQueryWrapper<ProcurementRecordStorage>()
                .eq(ProcurementRecordStorage::getType, 1)
                .eq(ProcurementRecordStorage::getSalesLedgerProductId, salesLedgerProductId)));
        return records.stream()
                .map(ProcurementRecordStorage::getInboundNum)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    private Map<String, Object> toArrivalItem(InboundManagement item) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("id", item.getId());
        map.put("orderNo", safe(item.getOrderNo()));
        map.put("arrivalNo", safe(item.getArrivalNo()));
        map.put("supplierName", safe(item.getSupplierName()));
        map.put("status", safe(item.getStatus()));
        map.put("arrivalTime", formatDate(item.getArrivalTime()));
        map.put("arrivalQuantity", safe(item.getArrivalQuantity()));
        map.put("remark", safe(item.getRemark()));
        return map;
    }

    private Map<String, Object> toPendingPaymentItem(LoginUser loginUser, PurchaseLedger ledger) {
        BigDecimal contractAmount = defaultDecimal(ledger.getContractAmount());
        BigDecimal paidAmount = sumPaymentAmount(loginUser, ledger.getId());
        BigDecimal pendingAmount = contractAmount.subtract(paidAmount);
        if (pendingAmount.compareTo(BigDecimal.ZERO) <= 0) {
            return null;
        }
        Map<String, Object> item = toLedgerItem(ledger);
        item.put("paidAmount", paidAmount);
        item.put("pendingAmount", pendingAmount);
        return item;
    }

    private BigDecimal sumPaymentAmount(LoginUser loginUser, Long purchaseLedgerId) {
        LambdaQueryWrapper<PaymentRegistration> wrapper = new LambdaQueryWrapper<>();
        applyTenantFilter(wrapper, loginUser.getTenantId(), PaymentRegistration::getTenantId);
        wrapper.eq(PaymentRegistration::getPurchaseLedgerId, purchaseLedgerId);
        return defaultList(paymentRegistrationMapper.selectList(wrapper)).stream()
                .map(PaymentRegistration::getCurrentPaymentAmount)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    private Map<String, Object> toReturnItem(PurchaseReturnOrders item) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("id", item.getId());
        map.put("no", safe(item.getNo()));
        map.put("returnType", item.getReturnType());
        map.put("purchaseLedgerId", item.getPurchaseLedgerId());
        map.put("preparedAt", item.getPreparedAt() == null ? "" : item.getPreparedAt().toString());
        map.put("returnUserName", safe(item.getReturnUserName()));
        map.put("totalAmount", item.getTotalAmount());
        map.put("remark", safe(item.getRemark()));
        return map;
    }

    private BigDecimal defaultDecimal(BigDecimal value) {
        return value == null ? BigDecimal.ZERO : value;
    }

    private List<PaymentRegistration> queryPayments(LoginUser loginUser, DateRange range) {
        LambdaQueryWrapper<PaymentRegistration> wrapper = new LambdaQueryWrapper<>();
        applyTenantFilter(wrapper, loginUser.getTenantId(), PaymentRegistration::getTenantId);
        wrapper.ge(PaymentRegistration::getPaymentDate, toDate(range.start()))
                .lt(PaymentRegistration::getPaymentDate, toExclusiveEndDate(range.end()));
        return defaultList(paymentRegistrationMapper.selectList(wrapper));
    }

    private List<InvoicePurchase> queryInvoices(LoginUser loginUser, DateRange range) {
        LambdaQueryWrapper<InvoicePurchase> wrapper = new LambdaQueryWrapper<>();
        applyTenantFilter(wrapper, loginUser.getTenantId(), InvoicePurchase::getTenantId);
        wrapper.ge(InvoicePurchase::getIssueDate, range.start())
                .le(InvoicePurchase::getIssueDate, range.end());
        return defaultList(invoicePurchaseMapper.selectList(wrapper));
    }

    private List<PurchaseReturnOrders> queryReturns(LoginUser loginUser, DateRange range) {
        LambdaQueryWrapper<PurchaseReturnOrders> wrapper = new LambdaQueryWrapper<>();
        applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), PurchaseReturnOrders::getDeptId);
        wrapper.ge(PurchaseReturnOrders::getPreparedAt, range.start())
                .le(PurchaseReturnOrders::getPreparedAt, range.end());
        return defaultList(purchaseReturnOrdersMapper.selectList(wrapper));
    }

    private Map<String, Object> toLedgerItem(PurchaseLedger item) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("id", item.getId());
        map.put("purchaseContractNumber", safe(item.getPurchaseContractNumber()));
        map.put("supplierName", safe(item.getSupplierName()));
        map.put("projectName", safe(item.getProjectName()));
        map.put("entryDate", formatDate(item.getEntryDate()));
        map.put("contractAmount", item.getContractAmount());
        map.put("approvalStatus", item.getApprovalStatus());
        map.put("paymentMethod", safe(item.getPaymentMethod()));
        return map;
    }

    private DateRange resolveDateRange(String startDate, String endDate, String timeRange) {
        LocalDate today = LocalDate.now();
        LocalDate start = parseLocalDate(startDate);
        LocalDate end = parseLocalDate(endDate);
        if (start != null || end != null) {
            LocalDate s = start != null ? start : end;
            LocalDate e = end != null ? end : start;
            if (s.isAfter(e)) {
                LocalDate temp = s;
                s = e;
                e = temp;
            }
            return new DateRange(s, e, s + "至" + e);
        }
        if (!StringUtils.hasText(timeRange)) {
            return new DateRange(today.minusDays(29), today, "近30天");
        }
        String text = timeRange.trim();
        if (text.contains("今年") || text.contains("本年")) {
            return new DateRange(today.withDayOfYear(1), today, "今年");
        }
        if (text.contains("本月")) {
            return new DateRange(today.withDayOfMonth(1), today, "本月");
        }
        if (text.contains("上月")) {
            LocalDate first = today.minusMonths(1).withDayOfMonth(1);
            LocalDate last = first.withDayOfMonth(first.lengthOfMonth());
            return new DateRange(first, last, "上月");
        }
        if (text.contains("近半年") || text.contains("最近半年")) {
            return new DateRange(today.minusMonths(6).plusDays(1), today, "近半年");
        }
        if (text.contains("近半个月") || text.contains("最近半个月") || text.contains("半个月")) {
            return new DateRange(today.minusDays(14), today, "近半个月");
        }
        java.util.regex.Matcher relativeMatcher = java.util.regex.Pattern.compile("(近|最近)(\\d+)(天|周|个月|月|å¹´)").matcher(text);
        if (relativeMatcher.find()) {
            int amount = Integer.parseInt(relativeMatcher.group(2));
            String unit = relativeMatcher.group(3);
            LocalDate relativeStart = switch (unit) {
                case "天" -> today.minusDays(Math.max(amount - 1L, 0));
                case "周" -> today.minusWeeks(Math.max(amount, 1)).plusDays(1);
                case "个月", "月" -> today.minusMonths(Math.max(amount, 1)).plusDays(1);
                case "å¹´" -> today.minusYears(Math.max(amount, 1)).plusDays(1);
                default -> today.minusDays(29);
            };
            return new DateRange(relativeStart, today, "近" + amount + unit);
        }
        return new DateRange(today.minusDays(29), today, "近30天");
    }

    private LocalDate parseLocalDate(String text) {
        if (!StringUtils.hasText(text)) {
            return null;
        }
        return LocalDate.parse(text.trim(), DATE_FMT);
    }

    private Date toDate(LocalDate localDate) {
        return Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
    }

    private Date toExclusiveEndDate(LocalDate localDate) {
        return Date.from(localDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant());
    }

    private String formatDate(Date date) {
        if (date == null) {
            return "";
        }
        return DATE_FMT.format(date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate());
    }

    private boolean tenantMatched(Long dataTenantId, Long userTenantId) {
        if (userTenantId == null) {
            return true;
        }
        return Objects.equals(dataTenantId, userTenantId);
    }

    private <T> void applyTenantFilter(LambdaQueryWrapper<T> wrapper, Long tenantId, com.baomidou.mybatisplus.core.toolkit.support.SFunction<T, Long> field) {
        if (tenantId != null) {
            wrapper.eq(field, tenantId);
        }
    }

    private <T> void applyDeptFilter(LambdaQueryWrapper<T> wrapper, Long deptId, com.baomidou.mybatisplus.core.toolkit.support.SFunction<T, Long> field) {
        if (deptId != null) {
            wrapper.eq(field, deptId);
        }
    }

    private LoginUser currentLoginUser(String memoryId) {
        LoginUser loginUser = aiSessionUserContext.get(memoryId);
        if (loginUser != null) {
            return loginUser;
        }
        return SecurityUtils.getLoginUser();
    }

    private int normalizeLimit(Integer limit) {
        if (limit == null || limit <= 0) {
            return DEFAULT_LIMIT;
        }
        return Math.min(limit, MAX_LIMIT);
    }

    private String safe(Object value) {
        return value == null ? "" : String.valueOf(value).replace('\n', ' ').replace('\r', ' ');
    }

    private <T> List<T> defaultList(List<T> list) {
        return list == null ? List.of() : list;
    }

    private String jsonResponse(boolean success,
                                String type,
                                String description,
                                Map<String, Object> summary,
                                Map<String, Object> data,
                                Map<String, Object> charts) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("success", success);
        result.put("type", type);
        result.put("description", description);
        result.put("summary", summary == null ? Map.of() : summary);
        result.put("data", data == null ? Map.of() : data);
        result.put("charts", charts == null ? Map.of() : charts);
        return JSON.toJSONString(result);
    }

    private record DateRange(LocalDate start, LocalDate end, String label) {
    }

    private static class MaterialRankItem {
        private final String productCategory;
        private final String specificationModel;
        private final String unit;
        private BigDecimal quantity = BigDecimal.ZERO;
        private BigDecimal amount = BigDecimal.ZERO;

        private MaterialRankItem(String productCategory, String specificationModel, String unit) {
            this.productCategory = productCategory;
            this.specificationModel = specificationModel;
            this.unit = unit;
        }

        private Map<String, Object> toMap() {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("productCategory", productCategory);
            map.put("specificationModel", specificationModel);
            map.put("unit", unit);
            map.put("quantity", quantity);
            map.put("amount", amount);
            return map;
        }
    }
}