| ¶Ô±ÈÐÂÎļþ |
| | |
|---|
| | | package com.ruoyi.ai.tools; |
|---|
| | | |
|---|
| | | import com.alibaba.fastjson2.JSON; |
|---|
| | | import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; |
|---|
| | | import com.baomidou.mybatisplus.core.toolkit.support.SFunction; |
|---|
| | | import com.ruoyi.account.mapper.SalesReceiptReturnMapper; |
|---|
| | | import com.ruoyi.account.pojo.SalesReceiptReturn; |
|---|
| | | import com.ruoyi.ai.context.AiSessionUserContext; |
|---|
| | | import com.ruoyi.basic.dto.CustomerDto; |
|---|
| | | import com.ruoyi.basic.mapper.CustomerMapper; |
|---|
| | | import com.ruoyi.basic.vo.CustomerVo; |
|---|
| | | import com.ruoyi.common.utils.SecurityUtils; |
|---|
| | | import com.ruoyi.framework.security.LoginUser; |
|---|
| | | import com.ruoyi.sales.dto.InvoiceLedgerDto; |
|---|
| | | import com.ruoyi.sales.mapper.InvoiceLedgerMapper; |
|---|
| | | import com.ruoyi.sales.mapper.ReceiptPaymentMapper; |
|---|
| | | import com.ruoyi.sales.mapper.SalesLedgerMapper; |
|---|
| | | import com.ruoyi.sales.mapper.SalesQuotationMapper; |
|---|
| | | import com.ruoyi.sales.mapper.ShippingInfoMapper; |
|---|
| | | import com.ruoyi.sales.pojo.ReceiptPayment; |
|---|
| | | import com.ruoyi.sales.pojo.SalesLedger; |
|---|
| | | import com.ruoyi.sales.pojo.SalesQuotation; |
|---|
| | | import com.ruoyi.sales.pojo.ShippingInfo; |
|---|
| | | 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.math.RoundingMode; |
|---|
| | | import java.time.LocalDate; |
|---|
| | | import java.time.LocalDateTime; |
|---|
| | | import java.time.YearMonth; |
|---|
| | | import java.time.ZoneId; |
|---|
| | | import java.time.format.DateTimeFormatter; |
|---|
| | | import java.util.ArrayList; |
|---|
| | | import java.util.Comparator; |
|---|
| | | import java.util.Date; |
|---|
| | | import java.util.HashMap; |
|---|
| | | import java.util.LinkedHashMap; |
|---|
| | | import java.util.LinkedList; |
|---|
| | | import java.util.List; |
|---|
| | | import java.util.Locale; |
|---|
| | | import java.util.Map; |
|---|
| | | import java.util.Objects; |
|---|
| | | import java.util.regex.Matcher; |
|---|
| | | import java.util.regex.Pattern; |
|---|
| | | import java.util.stream.Collectors; |
|---|
| | | |
|---|
| | | @Component |
|---|
| | | public class SalesAgentTools { |
|---|
| | | |
|---|
| | | 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 static final BigDecimal ONE_HUNDRED = new BigDecimal("100"); |
|---|
| | | private static final Pattern RELATIVE_PATTERN = Pattern.compile("(è¿|æè¿)?\\s*(\\d+)\\s*(天|å¨|个æ|æ|å¹´)"); |
|---|
| | | private static final Pattern DATE_PATTERN = Pattern.compile("(\\d{4}-\\d{2}-\\d{2})"); |
|---|
| | | |
|---|
| | | private final CustomerMapper customerMapper; |
|---|
| | | private final SalesLedgerMapper salesLedgerMapper; |
|---|
| | | private final SalesQuotationMapper salesQuotationMapper; |
|---|
| | | private final ShippingInfoMapper shippingInfoMapper; |
|---|
| | | private final ReceiptPaymentMapper receiptPaymentMapper; |
|---|
| | | private final InvoiceLedgerMapper invoiceLedgerMapper; |
|---|
| | | private final SalesReceiptReturnMapper salesReceiptReturnMapper; |
|---|
| | | private final AiSessionUserContext aiSessionUserContext; |
|---|
| | | |
|---|
| | | public SalesAgentTools(CustomerMapper customerMapper, |
|---|
| | | SalesLedgerMapper salesLedgerMapper, |
|---|
| | | SalesQuotationMapper salesQuotationMapper, |
|---|
| | | ShippingInfoMapper shippingInfoMapper, |
|---|
| | | ReceiptPaymentMapper receiptPaymentMapper, |
|---|
| | | InvoiceLedgerMapper invoiceLedgerMapper, |
|---|
| | | SalesReceiptReturnMapper salesReceiptReturnMapper, |
|---|
| | | AiSessionUserContext aiSessionUserContext) { |
|---|
| | | this.customerMapper = customerMapper; |
|---|
| | | this.salesLedgerMapper = salesLedgerMapper; |
|---|
| | | this.salesQuotationMapper = salesQuotationMapper; |
|---|
| | | this.shippingInfoMapper = shippingInfoMapper; |
|---|
| | | this.receiptPaymentMapper = receiptPaymentMapper; |
|---|
| | | this.invoiceLedgerMapper = invoiceLedgerMapper; |
|---|
| | | this.salesReceiptReturnMapper = salesReceiptReturnMapper; |
|---|
| | | this.aiSessionUserContext = aiSessionUserContext; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢å®¢æ·æ¡£æ¡", value = "æç§æµ·/å
¬æµ·ç±»ååå
³é®è¯æ¥è¯¢å®¢æ·æ¡£æ¡å表") |
|---|
| | | public String listCustomerProfiles(@ToolMemoryId String memoryId, |
|---|
| | | @P(value = "客æ·æ± ç±»åï¼å¯é private/public", required = false) String seaType, |
|---|
| | | @P(value = "å
³é®è¯ï¼å¯å¹é
客æ·å称/è系人/çµè¯", required = false) String keyword, |
|---|
| | | @P(value = "è¿åæ¡æ°ï¼é»è®¤10ï¼æ大30", required = false) Integer limit) { |
|---|
| | | LoginUser loginUser = currentLoginUser(memoryId); |
|---|
| | | CustomerDto customerDto = new CustomerDto(); |
|---|
| | | customerDto.setType(normalizeSeaType(seaType)); |
|---|
| | | customerDto.setUsageStatus(1L); |
|---|
| | | |
|---|
| | | List<CustomerVo> rows = defaultList(customerMapper.list(customerDto, loginUser.getUserId())); |
|---|
| | | List<CustomerVo> filtered = rows.stream() |
|---|
| | | .filter(item -> matchCustomerKeyword(item, keyword)) |
|---|
| | | .sorted(Comparator.comparing(CustomerVo::getId, Comparator.nullsLast(Comparator.reverseOrder()))) |
|---|
| | | .limit(normalizeLimit(limit)) |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = filtered.stream().map(item -> { |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("id", item.getId()); |
|---|
| | | map.put("customerName", safe(item.getCustomerName())); |
|---|
| | | map.put("customerType", safe(item.getCustomerType())); |
|---|
| | | map.put("contactPerson", safe(item.getContactPerson())); |
|---|
| | | map.put("contactPhone", safe(item.getContactPhone())); |
|---|
| | | map.put("companyPhone", safe(item.getCompanyPhone())); |
|---|
| | | map.put("maintainer", safe(item.getMaintainer())); |
|---|
| | | map.put("maintenanceTime", formatDate(item.getMaintenanceTime())); |
|---|
| | | map.put("usageUserName", safe(item.getUsageUserName())); |
|---|
| | | map.put("seaType", customerSeaTypeName(item.getType())); |
|---|
| | | map.put("isAssigned", item.getIsAssigned()); |
|---|
| | | return map; |
|---|
| | | }).collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | Map<String, Object> summary = new LinkedHashMap<>(); |
|---|
| | | summary.put("count", items.size()); |
|---|
| | | summary.put("seaType", seaType == null ? "all" : seaType); |
|---|
| | | summary.put("keyword", safe(keyword)); |
|---|
| | | summary.put("userId", loginUser.getUserId()); |
|---|
| | | |
|---|
| | | return jsonResponse(true, "sales_customer_profile_list", "å·²è¿å客æ·æ¡£æ¡å表", summary, Map.of("items", items), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢éå®æ¥ä»·", value = "æå
³é®è¯åæ¶é´èå´æ¥è¯¢éå®æ¥ä»·å") |
|---|
| | | public String listSalesQuotations(@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); |
|---|
| | | DateRange range = resolveDateRange(startDate, endDate, null); |
|---|
| | | LambdaQueryWrapper<SalesQuotation> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), SalesQuotation::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), SalesQuotation::getDeptId); |
|---|
| | | if (StringUtils.hasText(keyword)) { |
|---|
| | | wrapper.and(w -> w.like(SalesQuotation::getQuotationNo, keyword) |
|---|
| | | .or().like(SalesQuotation::getCustomer, keyword) |
|---|
| | | .or().like(SalesQuotation::getSalesperson, keyword) |
|---|
| | | .or().like(SalesQuotation::getStatus, keyword)); |
|---|
| | | } |
|---|
| | | wrapper.ge(SalesQuotation::getQuotationDate, range.start()) |
|---|
| | | .le(SalesQuotation::getQuotationDate, range.end()) |
|---|
| | | .orderByDesc(SalesQuotation::getQuotationDate, SalesQuotation::getId) |
|---|
| | | .last("limit " + normalizeLimit(limit)); |
|---|
| | | |
|---|
| | | List<SalesQuotation> rows = defaultList(salesQuotationMapper.selectList(wrapper)); |
|---|
| | | BigDecimal quotationAmountTotal = rows.stream() |
|---|
| | | .map(SalesQuotation::getTotalAmount) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .reduce(BigDecimal.ZERO, BigDecimal::add); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = rows.stream().map(item -> { |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("id", item.getId()); |
|---|
| | | map.put("quotationNo", safe(item.getQuotationNo())); |
|---|
| | | map.put("customer", safe(item.getCustomer())); |
|---|
| | | map.put("salesperson", safe(item.getSalesperson())); |
|---|
| | | map.put("quotationDate", formatDate(item.getQuotationDate())); |
|---|
| | | map.put("validDate", formatDate(item.getValidDate())); |
|---|
| | | map.put("status", safe(item.getStatus())); |
|---|
| | | map.put("paymentMethod", safe(item.getPaymentMethod())); |
|---|
| | | map.put("deliveryPeriod", safe(item.getDeliveryPeriod())); |
|---|
| | | map.put("totalAmount", item.getTotalAmount()); |
|---|
| | | return map; |
|---|
| | | }).collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("quotationAmountTotal", quotationAmountTotal); |
|---|
| | | return jsonResponse(true, "sales_quotation_list", "å·²è¿åéå®æ¥ä»·å表", summary, Map.of("items", items), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢éå®å°è´¦", value = "æå
³é®è¯åæ¶é´èå´æ¥è¯¢éå®å°è´¦ï¼å¹¶è¿åå¼ç¥¨å款ä¸åè´§ç¶æ") |
|---|
| | | public String listSalesLedgers(@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); |
|---|
| | | DateRange range = resolveDateRange(startDate, endDate, null); |
|---|
| | | LambdaQueryWrapper<SalesLedger> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), SalesLedger::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), SalesLedger::getDeptId); |
|---|
| | | if (StringUtils.hasText(keyword)) { |
|---|
| | | wrapper.and(w -> w.like(SalesLedger::getSalesContractNo, keyword) |
|---|
| | | .or().like(SalesLedger::getCustomerContractNo, keyword) |
|---|
| | | .or().like(SalesLedger::getCustomerName, keyword) |
|---|
| | | .or().like(SalesLedger::getProjectName, keyword) |
|---|
| | | .or().like(SalesLedger::getSalesman, keyword)); |
|---|
| | | } |
|---|
| | | wrapper.ge(SalesLedger::getEntryDate, toDate(range.start())) |
|---|
| | | .lt(SalesLedger::getEntryDate, toExclusiveEndDate(range.end())) |
|---|
| | | .orderByDesc(SalesLedger::getEntryDate, SalesLedger::getId) |
|---|
| | | .last("limit " + normalizeLimit(limit)); |
|---|
| | | List<SalesLedger> rows = defaultList(salesLedgerMapper.selectList(wrapper)); |
|---|
| | | if (rows.isEmpty()) { |
|---|
| | | return jsonResponse(true, "sales_ledger_list", "æªæ¥è¯¢å°ç¬¦åæ¡ä»¶çéå®å°è´¦", rangeSummary(range, 0, keyword), Map.of("items", List.of()), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | List<Long> ledgerIds = rows.stream().map(SalesLedger::getId).filter(Objects::nonNull).collect(Collectors.toList()); |
|---|
| | | Map<Long, BigDecimal> invoiceAmountByLedgerId = sumInvoiceAmounts(ledgerIds); |
|---|
| | | Map<Long, BigDecimal> receiptAmountByLedgerId = sumReceiptAmounts(loginUser, ledgerIds); |
|---|
| | | Map<Long, List<ShippingInfo>> shippingByLedgerId = queryShippingsByLedgerIds(loginUser, ledgerIds).stream() |
|---|
| | | .collect(Collectors.groupingBy(ShippingInfo::getSalesLedgerId)); |
|---|
| | | |
|---|
| | | BigDecimal contractAmountTotal = BigDecimal.ZERO; |
|---|
| | | BigDecimal invoicedAmountTotal = BigDecimal.ZERO; |
|---|
| | | BigDecimal receivedAmountTotal = BigDecimal.ZERO; |
|---|
| | | BigDecimal pendingAmountTotal = BigDecimal.ZERO; |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = new ArrayList<>(); |
|---|
| | | for (SalesLedger ledger : rows) { |
|---|
| | | BigDecimal contractAmount = defaultDecimal(ledger.getContractAmount()); |
|---|
| | | BigDecimal invoicedAmount = invoiceAmountByLedgerId.getOrDefault(ledger.getId(), BigDecimal.ZERO); |
|---|
| | | BigDecimal receivedAmount = receiptAmountByLedgerId.getOrDefault(ledger.getId(), BigDecimal.ZERO); |
|---|
| | | BigDecimal unbilledAmount = maxZero(contractAmount.subtract(invoicedAmount)); |
|---|
| | | BigDecimal pendingAmount = maxZero(invoicedAmount.subtract(receivedAmount)); |
|---|
| | | |
|---|
| | | contractAmountTotal = contractAmountTotal.add(contractAmount); |
|---|
| | | invoicedAmountTotal = invoicedAmountTotal.add(invoicedAmount); |
|---|
| | | receivedAmountTotal = receivedAmountTotal.add(receivedAmount); |
|---|
| | | pendingAmountTotal = pendingAmountTotal.add(pendingAmount); |
|---|
| | | |
|---|
| | | Map<String, Object> item = new LinkedHashMap<>(); |
|---|
| | | item.put("id", ledger.getId()); |
|---|
| | | item.put("salesContractNo", safe(ledger.getSalesContractNo())); |
|---|
| | | item.put("customerContractNo", safe(ledger.getCustomerContractNo())); |
|---|
| | | item.put("customerName", safe(ledger.getCustomerName())); |
|---|
| | | item.put("projectName", safe(ledger.getProjectName())); |
|---|
| | | item.put("salesman", safe(ledger.getSalesman())); |
|---|
| | | item.put("entryDate", formatDate(ledger.getEntryDate())); |
|---|
| | | item.put("executionDate", formatDate(ledger.getExecutionDate())); |
|---|
| | | item.put("deliveryDate", formatDate(ledger.getDeliveryDate())); |
|---|
| | | item.put("contractAmount", contractAmount); |
|---|
| | | item.put("invoicedAmount", invoicedAmount); |
|---|
| | | item.put("receivedAmount", receivedAmount); |
|---|
| | | item.put("unbilledAmount", unbilledAmount); |
|---|
| | | item.put("pendingAmount", pendingAmount); |
|---|
| | | item.put("shippingStatus", calcLedgerShippingStatus(shippingByLedgerId.get(ledger.getId()))); |
|---|
| | | items.add(item); |
|---|
| | | } |
|---|
| | | |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("contractAmountTotal", contractAmountTotal); |
|---|
| | | summary.put("invoicedAmountTotal", invoicedAmountTotal); |
|---|
| | | summary.put("receivedAmountTotal", receivedAmountTotal); |
|---|
| | | summary.put("pendingAmountTotal", pendingAmountTotal); |
|---|
| | | return jsonResponse(true, "sales_ledger_list", "å·²è¿åéå®å°è´¦å表", summary, Map.of("items", items), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢éå®éè´§", value = "ææ¶é´èå´åå
³é®è¯æ¥è¯¢éå®é货记å½") |
|---|
| | | public String listSalesReturns(@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<SalesReceiptReturn> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), SalesReceiptReturn::getDeptId); |
|---|
| | | if (StringUtils.hasText(keyword)) { |
|---|
| | | wrapper.and(w -> w.like(SalesReceiptReturn::getRefundId, keyword) |
|---|
| | | .or().like(SalesReceiptReturn::getTransactionNo, keyword) |
|---|
| | | .or().like(SalesReceiptReturn::getPaymentAccountName, keyword)); |
|---|
| | | } |
|---|
| | | wrapper.ge(SalesReceiptReturn::getCreateTime, range.start().atStartOfDay()) |
|---|
| | | .le(SalesReceiptReturn::getCreateTime, range.end().atTime(23, 59, 59)) |
|---|
| | | .orderByDesc(SalesReceiptReturn::getCreateTime, SalesReceiptReturn::getId) |
|---|
| | | .last("limit " + normalizeLimit(limit)); |
|---|
| | | List<SalesReceiptReturn> rows = defaultList(salesReceiptReturnMapper.selectList(wrapper)); |
|---|
| | | |
|---|
| | | BigDecimal returnAmount = rows.stream() |
|---|
| | | .map(SalesReceiptReturn::getActualAmount) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .reduce(BigDecimal.ZERO, BigDecimal::add); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = rows.stream().map(item -> { |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("id", item.getId()); |
|---|
| | | map.put("refundId", safe(item.getRefundId())); |
|---|
| | | map.put("paymentAccount", safe(item.getPaymentAccount())); |
|---|
| | | map.put("paymentAccountName", safe(item.getPaymentAccountName())); |
|---|
| | | map.put("paymentMethod", item.getPaymentMethod()); |
|---|
| | | map.put("actualAmount", item.getActualAmount()); |
|---|
| | | map.put("fee", item.getFee()); |
|---|
| | | map.put("discountAmount", item.getDiscountAmount()); |
|---|
| | | map.put("transactionNo", safe(item.getTransactionNo())); |
|---|
| | | map.put("createTime", formatDateTime(item.getCreateTime())); |
|---|
| | | return map; |
|---|
| | | }).collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("returnAmount", returnAmount); |
|---|
| | | return jsonResponse(true, "sales_return_list", "å·²è¿åéå®é货记å½", summary, Map.of("items", items), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢å®¢æ·å¾æ¥", value = "ææ¶é´èå´åå
³é®è¯æ¥è¯¢å®¢æ·å款å¾æ¥æç»") |
|---|
| | | public String listCustomerInteractions(@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); |
|---|
| | | DateRange range = resolveDateRange(startDate, endDate, null); |
|---|
| | | LambdaQueryWrapper<ReceiptPayment> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), ReceiptPayment::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), ReceiptPayment::getDeptId); |
|---|
| | | wrapper.ge(ReceiptPayment::getReceiptPaymentDate, range.start()) |
|---|
| | | .le(ReceiptPayment::getReceiptPaymentDate, range.end()) |
|---|
| | | .orderByDesc(ReceiptPayment::getReceiptPaymentDate, ReceiptPayment::getId); |
|---|
| | | List<ReceiptPayment> payments = defaultList(receiptPaymentMapper.selectList(wrapper)); |
|---|
| | | if (payments.isEmpty()) { |
|---|
| | | return jsonResponse(true, "sales_customer_interaction_list", "æªæ¥è¯¢å°å®¢æ·å¾æ¥è®°å½", rangeSummary(range, 0, keyword), Map.of("items", List.of()), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | List<Long> ledgerIds = payments.stream() |
|---|
| | | .map(ReceiptPayment::getSalesLedgerId) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .distinct() |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | Map<Long, SalesLedger> ledgerMap = defaultList(salesLedgerMapper.selectBatchIds(ledgerIds)).stream() |
|---|
| | | .filter(ledger -> tenantMatched(ledger.getTenantId(), loginUser.getTenantId())) |
|---|
| | | .collect(Collectors.toMap(SalesLedger::getId, item -> item, (a, b) -> a, LinkedHashMap::new)); |
|---|
| | | |
|---|
| | | List<ReceiptPayment> filtered = payments.stream() |
|---|
| | | .filter(item -> matchInteractionKeyword(item, ledgerMap.get(item.getSalesLedgerId()), keyword)) |
|---|
| | | .limit(normalizeLimit(limit)) |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | BigDecimal totalReceiptAmount = filtered.stream() |
|---|
| | | .map(ReceiptPayment::getReceiptPaymentAmount) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .reduce(BigDecimal.ZERO, BigDecimal::add); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = filtered.stream().map(item -> { |
|---|
| | | SalesLedger ledger = ledgerMap.get(item.getSalesLedgerId()); |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("id", item.getId()); |
|---|
| | | map.put("salesLedgerId", item.getSalesLedgerId()); |
|---|
| | | map.put("salesContractNo", ledger == null ? "" : safe(ledger.getSalesContractNo())); |
|---|
| | | map.put("customerName", ledger == null ? "" : safe(ledger.getCustomerName())); |
|---|
| | | map.put("projectName", ledger == null ? "" : safe(ledger.getProjectName())); |
|---|
| | | map.put("receiptPaymentDate", formatDate(item.getReceiptPaymentDate())); |
|---|
| | | map.put("receiptPaymentAmount", item.getReceiptPaymentAmount()); |
|---|
| | | map.put("receiptPaymentType", safe(item.getReceiptPaymentType())); |
|---|
| | | map.put("registrant", safe(item.getRegistrant())); |
|---|
| | | return map; |
|---|
| | | }).collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("totalReceiptAmount", totalReceiptAmount); |
|---|
| | | summary.put("customerCount", items.stream().map(item -> String.valueOf(item.get("customerName"))).filter(StringUtils::hasText).distinct().count()); |
|---|
| | | return jsonResponse(true, "sales_customer_interaction_list", "å·²è¿å客æ·å¾æ¥æç»", summary, Map.of("items", items), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢åè´§å°è´¦", value = "æå
³é®è¯åæ¶é´èå´æ¥è¯¢åè´§å°è´¦") |
|---|
| | | public String listShippingLedgers(@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); |
|---|
| | | DateRange range = resolveDateRange(startDate, endDate, null); |
|---|
| | | LambdaQueryWrapper<ShippingInfo> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), ShippingInfo::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), ShippingInfo::getDeptId); |
|---|
| | | if (StringUtils.hasText(keyword)) { |
|---|
| | | wrapper.and(w -> w.like(ShippingInfo::getShippingNo, keyword) |
|---|
| | | .or().like(ShippingInfo::getExpressNumber, keyword) |
|---|
| | | .or().like(ShippingInfo::getExpressCompany, keyword) |
|---|
| | | .or().like(ShippingInfo::getShippingCarNumber, keyword) |
|---|
| | | .or().like(ShippingInfo::getStatus, keyword)); |
|---|
| | | } |
|---|
| | | wrapper.ge(ShippingInfo::getShippingDate, toDate(range.start())) |
|---|
| | | .lt(ShippingInfo::getShippingDate, toExclusiveEndDate(range.end())) |
|---|
| | | .orderByDesc(ShippingInfo::getShippingDate, ShippingInfo::getId) |
|---|
| | | .last("limit " + normalizeLimit(limit)); |
|---|
| | | List<ShippingInfo> rows = defaultList(shippingInfoMapper.selectList(wrapper)); |
|---|
| | | if (rows.isEmpty()) { |
|---|
| | | return jsonResponse(true, "sales_shipping_list", "æªæ¥è¯¢å°åè´§å°è´¦è®°å½", rangeSummary(range, 0, keyword), Map.of("items", List.of()), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | List<Long> ledgerIds = rows.stream().map(ShippingInfo::getSalesLedgerId).filter(Objects::nonNull).distinct().collect(Collectors.toList()); |
|---|
| | | Map<Long, SalesLedger> ledgerMap = defaultList(salesLedgerMapper.selectBatchIds(ledgerIds)).stream() |
|---|
| | | .filter(ledger -> tenantMatched(ledger.getTenantId(), loginUser.getTenantId())) |
|---|
| | | .collect(Collectors.toMap(SalesLedger::getId, item -> item, (a, b) -> a, LinkedHashMap::new)); |
|---|
| | | |
|---|
| | | long shippedCount = rows.stream().filter(item -> isShippedStatus(item.getStatus())).count(); |
|---|
| | | List<Map<String, Object>> items = rows.stream().map(item -> { |
|---|
| | | SalesLedger ledger = ledgerMap.get(item.getSalesLedgerId()); |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("id", item.getId()); |
|---|
| | | map.put("salesLedgerId", item.getSalesLedgerId()); |
|---|
| | | map.put("salesContractNo", ledger == null ? "" : safe(ledger.getSalesContractNo())); |
|---|
| | | map.put("customerName", ledger == null ? "" : safe(ledger.getCustomerName())); |
|---|
| | | map.put("shippingNo", safe(item.getShippingNo())); |
|---|
| | | map.put("status", safe(item.getStatus())); |
|---|
| | | map.put("shippingDate", formatDate(item.getShippingDate())); |
|---|
| | | map.put("type", safe(item.getType())); |
|---|
| | | map.put("shippingCarNumber", safe(item.getShippingCarNumber())); |
|---|
| | | map.put("expressCompany", safe(item.getExpressCompany())); |
|---|
| | | map.put("expressNumber", safe(item.getExpressNumber())); |
|---|
| | | return map; |
|---|
| | | }).collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("shippingCount", rows.size()); |
|---|
| | | summary.put("shippedCount", shippedCount); |
|---|
| | | summary.put("pendingCount", Math.max(rows.size() - shippedCount, 0)); |
|---|
| | | return jsonResponse(true, "sales_shipping_list", "å·²è¿ååè´§å°è´¦è®°å½", summary, Map.of("items", items), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "æ¥è¯¢éå®ææ ç»è®¡", value = "ææ¶é´èå´ç»è®¡éå®ååãæ¥ä»·ãåè´§ãå款çå
³é®ææ ") |
|---|
| | | public String getSalesDashboard(@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<SalesLedger> ledgers = querySalesLedgers(loginUser, range); |
|---|
| | | List<SalesQuotation> quotations = querySalesQuotations(loginUser, range); |
|---|
| | | List<ShippingInfo> shippings = queryShippings(loginUser, range); |
|---|
| | | List<ReceiptPayment> receipts = queryReceipts(loginUser, range); |
|---|
| | | |
|---|
| | | BigDecimal contractAmountTotal = ledgers.stream() |
|---|
| | | .map(SalesLedger::getContractAmount) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .reduce(BigDecimal.ZERO, BigDecimal::add); |
|---|
| | | BigDecimal quotationAmountTotal = quotations.stream() |
|---|
| | | .map(SalesQuotation::getTotalAmount) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .reduce(BigDecimal.ZERO, BigDecimal::add); |
|---|
| | | BigDecimal receivedAmountTotal = receipts.stream() |
|---|
| | | .map(ReceiptPayment::getReceiptPaymentAmount) |
|---|
| | | .filter(Objects::nonNull) |
|---|
| | | .reduce(BigDecimal.ZERO, BigDecimal::add); |
|---|
| | | BigDecimal pendingAmountTotal = maxZero(contractAmountTotal.subtract(receivedAmountTotal)); |
|---|
| | | |
|---|
| | | long shippingCount = shippings.size(); |
|---|
| | | long shippedCount = shippings.stream().filter(item -> isShippedStatus(item.getStatus())).count(); |
|---|
| | | String shipRate = toRate(shippedCount, shippingCount); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> topCustomers = buildTopCustomers(ledgers); |
|---|
| | | TrendData trendData = buildContractTrendData(ledgers, range); |
|---|
| | | |
|---|
| | | 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("orderCount", ledgers.size()); |
|---|
| | | summary.put("quotationCount", quotations.size()); |
|---|
| | | summary.put("shippingCount", shippingCount); |
|---|
| | | summary.put("shippedCount", shippedCount); |
|---|
| | | summary.put("shipRate", shipRate); |
|---|
| | | summary.put("contractAmountTotal", contractAmountTotal); |
|---|
| | | summary.put("quotationAmountTotal", quotationAmountTotal); |
|---|
| | | summary.put("receivedAmountTotal", receivedAmountTotal); |
|---|
| | | summary.put("pendingAmountTotal", pendingAmountTotal); |
|---|
| | | |
|---|
| | | Map<String, Object> charts = new LinkedHashMap<>(); |
|---|
| | | charts.put("amountBarOption", buildAmountBarOption(contractAmountTotal, quotationAmountTotal, receivedAmountTotal, pendingAmountTotal)); |
|---|
| | | charts.put("shippingPieOption", buildShippingPieOption(shippedCount, Math.max(shippingCount - shippedCount, 0))); |
|---|
| | | charts.put("customerTopBarOption", buildCustomerTopBarOption(topCustomers)); |
|---|
| | | charts.put("contractTrendLineOption", buildContractTrendLineOption(trendData.labels(), trendData.values())); |
|---|
| | | |
|---|
| | | Map<String, Object> data = new LinkedHashMap<>(); |
|---|
| | | data.put("topCustomers", topCustomers); |
|---|
| | | data.put("contractTrend", trendData.toItemList()); |
|---|
| | | |
|---|
| | | return jsonResponse(true, "sales_dashboard", "å·²è¿åéå®ææ ç»è®¡", summary, data, charts); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "客æ·æµå¤±é£é©åæ", value = "æ客æ·ç»´åº¦è¯ä¼°æµå¤±é£é©ï¼è¾åºé£é©å级ãåå å建议ä¼å
级") |
|---|
| | | public String analyzeCustomerChurnRisk(@ToolMemoryId String memoryId, |
|---|
| | | @P(value = "å¼å§æ¥æ yyyy-MM-dd", required = false) String startDate, |
|---|
| | | @P(value = "ç»ææ¥æ yyyy-MM-dd", required = false) String endDate, |
|---|
| | | @P(value = "æ¶é´èå´æè¿°ï¼å¦è¿90天ãæ¬å¹´", required = false) String timeRange, |
|---|
| | | @P(value = "å
³é®è¯ï¼å¯å¹é
客æ·å称", required = false) String keyword, |
|---|
| | | @P(value = "è¿åæ¡æ°ï¼é»è®¤10ï¼æ大30", required = false) Integer limit) { |
|---|
| | | LoginUser loginUser = currentLoginUser(memoryId); |
|---|
| | | DateRange range = resolveDateRange(startDate, endDate, StringUtils.hasText(timeRange) ? timeRange : "è¿180天"); |
|---|
| | | List<CustomerRiskMetric> metrics = buildCustomerRiskMetrics(loginUser, range, keyword); |
|---|
| | | if (metrics.isEmpty()) { |
|---|
| | | return jsonResponse(true, "sales_customer_churn_risk", "å½åèå´å
æªæ¥è¯¢å°å¯åæç客æ·æ°æ®", |
|---|
| | | rangeSummary(range, 0, keyword), Map.of("items", List.of()), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | List<CustomerRiskMetric> sorted = metrics.stream() |
|---|
| | | .sorted(Comparator.comparing(CustomerRiskMetric::getRiskScore).reversed() |
|---|
| | | .thenComparing(CustomerRiskMetric::getPendingAmount, Comparator.reverseOrder())) |
|---|
| | | .limit(normalizeLimit(limit)) |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | long highCount = sorted.stream().filter(item -> "high".equals(item.getRiskLevel())).count(); |
|---|
| | | long mediumCount = sorted.stream().filter(item -> "medium".equals(item.getRiskLevel())).count(); |
|---|
| | | long lowCount = sorted.stream().filter(item -> "low".equals(item.getRiskLevel())).count(); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = sorted.stream().map(this::toRiskItem).collect(Collectors.toList()); |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("highRiskCount", highCount); |
|---|
| | | summary.put("mediumRiskCount", mediumCount); |
|---|
| | | summary.put("lowRiskCount", lowCount); |
|---|
| | | |
|---|
| | | Map<String, Object> charts = new LinkedHashMap<>(); |
|---|
| | | charts.put("riskLevelPieOption", buildRiskLevelPieOption(highCount, mediumCount, lowCount)); |
|---|
| | | charts.put("riskScoreBarOption", buildRiskScoreBarOption(sorted)); |
|---|
| | | |
|---|
| | | return jsonResponse(true, "sales_customer_churn_risk", "å·²å®æ客æ·æµå¤±é£é©åæ", summary, Map.of("items", items), charts); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Tool(name = "å款ä¸æ¥ä»·çç¥å»ºè®®", value = "åºäºå®¢æ·é£é©ãå款åæ¥ä»·æ
åµçæå¯æ§è¡çè·è¿çç¥") |
|---|
| | | public String suggestCollectionAndQuotationStrategy(@ToolMemoryId String memoryId, |
|---|
| | | @P(value = "å¼å§æ¥æ yyyy-MM-dd", required = false) String startDate, |
|---|
| | | @P(value = "ç»ææ¥æ yyyy-MM-dd", required = false) String endDate, |
|---|
| | | @P(value = "æ¶é´èå´æè¿°ï¼å¦è¿90天ãæ¬æ", required = false) String timeRange, |
|---|
| | | @P(value = "å
³é®è¯ï¼å¯å¹é
客æ·å称", required = false) String keyword, |
|---|
| | | @P(value = "è¿åæ¡æ°ï¼é»è®¤10ï¼æ大30", required = false) Integer limit, |
|---|
| | | @P(value = "æ¯å¦ä¼å
é«é£é©å®¢æ·ï¼true 表示é«é£é©ä¼å
", required = false) Boolean prioritizeHighRisk) { |
|---|
| | | LoginUser loginUser = currentLoginUser(memoryId); |
|---|
| | | DateRange range = resolveDateRange(startDate, endDate, StringUtils.hasText(timeRange) ? timeRange : "è¿90天"); |
|---|
| | | List<CustomerRiskMetric> metrics = buildCustomerRiskMetrics(loginUser, range, keyword); |
|---|
| | | if (metrics.isEmpty()) { |
|---|
| | | return jsonResponse(true, "sales_collection_quote_strategy", "å½åèå´å
æªæ¥è¯¢å°å¯çæçç¥ç客æ·æ°æ®", |
|---|
| | | rangeSummary(range, 0, keyword), Map.of("items", List.of()), Map.of()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | boolean highRiskFirst = Boolean.TRUE.equals(prioritizeHighRisk); |
|---|
| | | Comparator<CustomerRiskMetric> sortComparator; |
|---|
| | | if (highRiskFirst) { |
|---|
| | | sortComparator = Comparator |
|---|
| | | .comparingInt((CustomerRiskMetric metric) -> riskLevelRank(metric.getRiskLevel())).reversed() |
|---|
| | | .thenComparing(CustomerRiskMetric::getRiskScore, Comparator.reverseOrder()) |
|---|
| | | .thenComparing(CustomerRiskMetric::getPendingAmount, Comparator.reverseOrder()); |
|---|
| | | } else { |
|---|
| | | sortComparator = Comparator |
|---|
| | | .comparing(CustomerRiskMetric::getPendingAmount, Comparator.reverseOrder()) |
|---|
| | | .thenComparing(CustomerRiskMetric::getRiskScore, Comparator.reverseOrder()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | List<CustomerRiskMetric> sorted = metrics.stream() |
|---|
| | | .sorted(sortComparator) |
|---|
| | | .limit(normalizeLimit(limit)) |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | |
|---|
| | | List<Map<String, Object>> items = sorted.stream().map(this::toStrategyItem).collect(Collectors.toList()); |
|---|
| | | long highPriorityCount = items.stream().filter(item -> "high".equals(item.get("priority"))).count(); |
|---|
| | | long mediumPriorityCount = items.stream().filter(item -> "medium".equals(item.get("priority"))).count(); |
|---|
| | | long lowPriorityCount = items.stream().filter(item -> "low".equals(item.get("priority"))).count(); |
|---|
| | | |
|---|
| | | Map<String, Object> summary = rangeSummary(range, items.size(), keyword); |
|---|
| | | summary.put("highPriorityCount", highPriorityCount); |
|---|
| | | summary.put("mediumPriorityCount", mediumPriorityCount); |
|---|
| | | summary.put("lowPriorityCount", lowPriorityCount); |
|---|
| | | summary.put("prioritizeHighRisk", highRiskFirst); |
|---|
| | | summary.put("priorityMode", highRiskFirst ? "high_risk_first" : "pending_amount_first"); |
|---|
| | | |
|---|
| | | Map<String, Object> charts = new LinkedHashMap<>(); |
|---|
| | | charts.put("pendingAmountBarOption", buildPendingAmountBarOption(sorted)); |
|---|
| | | charts.put("priorityPieOption", buildPriorityPieOption(highPriorityCount, mediumPriorityCount, lowPriorityCount)); |
|---|
| | | |
|---|
| | | return jsonResponse(true, "sales_collection_quote_strategy", "å·²çæå款ä¸æ¥ä»·çç¥å»ºè®®", summary, Map.of("items", items), charts); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<CustomerRiskMetric> buildCustomerRiskMetrics(LoginUser loginUser, DateRange range, String keyword) { |
|---|
| | | List<SalesLedger> ledgers = querySalesLedgers(loginUser, range).stream() |
|---|
| | | .filter(item -> matchLedgerCustomerKeyword(item, keyword)) |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | if (ledgers.isEmpty()) { |
|---|
| | | return List.of(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | Map<String, CustomerRiskMetric> metricMap = new LinkedHashMap<>(); |
|---|
| | | for (SalesLedger ledger : ledgers) { |
|---|
| | | String customerName = StringUtils.hasText(ledger.getCustomerName()) ? ledger.getCustomerName().trim() : "æªç¥å®¢æ·"; |
|---|
| | | CustomerRiskMetric metric = metricMap.computeIfAbsent(customerName, CustomerRiskMetric::new); |
|---|
| | | metric.setOrderCount(metric.getOrderCount() + 1); |
|---|
| | | metric.setContractAmount(metric.getContractAmount().add(defaultDecimal(ledger.getContractAmount()))); |
|---|
| | | metric.setTopSingleOrderAmount(metric.getTopSingleOrderAmount().max(defaultDecimal(ledger.getContractAmount()))); |
|---|
| | | LocalDate entryDate = toLocalDate(ledger.getEntryDate()); |
|---|
| | | if (entryDate != null && (metric.getLastOrderDate() == null || entryDate.isAfter(metric.getLastOrderDate()))) { |
|---|
| | | metric.setLastOrderDate(entryDate); |
|---|
| | | } |
|---|
| | | if (ledger.getId() != null) { |
|---|
| | | metric.getLedgerIds().add(ledger.getId()); |
|---|
| | | if (ledger.getDeliveryDate() != null) { |
|---|
| | | metric.getDeliveryDateByLedgerId().put(ledger.getId(), ledger.getDeliveryDate()); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | List<Long> allLedgerIds = metricMap.values().stream() |
|---|
| | | .flatMap(metric -> metric.getLedgerIds().stream()) |
|---|
| | | .distinct() |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | Map<Long, BigDecimal> receiptAmountByLedgerId = sumReceiptAmounts(loginUser, allLedgerIds); |
|---|
| | | Map<Long, List<ShippingInfo>> shippingByLedgerId = queryShippingsByLedgerIds(loginUser, allLedgerIds).stream() |
|---|
| | | .collect(Collectors.groupingBy(ShippingInfo::getSalesLedgerId)); |
|---|
| | | |
|---|
| | | List<SalesQuotation> quotations = querySalesQuotations(loginUser, range); |
|---|
| | | for (SalesQuotation quotation : quotations) { |
|---|
| | | String customerName = safe(quotation.getCustomer()); |
|---|
| | | CustomerRiskMetric metric = metricMap.get(customerName); |
|---|
| | | if (metric == null) { |
|---|
| | | continue; |
|---|
| | | } |
|---|
| | | metric.setQuoteCount(metric.getQuoteCount() + 1); |
|---|
| | | metric.setQuoteAmount(metric.getQuoteAmount().add(defaultDecimal(quotation.getTotalAmount()))); |
|---|
| | | } |
|---|
| | | |
|---|
| | | LocalDate today = LocalDate.now(); |
|---|
| | | for (CustomerRiskMetric metric : metricMap.values()) { |
|---|
| | | BigDecimal receivedAmount = BigDecimal.ZERO; |
|---|
| | | long overdueDeliveryCount = 0; |
|---|
| | | for (Long ledgerId : metric.getLedgerIds()) { |
|---|
| | | receivedAmount = receivedAmount.add(receiptAmountByLedgerId.getOrDefault(ledgerId, BigDecimal.ZERO)); |
|---|
| | | LocalDate deliveryDate = metric.getDeliveryDateByLedgerId().get(ledgerId); |
|---|
| | | if (deliveryDate != null && deliveryDate.isBefore(today) && !isLedgerFullyShipped(ledgerId, shippingByLedgerId)) { |
|---|
| | | overdueDeliveryCount++; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | metric.setReceivedAmount(receivedAmount); |
|---|
| | | metric.setPendingAmount(maxZero(metric.getContractAmount().subtract(receivedAmount))); |
|---|
| | | if (metric.getContractAmount().compareTo(BigDecimal.ZERO) > 0) { |
|---|
| | | metric.setPendingRate(metric.getPendingAmount() |
|---|
| | | .divide(metric.getContractAmount(), 4, RoundingMode.HALF_UP)); |
|---|
| | | } else { |
|---|
| | | metric.setPendingRate(BigDecimal.ZERO); |
|---|
| | | } |
|---|
| | | metric.setOverdueDeliveryCount(overdueDeliveryCount); |
|---|
| | | if (metric.getLastOrderDate() == null) { |
|---|
| | | metric.setDaysSinceLastOrder(999); |
|---|
| | | } else { |
|---|
| | | metric.setDaysSinceLastOrder(Math.max(today.toEpochDay() - metric.getLastOrderDate().toEpochDay(), 0)); |
|---|
| | | } |
|---|
| | | evaluateRiskMetric(metric); |
|---|
| | | } |
|---|
| | | return new ArrayList<>(metricMap.values()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void evaluateRiskMetric(CustomerRiskMetric metric) { |
|---|
| | | int score = 0; |
|---|
| | | List<String> reasons = new ArrayList<>(); |
|---|
| | | if (metric.getDaysSinceLastOrder() >= 90) { |
|---|
| | | score += 35; |
|---|
| | | reasons.add("è¿90天æ æ°å¢è®¢å"); |
|---|
| | | } else if (metric.getDaysSinceLastOrder() >= 60) { |
|---|
| | | score += 25; |
|---|
| | | reasons.add("è¿60天订åæ´»è·åº¦ä¸é"); |
|---|
| | | } else if (metric.getDaysSinceLastOrder() >= 30) { |
|---|
| | | score += 12; |
|---|
| | | reasons.add("è¿30天订åæ³¢å¨åå¼±"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (metric.getPendingRate().compareTo(new BigDecimal("0.60")) >= 0) { |
|---|
| | | score += 30; |
|---|
| | | reasons.add("å¾
å款å æ¯é«äº60%"); |
|---|
| | | } else if (metric.getPendingRate().compareTo(new BigDecimal("0.30")) >= 0) { |
|---|
| | | score += 20; |
|---|
| | | reasons.add("å¾
å款å æ¯é«äº30%"); |
|---|
| | | } else if (metric.getPendingRate().compareTo(new BigDecimal("0.10")) >= 0) { |
|---|
| | | score += 10; |
|---|
| | | reasons.add("åå¨å¾
å款é£é©"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (metric.getOverdueDeliveryCount() > 0) { |
|---|
| | | score += Math.min((int) metric.getOverdueDeliveryCount() * 6, 20); |
|---|
| | | reasons.add("åå¨äº¤æé¾æ订å"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (metric.getOrderCount() <= 1) { |
|---|
| | | score += 8; |
|---|
| | | reasons.add("订ååºæ°åä½"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (metric.getQuoteCount() > 0 && metric.getOrderCount() == 0) { |
|---|
| | | score += 10; |
|---|
| | | reasons.add("æ¥ä»·æªå½¢æ订å转å"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | score = Math.min(score, 100); |
|---|
| | | metric.setRiskScore(score); |
|---|
| | | if (score >= 70) { |
|---|
| | | metric.setRiskLevel("high"); |
|---|
| | | } else if (score >= 40) { |
|---|
| | | metric.setRiskLevel("medium"); |
|---|
| | | } else { |
|---|
| | | metric.setRiskLevel("low"); |
|---|
| | | } |
|---|
| | | metric.setRiskReasons(reasons); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> toRiskItem(CustomerRiskMetric metric) { |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("customerName", metric.getCustomerName()); |
|---|
| | | map.put("riskLevel", metric.getRiskLevel()); |
|---|
| | | map.put("riskScore", metric.getRiskScore()); |
|---|
| | | map.put("contractAmount", metric.getContractAmount()); |
|---|
| | | map.put("receivedAmount", metric.getReceivedAmount()); |
|---|
| | | map.put("pendingAmount", metric.getPendingAmount()); |
|---|
| | | map.put("pendingRate", toPercent(metric.getPendingRate())); |
|---|
| | | map.put("orderCount", metric.getOrderCount()); |
|---|
| | | map.put("quoteCount", metric.getQuoteCount()); |
|---|
| | | map.put("overdueDeliveryCount", metric.getOverdueDeliveryCount()); |
|---|
| | | map.put("daysSinceLastOrder", metric.getDaysSinceLastOrder()); |
|---|
| | | map.put("lastOrderDate", formatDate(metric.getLastOrderDate())); |
|---|
| | | map.put("riskReasons", metric.getRiskReasons()); |
|---|
| | | return map; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> toStrategyItem(CustomerRiskMetric metric) { |
|---|
| | | String priority = strategyPriority(metric); |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("customerName", metric.getCustomerName()); |
|---|
| | | map.put("riskLevel", metric.getRiskLevel()); |
|---|
| | | map.put("riskScore", metric.getRiskScore()); |
|---|
| | | map.put("priority", priority); |
|---|
| | | map.put("pendingAmount", metric.getPendingAmount()); |
|---|
| | | map.put("pendingRate", toPercent(metric.getPendingRate())); |
|---|
| | | map.put("quoteCount", metric.getQuoteCount()); |
|---|
| | | map.put("orderCount", metric.getOrderCount()); |
|---|
| | | map.put("quoteConversionRate", toRate(metric.getOrderCount(), Math.max(metric.getQuoteCount(), 1))); |
|---|
| | | map.put("collectionStrategy", buildCollectionStrategy(metric)); |
|---|
| | | map.put("quotationStrategy", buildQuotationStrategy(metric)); |
|---|
| | | map.put("nextAction", buildNextAction(priority)); |
|---|
| | | map.put("topSingleOrderAmount", metric.getTopSingleOrderAmount()); |
|---|
| | | return map; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String buildCollectionStrategy(CustomerRiskMetric metric) { |
|---|
| | | if (metric.getPendingAmount().compareTo(BigDecimal.ZERO) <= 0) { |
|---|
| | | return "ä¿ææ£å¸¸æ度对账ä¸å款确认ï¼ç»´æ客æ·å款èå¥ã"; |
|---|
| | | } |
|---|
| | | if (metric.getPendingRate().compareTo(new BigDecimal("0.60")) >= 0) { |
|---|
| | | return "ä¼å
éå®å款计åï¼æå¨æåå款èç¹å¹¶ç»å®åè´§æ¡ä»¶ï¼é¿å
æ°å¢ä¿¡ç¨æå£ã"; |
|---|
| | | } |
|---|
| | | if (metric.getPendingRate().compareTo(new BigDecimal("0.30")) >= 0) { |
|---|
| | | return "建议æ§è¡åå¨å¬æ¶æºå¶ï¼åæ¥è´¢å¡ä¸ä¸å¡èåè·è¿éç¹ååã"; |
|---|
| | | } |
|---|
| | | return "ä¿ææ£å¸¸å¬æ¶èå¥ï¼æååèç¹æå3天æé客æ·ä»æ¬¾ã"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String buildQuotationStrategy(CustomerRiskMetric metric) { |
|---|
| | | if ("high".equals(metric.getRiskLevel())) { |
|---|
| | | return "æ¥ä»·ä¼å
ä¿æ¯å©ä¸å款æ¡æ¬¾ï¼åå°è¶
é¿è´¦æï¼å¿
è¦æ¶éç¨åé¶æ®µæ¥ä»·ã"; |
|---|
| | | } |
|---|
| | | if (metric.getQuoteCount() > 0 && metric.getOrderCount() < metric.getQuoteCount()) { |
|---|
| | | return "ä¼åæ¥ä»·ç»æï¼å»ºè®®æä¾åºç¡ç+å级çç»åæ¥ä»·ï¼æé«è½¬åçã"; |
|---|
| | | } |
|---|
| | | if (metric.getOrderCount() <= 1) { |
|---|
| | | return "å 强éæ±ææï¼å´ç»å®¢æ·åºæ¯è¡¥å
å¢å¼é¡¹ä¸äº¤ä»ä¿éæ¡æ¬¾ã"; |
|---|
| | | } |
|---|
| | | return "ä¿æå½åæ¥ä»·çç¥ï¼éç¹å´ç»äº¤æåæå¡è½ååå·®å¼ååç°ã"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String buildNextAction(String priority) { |
|---|
| | | return switch (priority) { |
|---|
| | | case "high" -> "48å°æ¶å
å®æ客æ·å访ï¼ç¡®è®¤å款计å并å¤æ ¸æ¥ä»·æææã"; |
|---|
| | | case "medium" -> "æ¬å¨å
å®æ客æ·éæ±å¤çï¼æ´æ°æ¥ä»·çæ¬å¹¶åæ¥å款èç¹ã"; |
|---|
| | | default -> "ä¿ææ度ä¾è¡è·è¿ï¼æç»è¿½è¸ªå®¢æ·éè´è®¡åååã"; |
|---|
| | | }; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String strategyPriority(CustomerRiskMetric metric) { |
|---|
| | | if ("high".equals(metric.getRiskLevel()) || metric.getPendingRate().compareTo(new BigDecimal("0.50")) >= 0) { |
|---|
| | | return "high"; |
|---|
| | | } |
|---|
| | | if ("medium".equals(metric.getRiskLevel()) || metric.getPendingRate().compareTo(new BigDecimal("0.30")) >= 0) { |
|---|
| | | return "medium"; |
|---|
| | | } |
|---|
| | | return "low"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private int riskLevelRank(String riskLevel) { |
|---|
| | | if ("high".equals(riskLevel)) { |
|---|
| | | return 3; |
|---|
| | | } |
|---|
| | | if ("medium".equals(riskLevel)) { |
|---|
| | | return 2; |
|---|
| | | } |
|---|
| | | return 1; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<Map<String, Object>> buildTopCustomers(List<SalesLedger> ledgers) { |
|---|
| | | Map<String, BigDecimal> grouped = new LinkedHashMap<>(); |
|---|
| | | for (SalesLedger ledger : ledgers) { |
|---|
| | | String customerName = StringUtils.hasText(ledger.getCustomerName()) ? ledger.getCustomerName().trim() : "æªç¥å®¢æ·"; |
|---|
| | | grouped.merge(customerName, defaultDecimal(ledger.getContractAmount()), BigDecimal::add); |
|---|
| | | } |
|---|
| | | return grouped.entrySet().stream() |
|---|
| | | .sorted(Map.Entry.<String, BigDecimal>comparingByValue().reversed()) |
|---|
| | | .limit(5) |
|---|
| | | .map(entry -> { |
|---|
| | | Map<String, Object> map = new LinkedHashMap<>(); |
|---|
| | | map.put("customerName", entry.getKey()); |
|---|
| | | map.put("contractAmount", entry.getValue()); |
|---|
| | | return map; |
|---|
| | | }) |
|---|
| | | .collect(Collectors.toList()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private TrendData buildContractTrendData(List<SalesLedger> ledgers, DateRange range) { |
|---|
| | | Map<String, BigDecimal> amountByMonth = new LinkedHashMap<>(); |
|---|
| | | YearMonth startMonth = YearMonth.from(range.start()); |
|---|
| | | YearMonth endMonth = YearMonth.from(range.end()); |
|---|
| | | for (YearMonth month = startMonth; !month.isAfter(endMonth); month = month.plusMonths(1)) { |
|---|
| | | amountByMonth.put(month.toString(), BigDecimal.ZERO); |
|---|
| | | } |
|---|
| | | for (SalesLedger ledger : ledgers) { |
|---|
| | | LocalDate entryDate = toLocalDate(ledger.getEntryDate()); |
|---|
| | | if (entryDate == null) { |
|---|
| | | continue; |
|---|
| | | } |
|---|
| | | String monthKey = YearMonth.from(entryDate).toString(); |
|---|
| | | if (!amountByMonth.containsKey(monthKey)) { |
|---|
| | | continue; |
|---|
| | | } |
|---|
| | | amountByMonth.put(monthKey, amountByMonth.get(monthKey).add(defaultDecimal(ledger.getContractAmount()))); |
|---|
| | | } |
|---|
| | | return new TrendData(new ArrayList<>(amountByMonth.keySet()), new ArrayList<>(amountByMonth.values())); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<SalesLedger> querySalesLedgers(LoginUser loginUser, DateRange range) { |
|---|
| | | LambdaQueryWrapper<SalesLedger> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), SalesLedger::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), SalesLedger::getDeptId); |
|---|
| | | if (range != null) { |
|---|
| | | wrapper.ge(SalesLedger::getEntryDate, toDate(range.start())) |
|---|
| | | .lt(SalesLedger::getEntryDate, toExclusiveEndDate(range.end())); |
|---|
| | | } |
|---|
| | | return defaultList(salesLedgerMapper.selectList(wrapper)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<SalesQuotation> querySalesQuotations(LoginUser loginUser, DateRange range) { |
|---|
| | | LambdaQueryWrapper<SalesQuotation> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), SalesQuotation::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), SalesQuotation::getDeptId); |
|---|
| | | if (range != null) { |
|---|
| | | wrapper.ge(SalesQuotation::getQuotationDate, range.start()) |
|---|
| | | .le(SalesQuotation::getQuotationDate, range.end()); |
|---|
| | | } |
|---|
| | | return defaultList(salesQuotationMapper.selectList(wrapper)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<ShippingInfo> queryShippings(LoginUser loginUser, DateRange range) { |
|---|
| | | LambdaQueryWrapper<ShippingInfo> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), ShippingInfo::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), ShippingInfo::getDeptId); |
|---|
| | | if (range != null) { |
|---|
| | | wrapper.ge(ShippingInfo::getShippingDate, toDate(range.start())) |
|---|
| | | .lt(ShippingInfo::getShippingDate, toExclusiveEndDate(range.end())); |
|---|
| | | } |
|---|
| | | return defaultList(shippingInfoMapper.selectList(wrapper)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<ReceiptPayment> queryReceipts(LoginUser loginUser, DateRange range) { |
|---|
| | | LambdaQueryWrapper<ReceiptPayment> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), ReceiptPayment::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), ReceiptPayment::getDeptId); |
|---|
| | | if (range != null) { |
|---|
| | | wrapper.ge(ReceiptPayment::getReceiptPaymentDate, range.start()) |
|---|
| | | .le(ReceiptPayment::getReceiptPaymentDate, range.end()); |
|---|
| | | } |
|---|
| | | return defaultList(receiptPaymentMapper.selectList(wrapper)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<ReceiptPayment> queryReceiptsByLedgerIds(LoginUser loginUser, List<Long> ledgerIds) { |
|---|
| | | if (ledgerIds == null || ledgerIds.isEmpty()) { |
|---|
| | | return List.of(); |
|---|
| | | } |
|---|
| | | LambdaQueryWrapper<ReceiptPayment> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), ReceiptPayment::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), ReceiptPayment::getDeptId); |
|---|
| | | wrapper.in(ReceiptPayment::getSalesLedgerId, ledgerIds); |
|---|
| | | return defaultList(receiptPaymentMapper.selectList(wrapper)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<ShippingInfo> queryShippingsByLedgerIds(LoginUser loginUser, List<Long> ledgerIds) { |
|---|
| | | if (ledgerIds == null || ledgerIds.isEmpty()) { |
|---|
| | | return List.of(); |
|---|
| | | } |
|---|
| | | LambdaQueryWrapper<ShippingInfo> wrapper = new LambdaQueryWrapper<>(); |
|---|
| | | applyTenantFilter(wrapper, loginUser.getTenantId(), ShippingInfo::getTenantId); |
|---|
| | | applyDeptFilter(wrapper, loginUser.getCurrentDeptId(), ShippingInfo::getDeptId); |
|---|
| | | wrapper.in(ShippingInfo::getSalesLedgerId, ledgerIds); |
|---|
| | | return defaultList(shippingInfoMapper.selectList(wrapper)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<Long, BigDecimal> sumInvoiceAmounts(List<Long> ledgerIds) { |
|---|
| | | if (ledgerIds == null || ledgerIds.isEmpty()) { |
|---|
| | | return Map.of(); |
|---|
| | | } |
|---|
| | | Map<Long, BigDecimal> result = new HashMap<>(); |
|---|
| | | for (InvoiceLedgerDto item : defaultList(invoiceLedgerMapper.invoicedTotal(ledgerIds))) { |
|---|
| | | if (item.getSalesLedgerId() == null) { |
|---|
| | | continue; |
|---|
| | | } |
|---|
| | | result.merge(item.getSalesLedgerId().longValue(), defaultDecimal(item.getInvoiceTotal()), BigDecimal::add); |
|---|
| | | } |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<Long, BigDecimal> sumReceiptAmounts(LoginUser loginUser, List<Long> ledgerIds) { |
|---|
| | | Map<Long, BigDecimal> result = new HashMap<>(); |
|---|
| | | for (ReceiptPayment item : queryReceiptsByLedgerIds(loginUser, ledgerIds)) { |
|---|
| | | if (item.getSalesLedgerId() == null) { |
|---|
| | | continue; |
|---|
| | | } |
|---|
| | | result.merge(item.getSalesLedgerId(), defaultDecimal(item.getReceiptPaymentAmount()), BigDecimal::add); |
|---|
| | | } |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private boolean isLedgerFullyShipped(Long ledgerId, Map<Long, List<ShippingInfo>> shippingByLedgerId) { |
|---|
| | | List<ShippingInfo> shippingInfos = shippingByLedgerId.get(ledgerId); |
|---|
| | | if (shippingInfos == null || shippingInfos.isEmpty()) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | return shippingInfos.stream().allMatch(item -> isShippedStatus(item.getStatus())); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String calcLedgerShippingStatus(List<ShippingInfo> shippingInfos) { |
|---|
| | | if (shippingInfos == null || shippingInfos.isEmpty()) { |
|---|
| | | return "æªåè´§"; |
|---|
| | | } |
|---|
| | | long shippedCount = shippingInfos.stream().filter(item -> isShippedStatus(item.getStatus())).count(); |
|---|
| | | if (shippedCount == 0) { |
|---|
| | | return "å¾
åè´§"; |
|---|
| | | } |
|---|
| | | if (shippedCount == shippingInfos.size()) { |
|---|
| | | return "å·²åè´§"; |
|---|
| | | } |
|---|
| | | return "é¨ååè´§"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private boolean isShippedStatus(String status) { |
|---|
| | | return StringUtils.hasText(status) && status.contains("å·²åè´§"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private boolean matchCustomerKeyword(CustomerVo customer, String keyword) { |
|---|
| | | if (!StringUtils.hasText(keyword)) { |
|---|
| | | return true; |
|---|
| | | } |
|---|
| | | String text = keyword.trim(); |
|---|
| | | return safe(customer.getCustomerName()).contains(text) |
|---|
| | | || safe(customer.getContactPerson()).contains(text) |
|---|
| | | || safe(customer.getContactPhone()).contains(text) |
|---|
| | | || safe(customer.getCompanyPhone()).contains(text) |
|---|
| | | || safe(customer.getUsageUserName()).contains(text); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private boolean matchInteractionKeyword(ReceiptPayment payment, SalesLedger ledger, String keyword) { |
|---|
| | | if (!StringUtils.hasText(keyword)) { |
|---|
| | | return true; |
|---|
| | | } |
|---|
| | | String text = keyword.trim(); |
|---|
| | | return safe(payment.getRegistrant()).contains(text) |
|---|
| | | || (ledger != null && (safe(ledger.getCustomerName()).contains(text) |
|---|
| | | || safe(ledger.getSalesContractNo()).contains(text) |
|---|
| | | || safe(ledger.getProjectName()).contains(text))); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private boolean matchLedgerCustomerKeyword(SalesLedger ledger, String keyword) { |
|---|
| | | if (!StringUtils.hasText(keyword)) { |
|---|
| | | return true; |
|---|
| | | } |
|---|
| | | String text = keyword.trim(); |
|---|
| | | return safe(ledger.getCustomerName()).contains(text) |
|---|
| | | || safe(ledger.getSalesContractNo()).contains(text) |
|---|
| | | || safe(ledger.getProjectName()).contains(text); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Integer normalizeSeaType(String seaType) { |
|---|
| | | if (!StringUtils.hasText(seaType)) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | String value = seaType.trim().toLowerCase(Locale.ROOT); |
|---|
| | | return switch (value) { |
|---|
| | | case "private", "ç§æµ·", "0" -> 0; |
|---|
| | | case "public", "å
¬æµ·", "1" -> 1; |
|---|
| | | default -> null; |
|---|
| | | }; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String customerSeaTypeName(Integer type) { |
|---|
| | | if (type == null) { |
|---|
| | | return "æªç¥"; |
|---|
| | | } |
|---|
| | | return type == 1 ? "å
¬æµ·" : "ç§æµ·"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private int normalizeLimit(Integer limit) { |
|---|
| | | if (limit == null || limit <= 0) { |
|---|
| | | return DEFAULT_LIMIT; |
|---|
| | | } |
|---|
| | | return Math.min(limit, MAX_LIMIT); |
|---|
| | | } |
|---|
| | | |
|---|
| | | 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, SFunction<T, Long> field) { |
|---|
| | | if (tenantId != null) { |
|---|
| | | wrapper.eq(field, tenantId); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | private <T> void applyDeptFilter(LambdaQueryWrapper<T> wrapper, Long deptId, 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 DateRange resolveDateRange(String startDate, String endDate, String timeRange) { |
|---|
| | | LocalDate today = LocalDate.now(); |
|---|
| | | LocalDate explicitStart = parseLocalDate(startDate); |
|---|
| | | LocalDate explicitEnd = parseLocalDate(endDate); |
|---|
| | | if (explicitStart != null || explicitEnd != null) { |
|---|
| | | LocalDate start = explicitStart != null ? explicitStart : explicitEnd; |
|---|
| | | LocalDate end = explicitEnd != null ? explicitEnd : explicitStart; |
|---|
| | | if (start.isAfter(end)) { |
|---|
| | | LocalDate temp = start; |
|---|
| | | start = end; |
|---|
| | | end = temp; |
|---|
| | | } |
|---|
| | | return new DateRange(start, end, start + "è³" + end); |
|---|
| | | } |
|---|
| | | if (!StringUtils.hasText(timeRange)) { |
|---|
| | | return new DateRange(today.minusDays(29), today, "è¿30天"); |
|---|
| | | } |
|---|
| | | String text = timeRange.trim(); |
|---|
| | | if (text.contains("ä»å¤©")) { |
|---|
| | | return new DateRange(today, today, "ä»å¤©"); |
|---|
| | | } |
|---|
| | | if (text.contains("æ¨å¤©") || text.contains("æ¨æ¥")) { |
|---|
| | | LocalDate day = today.minusDays(1); |
|---|
| | | return new DateRange(day, day, "æ¨å¤©"); |
|---|
| | | } |
|---|
| | | if (text.contains("æ¬å¨")) { |
|---|
| | | LocalDate start = today.minusDays(today.getDayOfWeek().getValue() - 1L); |
|---|
| | | return new DateRange(start, today, "æ¬å¨"); |
|---|
| | | } |
|---|
| | | if (text.contains("ä¸å¨")) { |
|---|
| | | LocalDate thisWeekStart = today.minusDays(today.getDayOfWeek().getValue() - 1L); |
|---|
| | | LocalDate start = thisWeekStart.minusWeeks(1); |
|---|
| | | LocalDate end = thisWeekStart.minusDays(1); |
|---|
| | | return new DateRange(start, end, "ä¸å¨"); |
|---|
| | | } |
|---|
| | | if (text.contains("æ¬æ")) { |
|---|
| | | return new DateRange(today.withDayOfMonth(1), today, "æ¬æ"); |
|---|
| | | } |
|---|
| | | if (text.contains("ä¸æ")) { |
|---|
| | | YearMonth lastMonth = YearMonth.from(today).minusMonths(1); |
|---|
| | | return new DateRange(lastMonth.atDay(1), lastMonth.atEndOfMonth(), "ä¸æ"); |
|---|
| | | } |
|---|
| | | if (text.contains("ä»å¹´") || text.contains("æ¬å¹´")) { |
|---|
| | | return new DateRange(today.withDayOfYear(1), today, "ä»å¹´"); |
|---|
| | | } |
|---|
| | | if (text.contains("å»å¹´")) { |
|---|
| | | LocalDate start = today.minusYears(1).withDayOfYear(1); |
|---|
| | | LocalDate end = today.minusYears(1).withMonth(12).withDayOfMonth(31); |
|---|
| | | return new DateRange(start, end, "å»å¹´"); |
|---|
| | | } |
|---|
| | | Matcher relativeMatcher = RELATIVE_PATTERN.matcher(text); |
|---|
| | | if (relativeMatcher.find()) { |
|---|
| | | int amount = Integer.parseInt(relativeMatcher.group(2)); |
|---|
| | | String unit = relativeMatcher.group(3); |
|---|
| | | LocalDate start = 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(start, today, "è¿" + amount + unit); |
|---|
| | | } |
|---|
| | | Matcher dateMatcher = DATE_PATTERN.matcher(text); |
|---|
| | | if (dateMatcher.find()) { |
|---|
| | | LocalDate start = parseLocalDate(dateMatcher.group(1)); |
|---|
| | | LocalDate end = dateMatcher.find() ? parseLocalDate(dateMatcher.group(1)) : start; |
|---|
| | | if (start != null && end != null) { |
|---|
| | | if (start.isAfter(end)) { |
|---|
| | | LocalDate temp = start; |
|---|
| | | start = end; |
|---|
| | | end = temp; |
|---|
| | | } |
|---|
| | | return new DateRange(start, end, start + "è³" + end); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return new DateRange(today.minusDays(29), today, "è¿30天"); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private LocalDate parseLocalDate(String text) { |
|---|
| | | if (!StringUtils.hasText(text)) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | try { |
|---|
| | | return LocalDate.parse(text.trim(), DATE_FMT); |
|---|
| | | } catch (Exception ignored) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | 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 LocalDate toLocalDate(Date date) { |
|---|
| | | if (date == null) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String formatDate(Date date) { |
|---|
| | | LocalDate localDate = toLocalDate(date); |
|---|
| | | return formatDate(localDate); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String formatDate(LocalDate date) { |
|---|
| | | return date == null ? "" : date.format(DATE_FMT); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String formatDateTime(LocalDateTime time) { |
|---|
| | | return time == null ? "" : time.toString().replace('T', ' '); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal defaultDecimal(BigDecimal value) { |
|---|
| | | return value == null ? BigDecimal.ZERO : value; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal maxZero(BigDecimal value) { |
|---|
| | | return value == null || value.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : value; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String toRate(long numerator, long denominator) { |
|---|
| | | if (denominator <= 0) { |
|---|
| | | return "0.00%"; |
|---|
| | | } |
|---|
| | | BigDecimal rate = new BigDecimal(numerator) |
|---|
| | | .multiply(ONE_HUNDRED) |
|---|
| | | .divide(new BigDecimal(denominator), 2, RoundingMode.HALF_UP); |
|---|
| | | return rate.toPlainString() + "%"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String toPercent(BigDecimal decimal) { |
|---|
| | | if (decimal == null) { |
|---|
| | | return "0.00%"; |
|---|
| | | } |
|---|
| | | BigDecimal rate = decimal.multiply(ONE_HUNDRED).setScale(2, RoundingMode.HALF_UP); |
|---|
| | | return rate.toPlainString() + "%"; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String safe(Object value) { |
|---|
| | | return value == null ? "" : String.valueOf(value).replace('\n', ' ').replace('\r', ' ').trim(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private <T> List<T> defaultList(List<T> list) { |
|---|
| | | return list == null ? List.of() : list; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> rangeSummary(DateRange range, int count, String keyword) { |
|---|
| | | 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); |
|---|
| | | summary.put("keyword", safe(keyword)); |
|---|
| | | return summary; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildAmountBarOption(BigDecimal contractAmount, |
|---|
| | | BigDecimal quotationAmount, |
|---|
| | | BigDecimal receivedAmount, |
|---|
| | | BigDecimal pendingAmount) { |
|---|
| | | List<String> xData = List.of("ååé¢", "æ¥ä»·é¢", "å款é¢", "å¾
å款"); |
|---|
| | | List<BigDecimal> yData = List.of(contractAmount, quotationAmount, receivedAmount, pendingAmount); |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "éå®ç»è¥éé¢æ¦è§", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "axis")); |
|---|
| | | option.put("xAxis", Map.of("type", "category", "data", xData)); |
|---|
| | | option.put("yAxis", Map.of("type", "value")); |
|---|
| | | option.put("series", List.of(Map.of("name", "éé¢", "type", "bar", "data", yData))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildShippingPieOption(long shippedCount, long pendingCount) { |
|---|
| | | List<Map<String, Object>> data = List.of( |
|---|
| | | Map.of("name", "å·²åè´§", "value", shippedCount), |
|---|
| | | Map.of("name", "æªåè´§", "value", pendingCount) |
|---|
| | | ); |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "åè´§ç¶æåå¸", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "item")); |
|---|
| | | option.put("series", List.of(Map.of("type", "pie", "radius", "60%", "data", data))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildCustomerTopBarOption(List<Map<String, Object>> topCustomers) { |
|---|
| | | List<String> xData = new ArrayList<>(); |
|---|
| | | List<BigDecimal> yData = new ArrayList<>(); |
|---|
| | | for (Map<String, Object> item : topCustomers) { |
|---|
| | | xData.add(String.valueOf(item.get("customerName"))); |
|---|
| | | yData.add((BigDecimal) item.get("contractAmount")); |
|---|
| | | } |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "客æ·ååé¢TOP5", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "axis")); |
|---|
| | | option.put("xAxis", Map.of("type", "category", "data", xData)); |
|---|
| | | option.put("yAxis", Map.of("type", "value")); |
|---|
| | | option.put("series", List.of(Map.of("name", "ååé¢", "type", "bar", "data", yData))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildContractTrendLineOption(List<String> labels, List<BigDecimal> values) { |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "ååé¢æ度è¶å¿", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "axis")); |
|---|
| | | option.put("xAxis", Map.of("type", "category", "data", labels)); |
|---|
| | | option.put("yAxis", Map.of("type", "value")); |
|---|
| | | option.put("series", List.of(Map.of("name", "ååé¢", "type", "line", "smooth", true, "data", values))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildRiskLevelPieOption(long highCount, long mediumCount, long lowCount) { |
|---|
| | | List<Map<String, Object>> data = List.of( |
|---|
| | | Map.of("name", "é«é£é©", "value", highCount), |
|---|
| | | Map.of("name", "ä¸é£é©", "value", mediumCount), |
|---|
| | | Map.of("name", "ä½é£é©", "value", lowCount) |
|---|
| | | ); |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "客æ·é£é©ç级åå¸", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "item")); |
|---|
| | | option.put("series", List.of(Map.of("name", "é£é©ç级", "type", "pie", "radius", "60%", "data", data))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildRiskScoreBarOption(List<CustomerRiskMetric> metrics) { |
|---|
| | | List<String> xData = metrics.stream().map(CustomerRiskMetric::getCustomerName).collect(Collectors.toList()); |
|---|
| | | List<Integer> yData = metrics.stream().map(CustomerRiskMetric::getRiskScore).collect(Collectors.toList()); |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "客æ·é£é©åå¼", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "axis")); |
|---|
| | | option.put("xAxis", Map.of("type", "category", "data", xData)); |
|---|
| | | option.put("yAxis", Map.of("type", "value", "max", 100)); |
|---|
| | | option.put("series", List.of(Map.of("name", "é£é©åå¼", "type", "bar", "data", yData))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildPendingAmountBarOption(List<CustomerRiskMetric> metrics) { |
|---|
| | | List<String> xData = metrics.stream().map(CustomerRiskMetric::getCustomerName).collect(Collectors.toList()); |
|---|
| | | List<BigDecimal> yData = metrics.stream().map(CustomerRiskMetric::getPendingAmount).collect(Collectors.toList()); |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "客æ·å¾
å款æå", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "axis")); |
|---|
| | | option.put("xAxis", Map.of("type", "category", "data", xData)); |
|---|
| | | option.put("yAxis", Map.of("type", "value")); |
|---|
| | | option.put("series", List.of(Map.of("name", "å¾
å款", "type", "bar", "data", yData))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<String, Object> buildPriorityPieOption(long high, long medium, long low) { |
|---|
| | | List<Map<String, Object>> data = List.of( |
|---|
| | | Map.of("name", "é«ä¼å
级", "value", high), |
|---|
| | | Map.of("name", "ä¸ä¼å
级", "value", medium), |
|---|
| | | Map.of("name", "ä½ä¼å
级", "value", low) |
|---|
| | | ); |
|---|
| | | Map<String, Object> option = new LinkedHashMap<>(); |
|---|
| | | option.put("title", Map.of("text", "çç¥ä¼å
级åå¸", "left", "center")); |
|---|
| | | option.put("tooltip", Map.of("trigger", "item")); |
|---|
| | | option.put("series", List.of(Map.of("name", "ä¼å
级", "type", "pie", "radius", "60%", "data", data))); |
|---|
| | | return option; |
|---|
| | | } |
|---|
| | | |
|---|
| | | 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 record TrendData(List<String> labels, List<BigDecimal> values) { |
|---|
| | | private List<Map<String, Object>> toItemList() { |
|---|
| | | List<Map<String, Object>> items = new LinkedList<>(); |
|---|
| | | for (int i = 0; i < labels.size(); i++) { |
|---|
| | | Map<String, Object> item = new LinkedHashMap<>(); |
|---|
| | | item.put("month", labels.get(i)); |
|---|
| | | item.put("amount", values.get(i)); |
|---|
| | | items.add(item); |
|---|
| | | } |
|---|
| | | return items; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | private static class CustomerRiskMetric { |
|---|
| | | private final String customerName; |
|---|
| | | private final List<Long> ledgerIds = new ArrayList<>(); |
|---|
| | | private final Map<Long, LocalDate> deliveryDateByLedgerId = new HashMap<>(); |
|---|
| | | private BigDecimal contractAmount = BigDecimal.ZERO; |
|---|
| | | private BigDecimal receivedAmount = BigDecimal.ZERO; |
|---|
| | | private BigDecimal pendingAmount = BigDecimal.ZERO; |
|---|
| | | private BigDecimal pendingRate = BigDecimal.ZERO; |
|---|
| | | private BigDecimal quoteAmount = BigDecimal.ZERO; |
|---|
| | | private BigDecimal topSingleOrderAmount = BigDecimal.ZERO; |
|---|
| | | private int orderCount; |
|---|
| | | private int quoteCount; |
|---|
| | | private LocalDate lastOrderDate; |
|---|
| | | private long daysSinceLastOrder; |
|---|
| | | private long overdueDeliveryCount; |
|---|
| | | private int riskScore; |
|---|
| | | private String riskLevel = "low"; |
|---|
| | | private List<String> riskReasons = new ArrayList<>(); |
|---|
| | | |
|---|
| | | private CustomerRiskMetric(String customerName) { |
|---|
| | | this.customerName = customerName; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String getCustomerName() { |
|---|
| | | return customerName; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<Long> getLedgerIds() { |
|---|
| | | return ledgerIds; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private Map<Long, LocalDate> getDeliveryDateByLedgerId() { |
|---|
| | | return deliveryDateByLedgerId; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal getContractAmount() { |
|---|
| | | return contractAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setContractAmount(BigDecimal contractAmount) { |
|---|
| | | this.contractAmount = contractAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal getReceivedAmount() { |
|---|
| | | return receivedAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setReceivedAmount(BigDecimal receivedAmount) { |
|---|
| | | this.receivedAmount = receivedAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal getPendingAmount() { |
|---|
| | | return pendingAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setPendingAmount(BigDecimal pendingAmount) { |
|---|
| | | this.pendingAmount = pendingAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal getPendingRate() { |
|---|
| | | return pendingRate; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setPendingRate(BigDecimal pendingRate) { |
|---|
| | | this.pendingRate = pendingRate; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal getQuoteAmount() { |
|---|
| | | return quoteAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setQuoteAmount(BigDecimal quoteAmount) { |
|---|
| | | this.quoteAmount = quoteAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private BigDecimal getTopSingleOrderAmount() { |
|---|
| | | return topSingleOrderAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setTopSingleOrderAmount(BigDecimal topSingleOrderAmount) { |
|---|
| | | this.topSingleOrderAmount = topSingleOrderAmount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private int getOrderCount() { |
|---|
| | | return orderCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setOrderCount(int orderCount) { |
|---|
| | | this.orderCount = orderCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private int getQuoteCount() { |
|---|
| | | return quoteCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setQuoteCount(int quoteCount) { |
|---|
| | | this.quoteCount = quoteCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private LocalDate getLastOrderDate() { |
|---|
| | | return lastOrderDate; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setLastOrderDate(LocalDate lastOrderDate) { |
|---|
| | | this.lastOrderDate = lastOrderDate; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private long getDaysSinceLastOrder() { |
|---|
| | | return daysSinceLastOrder; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setDaysSinceLastOrder(long daysSinceLastOrder) { |
|---|
| | | this.daysSinceLastOrder = daysSinceLastOrder; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private long getOverdueDeliveryCount() { |
|---|
| | | return overdueDeliveryCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setOverdueDeliveryCount(long overdueDeliveryCount) { |
|---|
| | | this.overdueDeliveryCount = overdueDeliveryCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private int getRiskScore() { |
|---|
| | | return riskScore; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setRiskScore(int riskScore) { |
|---|
| | | this.riskScore = riskScore; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private String getRiskLevel() { |
|---|
| | | return riskLevel; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setRiskLevel(String riskLevel) { |
|---|
| | | this.riskLevel = riskLevel; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private List<String> getRiskReasons() { |
|---|
| | | return riskReasons; |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void setRiskReasons(List<String> riskReasons) { |
|---|
| | | this.riskReasons = riskReasons; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | } |
|---|
