产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
chenhj
2026-04-22 fa3428b4bb32179a42d5618357c22fe2695716ae 
 src/main/java/com/ruoyi/home/service/impl/HomeServiceImpl.java


@@ -2,16 +2,14 @@




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


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


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


import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;


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;


@@ -26,24 +24,12 @@


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.ProductWorkOrderMapper;


import com.ruoyi.production.mapper.ProductionProductInputMapper;


import com.ruoyi.production.mapper.ProductionProductOutputMapper;


import com.ruoyi.production.mapper.SalesLedgerProductionAccountingMapper;


import com.ruoyi.production.pojo.ProductWorkOrder;


import com.ruoyi.production.bean.dto.ProductionProductOutputDto;


import com.ruoyi.production.mapper.*;


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


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


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


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


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


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


import com.ruoyi.purchase.mapper.PaymentRegistrationMapper;


import com.ruoyi.purchase.mapper.PurchaseLedgerMapper;


import com.ruoyi.purchase.pojo.PaymentRegistration;


@@ -61,8 +47,8 @@


import com.ruoyi.staff.mapper.StaffOnJobMapper;


import com.ruoyi.staff.pojo.StaffOnJob;


import com.ruoyi.stock.mapper.StockInventoryMapper;


import lombok.RequiredArgsConstructor;


import lombok.extern.slf4j.Slf4j;


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


import org.springframework.stereotype.Service;


import org.springframework.util.CollectionUtils;




@@ -82,67 +68,52 @@


 */


@Service


@Slf4j


@RequiredArgsConstructor


public class HomeServiceImpl implements HomeService {




    @Autowired


    private SalesLedgerMapper salesLedgerMapper;


    private final SalesLedgerMapper salesLedgerMapper;




    @Autowired


    private PurchaseLedgerMapper purchaseLedgerMapper;


    private final PurchaseLedgerMapper purchaseLedgerMapper;




    @Autowired


    private SalesLedgerProductMapper salesLedgerProductMapper;


    private final SalesLedgerProductMapper salesLedgerProductMapper;




    @Autowired


    private StockInventoryMapper stockInventoryMapper;


    private final StockInventoryMapper stockInventoryMapper;




    @Autowired


    private QualityInspectMapper qualityStatisticsMapper;


    private final QualityInspectMapper qualityStatisticsMapper;




    @Autowired


    private ApproveProcessMapper approveProcessMapper;


    private final ApproveProcessMapper approveProcessMapper;




    @Autowired


    private ReceiptPaymentMapper receiptPaymentMapper;


    private final ReceiptPaymentMapper receiptPaymentMapper;




    @Autowired


    private PaymentRegistrationMapper paymentRegistrationMapper;


    private final PaymentRegistrationMapper paymentRegistrationMapper;




    @Autowired


    private SysDeptMapper sysDeptMapper;


    private  SysDeptMapper sysDeptMapper;




    @Autowired


    private NoticeMapper noticeMapper;


    private final NoticeMapper noticeMapper;


    


    private final ProductionOrderMapper productionOrderMapper;




    @Autowired


    private ProductOrderMapper productOrderMapper;




    @Autowired


    private ProductWorkOrderMapper productWorkOrderMapper;




    @Autowired


    private ProductMapper productMapper;




    @Autowired


    private StaffOnJobMapper staffOnJobMapper;




    @Autowired


    private CustomerMapper customerMapper;




    @Autowired


    private SupplierManageMapper supplierManageMapper;




    @Autowired


    private HomeMapper homeMapper;




    @Autowired


    private ProductionProductOutputMapper productionProductOutputMapper;




    @Autowired


    private QualityInspectMapper qualityInspectMapper;




    @Autowired


    private QualityUnqualifiedMapper qualityUnqualifiedMapper;


    private final ProductMapper productMapper;


    


    private final StaffOnJobMapper staffOnJobMapper;


    


    private final CustomerMapper customerMapper;


    


    private final SupplierManageMapper supplierManageMapper;


    


    private final HomeMapper homeMapper;


    


    private final ProductionProductOutputMapper productionProductOutputMapper;


    


    private final QualityInspectMapper qualityInspectMapper;


    


    private final QualityUnqualifiedMapper qualityUnqualifiedMapper;


    


    private final ProductionOperationTaskMapper productionOperationTaskMapper;


    


    private final AccountExpenseMapper accountExpenseMapper;


    


    private final AccountIncomeMapper accountIncomeMapper;




    @Override


    public HomeBusinessDto business() {


@@ -177,28 +148,31 @@


        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();


@@ -329,10 +303,10 @@


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


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




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


            // 构建当月的查询条件


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


            queryWrapper.ge(QualityInspect::getCheckTime, monthStart)


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


            queryWrapper.ge(QualityInspect::getCheckTime, monthStart.toString())


                    .le(QualityInspect::getCheckTime, monthEnd.toString());


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


            BigDecimal reduce = monthInspects.stream()


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


@@ -516,7 +490,7 @@


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


    }




    @Autowired


    


    private DeviceRepairMapper deviceRepairMapper;




    @Override


@@ -549,18 +523,15 @@


    @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)


        List<ProductionProgressOrderDto> orderDetails = productionOrderMapper.selectProgressOrders(


                LocalDateTime.now().minusMonths(1), LocalDateTime.now());


        productionProgressDto.setCompletedOrderDetails(orderDetails);


        long totalCount = orderDetails.size();


        long count = orderDetails.stream().filter(


                        item -> defaultDecimal(item.getCompleteQuantity()).compareTo(defaultDecimal(item.getQuantity())) >= 0)


                .count();


        long count2 = productOrderDtos.stream()


                .filter(productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(BigDecimal.ZERO) == 0)


        long count2 = orderDetails.stream()


                .filter(item -> defaultDecimal(item.getCompleteQuantity()).compareTo(BigDecimal.ZERO) == 0)


                .count();


        productionProgressDto.setTotalOrderCount(totalCount);


        productionProgressDto.setCompletedOrderCount(count);


@@ -572,15 +543,11 @@


    @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)


        List<ProductionTaskStatisticsDto> taskList = productionOperationTaskMapper


                .selectTaskStatisticsByDate(LocalDate.now().minusMonths(1), LocalDate.now());


        long sum = taskList.stream()


                .filter(task -> defaultDecimal(task.getPlanQuantity()).compareTo(defaultDecimal(task.getCompleteQuantity())) > 0)


                .map(ProductionTaskStatisticsDto::getPlanQuantity)


                .mapToLong(BigDecimal::longValue)


                .sum();


        if (sum == 0)


@@ -589,23 +556,21 @@


        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)


        long completeQuantity = taskList.stream()


                .filter(task -> defaultDecimal(task.getCompleteQuantity()).compareTo(defaultDecimal(task.getPlanQuantity())) >= 0)


                .map(ProductionTaskStatisticsDto::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));


        Map<String, List<ProductionTaskStatisticsDto>> map = taskList.stream()


                .filter(task -> defaultDecimal(task.getPlanQuantity()).compareTo(defaultDecimal(task.getCompleteQuantity())) > 0)


                .collect(Collectors.groupingBy(ProductionTaskStatisticsDto::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)


            long completeSum = entry.getValue().stream().map(ProductionTaskStatisticsDto::getCompleteQuantity)


                    .mapToLong(BigDecimal::longValue).sum();


            strings.add(key);


            processQuantityDetails.add(completeSum);


@@ -1030,28 +995,20 @@




    @Override


    public List<MapDto> salesPurchaseStorageProductCount() {


        LocalDate now = LocalDate.now();


        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");


        LocalDateTime now = LocalDateTime.now();


        LocalDateTime currentMonthStart = now.with(TemporalAdjusters.firstDayOfMonth()).with(LocalTime.MIN);


        LocalDateTime lastMonth = now.minusMonths(1);


        LocalDateTime lastMonthStart = lastMonth.with(TemporalAdjusters.firstDayOfMonth()).with(LocalTime.MIN);


        LocalDateTime lastMonthEnd = lastMonth.with(TemporalAdjusters.lastDayOfMonth()).with(LocalTime.MAX);




        String currentMonthStart = now.with(TemporalAdjusters.firstDayOfMonth()).format(dtf);


        String currentMonthNow = now.format(dtf);




        LocalDate lastMonth = now.minusMonths(1);


        String lastMonthStart = lastMonth.with(TemporalAdjusters.firstDayOfMonth()).format(dtf);


        String lastMonthEnd = lastMonth.with(TemporalAdjusters.lastDayOfMonth()).format(dtf);




        // 销售


        int currentSales = salesLedgerProductMapper.selectProductCountByTypeAndDate(1, currentMonthStart,


                currentMonthNow);


        //  销售


        int currentSales = salesLedgerProductMapper.selectProductCountByTypeAndDate(1, currentMonthStart, now);


        int lastSales = salesLedgerProductMapper.selectProductCountByTypeAndDate(1, lastMonthStart, lastMonthEnd);




        // 采购


        int currentPurchase = salesLedgerProductMapper.selectProductCountByTypeAndDate(2, currentMonthStart,


                currentMonthNow);


        //  采购


        int currentPurchase = salesLedgerProductMapper.selectProductCountByTypeAndDate(2, currentMonthStart, now);


        int lastPurchase = salesLedgerProductMapper.selectProductCountByTypeAndDate(2, lastMonthStart, lastMonthEnd);




        // 储存


        int currentStorage = stockInventoryMapper.selectStorageProductCountByDate(currentMonthStart, currentMonthNow);


        //  储存


        int currentStorage = stockInventoryMapper.selectStorageProductCountByDate(currentMonthStart, now);


        int lastStorage = stockInventoryMapper.selectStorageProductCountByDate(lastMonthStart, lastMonthEnd);




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


@@ -1150,12 +1107,6 @@


    public List<MapDto> productTurnoverDays() {


        return homeMapper.productTurnoverDays();


    }




    @Autowired


    private AccountExpenseMapper accountExpenseMapper;




    @Autowired


    private AccountIncomeMapper accountIncomeMapper;




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




@@ -1280,36 +1231,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);


        }


@@ -1529,7 +1465,7 @@


        return dto;


    }




    @Autowired


    


    private ProductionProductInputMapper productionProductInputMapper;




    @Override


@@ -1628,12 +1564,7 @@


                break;


        }




        ProductWorkOrderDto queryDto = new ProductWorkOrderDto();


        queryDto.setPlanStartTime(startDate);


        queryDto.setPlanEndTime(endDate);




        List<ProductWorkOrderDto> list = productWorkOrderMapper.pageProductWorkOrder(new Page<>(1, -1), queryDto)


                .getRecords();


        List<ProductionTaskStatisticsDto> list = productionOperationTaskMapper.selectTaskStatisticsByDate(startDate, endDate);




        if (CollectionUtils.isEmpty(list)) {


            return new ArrayList<>();


@@ -1642,9 +1573,9 @@


        Map<String, BigDecimal> processOutputMap = list.stream()


                .filter(item -> item.getProcessName() != null && item.getCompleteQuantity() != null)


                .collect(Collectors.groupingBy(


                        ProductWorkOrderDto::getProcessName,


                        ProductionTaskStatisticsDto::getProcessName,


                        Collectors.reducing(BigDecimal.ZERO,


                                ProductWorkOrderDto::getCompleteQuantity,


                                ProductionTaskStatisticsDto::getCompleteQuantity,


                                BigDecimal::add)));




        BigDecimal total = processOutputMap.values().stream()


@@ -1698,17 +1629,17 @@


        String startStr = startDate.atStartOfDay().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));


        String endStr = endDate.atTime(LocalTime.MAX).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));




        List<ProductWorkOrderDto> startList = productWorkOrderMapper.selectWorkOrderStartStats(startStr, endStr);


        List<ProductionTaskStatisticsDto> startList = productionOperationTaskMapper.selectTaskStartStats(startStr, endStr);




        List<com.ruoyi.production.dto.ProductionProductOutputDto> outputList = productionProductOutputMapper


        List<ProductionProductOutputDto> outputList = productionProductOutputMapper


                .selectOutputStats(startStr, endStr);




        Map<String, WorkOrderEfficiencyDto> dateMap = new HashMap<>();




        if (!CollectionUtils.isEmpty(startList)) {


            for (ProductWorkOrderDto item : startList) {


                if (item.getPlanStartTime() != null) {


                    String date = item.getPlanStartTime().toString();


            for (ProductionTaskStatisticsDto item : startList) {


                if (item.getActualStartTime() != null) {


                    String date = item.getActualStartTime().toString();


                    WorkOrderEfficiencyDto dto = dateMap.getOrDefault(date, new WorkOrderEfficiencyDto());


                    dto.setDate(date);


                    BigDecimal qty = item.getPlanQuantity() != null ? item.getPlanQuantity() : BigDecimal.ZERO;


@@ -1720,7 +1651,7 @@




        // 完工数量和良品率


        if (!CollectionUtils.isEmpty(outputList)) {


            for (com.ruoyi.production.dto.ProductionProductOutputDto item : outputList) {


            for (ProductionProductOutputDto item : outputList) {


                if (item.getCreateTime() != null) {


                    String date = item.getCreateTime().toLocalDate().toString();


                    WorkOrderEfficiencyDto dto = dateMap.getOrDefault(date, new WorkOrderEfficiencyDto());


@@ -1729,7 +1660,8 @@


                    BigDecimal finishQty = item.getQuantity() != null ? item.getQuantity() : BigDecimal.ZERO;


                    BigDecimal scrapQty = item.getScrapQty() != null ? item.getScrapQty() : BigDecimal.ZERO;




                    dto.setFinishQuantity(dto.getFinishQuantity() != null ? dto.getFinishQuantity().add(finishQty) : finishQty);


                    dto.setFinishQuantity(


                            dto.getFinishQuantity() != null ? dto.getFinishQuantity().add(finishQty) : finishQty);


                }


            }




@@ -1792,8 +1724,8 @@


                .collect(Collectors.toList());


    }




    @Autowired


    private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;


    


    private ProductionAccountMapper salesLedgerProductionAccountingMapper;




    @Override


    public List<ProductionAccountingDto> productionAccountingAnalysis(Integer type) {


@@ -1858,16 +1790,16 @@


        String lastEnd = lastMonthDate.withDayOfMonth(lastMonthDate.lengthOfMonth()).atTime(LocalTime.MAX)


                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));




        int currentCreated = productOrderMapper.countCreated(currentStart, currentEnd);


        int lastCreated = productOrderMapper.countCreated(lastStart, lastEnd);


        int currentCreated = productionOrderMapper.countCreated(currentStart, currentEnd);


        int lastCreated = productionOrderMapper.countCreated(lastStart, lastEnd);


        MapDto createdDto = createOrderCountDto("生产订单数", currentCreated, lastCreated);




        int currentCompleted = productOrderMapper.countCompleted(currentStart, currentEnd);


        int lastCompleted = productOrderMapper.countCompleted(lastStart, lastEnd);


        int currentCompleted = productionOrderMapper.countCompleted(currentStart, currentEnd);


        int lastCompleted = productionOrderMapper.countCompleted(lastStart, lastEnd);


        MapDto completedDto = createOrderCountDto("已完成订单数", currentCompleted, lastCompleted);




        int currentPending = productOrderMapper.countPending(currentStart, currentEnd);


        int lastPending = productOrderMapper.countPending(lastStart, lastEnd);


        int currentPending = productionOrderMapper.countPending(currentStart, currentEnd);


        int lastPending = productionOrderMapper.countPending(lastStart, lastEnd);


        MapDto pendingDto = createOrderCountDto("待生产订单数", currentPending, lastPending);




        return Arrays.asList(createdDto, completedDto, pendingDto);


@@ -1893,7 +1825,6 @@


        return dto;


    }






    @Override


    public QualityQualifiedAnalysisDto rawMaterialDetection(Integer type) {


        return commonDetection(type, 0);


@@ -1915,10 +1846,8 @@


        LocalDate startDate = range[0];


        LocalDate endDate = range[1];




        String startStr = startDate.atStartOfDay()


                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));


        String endStr = endDate.atTime(LocalTime.MAX)


                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));


        String startStr = startDate.toString();


        String endStr = endDate.toString();




        List<QualityInspect> list = qualityInspectMapper.selectList(


                new LambdaQueryWrapper<QualityInspect>()


@@ -2008,20 +1937,14 @@




    @Override


    public QualityInspectionCountDto qualityInspectionCount() {


        // 获取今天的开始和结束日期,包含时分秒


        LocalDateTime todayStart = LocalDateTime.now().withHour(0).withMinute(0).withSecond(0).withNano(0);


        LocalDateTime todayEnd = LocalDateTime.now().withHour(23).withMinute(59).withSecond(59).withNano(0);


        // 获取前一天的开始和结束日期,包含时分秒


        LocalDateTime prevStart = todayStart.minusDays(1);


        LocalDateTime prevEnd = todayEnd.minusDays(1);


        String todayStr = LocalDate.now().toString();


        String prevDayStr = LocalDate.now().minusDays(1).toString();


        // 查询出截止今日的总检验数


        List<QualityInspect> todayList = qualityInspectMapper.selectList(new LambdaQueryWrapper<QualityInspect>()


                // .eq(QualityInspect::getInspectState, 1)


                .le(QualityInspect::getCheckTime, todayEnd));


                .le(QualityInspect::getCheckTime, todayStr));


        // 查询出截止前一天的总检验数


        List<QualityInspect> prevList = qualityInspectMapper.selectList(new LambdaQueryWrapper<QualityInspect>()


                // .eq(QualityInspect::getInspectState, 1)


                .le(QualityInspect::getCheckTime, prevEnd));


                .le(QualityInspect::getCheckTime, prevDayStr));


        // 计算今日的总检验数


        BigDecimal todayCount = todayList.stream()


                .map(QualityInspect::getQuantity)


@@ -2037,14 +1960,12 @@


        // 计算今天的待完成数量


        List<QualityInspect> todayPendingList = qualityInspectMapper.selectList(new LambdaQueryWrapper<QualityInspect>()


                .eq(QualityInspect::getInspectState, 0)


                .ge(QualityInspect::getCheckTime, todayStart)


                .le(QualityInspect::getCheckTime, todayEnd));


                .eq(QualityInspect::getCheckTime, todayStr));




        // 计算前一天的待完成数量


        List<QualityInspect> prevPendingList = qualityInspectMapper.selectList(new LambdaQueryWrapper<QualityInspect>()


                .eq(QualityInspect::getInspectState, 0)


                .ge(QualityInspect::getCheckTime, prevStart)


                .le(QualityInspect::getCheckTime, prevEnd));


                .eq(QualityInspect::getCheckTime, prevDayStr));


        // 计算今天的待完成数量


        BigDecimal todayPendingCount = todayPendingList.stream()


                .map(QualityInspect::getQuantity)


@@ -2060,14 +1981,12 @@


        List<QualityInspect> todayCompletedList = qualityInspectMapper


                .selectList(new LambdaQueryWrapper<QualityInspect>()


                        .eq(QualityInspect::getInspectState, 1)


                        .ge(QualityInspect::getCheckTime, todayStart)


                        .le(QualityInspect::getCheckTime, todayEnd));


                        .eq(QualityInspect::getCheckTime, todayStr));


        // 计算前一天的已完成数量


        List<QualityInspect> prevCompletedList = qualityInspectMapper


                .selectList(new LambdaQueryWrapper<QualityInspect>()


                        .eq(QualityInspect::getInspectState, 1)


                        .ge(QualityInspect::getCheckTime, prevStart)


                        .le(QualityInspect::getCheckTime, prevEnd));


                        .eq(QualityInspect::getCheckTime, prevDayStr));


        // 计算今天的已完成数量


        BigDecimal todayCompletedCount = todayCompletedList.stream()


                .map(QualityInspect::getQuantity)


@@ -2100,18 +2019,16 @@




    @Override


    public NonComplianceWarningDto nonComplianceWarning() {




        // 近七天时间区间


        LocalDateTime[] range = lastSevenDaysRange();


        LocalDateTime startTime = range[0];


        LocalDateTime endTime = range[1];


        String[] range = lastSevenDaysDateRange();


        String startStr = range[0];


        String endStr = range[1];




        // 查询近七天已处理不合格数据


        List<QualityUnqualified> list = qualityUnqualifiedMapper.selectList(


                new LambdaQueryWrapper<QualityUnqualified>()


                        .eq(QualityUnqualified::getInspectState, 1)


                        .ge(QualityUnqualified::getCheckTime, startTime)


                        .le(QualityUnqualified::getCheckTime, endTime));


                        .ge(QualityUnqualified::getCheckTime, startStr)


                        .le(QualityUnqualified::getCheckTime, endStr));




        NonComplianceWarningDto dto = new NonComplianceWarningDto();




@@ -2210,29 +2127,24 @@


    }




    /**


     * 获取近七天的时间区间（包含今天）


     * 获取近七天的日期区间（仅含年月日）


     */


    public static LocalDateTime[] lastSevenDaysRange() {


    public static String[] lastSevenDaysDateRange() {


        LocalDate today = LocalDate.now();




        LocalDateTime startTime = today.minusDays(6).atStartOfDay();


        LocalDateTime endTime = today.atTime(23, 59, 59);




        return new LocalDateTime[]{startTime, endTime};


        return new String[]{today.minusDays(6).toString(), today.toString()};


    }




    @Override


    public List<CompletedInspectionCountDto> completedInspectionCount() {


        // 近七天时间区间


        LocalDateTime[] range = lastSevenDaysRange();


        LocalDateTime startTime = range[0];


        LocalDateTime endTime = range[1];


        String[] range = lastSevenDaysDateRange();


        String startStr = range[0];


        String endStr = range[1];




        // 查询近七天已完成的检验数据


        List<QualityInspect> list = qualityInspectMapper.selectList(new LambdaQueryWrapper<QualityInspect>()


                .eq(QualityInspect::getInspectState, 1)


                .ge(QualityInspect::getCheckTime, startTime)


                .le(QualityInspect::getCheckTime, endTime));


                .ge(QualityInspect::getCheckTime, startStr)


                .le(QualityInspect::getCheckTime, endStr));




        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM-dd");




@@ -2353,7 +2265,7 @@


            return new ArrayList<>();


        }




        //  统计每种处理结果的数量


        // 统计每种处理结果的数量


        Map<String, BigDecimal> countMap = new HashMap<>();


        for (QualityUnqualified item : list) {


            if (StringUtils.isEmpty(item.getDealResult()) || item.getQuantity() == null) {


@@ -2366,7 +2278,7 @@


            return new ArrayList<>();


        }




        //  计算总数


        // 计算总数


        BigDecimal totalCount = countMap.values()


                .stream()


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


@@ -2375,7 +2287,7 @@


            return new ArrayList<>();


        }




        //  按数量倒序排序


        // 按数量倒序排序


        List<Map.Entry<String, BigDecimal>> sortedList = countMap.entrySet()


                .stream()


                .sorted((a, b) -> b.getValue().compareTo(a.getValue()))


@@ -2411,4 +2323,146 @@


        return result;


    }




}


    @Override


    public QualityStatisticsDto qualityInspectionStatistics(Integer type) {


        LocalDate today = LocalDate.now();


        LocalDate startDate;


        LocalDate endDate;




        switch (type) {


            case 1: // 本周


                startDate = today.with(DayOfWeek.MONDAY);


                endDate = today.with(DayOfWeek.SUNDAY);


                break;


            case 2: // 本月


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


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


                break;


            case 3: // 本季度


                int currentMonth = today.getMonthValue();


                int startMonth = ((currentMonth - 1) / 3) * 3 + 1;


                startDate = LocalDate.of(today.getYear(), startMonth, 1);


                endDate = startDate.plusMonths(2).with(TemporalAdjusters.lastDayOfMonth());


                break;


            default:


                startDate = today.with(DayOfWeek.MONDAY);


                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));




        QualityStatisticsDto dto = new QualityStatisticsDto();


        dto.setSupplierNum(sumQuantity(qualityInspectList, 0)); // 原材料


        dto.setProcessNum(sumQuantity(qualityInspectList, 1)); // 过程


        dto.setFactoryNum(sumQuantity(qualityInspectList, 2)); // 出厂




        // 假设 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;


        }


        // 4. 处理图表项 (Item)


        List<QualityStatisticsItem> 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"));


                    }));




            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<>())));


            }


        } else {


            // 周或月模式：按天分组


            Map<String, List<QualityInspect>> groupByDay = qualityInspects.stream()


                    .collect(Collectors.groupingBy(i -> {


                        LocalDate ld = dateMap.get(i);


                        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<>())));


            }


        }




        dto.setItem(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();


        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));




        return item;


    }




    @Override


    public List<processDataProductionStatisticsDto> processDataProductionStatistics(Integer type,


                                                                                    List<Long> processIds) {


        LoginUser loginUser = SecurityUtils.getLoginUser();


        Long userId = SecurityUtils.isAdmin(loginUser.getUserId()) ? null : loginUser.getUserId();




        LocalDate today = LocalDate.now();


        LocalDate startDate;


        LocalDate endDate;




        switch (type) {


            case 1:


                startDate = today;


                endDate = today;


                break;


            case 2:


                startDate = today.with(DayOfWeek.MONDAY);


                endDate = today.with(DayOfWeek.SUNDAY);


                break;


            case 3:


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


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


                break;


            default:


                startDate = today;


                endDate = today;


        }




        LocalDateTime startDateTime = startDate.atStartOfDay();


        LocalDateTime endDateTime = endDate.atTime(LocalTime.MAX);




        return productionOperationTaskMapper.calculateProductionStatistics(startDateTime, endDateTime, userId, processIds);


    }




    private BigDecimal defaultDecimal(BigDecimal value) {


        return value == null ? BigDecimal.ZERO : value;


    }


}