fix:1.入库管理和耗材导出优化 2.仓储物流和耗材物流导出修改 3.首页统计仓储物流和耗材物料两边的数据

liding

2026-03-19 712b1df6fdee09bd92388a60a9f5d890d711387b

 src/main/java/com/ruoyi/home/service/impl/HomeServiceImpl.java

@@ -2,17 +2,14 @@

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.account.mapper.AccountExpenseMapper;
import com.ruoyi.account.mapper.AccountIncomeMapper;
import com.ruoyi.account.pojo.AccountExpense;
import com.ruoyi.home.mapper.HomeMapper;
import com.ruoyi.account.mapper.AccountExpenseMapper;
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;
@@ -22,24 +19,17 @@
import com.ruoyi.common.enums.ApproveTypeEnum;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.consumables.mapper.ConsumablesInventoryMapper;
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.mapper.HomeMapper;
import com.ruoyi.home.service.HomeService;
import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;
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.ProductProcessMapper;
import com.ruoyi.production.mapper.ProductWorkOrderMapper;
import com.ruoyi.production.mapper.ProductionProductInputMapper;
import com.ruoyi.production.mapper.ProductionProductOutputMapper;
import com.ruoyi.production.mapper.SalesLedgerProductionAccountingMapper;
import com.ruoyi.production.pojo.ProductProcess;
import com.ruoyi.production.mapper.*;
import com.ruoyi.production.pojo.ProductWorkOrder;
import com.ruoyi.project.system.domain.SysDept;
import com.ruoyi.project.system.mapper.SysDeptMapper;
@@ -49,8 +39,10 @@
import com.ruoyi.purchase.pojo.PurchaseLedger;
import com.ruoyi.quality.mapper.QualityInspectMapper;
import com.ruoyi.quality.mapper.QualityUnqualifiedMapper;
import com.ruoyi.quality.mapper.RawMaterialMapper;
import com.ruoyi.quality.pojo.QualityInspect;
import com.ruoyi.quality.pojo.QualityUnqualified;
import com.ruoyi.quality.pojo.RawMaterial;
import com.ruoyi.sales.mapper.ReceiptPaymentMapper;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
@@ -94,6 +86,9 @@

    @Autowired
    private StockInventoryMapper stockInventoryMapper;

    @Autowired
    private ConsumablesInventoryMapper consumablesInventoryMapper;

    @Autowired
    private QualityInspectMapper qualityStatisticsMapper;
@@ -141,10 +136,19 @@
    private QualityInspectMapper qualityInspectMapper;

    @Autowired
    private RawMaterialMapper rawMaterialMapper;

    @Autowired
    private QualityUnqualifiedMapper qualityUnqualifiedMapper;

    @Autowired
    private ProductProcessMapper productProcessMapper;
    
    @Autowired
    private AccountExpenseMapper accountExpenseMapper;

    @Autowired
    private AccountIncomeMapper accountIncomeMapper;

    @Override
    public HomeBusinessDto business() {
@@ -179,36 +183,43 @@
        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)) {
            LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapperCopy = new LambdaQueryWrapper<SalesLedgerProduct>();
            salesLedgerProductMapperLambdaQueryWrapperCopy.eq(SalesLedgerProduct::getType, 2)
            LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapperCopy = new LambdaQueryWrapper<>();
            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)
                    .map(SalesLedgerProduct::getPendingTicketsTotal)
                    .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.setMonthPurchaseHaveMoney(unReceiptPaymentAmount.setScale(2, RoundingMode.HALF_UP).toString());
        }
        // 统计库存
        BigDecimal stockQuantityTotal = stockInventoryMapper.selectTotal();
        BigDecimal consumablesQuantityTotal = consumablesInventoryMapper.selectTotal();
        homeBusinessDto.setInventoryNum(stockQuantityTotal.setScale(2, RoundingMode.HALF_UP).toString());
        homeBusinessDto.setConsumablesQuantityTotal(consumablesQuantityTotal.setScale(2, RoundingMode.HALF_UP).toString());

        // 获取当天入库数量
        BigDecimal bigDecimal = stockInventoryMapper.selectTotalByDate(LocalDate.now());
        BigDecimal consumablesTodayNum = consumablesInventoryMapper.selectTotalByDate(LocalDate.now());
        homeBusinessDto.setTodayInventoryNum(bigDecimal.setScale(2, RoundingMode.HALF_UP).toString());
        homeBusinessDto.setConsumablesTodayNum(consumablesTodayNum.setScale(2, RoundingMode.HALF_UP).toString());
        return homeBusinessDto;
    }

@@ -465,8 +476,8 @@
        }
        // 应收
        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,
@@ -475,8 +486,8 @@
        // 应付
        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,
@@ -484,8 +495,8 @@
        BigDecimal payableMoney = sumAmount(procurementRecords, PurchaseLedger::getContractAmount);
        // 预收
        List<ReceiptPayment> receiptPayments = receiptPaymentMapper.selectList(new LambdaQueryWrapper<ReceiptPayment>()
        // .ge(ReceiptPayment::getReceiptPaymentDate, startDate)
        // .lt(ReceiptPayment::getReceiptPaymentDate, endDate)
                // .ge(ReceiptPayment::getReceiptPaymentDate, startDate)
                // .lt(ReceiptPayment::getReceiptPaymentDate, endDate)
        );
        // BigDecimal advanceMoney =
        // receiptPayments.stream().map(ReceiptPayment::getReceiptPaymentAmount).reduce(BigDecimal.ZERO,
@@ -494,8 +505,8 @@
        // 预付
        List<PaymentRegistration> paymentRegistrations = paymentRegistrationMapper
                .selectList(new LambdaQueryWrapper<PaymentRegistration>()
                // .ge(PaymentRegistration::getPaymentDate, startDate)
                // .lt(PaymentRegistration::getPaymentDate, endDate)
                        // .ge(PaymentRegistration::getPaymentDate, startDate)
                        // .lt(PaymentRegistration::getPaymentDate, endDate)
                );
        // BigDecimal prepayMoney =
        // paymentRegistrations.stream().map(PaymentRegistration::getCurrentPaymentAmount).reduce(BigDecimal.ZERO,
@@ -559,7 +570,7 @@
        productionProgressDto.setCompletedOrderDetails(productOrderDtos);
        long totalCount = productOrderDtos.size();
        long count = productOrderDtos.stream().filter(
                productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(productOrderDto.getQuantity()) >= 0)
                        productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(productOrderDto.getQuantity()) >= 0)
                .count();
        long count2 = productOrderDtos.stream()
                .filter(productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(BigDecimal.ZERO) == 0)
@@ -1145,12 +1156,6 @@
        return homeMapper.productTurnoverDays();
    }

    @Autowired
    private AccountExpenseMapper accountExpenseMapper;

    @Autowired
    private AccountIncomeMapper accountIncomeMapper;

    public List<Map<String, Object>> incomeExpenseAnalysis(Integer type) {

        LocalDate today = LocalDate.now();
@@ -1274,36 +1279,21 @@
        String startStr = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        String endStr = endDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));

        // List<IncomeExpenseAnalysisDto> incomeList =
        // salesLedgerMapper.selectIncomeStats(startStr, endStr, dateFormat);
        List<IncomeExpenseAnalysisDto> incomeList = new ArrayList<>();
        List<IncomeExpenseAnalysisDto> purchaseList = purchaseLedgerMapper.selectPurchaseStats(startStr, endStr,
                dateFormat);
        List<IncomeExpenseAnalysisDto> expenseList = accountExpenseMapper.selectAccountExpenseStats(startStr, endStr,
                dateFormat);
        List<IncomeExpenseAnalysisDto> incomeList = accountIncomeMapper.selectIncomeStats(startStr, endStr, dateFormat);
        List<IncomeExpenseAnalysisDto> expenseList = accountExpenseMapper.selectAccountExpenseStats(startStr, endStr, dateFormat);

        Map<String, BigDecimal> incomeMap = incomeList.stream().collect(Collectors
                .toMap(IncomeExpenseAnalysisDto::getDateStr, IncomeExpenseAnalysisDto::getAmount, BigDecimal::add));
        Map<String, BigDecimal> purchaseMap = purchaseList.stream().collect(Collectors
                .toMap(IncomeExpenseAnalysisDto::getDateStr, IncomeExpenseAnalysisDto::getAmount, BigDecimal::add));
        Map<String, BigDecimal> expenseMap = expenseList.stream().collect(Collectors
                .toMap(IncomeExpenseAnalysisDto::getDateStr, IncomeExpenseAnalysisDto::getAmount, BigDecimal::add));

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

        for (String month : months) {
            MapDto dto = new MapDto();
            dto.setName(month);

            BigDecimal income = incomeMap.getOrDefault(month, BigDecimal.ZERO);

            BigDecimal purchase = purchaseMap.getOrDefault(month, BigDecimal.ZERO);
            income = BigDecimal.ZERO;
            BigDecimal expense = expenseMap.getOrDefault(month, BigDecimal.ZERO);
            BigDecimal totalExpense = purchase.add(expense);

            BigDecimal profit = income.subtract(totalExpense);

            BigDecimal profit = income.subtract(expense);
            dto.setValue(profit.setScale(2, RoundingMode.HALF_UP).toString());
            result.add(dto);
        }
@@ -1948,7 +1938,7 @@
                endDate = today.with(DayOfWeek.SUNDAY);
        }

        return new LocalDate[] { startDate, endDate };
        return new LocalDate[]{startDate, endDate};
    }

    private QualityQualifiedAnalysisDto buildQualifiedAnalysis(List<QualityInspect> list) {
@@ -2194,7 +2184,7 @@
     */
    public static String[] lastSevenDaysDateRange() {
        LocalDate today = LocalDate.now();
        return new String[] { today.minusDays(6).toString(), today.toString() };
        return new String[]{today.minusDays(6).toString(), today.toString()};
    }

    @Override
@@ -2412,88 +2402,95 @@
                endDate = today.with(DayOfWeek.SUNDAY);
        }

        List<QualityInspect> qualityInspectList = qualityInspectMapper
                .selectList(new LambdaQueryWrapper<QualityInspect>()
                        .ge(QualityInspect::getCheckTime, startDate.toString())
                        .le(QualityInspect::getCheckTime, endDate.toString())
                        .eq(QualityInspect::getInspectState, 1));
        List<RawMaterial> rawMaterialList = rawMaterialMapper
                .selectList(new LambdaQueryWrapper<RawMaterial>()
                        .ge(RawMaterial::getCheckTime, startDate.toString())
                        .le(RawMaterial::getCheckTime, endDate.toString())
                        .eq(RawMaterial::getInspectState, 1));

        QualityStatisticsDto dto = new QualityStatisticsDto();
        dto.setSupplierNum(sumQuantity(qualityInspectList, 0)); // 原材料
        dto.setProcessNum(sumQuantity(qualityInspectList, 1)); // 过程
        dto.setFactoryNum(sumQuantity(qualityInspectList, 2)); // 出厂
        Map<Integer, BigDecimal> countMap = rawMaterialList.stream()
                .collect(Collectors.groupingBy(
                        RawMaterial::getCheckType,
                        Collectors.collectingAndThen(
                                Collectors.counting(),
                                count -> BigDecimal.valueOf(count)
                        )
                ));

        // 假设 qualityInspectList 是一个 List<QualityInspect> 类型的集合
        Map<String, List<QualityInspect>> groupedByCheckResult = qualityInspectList.stream()
                .collect(Collectors.groupingBy(QualityInspect::getCheckResult));
        List<QualityInspect> qualityInspects = groupedByCheckResult.get("不合格");
        if(ObjectUtils.isNull(qualityInspects) || qualityInspects.size()==0){
            return null;
        }
        dto.setSupplierNum(countMap.getOrDefault(0, BigDecimal.ZERO)); // 入厂
        dto.setProcessNum(countMap.getOrDefault(1, BigDecimal.ZERO));  // 车间
        dto.setFactoryNum(countMap.getOrDefault(2, BigDecimal.ZERO));  // 出厂

        // 3. 筛选不合格的记录（check_result = 0）
        List<RawMaterial> unqualifiedList = rawMaterialList.stream()
                .filter(i -> i.getCheckResult() == 0)  // 0表示不合格
                .collect(Collectors.toList());

        // 4. 处理图表项 (Item)
        List<QualityStatisticsItem> itemList = new ArrayList<>();
        List<RawMaterial> itemList = new ArrayList<>();

        Map<QualityInspect, LocalDate> dateMap = qualityInspectList.stream()
                .collect(Collectors.toMap(
                        i -> i,
                        i -> i.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()));
        if (type == 3) {
            // 季度模式：按月分组
            Map<String, List<QualityInspect>> groupByMonth = qualityInspects.stream()
                    .collect(Collectors.groupingBy(i -> {
                        LocalDate ld = dateMap.get(i);
                        return ld.format(DateTimeFormatter.ofPattern("yyyy-MM"));
                    }));
            Map<String, List<RawMaterial>> groupByMonth = unqualifiedList.isEmpty() ?
                    new HashMap<>() :
                    unqualifiedList.stream()
                            .collect(Collectors.groupingBy(i -> {
                                LocalDate ld = i.getCheckTime().toInstant()
                                        .atZone(ZoneId.systemDefault()).toLocalDate();
                                return ld.format(DateTimeFormatter.ofPattern("yyyy-MM"));
                            }));

            for (int i = 0; i < 3; i++) {
                LocalDate monthDate = startDate.plusMonths(i);
                String monthStr = monthDate.format(DateTimeFormatter.ofPattern("yyyy-MM"));
                itemList.add(buildItem(monthStr, groupByMonth.getOrDefault(monthStr, new ArrayList<>())));
                List<RawMaterial> monthData = groupByMonth.getOrDefault(monthStr, new ArrayList<>());
                itemList.add(buildItem(monthStr, monthData));
            }
        } else {
            // 周或月模式：按天分组
            Map<String, List<QualityInspect>> groupByDay = qualityInspects.stream()
                    .collect(Collectors.groupingBy(i -> {
                        LocalDate ld = dateMap.get(i);
                        return ld.format(DateTimeFormatter.ofPattern("MM/dd"));
                    }));
            Map<String, List<RawMaterial>> groupByDay = unqualifiedList.isEmpty() ?
                    new HashMap<>() :
                    unqualifiedList.stream()
                            .collect(Collectors.groupingBy(i -> {
                                LocalDate ld = i.getCheckTime().toInstant()
                                        .atZone(ZoneId.systemDefault()).toLocalDate();
                                return ld.format(DateTimeFormatter.ofPattern("MM/dd"));
                            }));

            long days = ChronoUnit.DAYS.between(startDate, endDate);
            for (int i = 0; i <= days; i++) {
                LocalDate tempDay = startDate.plusDays(i);
                String dayStr = tempDay.format(DateTimeFormatter.ofPattern("MM/dd"));
                itemList.add(buildItem(dayStr, groupByDay.getOrDefault(dayStr, new ArrayList<>())));
                List<RawMaterial> dayData = groupByDay.getOrDefault(dayStr, new ArrayList<>());
                itemList.add(buildItem(dayStr, dayData));
            }
        }

        dto.setItem(itemList);
        dto.setRawItem(itemList);
        return dto;
    }

    private BigDecimal sumQuantity(List<QualityInspect> list, Integer type) {
        return list.stream()
                .filter(i -> i.getInspectType().equals(type))
                .map(QualityInspect::getQuantity)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    private QualityStatisticsItem buildItem(String dateLabel, List<QualityInspect> list) {
        QualityStatisticsItem item = new QualityStatisticsItem();
    private RawMaterial buildItem(String dateLabel, List<RawMaterial> list) {
        RawMaterial item = new RawMaterial();
        item.setDate(dateLabel);

        item.setSupplierNum(list.stream().filter(i -> i.getInspectType() == 0).map(QualityInspect::getQuantity)
                .reduce(BigDecimal.ZERO, BigDecimal::add));
        item.setProcessNum(list.stream().filter(i -> i.getInspectType() == 1).map(QualityInspect::getQuantity)
                .reduce(BigDecimal.ZERO, BigDecimal::add));
        item.setFactoryNum(list.stream().filter(i -> i.getInspectType() == 2).map(QualityInspect::getQuantity)
                .reduce(BigDecimal.ZERO, BigDecimal::add));
        item.setSupplierNum(
                BigDecimal.valueOf(list.stream().filter(i -> i.getCheckType() == 0).count())
        );
        item.setProcessNum(
                BigDecimal.valueOf(list.stream().filter(i -> i.getCheckType() == 1).count())
        );
        item.setFactoryNum(
                BigDecimal.valueOf(list.stream().filter(i -> i.getCheckType() == 2).count())
        );

        return item;
    }

    @Override
    public List<processDataProductionStatisticsDto> processDataProductionStatistics(Integer type,
            List<Long> processIds) {
                                                                                    List<Long> processIds) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        Long userId = SecurityUtils.isAdmin(loginUser.getUserId()) ? null : loginUser.getUserId();