blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
guoyujie
2025-10-14 81cad8df0f1b33700e7fc80f271eda7f1180efb0 
 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportService.java


@@ -5,23 +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;


@@ -41,6 +43,7 @@


    private final BasicDataMapper basicDataMapper;


    private final ProductDetailMapper productDetailMapper;


    private final OrderDetailMapper orderDetailMapper;


    private final DamageDetailsMapper damageDetailsMapper;




    FlowCardMapper flowCardMapper;


    private ReportingWorkMapper reportingWorkMapper;


@@ -48,7 +51,6 @@




    //上工序报工班组


    private void mergeTeamsGroupsName( List<WorkInProgressDTO> dataList1,List<WorkInProgressDTO> dataList2) {




        for (WorkInProgressDTO dto1 : dataList1) {


            //根据当前工序获取 是否为单片、夹胶、或者全部


          BasicData basicData =  basicDataMapper.


@@ -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,58 +134,22 @@


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






        //获取表头工序筛选数据


        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(


@@ -192,67 +158,140 @@


                            .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, Integer>> 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",  row.get("RowNum"));


                getRow.put("col", col);


                getRow.put("rowspan", row.get("rowCount"));


                getRow.put("colspan", 0);


                rowCount.add(getRow);


            });


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


        });


        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")),


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


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


                       );


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




        }










@@ -298,6 +337,7 @@


        if (selectProcesses.equals("全部")){


            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")){


@@ -322,7 +362,7 @@


        } else {


            //没有选择分组


            //map.put("data", reportMapper.workInProgressMp(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));


            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressMpdataList1(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO);


            List<WorkInProgressDTO> dataList1  =reportMapper.workInProgressMpdataList1(offset, pageSize, orderId, inputProject, selectProcesses,laminating, workInProgressDTO);


            mergeTeamsGroupsName(dataList1, dataList2);


            map.put("data",dataList1);


            //map.put("total", reportMapper.workInProgressTotal(offset, pageSize, orderId, inputProject, selectProcesses, workInProgressDTO));


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


@@ -426,15 +466,15 @@


        map.put("title", uniqueList);






        List<Map<String, Integer>> getRowCount = orderProcessDetailMapper.getGlassLRow(orderId);


        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", row.get("RowNum"));


                getRow.put("row", ((Number) row.get("RowNum")).intValue());


                getRow.put("col", col);


                getRow.put("rowspan", row.get("rowCount"));


                getRow.put("rowspan", ((Number) row.get("rowCount")).intValue());


                getRow.put("colspan", 0);


                rowCount.add(getRow);


            });


@@ -648,7 +688,25 @@


            process="";


        }


        String laminating = reportMapper.getLaminating(process);


        return reportMapper.exportTeamOutputMp(date,process,laminating);


        List<TeamOutputDTO> list = reportMapper.exportTeamOutputMp(date, process, laminating);




        // 清洗每个 TeamOutputDTO 实例的 String 字段（去除前后空格）


        for (TeamOutputDTO dto : list) {


            for (Field field : dto.getClass().getDeclaredFields()) {


                field.setAccessible(true);


                try {


                    Object value = field.get(dto);


                    if (value instanceof String) {


                        String trimmed = ((String) value).trim();


                        field.set(dto, trimmed);


                    }


                } catch (IllegalAccessException e) {


                    e.printStackTrace();


                }


            }


        }




        return list;


    }




    public Map<String, Object> workInProgressCombinationSv(


@@ -789,4 +847,353 @@




        return resultList;


    }




    public Object processCardProgressCollectSv(String orderId, List<String> columns) {


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


        //获取表格内容数据


        List<Map<String, String>> dataList = reportMapper.processCardProgressCollectMp(orderId);


        //获取表头工序筛选数据


        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;


    }


}