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 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.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 AiSessionUserContext aiSessionUserContext;
|
|
public PurchaseAgentTools(PurchaseLedgerMapper purchaseLedgerMapper,
|
PaymentRegistrationMapper paymentRegistrationMapper,
|
InvoicePurchaseMapper invoicePurchaseMapper,
|
PurchaseReturnOrdersMapper purchaseReturnOrdersMapper,
|
AiSessionUserContext aiSessionUserContext) {
|
this.purchaseLedgerMapper = purchaseLedgerMapper;
|
this.paymentRegistrationMapper = paymentRegistrationMapper;
|
this.invoicePurchaseMapper = invoicePurchaseMapper;
|
this.purchaseReturnOrdersMapper = purchaseReturnOrdersMapper;
|
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.le(PurchaseLedger::getEntryDate, toDate(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());
|
}
|
|
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()))
|
.le(PurchaseLedger::getEntryDate, toDate(range.end()));
|
return defaultList(purchaseLedgerMapper.selectList(wrapper));
|
}
|
|
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()))
|
.le(PaymentRegistration::getPaymentDate, toDate(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, "近半个月");
|
}
|
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 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) {
|
}
|
}
|
