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


@@ -3,16 +3,13 @@


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;


@@ -27,20 +24,10 @@


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.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.mapper.SysDeptMapper;


import com.ruoyi.purchase.mapper.PaymentRegistrationMapper;


@@ -60,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;




@@ -81,70 +68,56 @@


 */


@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 final SysDeptMapper sysDeptMapper;




    @Autowired


    private NoticeMapper noticeMapper;


    private final NoticeMapper noticeMapper;




    @Autowired


    private ProductOrderMapper productOrderMapper;


    private final ProductionOrderMapper productionOrderMapper;




    @Autowired


    private ProductWorkOrderMapper productWorkOrderMapper;


    private final ProductMapper productMapper;




    @Autowired


    private ProductMapper productMapper;


    private final StaffOnJobMapper staffOnJobMapper;




    @Autowired


    private StaffOnJobMapper staffOnJobMapper;


    private final CustomerMapper customerMapper;




    @Autowired


    private CustomerMapper customerMapper;


    private final SupplierManageMapper supplierManageMapper;




    @Autowired


    private SupplierManageMapper supplierManageMapper;


    private final HomeMapper homeMapper;




    @Autowired


    private HomeMapper homeMapper;


    private final ProductionProductOutputMapper productionProductOutputMapper;




    @Autowired


    private ProductionProductOutputMapper productionProductOutputMapper;


    private final QualityInspectMapper qualityInspectMapper;




    @Autowired


    private QualityInspectMapper qualityInspectMapper;


    private final QualityUnqualifiedMapper qualityUnqualifiedMapper;




    @Autowired


    private QualityUnqualifiedMapper qualityUnqualifiedMapper;


    private final ProductionOperationTaskMapper productionOperationTaskMapper;




    @Autowired


    private ProductProcessMapper productProcessMapper;


    private final AccountExpenseMapper accountExpenseMapper;




    private final AccountIncomeMapper accountIncomeMapper;




    private final ProductionAccountMapper productionAccountMapper;




    private final ProductionProductInputMapper productionProductInputMapper;




    @Override


    public HomeBusinessDto business() {


@@ -179,28 +152,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();


@@ -465,8 +441,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 +451,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 +460,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 +470,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,


@@ -518,7 +494,7 @@


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


    }




    @Autowired




    private DeviceRepairMapper deviceRepairMapper;




    @Override


@@ -551,18 +527,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);


@@ -574,15 +547,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)


@@ -591,23 +560,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);


@@ -1032,28 +999,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<>();


@@ -1152,12 +1111,6 @@


    public List<MapDto> productTurnoverDays() {


        return homeMapper.productTurnoverDays();


    }




    @Autowired


    private AccountExpenseMapper accountExpenseMapper;




    @Autowired


    private AccountIncomeMapper accountIncomeMapper;




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




@@ -1282,36 +1235,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);


        }


@@ -1531,9 +1469,6 @@


        return dto;


    }




    @Autowired


    private ProductionProductInputMapper productionProductInputMapper;




    @Override


    public List<InputOutputAnalysisDto> inputOutputAnalysis(Integer type) {


        LocalDate today = LocalDate.now();


@@ -1564,7 +1499,8 @@


        String endStr = endDate.atStartOfDay()


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




        List<Map<String, Object>> inputList = productionProductInputMapper.selectInputStats(startStr, endStr);


//        List<Map<String, Object>> inputList = productionProductInputMapper.selectInputStats(startStr, endStr);


        List<Map<String, Object>> inputList = null;


        List<Map<String, Object>> outputList = productionProductOutputMapper.selectDailyOutputStats(startStr, endStr);




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


@@ -1630,12 +1566,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<>();


@@ -1644,9 +1575,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()


@@ -1700,17 +1631,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;


@@ -1722,7 +1653,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());


@@ -1795,8 +1726,6 @@


                .collect(Collectors.toList());


    }




    @Autowired


    private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;




    @Override


    public List<ProductionAccountingDto> productionAccountingAnalysis(Integer type) {


@@ -1825,7 +1754,7 @@




        String endStr = endDate.plusDays(1).atStartOfDay().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));




        List<Map<String, Object>> wagesList = salesLedgerProductionAccountingMapper.selectDailyWagesStats(startStr,


        List<Map<String, Object>> wagesList = productionAccountMapper.selectDailyWagesStats(startStr,


                endStr);




        if (CollectionUtils.isEmpty(wagesList)) {


@@ -1861,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);


@@ -1956,7 +1885,7 @@


                endDate = today.with(DayOfWeek.SUNDAY);


        }




        return new LocalDate[] { startDate, endDate };


        return new LocalDate[]{startDate, endDate};


    }




    private QualityQualifiedAnalysisDto buildQualifiedAnalysis(List<QualityInspect> list) {


@@ -2202,7 +2131,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


@@ -2435,7 +2364,7 @@


        Map<String, List<QualityInspect>> groupedByCheckResult = qualityInspectList.stream()


                .collect(Collectors.groupingBy(QualityInspect::getCheckResult));


        List<QualityInspect> qualityInspects = groupedByCheckResult.get("不合格");


        if(ObjectUtils.isNull(qualityInspects) || qualityInspects.size()==0){


        if (ObjectUtils.isNull(qualityInspects) || qualityInspects.size() == 0) {


            return null;


        }


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


@@ -2501,7 +2430,7 @@




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




@@ -2530,6 +2459,10 @@


        LocalDateTime startDateTime = startDate.atStartOfDay();


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




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


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


    }




    private BigDecimal defaultDecimal(BigDecimal value) {


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


    }


}