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

guoyujie

2025-10-14 81cad8df0f1b33700e7fc80f271eda7f1180efb0

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

@@ -5,24 +5,25 @@
import com.alibaba.fastjson.TypeReference;
import com.baomidou.dynamic.datasource.annotation.DS;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.FlowCardMapper;
import com.example.erp.mapper.pp.ProductionSchedulingMapper;
import com.example.erp.mapper.pp.ReportMapper;
import com.example.erp.mapper.pp.ReportingWorkMapper;
import com.example.erp.mapper.pp.*;
import com.example.erp.mapper.sd.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.sql.Date;
import java.sql.SQLOutput;
import java.time.LocalDate;
import java.util.*;
import java.util.function.Function;
@@ -42,6 +43,7 @@
    private final BasicDataMapper basicDataMapper;
    private final ProductDetailMapper productDetailMapper;
    private final OrderDetailMapper orderDetailMapper;
    private final DamageDetailsMapper damageDetailsMapper;

    FlowCardMapper flowCardMapper;
    private ReportingWorkMapper reportingWorkMapper;
@@ -72,7 +74,7 @@
                              .eq("glass_sort",dto1.getTechnologyNumber())
                      );
              dto1.setGlassName(productDetail.getDetail());

            //basicData.getNickname().equals("stepC")
          }else if(basicData.getNickname().equals("stepC")){
              OrderGlassDetail orderGlassDetailGroup = orderGlassDetailMapper
                      .selectOne(new QueryWrapper<OrderGlassDetail>()
@@ -122,7 +124,7 @@
                         ProductionSchedulingMapper productionSchedulingMapper, FlowCardMapper flowCardMapper,
                         OrderGlassDetailMapper orderGlassDetailMapper, BasicDataMapper basicDataMapper,
                         ProductDetailMapper productDetailMapper, OrderDetailMapper orderDetailMapper,
                         ReportingWorkMapper reportingWorkMapper) {
                         ReportingWorkMapper reportingWorkMapper, DamageDetailsMapper damageDetailsMapper) {
        this.reportMapper = reportMapper;
        this.orderProcessDetailMapper = orderProcessDetailMapper;
        this.productionSchedulingMapper = productionSchedulingMapper;
@@ -132,10 +134,11 @@
        this.productDetailMapper = productDetailMapper;
        this.orderDetailMapper = orderDetailMapper;
        this.reportingWorkMapper = reportingWorkMapper;
        this.damageDetailsMapper = damageDetailsMapper;
    }

    //流程卡进度方法
    public Map<String, Object> processCardProgressSv(String orderId, List<Integer> columns) {
    public Map<String, Object> processCardProgressSv(String orderId, List<String> columns) {
        Map<String, Object> map = new HashMap<>();
        //获取表格内容数据
        List<Map<String, String>> dataList = reportMapper.processCardProgressMp(orderId);
@@ -146,6 +149,7 @@

        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(
@@ -154,36 +158,102 @@
                            .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"), 15+i);
                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(15+i);
                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);
        });
        if(!clos.isEmpty()){
            //循环结果
            for (int i=0;i<dataList.size();i++ ) {
                Map<String, String> data = JSON.parseObject(dataList.get(i).get("reportWorkQuantity"),
                        new TypeReference<Map<String, String>>() {
                        });

        //循环结果
        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")),
@@ -194,27 +264,34 @@
                                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")))  ){
                            Map<String, Integer> getRow = new HashMap<>();
                            // { row: 0, col: 1, rowspan: 3, colspan: 0},
                            getRow.put("row", i );
                            getRow.put("col", clos.get(key));
                            getRow.put("rowspan", max-min+1);
                            getRow.put("colspan", 0);
                            rowCount.add(getRow);

                           // { 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("reportWorkQuantity",JSON.toJSONString(data));
            dataList.get(i).put("reportWorkQuantityShow",JSON.toJSONString(dataShow));

        }




@@ -333,7 +410,7 @@
        return map;
    }

    public Map<String, Object> yieldSv(Date selectTime1, Date selectTime2, String selectProcesses, Report report) {
    public Map<String, Object> yieldSv(String selectTime1, String selectTime2, String selectProcesses, Report report) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportMapper.yieldMp(selectTime1, selectTime2, selectProcesses, report));
        map.put("process", productionSchedulingMapper.selectProcess());
@@ -771,10 +848,352 @@
        return resultList;
    }

    public Object processCardProgressCollectSv(String orderId, List<Integer> columns) {
    public Object processCardProgressCollectSv(String orderId, List<String> columns) {
        Map<String, Object> map = new HashMap<>();
        //获取表格内容数据
        List<Map<String, String>> dataList = reportMapper.processCardProgressCollectMp(orderId);
        return  null;
        //获取表头工序筛选数据
        List<Map<String, String>> uniqueList = orderProcessDetailMapper.filterOrderProcess(orderId);
        map.put("title", uniqueList);
        Map<String,Map<String,Object>> clos = new HashMap<>();
        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")
            );
            Map<String,Object> getCol = new HashMap<>();
            //判断夹胶和夹胶后工序
            //Objects.equals(basicData.getNickname(), "stepA") || Objects.equals(basicData.getNickname(), "stepC")
            if(Objects.equals(basicData.getNickname(), "stepA") || Objects.equals(basicData.getNickname(), "stepC")){
                getCol.put("col", 11+i);
                getCol.put("step","stepA");
                clos.put(uniqueList.get(i).get("process"), getCol);
            }
            //判断中空和中空后工序
            //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"));
                getCol.put("col", 11+i);
                getCol.put("step","stepB");
                clos.put(uniqueList.get(i).get("process"), getCol);
            }
        }
        List<Map<String, Object>> getRowCount = orderProcessDetailMapper.getGlassLRow(orderId);
        HashMap<String,Map<String, Object>> getRowCountMap = new HashMap<>();
        getRowCount.forEach(col -> {
            String getRowCountProcessId = String.valueOf(col.get("process_id"));
            getRowCountMap.put(getRowCountProcessId, col);
        });
        HashMap<String,HashMap<String,Map<String, Integer>>> rowCount = new HashMap<String,HashMap<String,Map<String, Integer>>>();
        //循环结果
        for (int i=0;i<dataList.size();i++ ) {
            String processId = String.valueOf(dataList.get(i).get("process_id"));
            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(processId) != null){
                    Map<String,Object> row = getRowCountMap.get(processId);
                    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);
                }


            });


            dataList.get(i).put("reportWorkQuantityShow",dataList.get(i).get("reportWorkQuantity"));
            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("process_id"),
                            null,
                            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("process_id"),
                            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("process_id"),
                                String.valueOf(dataList.get(finalI).get("order_number")),
                                String.valueOf(dataList.get(finalI).get("technology_number")),
                                behindProcess,
                                null
                        );
                        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( clos.get(key).get("step")=="stepA"){
                            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")))  ){
                                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);
                        }else{//中空，中空后工序
                            //小片序号不是1 的时候赋值0
                            if(Integer.parseInt(String.valueOf(dataList.get(i).get("technology_number")))  !=1){
                                data.put(key,"0");
                            }
                        }

                    }

                }
            }
            dataList.get(i).put("reportWorkQuantity",JSON.toJSONString(data));
            dataList.get(i).put("reportWorkQuantityShow",JSON.toJSONString(dataShow));

        }

        map.put("mergeCells", rowCount);

        map.put("data",dataList);


        return  map;
    }

    public Map<String, Object> processCardProgressReportSv(String orderId, List<String> columns) {
        Map<String, Object> map = new HashMap<>();
        //获取表格内容数据
        List<Map<String, String>> dataList = reportMapper.processCardProgressReportMp(orderId);

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

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

    public Map<String, Object> yieldProcessSv(String selectTime1, String selectTime2, Report report) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportMapper.yieldProcessMp(selectTime1, selectTime2, report));
        map.put("process", productionSchedulingMapper.selectProcess());
        return map;
    }

    public Map<String, Object> selectProcessCompletedSv(Date selectTime1, Date selectTime2, String orderId, String inputProject, String selectProcesses, Report report) {
        if ("null".equals(orderId)) {
            orderId = "";
        }
        if ("null".equals(inputProject)) {
            inputProject = "";
        }
        Map<String, Object> map = new HashMap<>();
        String laminating = reportMapper.getLaminating(selectProcesses);
        map.put("data", reportMapper.selectProcessCompletedMp(selectTime1, selectTime2, orderId, inputProject, selectProcesses,laminating, report));
        map.put("process", productionSchedulingMapper.selectProcess());
        map.put("footSum" ,reportMapper.processToBeCompletedFootSum(selectTime1, selectTime2, orderId, inputProject, selectProcesses, report));

        return map;
    }
}