Merge branch 'master' of http://10.153.19.25:10105/r/ERP_override

廖井涛

2025-10-27 a3ad909e75ddb7a6271d95704dc002cc70337fd5

 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportService.java

@@ -4,6 +4,7 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.example.erp.common.AsyncQueryExecutor;
import com.example.erp.tools.AreaComputed.*;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -21,6 +22,8 @@
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.sql.Date;
@@ -51,23 +54,9 @@
    FlowCardMapper flowCardMapper;
    private ReportingWorkMapper reportingWorkMapper;

    private static final ExecutorService EXECUTOR = new ThreadPoolExecutor(
            4, 8, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100),
            new ThreadFactory() {
                private final ThreadFactory defaultFactory = Executors.defaultThreadFactory();
                private int counter = 1;
    @Resource
    private AsyncQueryExecutor asyncExecutor;

                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = defaultFactory.newThread(r);
                    thread.setName("damage-report-query-" + counter++);
                    thread.setDaemon(true);
                    return thread;
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    //上工序报工班组
    private void mergeTeamsGroupsName( List<WorkInProgressDTO> dataList1,List<WorkInProgressDTO> dataList2) {
@@ -321,10 +310,37 @@
        return map;
    }

    public Map<String, Object> crossProcessBreakingSv(Integer pageNum, Integer pageSize, List<String> selectDate, CrossProcessBreakingDTO crossProcessBreakingDTO) {
//    public Map<String, Object> crossProcessBreakingSv(Integer pageNum, Integer pageSize, List<String> selectDate, CrossProcessBreakingDTO crossProcessBreakingDTO) {
//        Integer offset = (pageNum - 1) * pageSize;
//        String endDate = LocalDate.now().toString();
//        String startDate = LocalDate.now().minusDays(15).toString();
//        if (selectDate != null && selectDate.size() == 2) {
//            if (!selectDate.get(0).isEmpty()) {
//                startDate = selectDate.get(0);
//            }
//            if (!selectDate.get(1).isEmpty()) {
//                endDate = selectDate.get(1);
//            }
//        }
//        Map<String, Object> map = new HashMap<>();
//        map.put("data", reportMapper.getProcessBreaking(offset, pageSize, startDate, endDate, crossProcessBreakingDTO));
//        map.put("total", reportMapper.getProcessBreakingTotal(offset, pageSize, startDate, endDate, crossProcessBreakingDTO));
//        List<String> list = new ArrayList<>();
//        list.add(startDate);
//        list.add(endDate);
//        map.put("selectDate", list);
//        return map;
//    }

    public Map<String, Object> crossProcessBreakingSv(Integer pageNum, Integer pageSize,
                                                      List<String> selectDate,
                                                      CrossProcessBreakingDTO crossProcessBreakingDTO) {
        Integer offset = (pageNum - 1) * pageSize;

        // 默认时间范围：过去 15 天
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();

        if (selectDate != null && selectDate.size() == 2) {
            if (!selectDate.get(0).isEmpty()) {
                startDate = selectDate.get(0);
@@ -333,65 +349,171 @@
                endDate = selectDate.get(1);
            }
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportMapper.getProcessBreaking(offset, pageSize, startDate, endDate, crossProcessBreakingDTO));
        map.put("total", reportMapper.getProcessBreakingTotal(offset, pageSize, startDate, endDate, crossProcessBreakingDTO));

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

        // 使用异步线程池
        String finalEndDate = endDate;
        String finalStartDate = startDate;
        CompletableFuture<List<CrossProcessBreakingDTO>> dataFuture = asyncExecutor.runAsync(() ->
                reportMapper.getProcessBreaking(offset, pageSize, finalStartDate, finalEndDate, crossProcessBreakingDTO));

        CompletableFuture<Map<String, Integer>> totalFuture = asyncExecutor.runAsync(() ->
                reportMapper.getProcessBreakingTotal(offset, pageSize, finalStartDate, finalEndDate, crossProcessBreakingDTO));

        // 等待两个任务执行完毕
        CompletableFuture.allOf(dataFuture, totalFuture).join();

        try {
            result.put("data", dataFuture.get());
            result.put("total", totalFuture.get());
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("并行查询异常：" + e.getMessage(), e);
        }

        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate", list);
        return map;
        result.put("selectDate", list);

        return result;
    }

    public Map<String, Object> workInProgressSv(Integer pageNum, Integer pageSize, String orderId, String inputProject, String selectProcesses, String optionVal, WorkInProgressDTO workInProgressDTO) {
//    public Map<String, Object> workInProgressSv(Integer pageNum, Integer pageSize, String orderId, String inputProject, String selectProcesses, String optionVal, WorkInProgressDTO workInProgressDTO) {
//        Integer offset = (pageNum - 1) * pageSize;
//        if ("null".equals(orderId)) {
//            orderId = "";
//        }
//        if ("null".equals(inputProject)) {
//            inputProject = "";
//        }
//        if ("null".equals(optionVal)) {
//            optionVal = ("");
//        }
//        if (selectProcesses.equals("all")){
//            selectProcesses="";
//        }
//        String laminating = reportMapper.getLaminating(selectProcesses);
//        Map<String, Object> map = new HashMap<>();
//        List<WorkInProgressDTO> dataList2  =reportMapper.workInProgressMpdataList2(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);
//        if (optionVal.equals("1")){
//            /* 根据销售单号汇总*/
//            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressOrderMpList1(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);
//            mergeTeamsGroupsName(dataList1, dataList2);
//            map.put("data",dataList1);
//            map.put("total" ,reportMapper.workInProgressOrderFootSum(offset, pageSize,orderId, inputProject, selectProcesses, workInProgressDTO));
//        }else if(optionVal.equals("2")){
//            /* 根据流程卡号汇总*/
//            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressProcessMpList1(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);
//            mergeTeamsGroupsName(dataList1, dataList2);
//            map.put("data",dataList1);
//            map.put("total" ,reportMapper.workInProgressOrderFootSum(offset, pageSize,orderId, inputProject, selectProcesses, workInProgressDTO));
//
//        } else if (optionVal.equals("3")) {
//
//        } else {
//            //没有选择分组
//            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressMpdataList1(offset, pageSize, orderId, inputProject, selectProcesses,laminating, workInProgressDTO);
//            mergeTeamsGroupsName(dataList1, dataList2);
//            map.put("data",dataList1);
//            map.put("total" ,reportMapper.workInProgressOrderFootSum(offset, pageSize,orderId, inputProject, selectProcesses, workInProgressDTO));
//
//        }
//        map.put("process", productionSchedulingMapper.selectProcess());
//        return map;
//    }

    public Map<String, Object> workInProgressSv(
            Integer pageNum, Integer pageSize,
            String orderId, String inputProject, String selectProcesses,
            String optionVal, WorkInProgressDTO workInProgressDTO) {

        Integer offset = (pageNum - 1) * pageSize;
        if ("null".equals(orderId)) {
            orderId = "";
        }
        if ("null".equals(inputProject)) {
            inputProject = "";
        }
        if ("null".equals(optionVal)) {
            optionVal = ("");
        }
        if (selectProcesses.equals("all")){
            selectProcesses="";
        }

        if ("null".equals(orderId)) orderId = "";
        if ("null".equals(inputProject)) inputProject = "";
        if ("null".equals(optionVal)) optionVal = "";
        if ("all".equals(selectProcesses)) selectProcesses = "";

        String laminating = reportMapper.getLaminating(selectProcesses);
        Map<String, Object> map = new HashMap<>();
        List<WorkInProgressDTO> dataList2  =reportMapper.workInProgressMpdataList2(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);
        if (optionVal.equals("1")){
            /* 根据销售单号汇总*/
            //map.put("data", reportMapper.workInProgressOrderMp(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));
            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressOrderMpList1(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);
            mergeTeamsGroupsName(dataList1, dataList2);
            map.put("data",dataList1);
            // map.put("total", reportMapper.workInProgressOrderTotal(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));
            map.put("total" ,reportMapper.workInProgressOrderFootSum(offset, pageSize,orderId, inputProject, selectProcesses, workInProgressDTO));
        }else if(optionVal.equals("2")){
            /* 根据流程卡号汇总*/
            //map.put("data", reportMapper.workInProgressProcessMp(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));
            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressProcessMpList1(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);
            mergeTeamsGroupsName(dataList1, dataList2);
            map.put("data",dataList1);
            // map.put("total", reportMapper.workInProgressProcessTotal(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));
            map.put("total" ,reportMapper.workInProgressOrderFootSum(offset, pageSize,orderId, inputProject, selectProcesses, workInProgressDTO));
        Map<String, Object> result = new HashMap<>();

        } else if (optionVal.equals("3")) {
        try {
            // dataList2 是所有分组下的基础数据，独立执行
            String finalOrderId = orderId;
            String finalInputProject = inputProject;
            String finalSelectProcesses = selectProcesses;
            CompletableFuture<List<WorkInProgressDTO>> dataList2Future =
                    asyncExecutor.runAsync(() ->
                            reportMapper.workInProgressMpdataList2(
                                    offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));

        } else {
            //没有选择分组
            //map.put("data", reportMapper.workInProgressMp(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));
            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressMpdataList1(offset, pageSize, orderId, inputProject, selectProcesses,laminating, workInProgressDTO);
            CompletableFuture<List<WorkInProgressDTO>> dataList1Future;
            CompletableFuture<Map<String, Float>> totalFuture;

            // 根据 optionVal 决定查询类型
            if ("1".equals(optionVal)) {
                // 销售单号汇总
                dataList1Future = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressOrderMpList1(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));

                totalFuture = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressOrderFootSum(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));

            } else if ("2".equals(optionVal)) {
                // 流程卡号汇总
                dataList1Future = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressProcessMpList1(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));

                totalFuture = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressOrderFootSum(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));

            } else if ("3".equals(optionVal)) {
                dataList1Future = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressMpdataList1(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, laminating, workInProgressDTO));
                totalFuture = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressOrderFootSum(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));

            } else {
                // 不分组
                dataList1Future = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressMpdataList1(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, laminating, workInProgressDTO));

                totalFuture = asyncExecutor.runAsync(() ->
                        reportMapper.workInProgressOrderFootSum(
                                offset, pageSize, finalOrderId, finalInputProject, finalSelectProcesses, workInProgressDTO));
            }

            // 等待全部任务完成
            CompletableFuture.allOf(dataList1Future, dataList2Future, totalFuture).join();

            List<WorkInProgressDTO> dataList1 = dataList1Future.get();
            List<WorkInProgressDTO> dataList2 = dataList2Future.get();
            mergeTeamsGroupsName(dataList1, dataList2);
            map.put("data",dataList1);
            //map.put("total", reportMapper.workInProgressTotal(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));
            map.put("total" ,reportMapper.workInProgressOrderFootSum(offset, pageSize,orderId, inputProject, selectProcesses, workInProgressDTO));

            result.put("data", dataList1);
            result.put("total", totalFuture.get());

            // 并行查询工序信息
            List<Map<String, String>> process = productionSchedulingMapper.selectProcess();
            result.put("process", process);

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("并行查询在制品信息异常：" + e.getMessage(), e);
        }
        map.put("process", productionSchedulingMapper.selectProcess());
        return map;

        return result;
    }


    public Map<String, Object> selectProcessToBeCompletedSv(Date selectTime1, Date selectTime2, String orderId, String inputProject, String selectProcesses, Report report) {
        if ("null".equals(orderId)) {
@@ -424,19 +546,20 @@
        Map<String, Object> result = new HashMap<>();

        // 异步任务定义
        CompletableFuture<List<DamageReportDTO>> dataFuture = CompletableFuture.supplyAsync(() ->
                reportMapper.selectDamageReportMp(offset, pageSize, selectTime1, selectTime2, damageReportDTO), EXECUTOR);

        CompletableFuture<Map<String, Integer>> totalFuture = CompletableFuture.supplyAsync(() ->
                reportMapper.getDamageReportPageTotal(offset, pageSize, selectTime1, selectTime2, damageReportDTO), EXECUTOR);
        CompletableFuture<List<DamageReportDTO>> dataFuture = asyncExecutor.runAsync(() ->
                reportMapper.selectDamageReportMp(offset, pageSize, selectTime1, selectTime2, damageReportDTO));

        CompletableFuture<Map<String, Float>> footSumFuture = CompletableFuture.supplyAsync(() ->
                reportMapper.damageReportFootSum(selectTime1, selectTime2, damageReportDTO), EXECUTOR);
        CompletableFuture<Map<String, Integer>> totalFuture = asyncExecutor.runAsync(() ->
                reportMapper.getDamageReportPageTotal(offset, pageSize, selectTime1, selectTime2, damageReportDTO));

        CompletableFuture<Map<String, Float>> footSumFuture = asyncExecutor.runAsync(() ->
                reportMapper.damageReportFootSum(selectTime1, selectTime2, damageReportDTO));

        //等待全部任务完成
        CompletableFuture.allOf(dataFuture, totalFuture, footSumFuture).join();

        try {
            //等待全部任务完成
            CompletableFuture.allOf(dataFuture, totalFuture, footSumFuture).join();

            result.put("data", dataFuture.get());
            result.put("total", totalFuture.get());
            result.put("footSum", footSumFuture.get());
@@ -730,29 +853,28 @@

        String laminating = reportMapper.getLaminating(selectProcesses);

        // 并行执行四个查询任务
        String finalSelectProcesses = selectProcesses;
        CompletableFuture<List<TeamOutputDTO>> dataFuture = CompletableFuture.supplyAsync(() ->
                reportMapper.teamOutputMp(offset, pageSize, selectTime1, selectTime2, finalSelectProcesses, laminating, teamOutputDTO), EXECUTOR);
        CompletableFuture<List<TeamOutputDTO>> dataFuture = asyncExecutor.runAsync(() ->
                reportMapper.teamOutputMp(offset, pageSize, selectTime1, selectTime2, finalSelectProcesses, laminating, teamOutputDTO));

        CompletableFuture<List<Map<String, String>>> processFuture = CompletableFuture.supplyAsync(() ->
                productionSchedulingMapper.selectProcess(), EXECUTOR);
        CompletableFuture<List<Map<String, String>>> processFuture = asyncExecutor.runAsync(() ->
                productionSchedulingMapper.selectProcess());

        CompletableFuture<Map<String, Integer>> totalFuture = CompletableFuture.supplyAsync(() ->
                reportMapper.teamOutputPageTotal(offset, pageSize, selectTime1, selectTime2, finalSelectProcesses, laminating, teamOutputDTO), EXECUTOR);
        CompletableFuture<Map<String, Integer>> totalFuture = asyncExecutor.runAsync(() ->
                reportMapper.teamOutputPageTotal(offset, pageSize, selectTime1, selectTime2, finalSelectProcesses, laminating, teamOutputDTO));

        CompletableFuture<Map<String, Float>> footSumFuture = CompletableFuture.supplyAsync(() ->
                reportMapper.teamOutputFootSum(selectTime1, selectTime2, finalSelectProcesses, laminating, teamOutputDTO), EXECUTOR);

        CompletableFuture<Map<String, Float>> footSumFuture = asyncExecutor.runAsync(() ->
                reportMapper.teamOutputFootSum(selectTime1, selectTime2, finalSelectProcesses, laminating, teamOutputDTO));

        // 等待所有任务完成
        CompletableFuture.allOf(dataFuture, processFuture, totalFuture, footSumFuture).join();

        try {
            // 等待全部任务执行完毕
            CompletableFuture.allOf(dataFuture, processFuture, totalFuture, footSumFuture).join();

            result.put("data", dataFuture.get());
            result.put("process", processFuture.get());
            result.put("total", totalFuture.get());
            result.put("footSum", footSumFuture.get());

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("并行查询异常：" + e.getMessage(), e);