Merge branch 'master' of http://bore.pub:10439/r/ERP_override

chenlu

2025-07-28 a99c1f36e52c75e0020127c62d39c1eddae4a036

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

@@ -1,27 +1,33 @@

package com.example.erp.service.pp;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.dynamic.datasource.annotation.DS;

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.sd.OrderProcessDetailMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import com.example.erp.mapper.pp.ReportingWorkMapper;
import com.example.erp.mapper.sd.*;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.sql.Date;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.function.Function;
import java.util.stream.Collectors;

import static cn.hutool.core.convert.Convert.toDouble;

@Service
@DS("pp")
@@ -31,13 +37,63 @@
    private final OrderProcessDetailMapper orderProcessDetailMapper;
    private final ProductionSchedulingMapper productionSchedulingMapper;

    private final OrderGlassDetailMapper orderGlassDetailMapper;
    private final BasicDataMapper basicDataMapper;
    private final ProductDetailMapper productDetailMapper;
    private final OrderDetailMapper orderDetailMapper;

    FlowCardMapper flowCardMapper;
    private ReportingWorkMapper reportingWorkMapper;


    private void mergeTeamsGroupsName(
            List<WorkInProgressDTO> dataList1,
            List<WorkInProgressDTO> dataList2
    ) {
    //上工序报工班组
    private void mergeTeamsGroupsName( List<WorkInProgressDTO> dataList1,List<WorkInProgressDTO> dataList2) {

        for (WorkInProgressDTO dto1 : dataList1) {
            //根据当前工序获取 是否为单片、夹胶、或者全部
          BasicData basicData =  basicDataMapper.
                  selectOne(new QueryWrapper<BasicData>()
                          .eq("basic_name", dto1.getThisProcess())
                          .last("limit 1")
                  );

          OrderDetail orderDetail = orderDetailMapper
                .selectOne(
                        new QueryWrapper<OrderDetail>()
                                .eq("order_id", dto1.getOrderId())
                                .eq("order_number", dto1.getOrderNumber())
                );

          //如果为单片，则根据产品名称和工艺编号获取玻璃名称
          if(basicData.getNickname()==null || basicData.getNickname().isEmpty()){
              ProductDetail productDetail = productDetailMapper.
                      selectOne(new QueryWrapper<ProductDetail>()
                              .eq("prod_id", orderDetail.getProductId())
                              .eq("glass_sort",dto1.getTechnologyNumber())
                      );
              dto1.setGlassName(productDetail.getDetail());

          }else if(basicData.getNickname().equals("stepC")){
              OrderGlassDetail orderGlassDetailGroup = orderGlassDetailMapper
                      .selectOne(new QueryWrapper<OrderGlassDetail>()
                              .eq("order_id", dto1.getOrderId())
                              .eq("order_number", dto1.getOrderNumber())
                              .eq("technology_number",dto1.getTechnologyNumber())
                      );

              String glassName = productDetailMapper.getGlassNameByGroup(
                      orderDetail.getProductId(),
                      orderGlassDetailMapper.getMinTechnologyNumberByGroup(dto1.getOrderId(),dto1.getOrderNumber(), String.valueOf(orderGlassDetailGroup.getGroup())),
                      orderGlassDetailMapper.getMaxTechnologyNumberByGroup(dto1.getOrderId(),dto1.getOrderNumber(), String.valueOf(orderGlassDetailGroup.getGroup()))
              );
              dto1.setGlassName(glassName);

          }else{
              dto1.setGlassName(dto1.getProductName());
          }

        }

        Function<WorkInProgressDTO, String> keyFn = dto ->
                dto.getProcessId() + "|" +
                        dto.getOrderNumber() + "|" +
@@ -62,18 +118,28 @@
    }


    public ReportService(ReportMapper reportMapper, OrderProcessDetailMapper orderProcessDetailMapper, ProductionSchedulingMapper productionSchedulingMapper,FlowCardMapper flowCardMapper) {
    public ReportService(ReportMapper reportMapper, OrderProcessDetailMapper orderProcessDetailMapper,
                         ProductionSchedulingMapper productionSchedulingMapper, FlowCardMapper flowCardMapper,
                         OrderGlassDetailMapper orderGlassDetailMapper, BasicDataMapper basicDataMapper,
                         ProductDetailMapper productDetailMapper, OrderDetailMapper orderDetailMapper,
                         ReportingWorkMapper reportingWorkMapper) {
        this.reportMapper = reportMapper;
        this.orderProcessDetailMapper = orderProcessDetailMapper;
        this.productionSchedulingMapper = productionSchedulingMapper;
        this.flowCardMapper = flowCardMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
        this.basicDataMapper = basicDataMapper;
        this.productDetailMapper = productDetailMapper;
        this.orderDetailMapper = orderDetailMapper;
        this.reportingWorkMapper = reportingWorkMapper;
    }

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


        //获取表头工序筛选数据
        List<Map<String, String>> processFilterList = orderProcessDetailMapper.filterOrderProcess(orderId);
@@ -117,6 +183,24 @@
            }
        }
        map.put("title", uniqueList);
        Map<String,Integer> 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")
            );
            //判断磨边和磨边后工序
            if(Objects.equals(basicData.getNickname(), "stepA") || Objects.equals(basicData.getNickname(), "stepC")){
                clos.put(uniqueList.get(i).get("process"), 15+i);
            }
            //判断中空和中空后工序
            if(Objects.equals(basicData.getNickname(), "stepB") || Objects.equals(basicData.getNickname(), "stepD")){
                columns.add(15+i);
            }
        }


        List<Map<String, Integer>> getRowCount = orderProcessDetailMapper.getGlassLRow(orderId);
@@ -125,20 +209,54 @@
            getRowCount.forEach(row -> {
                Map<String, Integer> getRow = new HashMap<>();
                // { row: 0, col: 1, rowspan: 3, colspan: 0},
                Object rowNumObj = row.get("RowNum");
                if (rowNumObj instanceof Double) {
                    getRow.put("row", ((Double) rowNumObj).intValue());
                } else if (rowNumObj instanceof Integer) {
                    getRow.put("row", (Integer) rowNumObj);
                }
                getRow.put("row",  row.get("RowNum"));
                getRow.put("col", col);
                getRow.put("rowspan", row.get("rowCount"));
                getRow.put("colspan", 0);
                rowCount.add(getRow);
            });
        });
        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 (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(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);
                        }else{
                           data.put(key,"0");
                       }

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

            }
        }



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

        return map;
@@ -230,7 +348,7 @@
        return map;
    }

    public Map<String, Object> selectDamageReportSv(Integer pageNum, Integer pageSize, Date selectTime1, Date selectTime2, DamageReportDTO damageReportDTO) {
    public Map<String, Object> selectDamageReportSv(Integer pageNum, Integer pageSize, String selectTime1, String selectTime2, DamageReportDTO damageReportDTO) {
        Integer offset = (pageNum - 1) * pageSize;
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportMapper.selectDamageReportMp(offset, pageSize, selectTime1, selectTime2, damageReportDTO));
@@ -328,13 +446,16 @@
        return map;
    }

    public Map<String, Object> taskCompletionStatusSv(Date selectTime1, Date selectTime2, List<Integer> columns) {
    public Map<String, Object> taskCompletionStatusSv(Date selectTime1, Date selectTime2, String orderId, List<Integer> columns) {
        if ("null".equals(orderId)) {
            orderId = "";
        }
        Map<String, Object> map = new HashMap<>();
        //获取表格内容数据
        map.put("data", reportMapper.taskCompletionStatusMp(selectTime1, selectTime2));
        map.put("data", reportMapper.taskCompletionStatusMp(selectTime1, selectTime2,orderId));

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

        List<String> filterList = new ArrayList<>();
@@ -376,22 +497,24 @@
        }
        map.put("title", uniqueList);


        List<Map<String, Integer>> getRowCount = orderProcessDetailMapper.getGlassLRowCollect(selectTime1, selectTime2);
        List<Map<String, Integer>> getRowCount = orderProcessDetailMapper.getGlassLRowCollect(selectTime1, selectTime2,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"));
                Object rowNumObj = row.get("RowNum");
                if (rowNumObj instanceof Double) {
                    getRow.put("row", ((Double) rowNumObj).intValue());
                } else if (rowNumObj instanceof Integer) {
                    getRow.put("row", (Integer) rowNumObj);
                }
                getRow.put("col", col);
                getRow.put("rowspan", row.get("rowCount"));
                getRow.put("colspan", 0);
                rowCount.add(getRow);
            });
        });


        map.put("mergeCells", rowCount);

        return map;
@@ -419,11 +542,18 @@
        return reportMapper.exportCrossProcessBreakingMp(dates);
    }

    public List exportDamageReportSv(List<LocalDate> dates) {
        if (dates != null && dates.size() > 1) {
            dates.set(1, dates.get(1).plusDays(1)); // 将第二个日期加一天
        }
        return reportMapper.exportDamageReportMp(dates);
    //    public List exportTeamOutputSv(Map<String, Object> dates) {
//        List<LocalDate> date= (List<LocalDate>) dates.get("date");
//        String process= (String) dates.get("processes");
//        if (process.equals("全部")){
//            process="";
//        }
//        String laminating = reportMapper.getLaminating(process);
//        return reportMapper.exportTeamOutputMp(date,process,laminating);
//    }
    public List exportDamageReportSv(Map<String, Object> dates) {
        List<LocalDate> date= (List<LocalDate>) dates.get("date");
        return reportMapper.exportDamageReportMp(date);
    }

    public List exportOrderPlanDecompositionSv(List<LocalDate> dates) {
@@ -482,7 +612,7 @@
        return reportMapper.exportYieldMp(date,process);
    }

    public Map<String, Object> teamOutputSv(Integer pageNum, Integer pageSize, Date selectTime1, Date selectTime2, String selectProcesses, TeamOutputDTO teamOutputDTO) {
    public Map<String, Object> teamOutputSv(Integer pageNum, Integer pageSize, String selectTime1, String selectTime2, String selectProcesses, TeamOutputDTO teamOutputDTO) {
        if (selectProcesses.equals("全部")){
            selectProcesses="";
        }
@@ -520,4 +650,143 @@
        String laminating = reportMapper.getLaminating(process);
        return reportMapper.exportTeamOutputMp(date,process,laminating);
    }

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

        Integer offset = (pageNum - 1) * pageSize;

        if ("null".equals(orderId)) {
            orderId = "";
        }
        if ("null".equals(inputProject)) {
            inputProject = "";
        }
        if ("null".equals(optionVal)) {
            optionVal = "";
        }
        if ("全部".equals(selectProcesses)) {
            selectProcesses = "";
        }

        String laminating = "";
        Map<String, Object> map = new HashMap<>();
        Map<String, Double> totalSumMap = new HashMap<>();

        double totalStockNum = 0;
        double totalStockArea = 0;

        // 获取所有工序
        List<String> processList = reportMapper.selectProcess();

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

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

            Map<String, Object> total =
                    reportMapper.getWorkInProgressCombinationFootSum(selectProcesses, laminating, optionVal);
            if (total != null) {
                BigDecimal stockNum = (BigDecimal) total.get("stockNum");
                BigDecimal stockArea = (BigDecimal) total.get("stockArea");

                if (stockNum != null) {
                    totalStockNum += stockNum.doubleValue();
                }
                if (stockArea != null) {
                    totalStockArea += stockArea.doubleValue();
                }
            }

        } else {
            for (String process : processList) {
                laminating = reportingWorkMapper.getProcessLaminating(process);

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

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

                Map<String, Object> total =
                        reportMapper.getWorkInProgressCombinationFootSum(process, laminating, optionVal);
                if (total != null) {
                    BigDecimal stockNum = (BigDecimal) total.get("stockNum");
                    BigDecimal stockArea = (BigDecimal) total.get("stockArea");

                    if (stockNum != null) {
                        totalStockNum += stockNum.doubleValue();
                    }
                    if (stockArea != null) {
                        totalStockArea += stockArea.doubleValue();
                    }
                }
            }
        }

        totalSumMap.put("stockNum", totalStockNum);
        totalSumMap.put("stockArea", totalStockArea);

        map.put("data", resultList);
        map.put("total", totalSumMap);
        map.put("process", productionSchedulingMapper.selectProcess());

        return map;
    }

    public List exportWorkInProgressCombinationSv(Map<String, Object> dates) {
        String process= (String) dates.get("processes");
        if (process.equals("全部")){
            process="";
        }
        String inputVal= (String) dates.get("inputVal");
        String project= (String) dates.get("project");
        if ("null".equals(inputVal)) {
            inputVal = "";
        }
        if ("null".equals(project)) {
            project = "";
        }

        String laminating = "";

        // 获取所有工序
        List<String> processList = reportMapper.selectProcess();

        // 最终数据集合
        List<WorkInProgressCombinationDTO> resultList = new ArrayList<>();

        if (!"".equals(process)) {
            laminating = reportingWorkMapper.getProcessLaminating(process);
            List<WorkInProgressCombinationDTO> singleResult =
                    reportMapper.exportWorkInProgressCombination(process, laminating, inputVal);
            if (singleResult != null && !singleResult.isEmpty()) {
                resultList.addAll((Collection<? extends WorkInProgressCombinationDTO>) singleResult);
            }


        } else {
            for (String processVal : processList) {
                laminating = reportingWorkMapper.getProcessLaminating(processVal);

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

                if (singleResult != null && !singleResult.isEmpty()) {
                    resultList.addAll((Collection<? extends WorkInProgressCombinationDTO>) singleResult);
                }
            }
        }

        return resultList;
    }
}