产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
liyong
7 小时以前 f90a37fa86568c94b5ed9be14942e7e234db016e 
 src/main/java/com/ruoyi/home/service/impl/HomeServiceImpl.java


@@ -1,21 +1,40 @@


package com.ruoyi.home.service.impl;




import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;


import com.baomidou.mybatisplus.core.metadata.IPage;


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;


import com.ruoyi.approve.mapper.ApproveProcessMapper;


import com.ruoyi.approve.pojo.ApproveProcess;


import com.ruoyi.basic.mapper.CustomerMapper;


import com.ruoyi.basic.mapper.ProductMapper;


import com.ruoyi.basic.mapper.ProductModelMapper;


import com.ruoyi.basic.mapper.SupplierManageMapper;


import com.ruoyi.basic.pojo.Customer;


import com.ruoyi.basic.pojo.Product;


import com.ruoyi.basic.pojo.ProductModel;


import com.ruoyi.basic.pojo.SupplierManage;


import com.ruoyi.collaborativeApproval.mapper.NoticeMapper;


import com.ruoyi.collaborativeApproval.pojo.Notice;


import com.ruoyi.common.utils.SecurityUtils;


import com.ruoyi.device.mapper.DeviceRepairMapper;


import com.ruoyi.device.pojo.DeviceRepair;


import com.ruoyi.dto.MapDto;


import com.ruoyi.framework.security.LoginUser;


import com.ruoyi.home.dto.*;


import com.ruoyi.home.service.HomeService;


import com.ruoyi.lavorissue.mapper.LavorIssueMapper;


import com.ruoyi.lavorissue.pojo.LaborIssue;


import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;


import com.ruoyi.procurementrecord.mapper.ProcurementRecordOutMapper;


import com.ruoyi.procurementrecord.pojo.ProcurementRecordOut;


import com.ruoyi.procurementrecord.pojo.ProcurementRecordStorage;


import com.ruoyi.procurementrecord.utils.StockUtils;


import com.ruoyi.production.dto.ProductOrderDto;


import com.ruoyi.production.dto.ProductWorkOrderDto;


import com.ruoyi.production.mapper.ProductOrderMapper;


import com.ruoyi.production.mapper.ProductWorkOrderMapper;


import com.ruoyi.production.pojo.ProductWorkOrder;


import com.ruoyi.project.system.domain.SysDept;


import com.ruoyi.project.system.domain.SysUserDept;


import com.ruoyi.project.system.mapper.SysDeptMapper;


import com.ruoyi.project.system.mapper.SysUserDeptMapper;


import com.ruoyi.purchase.mapper.PaymentRegistrationMapper;


import com.ruoyi.purchase.mapper.PurchaseLedgerMapper;


import com.ruoyi.purchase.pojo.PaymentRegistration;


@@ -25,9 +44,14 @@


import com.ruoyi.sales.mapper.ReceiptPaymentMapper;


import com.ruoyi.sales.mapper.SalesLedgerMapper;


import com.ruoyi.sales.mapper.SalesLedgerProductMapper;


import com.ruoyi.project.system.domain.SysUser;


import com.ruoyi.project.system.mapper.SysUserMapper;


import com.ruoyi.sales.pojo.ReceiptPayment;


import com.ruoyi.sales.pojo.SalesLedger;


import com.ruoyi.sales.pojo.SalesLedgerProduct;


import com.ruoyi.staff.mapper.StaffOnJobMapper;


import com.ruoyi.staff.pojo.StaffOnJob;


import com.ruoyi.stock.mapper.StockInventoryMapper;


import lombok.extern.slf4j.Slf4j;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.stereotype.Service;


@@ -36,11 +60,11 @@


import java.math.BigDecimal;


import java.math.RoundingMode;


import java.text.ParseException;


import java.text.SimpleDateFormat;


import java.time.*;


import java.time.format.DateTimeFormatter;


import java.time.temporal.ChronoUnit;


import java.time.temporal.TemporalAdjusters;


import java.util.*;


import java.util.concurrent.atomic.AtomicInteger;


import java.util.stream.Collectors;




/**


@@ -61,9 +85,6 @@


    private SalesLedgerProductMapper salesLedgerProductMapper;




    @Autowired


    private ProcurementRecordOutMapper procurementRecordOutMapper;




    @Autowired


    private ProcurementRecordMapper procurementRecordStorageMapper;




    @Autowired


@@ -79,10 +100,31 @@


    private PaymentRegistrationMapper paymentRegistrationMapper;




    @Autowired


    private LavorIssueMapper lavorIssueMapper;


    private SysDeptMapper sysDeptMapper;




    @Autowired


    private SysDeptMapper sysDeptMapper;


    private NoticeMapper noticeMapper;


    @Autowired


    private ProductOrderMapper productOrderMapper;


    @Autowired


    private ProductWorkOrderMapper productWorkOrderMapper;


    @Autowired


    private ProductModelMapper productModelMapper;


    @Autowired


    private ProductMapper productMapper;


    @Autowired


    private StockUtils stockUtils;


    @Autowired


    private StaffOnJobMapper staffOnJobMapper;


    @Autowired


    private CustomerMapper customerMapper;


    @Autowired


    private SupplierManageMapper supplierManageMapper;


    @Autowired


    private SysUserMapper sysUserMapper;


    @Autowired


    private SysUserDeptMapper sysUserDeptMapper;


    private StockInventoryMapper stockInventoryMapper;




    @Override


    public HomeBusinessDto business() {


@@ -95,61 +137,68 @@


        salesLedgerLambdaQueryWrapper.ge(SalesLedger::getEntryDate, currentMonth.atDay(1).atStartOfDay())  // 大于等于本月第一天


                .lt(SalesLedger::getEntryDate, currentMonth.plusMonths(1).atDay(1).atStartOfDay()); // 小于下月第一天


        List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(salesLedgerLambdaQueryWrapper);


        if(CollectionUtils.isEmpty(salesLedgers)){


            return homeBusinessDto;


        if (!CollectionUtils.isEmpty(salesLedgers)) {


            // 合计合同金额


            BigDecimal contractAmount = salesLedgers.stream().map(SalesLedger::getContractAmount)


                    .filter(Objects::nonNull)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapper = new LambdaQueryWrapper<SalesLedgerProduct>();


            salesLedgerProductMapperLambdaQueryWrapper.eq(SalesLedgerProduct::getType, 1)


                    .in(SalesLedgerProduct::getSalesLedgerId, salesLedgers.stream().map(SalesLedger::getId).collect(Collectors.toList()));


            List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectList(salesLedgerProductMapperLambdaQueryWrapper);


            // 未开票金额


            BigDecimal noInvoiceAmountTotal = salesLedgerProducts.stream().map(SalesLedgerProduct::getNoInvoiceAmount)


                    .filter(Objects::nonNull)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            homeBusinessDto.setMonthSaleMoney(contractAmount.setScale(2, RoundingMode.HALF_UP).toString());


            homeBusinessDto.setMonthSaleHaveMoney(noInvoiceAmountTotal.setScale(2, RoundingMode.HALF_UP).toString());


        }


        // 合计合同金额


        BigDecimal contractAmount = salesLedgers.stream().map(SalesLedger::getContractAmount)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapper = new LambdaQueryWrapper<SalesLedgerProduct>();


        salesLedgerProductMapperLambdaQueryWrapper.eq(SalesLedgerProduct::getType, 1)


                .in(SalesLedgerProduct::getSalesLedgerId, salesLedgers.stream().map(SalesLedger::getId).collect(Collectors.toList()));


        List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectList(salesLedgerProductMapperLambdaQueryWrapper);


        // 未开票金额


        BigDecimal noInvoiceAmountTotal = salesLedgerProducts.stream().map(SalesLedgerProduct::getNoInvoiceAmount)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        homeBusinessDto.setMonthSaleMoney(contractAmount.setScale(2, RoundingMode.HALF_UP).toString());


        homeBusinessDto.setMonthSaleHaveMoney(noInvoiceAmountTotal.setScale(2, RoundingMode.HALF_UP).toString());


        // 创建LambdaQueryWrapper


        LambdaQueryWrapper<PurchaseLedger> queryWrapper = new LambdaQueryWrapper<>();


        queryWrapper.ge(PurchaseLedger::getEntryDate, currentMonth.atDay(1).atStartOfDay())  // 大于等于本月第一天


                .lt(PurchaseLedger::getEntryDate, currentMonth.plusMonths(1).atDay(1).atStartOfDay()); // 小于下月第一天




        // 执行查询并计算总和


        List<PurchaseLedger> purchaseLedgers = purchaseLedgerMapper.selectList(queryWrapper);


        if(CollectionUtils.isEmpty(purchaseLedgers)){


            return homeBusinessDto;


        if (!CollectionUtils.isEmpty(purchaseLedgers)) {


            LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapperCopy = new LambdaQueryWrapper<SalesLedgerProduct>();


            salesLedgerProductMapperLambdaQueryWrapperCopy.eq(SalesLedgerProduct::getType, 2)


                    .in(SalesLedgerProduct::getSalesLedgerId, purchaseLedgers.stream().map(PurchaseLedger::getId).collect(Collectors.toList()));


            List<SalesLedgerProduct> salesLedgerProductsCopy = salesLedgerProductMapper.selectList(salesLedgerProductMapperLambdaQueryWrapperCopy);


            // 合计合同金额


            BigDecimal receiveAmount = purchaseLedgers.stream()


                    .map(PurchaseLedger::getContractAmount)


                    .filter(Objects::nonNull)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            // 未开票金额


            BigDecimal unReceiptPaymentAmount = salesLedgerProductsCopy.stream()


                    .map(SalesLedgerProduct::getNoInvoiceAmount)


                    .filter(Objects::nonNull)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            homeBusinessDto.setMonthPurchaseMoney(receiveAmount.setScale(2, RoundingMode.HALF_UP).toString());


            homeBusinessDto.setMonthPurchaseHaveMoney(unReceiptPaymentAmount.setScale(2, RoundingMode.HALF_UP).toString());


        }




        LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapperCopy = new LambdaQueryWrapper<SalesLedgerProduct>();


        salesLedgerProductMapperLambdaQueryWrapper.eq(SalesLedgerProduct::getType, 2)


                .in(SalesLedgerProduct::getSalesLedgerId, purchaseLedgers.stream().map(PurchaseLedger::getId).collect(Collectors.toList()));


        List<SalesLedgerProduct> salesLedgerProductsCopy = salesLedgerProductMapper.selectList(salesLedgerProductMapperLambdaQueryWrapperCopy);


        // 合计合同金额


        BigDecimal receiveAmount = purchaseLedgers.stream()


                .map(PurchaseLedger::getContractAmount)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        // 未开票金额


        BigDecimal unReceiptPaymentAmount = salesLedgerProductsCopy.stream()


                .map(SalesLedgerProduct::getNoInvoiceAmount)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);




        // 统计库存


        List<ProcurementRecordStorage> procurementRecordStorages = procurementRecordStorageMapper.selectList(null);


        BigDecimal stockAmount = procurementRecordStorages.stream()


                .map(ProcurementRecordStorage::getInboundNum)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        List<ProcurementRecordOut> procurementRecordOuts = procurementRecordOutMapper.selectList(null);


        BigDecimal outboundAmount = procurementRecordOuts.stream()


                .map(ProcurementRecordOut::getInboundNum)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        BigDecimal stock = stockAmount.subtract(outboundAmount);


//        List<ProcurementRecordStorage> procurementRecordStorages = procurementRecordStorageMapper.selectList(null);


//        BigDecimal stockAmount = procurementRecordStorages.stream()


//                .map(ProcurementRecordStorage::getInboundNum)


//                .filter(Objects::nonNull)


//                .reduce(BigDecimal.ZERO, BigDecimal::add);


//        // 自定义库存


//        List<CustomStorage> customStorages = customStorageMapper.selectList(null);


//        BigDecimal customStockAmount = customStorages.stream()


//                .map(CustomStorage::getInboundNum)


//                .filter(Objects::nonNull)


//                .reduce(BigDecimal.ZERO, BigDecimal::add);


//        List<ProcurementRecordOut> procurementRecordOuts = procurementRecordOutMapper.selectList(null);


//        BigDecimal outboundAmount = procurementRecordOuts.stream()


//                .map(ProcurementRecordOut::getInboundNum)


//                .filter(Objects::nonNull)


//                .reduce(BigDecimal.ZERO, BigDecimal::add);


//        BigDecimal stock = stockAmount.add(customStockAmount).subtract(outboundAmount);


        BigDecimal stockQuantityTotal = stockInventoryMapper.selectTotal();


        homeBusinessDto.setInventoryNum(stockQuantityTotal.setScale(2, RoundingMode.HALF_UP).toString());






        // 获取当天入库数量


        LambdaQueryWrapper<ProcurementRecordStorage> procurementRecordStorageLambdaQueryWrapper = new LambdaQueryWrapper<>();


        procurementRecordStorageLambdaQueryWrapper.ge(ProcurementRecordStorage::getCreateTime, now)  // 大于等于当天


@@ -159,10 +208,7 @@


                .map(ProcurementRecordStorage::getInboundNum)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);




        homeBusinessDto.setMonthPurchaseMoney(receiveAmount.setScale(2, RoundingMode.HALF_UP).toString());


        homeBusinessDto.setMonthPurchaseHaveMoney(unReceiptPaymentAmount.setScale(2, RoundingMode.HALF_UP).toString());


        homeBusinessDto.setInventoryNum(stock.setScale(2, RoundingMode.HALF_UP).toString());


//        homeBusinessDto.setInventoryNum(stock.setScale(2, RoundingMode.HALF_UP).toString());


        homeBusinessDto.setTodayInventoryNum(stockAmount1.setScale(2, RoundingMode.HALF_UP).toString());


        return homeBusinessDto;


    }


@@ -201,9 +247,9 @@


        BigDecimal subtract = weekContractAmount.subtract(lastYearWeekContractAmount);


        String weekYny = "";


        // 周同比


        if(subtract.compareTo(BigDecimal.ZERO) == 0 || lastYearWeekContractAmount.compareTo(BigDecimal.ZERO) == 0){


        if (subtract.compareTo(BigDecimal.ZERO) == 0 || lastYearWeekContractAmount.compareTo(BigDecimal.ZERO) == 0) {


            weekYny = "0.00";


        }else{


        } else {


            weekYny = String.format("%.2f", subtract.divide(lastYearWeekContractAmount, 2, RoundingMode.HALF_UP).multiply(new BigDecimal("100")));




        }


@@ -226,9 +272,9 @@


        BigDecimal subtract1 = todayContractAmount.subtract(lastYearYesterdayContractAmount); // 修改：使用 todayContractAmount 而不是 yesterdayContractAmount


        // 日环比


        String chain = "";


        if(subtract1.compareTo(BigDecimal.ZERO) == 0 || lastYearYesterdayContractAmount.compareTo(BigDecimal.ZERO) == 0){


        if (subtract1.compareTo(BigDecimal.ZERO) == 0 || lastYearYesterdayContractAmount.compareTo(BigDecimal.ZERO) == 0) {


            chain = "0.00";


        }else{


        } else {


            chain = String.format("%.2f", subtract1.divide(lastYearYesterdayContractAmount, 2, RoundingMode.HALF_UP).multiply(new BigDecimal("100")));


        }




@@ -242,14 +288,14 @@


        Map<String, BigDecimal> collect = salesLedgers.stream().collect(Collectors.groupingBy(SalesLedger::getCustomerName, Collectors.reducing(BigDecimal.ZERO,


                SalesLedger::getContractAmount, BigDecimal::add)));


        List<MapDto> mapDtos = new ArrayList<>();


        collect.forEach((k,v)->{


        collect.forEach((k, v) -> {


            MapDto mapDto = new MapDto();


            mapDto.setName(k);


            // 修改：将金额值保留两位小数


            mapDto.setValue(v.setScale(2, RoundingMode.HALF_UP).toString());


            if(contractAmount.compareTo(new BigDecimal(0)) == 0){


            if (contractAmount.compareTo(new BigDecimal(0)) == 0) {


                mapDto.setRate("0");


            }else{


            } else {


                mapDto.setRate(String.format("%.2f", v.divide(contractAmount, 2, RoundingMode.HALF_UP).multiply(new BigDecimal("100"))));


            }


            mapDtos.add(mapDto);


@@ -261,50 +307,83 @@




    @Override


    public QualityStatisticsDto qualityStatistics() {


        // 获取一周数据


        // 获取当前时间


        // 获取近四个月数据（往前推三个月，共4个完整月份）


        LocalDate today = LocalDate.now();


        // 获取本周周一


        LocalDate startOfWeek = today.with(DayOfWeek.MONDAY);


        // 获取本周周日


        LocalDate endOfWeek = today.with(DayOfWeek.SUNDAY);


        LambdaQueryWrapper<QualityInspect> qualityInspectLambdaQueryWrapper = new LambdaQueryWrapper<>();


        qualityInspectLambdaQueryWrapper.ge(QualityInspect::getCheckTime, startOfWeek)


                .gt(QualityInspect::getCheckTime, endOfWeek);


        List<QualityInspect> qualityInspects = qualityStatisticsMapper.selectList(qualityInspectLambdaQueryWrapper);


        // 定义日期格式化器（用于显示“年月”格式）


        DateTimeFormatter monthFormatter = DateTimeFormatter.ofPattern("yyyy-MM");




        QualityStatisticsDto qualityStatisticsDto = new QualityStatisticsDto();


        qualityStatisticsDto.setSupplierNum(qualityInspects.stream().filter(item -> item.getInspectType().equals(0)).map(QualityInspect::getQuantity).reduce(BigDecimal.ZERO, BigDecimal::add));


        qualityStatisticsDto.setProcessNum(qualityInspects.stream().filter(item -> item.getInspectType().equals(1)).map(QualityInspect::getQuantity).reduce(BigDecimal.ZERO, BigDecimal::add));


        qualityStatisticsDto.setFactoryNum(qualityInspects.stream().filter(item -> item.getInspectType().equals(2)).map(QualityInspect::getQuantity).reduce(BigDecimal.ZERO, BigDecimal::add));


        List<QualityStatisticsItem> qualityStatisticsItems = new ArrayList<>();


        for (int j = 1; j < 8; j++) {


            LocalDate endTime = startOfWeek.plusDays(j);


            LocalDate startTime = endTime.minusDays(1);


            QualityStatisticsItem qualityStatisticsItem = new QualityStatisticsItem();


            qualityStatisticsItem.setDate(startTime.toString());


            qualityStatisticsItem.setSupplierNum(qualityInspects.stream()


                    .filter(item -> item.getInspectType().equals(0) && "不合格".equals(item.getCheckResult())


                            && (startTime.isEqual(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()) || startTime.isAfter(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))


                            && endTime.isBefore(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))




        BigDecimal supplierNum = new BigDecimal(0);


        BigDecimal factoryNum = new BigDecimal(0);


        BigDecimal processNum = new BigDecimal(0);


        // 循环4次，分别统计近4个月的数据（当前月、前1个月、前2个月、前3个月）


        for (int i = 3; i >= 0; i--) {


            // 计算当前循环对应的月份（i=0：当前月，i=1：前1个月，以此类推）


            LocalDate currentMonth = today.minusMonths(i);


            // 当月的开始日期（每月1号）


            LocalDate monthStart = currentMonth.withDayOfMonth(1);


            // 当月的结束日期（每月最后一天）


            LocalDate monthEnd = currentMonth.withDayOfMonth(currentMonth.lengthOfMonth());




            // 构建当月的查询条件（如果想一次性查全4个月数据再内存筛选，可优化为先查全再循环筛选）


            LambdaQueryWrapper<QualityInspect> queryWrapper = new LambdaQueryWrapper<>();


            queryWrapper.ge(QualityInspect::getCheckTime, monthStart)


                    .le(QualityInspect::getCheckTime, monthEnd); // 筛选当月数据


            List<QualityInspect> monthInspects = qualityStatisticsMapper.selectList(queryWrapper);


            BigDecimal reduce = monthInspects.stream()


                    .filter(inspect -> inspect.getInspectType().equals(0))


                    .map(QualityInspect::getQuantity)


                    .reduce(BigDecimal.ZERO, BigDecimal::add)


            );


            qualityStatisticsItem.setFactoryNum(qualityInspects.stream()


                    .filter(item -> item.getInspectType().equals(1) && "不合格".equals(item.getCheckResult())


                            && (startTime.isEqual(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()) || startTime.isAfter(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))


                            && endTime.isBefore(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            supplierNum = supplierNum.add(reduce);


            BigDecimal reduce1 = monthInspects.stream()


                    .filter(inspect -> inspect.getInspectType().equals(1))


                    .map(QualityInspect::getQuantity)


                    .reduce(BigDecimal.ZERO, BigDecimal::add)


            );


            qualityStatisticsItem.setProcessNum(qualityInspects.stream()


                    .filter(item -> item.getInspectType().equals(2) && "不合格".equals(item.getCheckResult())


                            && (startTime.isEqual(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()) || startTime.isAfter(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))


                            && endTime.isBefore(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            processNum = processNum.add(reduce1);


            BigDecimal reduce2 = monthInspects.stream()


                    .filter(inspect -> inspect.getInspectType().equals(2))


                    .map(QualityInspect::getQuantity)


                    .reduce(BigDecimal.ZERO, BigDecimal::add));


            qualityStatisticsItems.add(qualityStatisticsItem);


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            factoryNum = factoryNum.add(reduce2);




            // 构建当月统计项


            QualityStatisticsItem item = new QualityStatisticsItem();


            item.setDate(monthStart.format(monthFormatter)); // 日期显示为“年月”（如 2025-10）




            // 1. 供应商检验（类型0）- 合格数量


            BigDecimal supplierQualified = monthInspects.stream()


                    .filter(inspect -> inspect.getInspectType().equals(0)


                            && "合格".equals(inspect.getCheckResult()))


                    .map(QualityInspect::getQuantity)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            item.setSupplierNum(supplierQualified);




            // 2. 工序检验（类型1）- 合格数量


            BigDecimal processQualified = monthInspects.stream()


                    .filter(inspect -> inspect.getInspectType().equals(1)


                            && "合格".equals(inspect.getCheckResult()))


                    .map(QualityInspect::getQuantity)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            item.setProcessNum(processQualified);




            // 3. 工厂检验（类型2）- 合格数量


            BigDecimal factoryQualified = monthInspects.stream()


                    .filter(inspect -> inspect.getInspectType().equals(2)


                            && "合格".equals(inspect.getCheckResult()))


                    .map(QualityInspect::getQuantity)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);


            item.setFactoryNum(factoryQualified);




            qualityStatisticsItems.add(item);


        }


        // 统计近4个月总数据（所有月份汇总）


        qualityStatisticsDto.setProcessNum(processNum);


        qualityStatisticsDto.setSupplierNum(supplierNum);


        qualityStatisticsDto.setFactoryNum(factoryNum);


        qualityStatisticsDto.setItem(qualityStatisticsItems);




        return qualityStatisticsDto;


    }




@@ -314,34 +393,33 @@


        LambdaQueryWrapper<ApproveProcess> approveProcessLambdaQueryWrapper = new LambdaQueryWrapper<>();


        approveProcessLambdaQueryWrapper.eq(ApproveProcess::getApproveDelete, 0)


                .eq(ApproveProcess::getApproveUserCurrentId, loginUser.getUserId())


                .ne(ApproveProcess::getApproveStatus, 2)


                .eq(ApproveProcess::getTenantId, loginUser.getTenantId());


                .ne(ApproveProcess::getApproveStatus, 2);


//                .eq(ApproveProcess::getTenantId, loginUser.getTenantId());


        List<ApproveProcess> approveProcesses = approveProcessMapper.selectList(approveProcessLambdaQueryWrapper);


        if(CollectionUtils.isEmpty(approveProcesses)){


        if (CollectionUtils.isEmpty(approveProcesses)) {


            approveProcesses = new ArrayList<>();


        }


        // 查询未领用劳保记录


        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");




        LaborIssue laborIssue1 = new LaborIssue();


        laborIssue1.setAdoptedDate(new Date());


        laborIssue1.setIssueDate(sdf.parse(sdf.format(new Date())));


        List<LaborIssue> laborIssues = lavorIssueMapper.list(laborIssue1);


        if(!CollectionUtils.isEmpty(laborIssues)){


            for (LaborIssue laborIssue : laborIssues) {


                ApproveProcess approveProcess = new ApproveProcess();


                approveProcess.setApproveId(laborIssue.getOrderNo());


                approveProcess.setApproveDeptName(sysDeptMapper.selectDeptById(loginUser.getTenantId()).getDeptName());


                approveProcess.setApproveTime(laborIssue.getIssueDate());


                approveProcess.setApproveReason(laborIssue.getDictTypeName() + "-" + laborIssue.getDictName() + "超时未领取");


                approveProcesses.add(approveProcess);


            }


        }


//        // 查询未领用劳保记录


//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");


//


//        LaborIssue laborIssue1 = new LaborIssue();


//        laborIssue1.setAdoptedDate(new Date());


//        laborIssue1.setIssueDate(sdf.parse(sdf.format(new Date())));


//        List<LaborIssue> laborIssues = lavorIssueMapper.list(laborIssue1);  //staff_join_leave_record表被删除


//        if(!CollectionUtils.isEmpty(laborIssues)){


//            for (LaborIssue laborIssue : laborIssues) {


//                ApproveProcess approveProcess = new ApproveProcess();


//                approveProcess.setApproveId(laborIssue.getOrderNo());


//                approveProcess.setApproveDeptName(sysDeptMapper.selectDeptById(loginUser.getTenantId()).getDeptName());


//                approveProcess.setApproveTime(laborIssue.getIssueDate());


//                approveProcess.setApproveReason(laborIssue.getDictTypeName() + "-" + laborIssue.getDictName() + "超时未领取");


//                approveProcesses.add(approveProcess);


//            }


//        }


        return approveProcesses;


    }




    /**


     *


     * @param type 1-周 2-月 3-季度


     * @return


     */


@@ -350,7 +428,7 @@


        LocalDate today = LocalDate.now();


        LocalDate startDate = null;


        LocalDate endDate = null;


        switch (type){


        switch (type) {


            case 1:


                // 获取本周周一


                startDate = today.with(DayOfWeek.MONDAY);


@@ -374,32 +452,522 @@


        }


        // 应收


        List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()


                .ge(SalesLedger::getEntryDate, startDate)


                .lt(SalesLedger::getEntryDate, endDate)


//                .ge(SalesLedger::getEntryDate, startDate)


//                .lt(SalesLedger::getEntryDate, endDate)


        );


        BigDecimal receivableMoney = salesLedgers.stream().map(SalesLedger::getContractAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


//        BigDecimal receivableMoney = salesLedgers.stream().map(SalesLedger::getContractAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


        BigDecimal receivableMoney = sumAmount(salesLedgers, SalesLedger::getContractAmount);


        // 应付


        List<PurchaseLedger> procurementRecords = purchaseLedgerMapper.selectList(new LambdaQueryWrapper<PurchaseLedger>()


                .ge(PurchaseLedger::getEntryDate, startDate)


                .lt(PurchaseLedger::getEntryDate, endDate)


//                .ge(PurchaseLedger::getEntryDate, startDate)


//                .lt(PurchaseLedger::getEntryDate, endDate)


        );


        BigDecimal payableMoney = procurementRecords.stream().map(PurchaseLedger::getContractAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


//        BigDecimal payableMoney = procurementRecords.stream().map(PurchaseLedger::getContractAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


        BigDecimal payableMoney = sumAmount(procurementRecords, PurchaseLedger::getContractAmount);


        // 预收


        List<ReceiptPayment> receiptPayments = receiptPaymentMapper.selectList(new LambdaQueryWrapper<ReceiptPayment>()


                .ge(ReceiptPayment::getReceiptPaymentDate, startDate)


                .lt(ReceiptPayment::getReceiptPaymentDate, endDate));


        BigDecimal advanceMoney = receiptPayments.stream().map(ReceiptPayment::getReceiptPaymentAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


//                .ge(ReceiptPayment::getReceiptPaymentDate, startDate)


//                .lt(ReceiptPayment::getReceiptPaymentDate, endDate)


        );


//        BigDecimal advanceMoney = receiptPayments.stream().map(ReceiptPayment::getReceiptPaymentAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


        BigDecimal advanceMoney = sumAmount(receiptPayments, ReceiptPayment::getReceiptPaymentAmount);


        // 预付


        List<PaymentRegistration> paymentRegistrations = paymentRegistrationMapper.selectList(new LambdaQueryWrapper<PaymentRegistration>()


                .ge(PaymentRegistration::getPaymentDate, startDate)


                .lt(PaymentRegistration::getPaymentDate, endDate));


        BigDecimal prepayMoney = paymentRegistrations.stream().map(PaymentRegistration::getCurrentPaymentAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


//                .ge(PaymentRegistration::getPaymentDate, startDate)


//                .lt(PaymentRegistration::getPaymentDate, endDate)


        );


//        BigDecimal prepayMoney = paymentRegistrations.stream().map(PaymentRegistration::getCurrentPaymentAmount).reduce(BigDecimal.ZERO, BigDecimal::add);


        BigDecimal prepayMoney = sumAmount(paymentRegistrations, PaymentRegistration::getCurrentPaymentAmount);


        StatisticsReceivablePayableDto statisticsReceivablePayableDto = new StatisticsReceivablePayableDto();


        statisticsReceivablePayableDto.setPayableMoney(payableMoney);


        statisticsReceivablePayableDto.setReceivableMoney(receivableMoney);


        statisticsReceivablePayableDto.setPayableMoney(payableMoney.subtract(prepayMoney));


        statisticsReceivablePayableDto.setReceivableMoney(receivableMoney.subtract(advanceMoney));


        statisticsReceivablePayableDto.setAdvanceMoney(advanceMoney);


        statisticsReceivablePayableDto.setPrepayMoney(prepayMoney);




        return statisticsReceivablePayableDto;


    }




    public static <T> BigDecimal sumAmount(List<T> list, java.util.function.Function<T, BigDecimal> amountExtractor) {


        return list.stream()


                // 提取金额时，将null替换为BigDecimal.ZERO


                .map(item -> Optional.ofNullable(amountExtractor.apply(item)).orElse(BigDecimal.ZERO))


                // 累加，初始值为0，避免空流问题


                .reduce(BigDecimal.ZERO, BigDecimal::add);


    }




    @Autowired


    private DeviceRepairMapper deviceRepairMapper;




    @Override


    public Map<String, Object> approveAndDeviceTodos() {


        // 审批协同待办


        Long aLong = approveProcessMapper.selectCount(new LambdaQueryWrapper<ApproveProcess>()


                .eq(ApproveProcess::getApproveUserCurrentId, SecurityUtils.getUserId())


                .eq(ApproveProcess::getApproveDelete, 0)


                .in(ApproveProcess::getApproveStatus, 0, 1, 3));


        // 设备报修待办


        Long aLong1 = deviceRepairMapper.selectCount(new LambdaQueryWrapper<DeviceRepair>()


                .eq(DeviceRepair::getStatus, 0)


                .eq(DeviceRepair::getRepairName, SecurityUtils.getLoginUser().getNickName()));


        return new HashMap<String, Object>() {{


            put("approveTodo", aLong);


            put("deviceRepairTodo", aLong1);


        }};


    }




    @Override


    public Long noticesCount() {


        // 查询未过期的通知数量：状态为发布且过期时间大于等于当前日期


        return noticeMapper.selectCount(new LambdaQueryWrapper<Notice>()


                .eq(Notice::getStatus, 1) // 1表示发布状态


                .ge(Notice::getExpirationDate, new Date())); // 过期时间大于等于当前日期


    }




    @Override


    public ProductionProgressDto productionProgress() {


        ProductionProgressDto productionProgressDto = new ProductionProgressDto();


        ProductOrderDto orderDto = new ProductOrderDto();


        orderDto.setStartTime(LocalDateTime.now().minusMonths(1));


        orderDto.setEndTime(LocalDateTime.now());


        List<ProductOrderDto> productOrderDtos = productOrderMapper.pageProductOrder(new Page<>(1, -1), orderDto).getRecords();


        productionProgressDto.setCompletedOrderDetails(productOrderDtos);


        long totalCount = productOrderDtos.size();


        long count = productOrderDtos.stream().filter(productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(productOrderDto.getQuantity()) >= 0).count();


        long count2 = productOrderDtos.stream().filter(productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(BigDecimal.ZERO) == 0).count();


        productionProgressDto.setTotalOrderCount(totalCount);


        productionProgressDto.setCompletedOrderCount(count);


        productionProgressDto.setUncompletedOrderCount(count2);


        productionProgressDto.setPartialCompletedOrderCount(totalCount - count - count2);


        return productionProgressDto;


    }




    @Override


    public ProductionTurnoverDto workInProcessTurnover() {


        ProductionTurnoverDto productionTurnoverDto = new ProductionTurnoverDto();


        ProductWorkOrderDto workOrder = new ProductWorkOrderDto();


        workOrder.setPlanStartTime(LocalDate.now().minusMonths(1));


        workOrder.setPlanEndTime(LocalDate.now());


        List<ProductWorkOrderDto> productWorkOrders = productWorkOrderMapper.pageProductWorkOrder(new Page<>(1, -1), workOrder).getRecords();


        long sum = productWorkOrders.stream()


                .filter(productWorkOrder -> productWorkOrder.getPlanQuantity().compareTo(productWorkOrder.getCompleteQuantity()) > 0)


                .map(ProductWorkOrder::getPlanQuantity)


                .mapToLong(BigDecimal::longValue)


                .sum();


        if (sum == 0) return null;


        productionTurnoverDto.setTotalOrderCount(sum);//总在制品数量


        productionTurnoverDto.setAverageTurnoverDays(BigDecimal.valueOf(sum).divide(BigDecimal.valueOf(ChronoUnit.DAYS.between(LocalDateTime.now().minusMonths(1), LocalDateTime.now())), 2, RoundingMode.HALF_UP));


        long completeQuantity = productWorkOrders.stream()


                .filter(productWorkOrder -> productWorkOrder.getCompleteQuantity().compareTo(productWorkOrder.getPlanQuantity()) >= 0)


                .map(ProductWorkOrder::getCompleteQuantity)


                .mapToLong(BigDecimal::longValue)


                .sum();


        productionTurnoverDto.setTurnoverEfficiency(BigDecimal.valueOf(completeQuantity).divide(BigDecimal.valueOf(sum), 2, RoundingMode.HALF_UP));


        Map<String, List<ProductWorkOrderDto>> map = productWorkOrders.stream()


                .filter(productWorkOrder -> productWorkOrder.getPlanQuantity().compareTo(productWorkOrder.getCompleteQuantity()) > 0)


                .collect(Collectors.groupingBy(ProductWorkOrderDto::getProcessName));


        List<String> strings = new ArrayList<>();


        List<Long> processQuantityDetails = new ArrayList<>();


        map.entrySet().stream().forEach(entry -> {


            String key = entry.getKey();


            long completeSum = entry.getValue().stream().map(ProductWorkOrderDto::getCompleteQuantity).mapToLong(BigDecimal::longValue).sum();


            strings.add(key);


            processQuantityDetails.add(completeSum);


        });


        productionTurnoverDto.setProcessDetails(strings);


        productionTurnoverDto.setProcessQuantityDetails(processQuantityDetails);


        return productionTurnoverDto;


    }




    @Override


    public DeptStaffDistributionDto deptStaffDistribution() {


        DeptStaffDistributionDto dto = new DeptStaffDistributionDto();


        List<MapDto> items = new ArrayList<>();




        // 查询所有正常且未删除的部门


        List<SysDept> depts = sysDeptMapper.selectDeptList(new SysDept());


        if (CollectionUtils.isEmpty(depts)) {


            dto.setItems(items);


            return dto;


        }




        long totalUsers = 0;


        List<Map<String, Object>> countsByDept = new ArrayList<>();




        for (SysDept dept : depts) {


            if ("0".equals(dept.getStatus()) && "0".equals(dept.getDelFlag())) {


                Long count = sysUserDeptMapper.selectCount(new LambdaQueryWrapper<SysUserDept>()


                        .eq(SysUserDept::getDeptId, dept.getDeptId()));


                if (count > 0) {


                    Map<String, Object> map = new HashMap<>();


                    map.put("name", dept.getDeptName());


                    map.put("count", count);


                    countsByDept.add(map);


                    totalUsers += count;


                }


            }


        }




        if (totalUsers > 0) {


            BigDecimal total = BigDecimal.valueOf(totalUsers);


            for (Map<String, Object> map : countsByDept) {


                MapDto mapDto = new MapDto();


                mapDto.setName((String) map.get("name"));


                Long count = (Long) map.get("count");


                mapDto.setValue(count.toString());


                mapDto.setRate(BigDecimal.valueOf(count).multiply(new BigDecimal("100"))


                        .divide(total, 2, RoundingMode.HALF_UP).toString());


                items.add(mapDto);


            }


        }




        dto.setTotal(totalUsers);


        dto.setItems(items);


        return dto;


    }




    @Override


    public HomeSummaryDto summaryStatistics() {


        HomeSummaryDto dto = new HomeSummaryDto();


        LocalDate now = LocalDate.now();


        YearMonth currentMonth = YearMonth.from(now);


        YearMonth prevMonth = currentMonth.minusMonths(1);




        LocalDateTime currentMonthEnd = currentMonth.atEndOfMonth().atTime(23, 59, 59);


        LocalDateTime prevMonthEnd = prevMonth.atEndOfMonth().atTime(23, 59, 59);




        //  总工作人员


        Long currentStaff = countStaff(currentMonthEnd);


        Long prevStaff = countStaff(prevMonthEnd);


        dto.setTotalStaff(currentStaff);


        dto.setStaffGrowthRate(calculateMoM(currentStaff, prevStaff));




        //  总客户数


        Long currentCustomers = countCustomers(currentMonthEnd);


        Long prevCustomers = countCustomers(prevMonthEnd);


        dto.setTotalCustomer(currentCustomers);


        dto.setCustomerGrowthRate(calculateMoM(currentCustomers, prevCustomers));




        //  总供应商数


        Long currentSuppliers = countSuppliers(currentMonthEnd);


        Long prevSuppliers = countSuppliers(prevMonthEnd);


        dto.setTotalSupplier(currentSuppliers);


        dto.setSupplierGrowthRate(calculateMoM(currentSuppliers, prevSuppliers));




        return dto;


    }




    private Long countStaff(LocalDateTime dateTime) {


        Long sysUserCount = sysUserMapper.selectCount(new LambdaQueryWrapper<SysUser>()


                .eq(SysUser::getDelFlag, "0")


                .le(SysUser::getCreateTime, dateTime));


        Long staffCountItem = staffOnJobMapper.selectCount(new LambdaQueryWrapper<StaffOnJob>()


                .le(StaffOnJob::getCreateTime, dateTime));


        return sysUserCount + staffCountItem;


    }






    private Long countCustomers(LocalDateTime dateTime) {


        return customerMapper.selectCount(new LambdaQueryWrapper<Customer>()


                .le(Customer::getMaintenanceTime, dateTime.toLocalDate()));


    }




    private Long countSuppliers(LocalDateTime dateTime) {


        return supplierManageMapper.selectCount(new LambdaQueryWrapper<SupplierManage>()


                .le(SupplierManage::getCreateTime, dateTime));


    }




    private String calculateMoM(Number current, Number prev) {


        BigDecimal curVal = new BigDecimal(current.toString());


        BigDecimal prevVal = new BigDecimal(prev.toString());


        if (prevVal.compareTo(BigDecimal.ZERO) == 0) {


            return curVal.compareTo(BigDecimal.ZERO) > 0 ? "100.00" : "0.00";


        }


        return curVal.subtract(prevVal)


                .divide(prevVal, 4, RoundingMode.HALF_UP)


                .multiply(new BigDecimal("100"))


                .setScale(2, RoundingMode.HALF_UP)


                .toString();


    }




    @Override


    public List<SupplierPurchaseRankingDto> supplierPurchaseRanking(Integer type) {


        LocalDate today = LocalDate.now();


        LocalDate startDate;


        LocalDate endDate;


        switch (type) {


            case 0: // 周


                startDate = today.with(DayOfWeek.MONDAY);


                endDate = today.with(DayOfWeek.SUNDAY);


                break;


            case 1: // 月


                startDate = today.with(TemporalAdjusters.firstDayOfMonth());


                endDate = today.with(TemporalAdjusters.lastDayOfMonth());


                break;


            case 2: // 季度


                Month currentMonth = today.getMonth();


                Month firstMonthOfQuarter = currentMonth.firstMonthOfQuarter();


                Month lastMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);




                startDate = today.withMonth(firstMonthOfQuarter.getValue()).with(TemporalAdjusters.firstDayOfMonth());


                endDate = today.withMonth(lastMonthOfQuarter.getValue()).with(TemporalAdjusters.lastDayOfMonth());


                break;


            default:


                return new ArrayList<>();


        }




        QueryWrapper<PurchaseLedger> queryWrapper = new QueryWrapper<>();


        queryWrapper.select("supplier_name", "SUM(contract_amount) as total_amount")


                .ge("entry_date", startDate)


                .le("entry_date", endDate)


//                .ne("approval_status", 3)


                .groupBy("supplier_name")


                .orderByDesc("total_amount")


                .last("LIMIT 5");




        List<Map<String, Object>> maps = purchaseLedgerMapper.selectMaps(queryWrapper);


        return maps.stream().map(map -> {


            SupplierPurchaseRankingDto dto = new SupplierPurchaseRankingDto();


            dto.setSupplierName(map.get("supplier_name") != null ? map.get("supplier_name").toString() : "");


            Object amount = map.get("total_amount");


            dto.setTotalAmount(amount != null ? new BigDecimal(amount.toString()) : BigDecimal.ZERO);


            return dto;


        }).collect(Collectors.toList());


    }




    @Override


    public CustomerRevenueAnalysisDto customerRevenueAnalysis(Long customerId, Integer type) {


        CustomerRevenueAnalysisDto dto = new CustomerRevenueAnalysisDto();


        List<MapDto> items = new ArrayList<>();


        LocalDate today = LocalDate.now();




        LocalDate start;


        LocalDate end;


        boolean groupByMonth = false;




        switch (type) {


            case 0: // 周


                start = today.with(DayOfWeek.MONDAY);


                end = today.with(DayOfWeek.SUNDAY);


                break;


            case 1: // 月


                start = today.with(TemporalAdjusters.firstDayOfMonth());


                end = today.with(TemporalAdjusters.lastDayOfMonth());


                break;


            case 2: // 季度


                Month firstMonthOfQuarter = today.getMonth().firstMonthOfQuarter();


                start = today.withMonth(firstMonthOfQuarter.getValue()).with(TemporalAdjusters.firstDayOfMonth());


                end = today.withMonth(firstMonthOfQuarter.plus(2).getValue()).with(TemporalAdjusters.lastDayOfMonth());


                groupByMonth = true;


                break;


            default:


                dto.setItems(items);


                return dto;


        }




        List<SalesLedger> list = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()


                .eq(SalesLedger::getCustomerId, customerId)


                .ge(SalesLedger::getEntryDate, start)


                .le(SalesLedger::getEntryDate, end));




        if (groupByMonth) {


            for (int i = 0; i < 3; i++) {


                LocalDate m = start.plusMonths(i);


                String monthName = m.getMonthValue() + "月";


                BigDecimal sum = list.stream()


                        .filter(l -> l.getEntryDate() != null)


                        .filter(l -> {


                            LocalDate ld = l.getEntryDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();


                            return ld.getMonth() == m.getMonth() && ld.getYear() == m.getYear();


                        })


                        .map(SalesLedger::getContractAmount)


                        .filter(Objects::nonNull)


                        .reduce(BigDecimal.ZERO, BigDecimal::add);


                MapDto mapDto = new MapDto();


                mapDto.setName(monthName);


                mapDto.setValue(sum.setScale(2, RoundingMode.HALF_UP).toString());


                items.add(mapDto);


            }


        } else {


            long days = ChronoUnit.DAYS.between(start, end) + 1;


            for (int i = 0; i < days; i++) {


                LocalDate d = start.plusDays(i);


                String dayName = d.getMonthValue() + "/" + d.getDayOfMonth();


                BigDecimal sum = list.stream()


                        .filter(l -> l.getEntryDate() != null)


                        .filter(l -> l.getEntryDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().equals(d))


                        .map(SalesLedger::getContractAmount)


                        .filter(Objects::nonNull)


                        .reduce(BigDecimal.ZERO, BigDecimal::add);


                MapDto mapDto = new MapDto();


                mapDto.setName(dayName);


                mapDto.setValue(sum.setScale(2, RoundingMode.HALF_UP).toString());


                items.add(mapDto);


            }


        }




        dto.setItems(items);


        return dto;


    }




    @Override


    public ProductCategoryDistributionDto productCategoryDistribution() {


        ProductCategoryDistributionDto dto = new ProductCategoryDistributionDto();


        List<ProductCategoryDistributionDto.MajorCategoryDto> majorItems = new ArrayList<>();




        //  所有的产品大类和小类


        List<Product> allProducts = productMapper.selectList(new LambdaQueryWrapper<Product>());


        if (CollectionUtils.isEmpty(allProducts)) {


            dto.setItems(majorItems);


            return dto;


        }




        List<Product> majorCategories = allProducts.stream().filter(p -> p.getParentId() == null).collect(Collectors.toList());


        List<Product> minorCategories = allProducts.stream().filter(p -> p.getParentId() != null).collect(Collectors.toList());




        //  从 sales_ledger_product 拿到每个产品的型号库存


        // 需包含规格型号以支持三级分布


        List<Map<String, Object>> quantityMaps = salesLedgerProductMapper.selectMaps(new QueryWrapper<SalesLedgerProduct>()


                .select("product_id", "specification_model", "type", "SUM(quantity) as sum_qty")


                .isNotNull("product_id")


                .groupBy("product_id", "specification_model", "type"));




        Map<Long, Map<String, Map<Integer, BigDecimal>>> modelStockGroups = new HashMap<>();


        for (Map<String, Object> map : quantityMaps) {


            Long productId = Long.parseLong(map.get("product_id").toString());


            String model = map.get("specification_model") != null ? map.get("specification_model").toString() : "未知型号";


            Integer type = Integer.parseInt(map.get("type").toString());


            BigDecimal sum = map.get("sum_qty") != null ? new BigDecimal(map.get("sum_qty").toString()) : BigDecimal.ZERO;




            modelStockGroups.computeIfAbsent(productId, k -> new HashMap<>())


                    .computeIfAbsent(model, k -> new HashMap<>())


                    .put(type, sum);


        }




        //  库存并汇总


        Map<Long, List<MapDto>> productModelsMap = new HashMap<>();


        Map<Long, BigDecimal> productTotalStockMap = new HashMap<>();




        for (Long pid : modelStockGroups.keySet()) {


            Map<String, Map<Integer, BigDecimal>> models = modelStockGroups.get(pid);


            BigDecimal productStock = BigDecimal.ZERO;


            List<MapDto> modelDtos = new ArrayList<>();




            for (String modelName : models.keySet()) {


                Map<Integer, BigDecimal> types = models.get(modelName);


                BigDecimal procurement = types.getOrDefault(2, BigDecimal.ZERO);


                BigDecimal sales = types.getOrDefault(1, BigDecimal.ZERO);


                BigDecimal stock = procurement.subtract(sales);


                if (stock.compareTo(BigDecimal.ZERO) < 0) stock = BigDecimal.ZERO;




                MapDto modelDto = new MapDto();


                modelDto.setName(modelName);


                modelDto.setValue(stock.stripTrailingZeros().toPlainString());


                modelDtos.add(modelDto);


                productStock = productStock.add(stock);


            }


            productModelsMap.put(pid, modelDtos);


            productTotalStockMap.put(pid, productStock);


        }




        BigDecimal totalInventory = productTotalStockMap.values().stream().reduce(BigDecimal.ZERO, BigDecimal::add);




        //  型号占比


        if (totalInventory.compareTo(BigDecimal.ZERO) > 0) {


            for (List<MapDto> dtos : productModelsMap.values()) {


                for (MapDto m : dtos) {


                    BigDecimal val = new BigDecimal(m.getValue());


                    m.setRate(val.multiply(new BigDecimal("100"))


                            .divide(totalInventory, 2, RoundingMode.HALF_UP).toString());


                }


            }


        }




        //  分层数据


        for (Product major : majorCategories) {


            ProductCategoryDistributionDto.MajorCategoryDto majorDto = new ProductCategoryDistributionDto.MajorCategoryDto();


            majorDto.setName(major.getProductName());




            List<ProductCategoryDistributionDto.MinorCategoryDto> minorDtos = new ArrayList<>();


            BigDecimal majorStock = BigDecimal.ZERO;




            for (Product minor : minorCategories) {


                if (major.getId().equals(minor.getParentId())) {


                    BigDecimal stock = productTotalStockMap.getOrDefault(minor.getId(), BigDecimal.ZERO);


                    ProductCategoryDistributionDto.MinorCategoryDto minorDto = new ProductCategoryDistributionDto.MinorCategoryDto();


                    minorDto.setName(minor.getProductName());


                    minorDto.setValue(stock.stripTrailingZeros().toPlainString());




                    if (totalInventory.compareTo(BigDecimal.ZERO) > 0) {


                        minorDto.setRate(stock.multiply(new BigDecimal("100"))


                                .divide(totalInventory, 2, RoundingMode.HALF_UP).toString());


                    } else {


                        minorDto.setRate("0.00");


                    }




                    minorDto.setChildren(productModelsMap.getOrDefault(minor.getId(), new ArrayList<>()));


                    minorDtos.add(minorDto);


                    majorStock = majorStock.add(stock);


                }


            }




            majorDto.setValue(majorStock.stripTrailingZeros().toPlainString());




            if (totalInventory.compareTo(BigDecimal.ZERO) > 0) {


                majorDto.setRate(majorStock.multiply(new BigDecimal("100"))


                        .divide(totalInventory, 2, RoundingMode.HALF_UP).toString());


            } else {


                majorDto.setRate("0.00");


            }


            majorDto.setChildren(minorDtos);


            majorItems.add(majorDto);


        }




        dto.setItems(majorItems);


        return dto;


    }




    @Override


    public List<CustomerContributionRankingDto> customerContributionRanking(Integer type) {


        LocalDate today = LocalDate.now();


        LocalDate startDate = null;


        LocalDate endDate = null;


        switch (type) {


            case 0:


                startDate = today.with(DayOfWeek.MONDAY);


                endDate = today.with(DayOfWeek.SUNDAY);


                break;


            case 1:


                startDate = today.with(TemporalAdjusters.firstDayOfMonth());


                endDate = today.with(TemporalAdjusters.lastDayOfMonth());


                break;


            case 2:


                Month currentMonth = today.getMonth();


                Month firstMonthOfQuarter = currentMonth.firstMonthOfQuarter();


                Month lastMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);


                startDate = today.withMonth(firstMonthOfQuarter.getValue()).with(TemporalAdjusters.firstDayOfMonth());


                endDate = today.withMonth(lastMonthOfQuarter.getValue()).with(TemporalAdjusters.lastDayOfMonth());


                break;


        }




        QueryWrapper<SalesLedger> queryWrapper = new QueryWrapper<>();


        queryWrapper.select("customer_name", "SUM(contract_amount) as total_amount")


                .isNotNull("customer_name")


                .groupBy("customer_name")


                .orderByDesc("total_amount")


                .last("LIMIT 5");




        if (startDate != null && endDate != null) {


            queryWrapper.between("entry_date", startDate, endDate);


        }




        List<Map<String, Object>> maps = salesLedgerMapper.selectMaps(queryWrapper);


        List<CustomerContributionRankingDto> result = new ArrayList<>();


        for (Map<String, Object> map : maps) {


            CustomerContributionRankingDto rankingDto = new CustomerContributionRankingDto();


            rankingDto.setCustomerName(map.get("customer_name").toString());


            rankingDto.setTotalAmount(map.get("total_amount") != null ? new BigDecimal(map.get("total_amount").toString()) : BigDecimal.ZERO);


            result.add(rankingDto);


        }


        return result;


    }


}