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

廖井涛

2025-12-01 21eed4f6a8065bb59d0aaf7481dfe145dba74f2a

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

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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -12,10 +13,6 @@
import com.example.erp.dto.pp.*;
import com.example.erp.entity.pp.DamageDetails;
import com.example.erp.entity.pp.Report;
import com.example.erp.entity.sd.BasicData;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.sd.OrderGlassDetail;
import com.example.erp.entity.sd.ProductDetail;
import com.example.erp.mapper.pp.*;
import com.example.erp.mapper.sd.*;
import org.springframework.beans.factory.annotation.Autowired;
@@ -29,6 +26,9 @@
import java.sql.Date;
import java.sql.SQLOutput;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Function;
@@ -53,6 +53,7 @@

    FlowCardMapper flowCardMapper;
    private ReportingWorkMapper reportingWorkMapper;
    private final OrderMapper orderMapper;

    @Resource
    private AsyncQueryExecutor asyncExecutor;
@@ -82,7 +83,10 @@
                              .eq("prod_id", orderDetail.getProductId())
                              .eq("glass_sort",dto1.getTechnologyNumber())
                      );
              dto1.setGlassName(productDetail.getDetail());
              if(productDetail!=null){
                  dto1.setGlassName(productDetail.getDetail());
              }

            //basicData.getNickname().equals("stepC")
          }else if(basicData.getNickname().equals("stepC")){
              OrderGlassDetail orderGlassDetailGroup = orderGlassDetailMapper
@@ -133,7 +137,7 @@
                         ProductionSchedulingMapper productionSchedulingMapper, FlowCardMapper flowCardMapper,
                         OrderGlassDetailMapper orderGlassDetailMapper, BasicDataMapper basicDataMapper,
                         ProductDetailMapper productDetailMapper, OrderDetailMapper orderDetailMapper,
                         ReportingWorkMapper reportingWorkMapper, DamageDetailsMapper damageDetailsMapper) {
                         ReportingWorkMapper reportingWorkMapper, DamageDetailsMapper damageDetailsMapper, OrderMapper orderMapper) {
        this.reportMapper = reportMapper;
        this.orderProcessDetailMapper = orderProcessDetailMapper;
        this.productionSchedulingMapper = productionSchedulingMapper;
@@ -144,6 +148,7 @@
        this.orderDetailMapper = orderDetailMapper;
        this.reportingWorkMapper = reportingWorkMapper;
        this.damageDetailsMapper = damageDetailsMapper;
        this.orderMapper = orderMapper;
    }

    //流程卡进度方法
@@ -302,8 +307,6 @@
        }




        map.put("data",dataList );
        map.put("mergeCells", rowCount);

@@ -332,22 +335,47 @@
//        return map;
//    }


    private static final DateTimeFormatter DATE_TIME_FMT =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private String toReportTime(String dateStr, String reportTime) {
        if (dateStr == null || dateStr.isEmpty()) {
            return null;
        }

        // 只保留 yyyy-MM-dd，防止前端传完整时间导致 parse 异常
        String onlyDate = dateStr.length() > 10 ? dateStr.substring(0, 10) : dateStr;


        String[] parts = reportTime.split(":");
        int hour   = Integer.parseInt(parts[0]);
        int minute = parts.length > 1 ? Integer.parseInt(parts[1]) : 0;
        int second = parts.length > 2 ? Integer.parseInt(parts[2]) : 0;

        LocalDate date = LocalDate.parse(onlyDate);
        LocalTime time = LocalTime.of(hour, minute, second);

        return LocalDateTime.of(date, time).format(DATE_TIME_FMT);
    }
    //跨工序次破
    public Map<String, Object> crossProcessBreakingSv(Integer pageNum, Integer pageSize,
                                                      List<String> selectDate,
                                                      String reportTime,
                                                      CrossProcessBreakingDTO crossProcessBreakingDTO) {
        Integer offset = (pageNum - 1) * pageSize;

        // 默认时间范围：过去 15 天
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        // 默认时间范围：过去 15 天（日期 + reportTime）
        String startDate = toReportTime(LocalDate.now().minusDays(15).toString(), reportTime);
        String endDate   = toReportTime(LocalDate.now().toString(), reportTime);

        // 如果前端传了时间，就用前端日期 + reportTime
        if (selectDate != null && selectDate.size() == 2) {
            if (!selectDate.get(0).isEmpty()) {
                startDate = selectDate.get(0);
            if (selectDate.get(0) != null && !selectDate.get(0).isEmpty()) {
                startDate = toReportTime(selectDate.get(0), reportTime);
            }
            if (!selectDate.get(1).isEmpty()) {
                endDate = selectDate.get(1);
            if (selectDate.get(1) != null && !selectDate.get(1).isEmpty()) {
                endDate = toReportTime(selectDate.get(1), reportTime);
            }
        }

@@ -384,19 +412,21 @@
    //非跨工序次破
    public Map<String, Object> notCrossProcessBreakingSv(Integer pageNum, Integer pageSize,
                                                      List<String> selectDate,
                                                      String reportTime,
                                                      CrossProcessBreakingDTO crossProcessBreakingDTO) {
        Integer offset = (pageNum - 1) * pageSize;

        // 默认时间范围：过去 15 天
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        // 默认时间范围：过去 15 天（日期 + reportTime）
        String startDate = toReportTime(LocalDate.now().minusDays(15).toString(), reportTime);
        String endDate   = toReportTime(LocalDate.now().toString(), reportTime);

        // 如果前端传了时间，就用前端日期 + reportTime
        if (selectDate != null && selectDate.size() == 2) {
            if (!selectDate.get(0).isEmpty()) {
                startDate = selectDate.get(0);
            if (selectDate.get(0) != null && !selectDate.get(0).isEmpty()) {
                startDate = toReportTime(selectDate.get(0), reportTime);
            }
            if (!selectDate.get(1).isEmpty()) {
                endDate = selectDate.get(1);
            if (selectDate.get(1) != null && !selectDate.get(1).isEmpty()) {
                endDate = toReportTime(selectDate.get(1), reportTime);
            }
        }

@@ -477,13 +507,14 @@
    public Map<String, Object> workInProgressSv(
            Integer pageNum, Integer pageSize,
            String orderId, String inputProject, String selectProcesses,
            String optionVal, WorkInProgressDTO workInProgressDTO) {
            String optionVal,String terminationVals, WorkInProgressDTO workInProgressDTO) {

        Integer offset = (pageNum - 1) * pageSize;

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

        String laminating = reportMapper.getLaminating(selectProcesses);
@@ -494,6 +525,7 @@
            String finalOrderId = orderId;
            String finalInputProject = inputProject;
            String finalSelectProcesses = selectProcesses;
            String finalTerminationVals = terminationVals;
            CompletableFuture<List<WorkInProgressDTO>> dataList2Future =
                    asyncExecutor.runAsync(() ->
                            reportMapper.workInProgressMpdataList2(
@@ -511,7 +543,7 @@

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

            } else if ("2".equals(optionVal)) {
                // 流程卡号汇总
@@ -521,25 +553,25 @@

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

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

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

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

            // 等待全部任务完成
@@ -590,23 +622,42 @@
//    }

    public Map<String, Object> selectDamageReportSv(Integer pageNum, Integer pageSize,
                                                    String selectTime1, String selectTime2,
                                                    List<String> selectDate,
                                                    String reportTime,
                                                    DamageReportDTO damageReportDTO) {

        Integer offset = (pageNum - 1) * pageSize;


        // 默认时间范围：过去 15 天（日期 + reportTime）
        String startDate = toReportTime(LocalDate.now().minusDays(15).toString(), reportTime);
        String endDate   = toReportTime(LocalDate.now().toString(), reportTime);

        // 如果前端传了时间，就用前端日期 + reportTime
        if (selectDate != null && selectDate.size() == 2) {
            if (selectDate.get(0) != null && !selectDate.get(0).isEmpty()) {
                startDate = toReportTime(selectDate.get(0), reportTime);
            }
            if (selectDate.get(1) != null && !selectDate.get(1).isEmpty()) {
                endDate = toReportTime(selectDate.get(1), reportTime);
            }
        }

        Map<String, Object> result = new HashMap<>();
        String finalStartDate = startDate;
        String finalEndDate = endDate;

        // 异步任务定义

        CompletableFuture<List<DamageReportDTO>> dataFuture = asyncExecutor.runAsync(() ->
                reportMapper.selectDamageReportMp(offset, pageSize, selectTime1, selectTime2, damageReportDTO));
                reportMapper.selectDamageReportMp(offset, pageSize, finalStartDate, finalEndDate, damageReportDTO));

        CompletableFuture<Map<String, Integer>> totalFuture = asyncExecutor.runAsync(() ->
                reportMapper.getDamageReportPageTotal(offset, pageSize, selectTime1, selectTime2, damageReportDTO));
                reportMapper.getDamageReportPageTotal(offset, pageSize, finalStartDate, finalEndDate, damageReportDTO));

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

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

        try {
@@ -615,11 +666,18 @@
            result.put("footSum", footSumFuture.get());
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("并行查询异常：" + e.getMessage(), e);
            throw new RuntimeException("次破总表并行查询异常：" + e.getMessage(), e);
        }

        // 回传前端的时间（现在是带时分秒的）
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        result.put("selectDate", list);

        return result;
    }


    public Map<String, Object> splittingDetailsOutsideSv(String orderId, Report report) {
        Map<String, Object> map = new HashMap<>();
@@ -641,70 +699,166 @@
        return map;
    }

    public Map<String, Object> productionScheduleSv(String orderId, List<Integer> columns) {
    public Map<String, Object> productionScheduleSv(String orderId, List<String> columns) {


        Map<String, Object> map = new HashMap<>();
        //获取表格内容数据
        map.put("data", reportMapper.productionScheduleMp(orderId));
        List<Map<String, String>> dataList = reportMapper.productionScheduleMp(orderId);


        //获取表头工序筛选数据
        List<Map<String, String>> processFilterList = orderProcessDetailMapper.filterOrderProcess(orderId);
        List<Map<String, String>> processList = processFilterList;
        List<Map<String, String>> uniqueList = orderProcessDetailMapper.filterOrderProcess(orderId);

        List<String> filterList = new ArrayList<>();
        //循环遍历数组，判断此序号当前的工序
        for (int i = 1; i < processFilterList.size(); i++) {
            filterList.add(processFilterList.get(i).get("process"));
            List<Map<String, String>> lastProcessList =
                    orderProcessDetailMapper.filterLastProcess(
                            orderId,
                            String.valueOf(processFilterList.get(i).get("order_number")),
                            String.valueOf(processFilterList.get(i).get("technology_number")),
                            String.valueOf(processFilterList.get(i).get("id"))
                    );
            if (!lastProcessList.isEmpty()) {
                int finalI = i;
                lastProcessList.forEach(lastProcess -> {
                    if (filterList.contains(lastProcess.get("process"))) {
                        processList.add(lastProcess);
                    }
                });
            }

        }
        // 使用HashSet来记录已经遇到的value值
        Set<String> seenValues = new HashSet<>();
        // 创建一个新的List来存储结果
        List<Map<String, String>> uniqueList = new ArrayList<>();

        // 反向遍历原始List
        for (int i = processList.size() - 1; i >= 0; i--) {
            Map<String, String> maps = processList.get(i);
            String value = maps.values().iterator().next(); // 假设每个Map只有一个value

            // 如果value还没有被看到过，就添加到结果List和HashSet中
            if (!seenValues.contains(value)) {
                uniqueList.add(0, maps); // 添加到结果List的开头，以保持原顺序
                seenValues.add(value);
            }
        }
        map.put("title", uniqueList);
        Map<String,Integer> clos = new HashMap<>();
        HashMap<String,HashMap<String,Map<String, Integer>>> rowCount = new HashMap<String,HashMap<String,Map<String, Integer>>>();
        for (int i=0;i<uniqueList.size();i++){
            //根据流程查询基础数据
            BasicData basicData =  basicDataMapper.selectOne(
                    new QueryWrapper<BasicData>()
                            .eq("basic_category","process")
                            .eq("basic_name",uniqueList.get(i).get("process"))
                            .last("limit 1")
            );

            //判断夹胶和夹胶后工序
            //Objects.equals(basicData.getNickname(), "stepA") || Objects.equals(basicData.getNickname(), "stepC")
            if(Objects.equals(basicData.getNickname(), "stepA") || Objects.equals(basicData.getNickname(), "stepC")){
                clos.put(uniqueList.get(i).get("process"), 14+i);
            }
            //判断中空和中空后工序
            //Objects.equals(basicData.getNickname(), "stepB") || Objects.equals(basicData.getNickname(), "stepD")
            if(Objects.equals(basicData.getNickname(), "stepB") || Objects.equals(basicData.getNickname(), "stepD")){
                columns.add("reportWorkQuantity."+uniqueList.get(i).get("process"));
            }
        }


        List<Map<String, Object>> getRowCount = orderProcessDetailMapper.getGlassLRow(orderId);
        List<Map<String, Integer>> rowCount = new ArrayList<>();
        columns.forEach(col -> {
            getRowCount.forEach(row -> {
                Map<String, Integer> getRow = new HashMap<>();
                // { row: 0, col: 1, rowspan: 3, colspan: 0},
                getRow.put("row", ((Number) row.get("RowNum")).intValue());
                getRow.put("col", col);
                getRow.put("rowspan", ((Number) row.get("rowCount")).intValue());
                getRow.put("colspan", 0);
                rowCount.add(getRow);
            });
        HashMap<Integer,Map<String, Object>> getRowCountMap = new HashMap<>();
        getRowCount.forEach(col -> {
            Integer getRowCountOrderNumber = ((Number) col.get("order_number")).intValue();
            getRowCountMap.put(getRowCountOrderNumber, col);
        });

        //循环结果
        for (int i=0;i<dataList.size();i++ ) {
            Integer orderNumber = Integer.parseInt(String.valueOf(dataList.get(i).get("order_number")));
            Integer technologyNumber = Integer.parseInt(String.valueOf(dataList.get(i).get("technology_number")));
            int finalI1 = i;
            columns.forEach(col -> {
                if(rowCount.get(col) == null){
                    rowCount.put(col, new HashMap<String,Map<String,Integer>>());
                }

                if(getRowCountMap.get(orderNumber) != null){
                    Map<String,Object> row = getRowCountMap.get(orderNumber);
                    Map<String, Integer> getRow = new HashMap<>();
                    //判断当前此次 是否为第一行 并且相同序号
                    if(technologyNumber==1){
                        getRow.put("rowspan", ((Number) row.get("rowCount")).intValue());
                        getRow.put("colspan", 1);
                    }else{
                        getRow.put("rowspan", 0);
                        getRow.put("colspan", 0);
                    }
                    rowCount.get(col).put(finalI1+"_"+col, getRow);
                }


            });


            Map<String, String> data = JSON.parseObject(dataList.get(i).get("reportWorkQuantity"),
                    new TypeReference<Map<String, String>>() {
                    });
            Map<String, String> dataShow = JSON.parseObject(dataList.get(i).get("reportWorkQuantityShow"),
                    new TypeReference<Map<String, String>>() {
                    });
            //判断后工序此流程卡号是否有次破
            List<DamageDetails> hasBreak = damageDetailsMapper
                    .getNotReview(dataList.get(i).get("processId"),
                            String.valueOf(dataList.get(i).get("order_number")),
                            String.valueOf(dataList.get(i).get("technology_number"))
                    );





            if(!hasBreak.isEmpty()){
                int finalI = i;
                data.forEach((thisProcess, index)->{
                    String behindProcess = orderProcessDetailMapper.getBehindProcess(
                            dataList.get(finalI).get("processId"),
                            String.valueOf(dataList.get(finalI).get("order_number")),
                            String.valueOf(dataList.get(finalI).get("technology_number")),
                            thisProcess,
                            orderId
                    );

                    if(behindProcess!=null &&!behindProcess.isEmpty()){
                        Integer behindDamageSum = damageDetailsMapper.getBehindDamageSum(
                                dataList.get(finalI).get("processId"),
                                String.valueOf(dataList.get(finalI).get("order_number")),
                                String.valueOf(dataList.get(finalI).get("technology_number")),
                                behindProcess,1
                        );
                        if(behindDamageSum>0){
                            data.put(thisProcess, String.valueOf(Integer.parseInt(data.get(thisProcess) )- behindDamageSum));
                            dataShow.put(thisProcess, String.valueOf(Integer.parseInt(dataShow.get(thisProcess) )- behindDamageSum));
                        }

                    }
                });

            }
            //夹胶工序判断合并行数
            if(!clos.isEmpty()){

                Integer max = orderGlassDetailMapper
                        .getMaxTechnologyNumberByGroup(dataList.get(i).get("order_id"),
                                String.valueOf(dataList.get(i).get("order_number")),
                                String.valueOf(dataList.get(i).get("group"))
                        );
                Integer min = orderGlassDetailMapper
                        .getMinTechnologyNumberByGroup(dataList.get(i).get("order_id"),
                                String.valueOf(dataList.get(i).get("order_number")),
                                String.valueOf(dataList.get(i).get("group"))
                        );

                for (String key : clos.keySet()) {
                    if(data.get(key) != null){
                        if (rowCount.get("reportWorkQuantity."+key)==null){
                            rowCount.put("reportWorkQuantity."+key, new HashMap<String,Map<String,Integer>>());
                        }
                        Map<String, Integer> getRow = new HashMap<>();
                        if(min == Integer.parseInt(String.valueOf(dataList.get(i).get("technology_number")))  ){

                            // { row: 0, col: 1, rowspan: 3, colspan: 0},
                            //getRow.put("row", i );
                            getRow.put("rowspan", max-min+1);
                            getRow.put("colspan", 1);

                        }else{
                            getRow.put("rowspan", 0);
                            getRow.put("colspan", 0);
                            data.put(key,"0");
                        }
                        rowCount.get("reportWorkQuantity."+key).put(i+"_reportWorkQuantity."+key, getRow);
                    }
                }
            }
            dataList.get(i).put("reportWorkQuantity",JSON.toJSONString(data));
            dataList.get(i).put("reportWorkQuantityShow",JSON.toJSONString(dataShow));

        }




        map.put("data",dataList );
        map.put("mergeCells", rowCount);

        return map;
@@ -849,13 +1003,17 @@
        }
        String inputVal= (String) dates.get("inputVal");
        String project= (String) dates.get("project");
        if ("null".equals(inputVal)) {
        String terminationVals= dates.get("terminationVals").toString();;
        if (inputVal==null) {
            inputVal = "";
        }
        if ("null".equals(project)) {
        if (project==null) {
            project = "";
        }
        List<WorkInProgressDTO> dataList1  =reportMapper.exportWorkInProgressMp(process,inputVal,project);
        if (terminationVals==null) {
            terminationVals = "";
        }
        List<WorkInProgressDTO> dataList1  =reportMapper.exportWorkInProgressMp(process,inputVal,project,terminationVals);
        List<WorkInProgressDTO> dataList2  =reportMapper.exportWorkInProgressMpdataList2(process);

        mergeTeamsGroupsName(dataList1, dataList2);
@@ -1018,7 +1176,7 @@
    public Map<String, Object> workInProgressCombinationSv(
            Integer pageNum, Integer pageSize,
            String orderId, String inputProject, String selectProcesses,
            String optionVal, WorkInProgressDTO workInProgressDTO) {
            String optionVal,String terminationVal, WorkInProgressDTO workInProgressDTO) {

        Integer offset = (pageNum - 1) * pageSize;

@@ -1030,6 +1188,9 @@
        }
        if ("null".equals(optionVal)) {
            optionVal = "";
        }
        if ("null".equals(terminationVal)) {
            terminationVal = "";
        }
        if ("all".equals(selectProcesses)) {
            selectProcesses = "";
@@ -1047,17 +1208,16 @@

        // 最终数据集合
        List<Map<String, Object>> resultList = new ArrayList<>();

        if (!"".equals(selectProcesses)) {
            laminating = reportingWorkMapper.getProcessLaminating(selectProcesses);
            List<Map<String, Object>> singleResult =
                    reportMapper.getWorkInProgressCombination(selectProcesses, laminating, optionVal);
                    reportMapper.getWorkInProgressCombination(selectProcesses, laminating, optionVal,terminationVal);
            if (singleResult != null && !singleResult.isEmpty()) {
                resultList.addAll(singleResult);
            }

            Map<String, Object> total =
                    reportMapper.getWorkInProgressCombinationFootSum(selectProcesses, laminating, optionVal);
                    reportMapper.getWorkInProgressCombinationFootSum(selectProcesses, laminating, optionVal,terminationVal);
            if (total != null) {
                BigDecimal stockNum = (BigDecimal) total.get("stockNum");
                BigDecimal stockArea = (BigDecimal) total.get("stockArea");
@@ -1075,14 +1235,14 @@
                laminating = reportingWorkMapper.getProcessLaminating(process);

                List<Map<String, Object>> singleResult =
                        reportMapper.getWorkInProgressCombination(process, laminating, optionVal);
                        reportMapper.getWorkInProgressCombination(process, laminating, optionVal,terminationVal);

                if (singleResult != null && !singleResult.isEmpty()) {
                    resultList.addAll(singleResult);
                }

                Map<String, Object> total =
                        reportMapper.getWorkInProgressCombinationFootSum(process, laminating, optionVal);
                        reportMapper.getWorkInProgressCombinationFootSum(process, laminating, optionVal,terminationVal);
                if (total != null) {
                    BigDecimal stockNum = (BigDecimal) total.get("stockNum");
                    BigDecimal stockArea = (BigDecimal) total.get("stockArea");
@@ -1114,11 +1274,15 @@
        }
        String inputVal= (String) dates.get("inputVal");
        String project= (String) dates.get("project");
        if ("null".equals(inputVal)) {
        String terminationVals= dates.get("terminationVals").toString();;
        if (inputVal==null) {
            inputVal = "";
        }
        if ("null".equals(project)) {
        if (project==null) {
            project = "";
        }
        if (terminationVals==null) {
            terminationVals = "";
        }

        String laminating = "";
@@ -1132,7 +1296,7 @@
        if (!"".equals(process)) {
            laminating = reportingWorkMapper.getProcessLaminating(process);
            List<WorkInProgressCombinationDTO> singleResult =
                    reportMapper.exportWorkInProgressCombination(process, laminating, inputVal);
                    reportMapper.exportWorkInProgressCombination(process, laminating, inputVal,terminationVals);
            if (singleResult != null && !singleResult.isEmpty()) {
                resultList.addAll((Collection<? extends WorkInProgressCombinationDTO>) singleResult);
            }
@@ -1143,7 +1307,7 @@
                laminating = reportingWorkMapper.getProcessLaminating(processVal);

                List<WorkInProgressCombinationDTO> singleResult =
                        reportMapper.exportWorkInProgressCombination(processVal, laminating, inputVal);
                        reportMapper.exportWorkInProgressCombination(processVal, laminating, inputVal,terminationVals);

                if (singleResult != null && !singleResult.isEmpty()) {
                    resultList.addAll((Collection<? extends WorkInProgressCombinationDTO>) singleResult);
@@ -1309,11 +1473,10 @@
            dataList.get(i).put("reportWorkQuantityShow",JSON.toJSONString(dataShow));

        }

        Order order = orderMapper.selectOrderId(orderId);
        map.put("mergeCells", rowCount);

        map.put("data",dataList);

        map.put("order",order);

        return  map;
    }