补充关联不到工艺路线的料号保存至气体异常料号报表

hongjli

2025-05-23 7c1e701b523bc54dc2decffac6e8f5a0e3987b98

 aps-modules/aps-core/src/main/java/com/aps/core/service/impl/ApsGasPipingRouteStatServiceImpl.java

@@ -6,10 +6,12 @@
import com.aps.common.core.utils.uuid.IdUtils;
import com.aps.common.security.utils.SecurityUtils;
import com.aps.core.domain.*;
import com.aps.core.domain.ApsPlate.ApsPlateStandardRequireError;
import com.aps.core.mapper.*;
import com.aps.core.service.IApsGasMaterialUsageService;
import com.aps.core.service.IApsGasPipingRouteStatService;
import com.aps.core.service.IApsStandardProcessService;
import com.aps.core.mapper.ApsPlateStandardRequireErrorMapper;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.*;
@@ -58,6 +60,9 @@

    @Autowired
    private IApsStandardProcessService apsStandardProcessService;

    @Autowired
    private ApsPlateStandardRequireErrorMapper apsPlateStandardRequireErrorMapper;

    /**
     * 查询气体管路产能负载统计
@@ -1117,6 +1122,12 @@
        // 处理手工气体工单数据 - 使用联合查询获取所有相关数据
        List<Map<String, Object>> moDataList = apsGasPipingRouteStatMapper.selectMoRouteData();
        
        // 获取所有的MO数据，用于检查哪些MO没有关联到工艺路线
        List<Map<String, Object>> allMoData = apsGasPipingRouteStatMapper.selectAllMoData();
        
        // 记录已关联工艺路线的MO编号
        Set<String> processedMoSet = new HashSet<>();
        
        // 按工单号分组，便于处理同一工单的不同工序
        Map<String, List<Map<String, Object>>> moGroups = moDataList.stream()
                .collect(Collectors.groupingBy(data -> data.get("work_order_no").toString()));
@@ -1124,6 +1135,9 @@
        // 处理每个工单的工艺路线
        for (String workOrderNo : moGroups.keySet()) {
            List<Map<String, Object>> workOrderData = moGroups.get(workOrderNo);
            
            // 标记该工单已处理
            processedMoSet.add(workOrderNo);
            
            // 按工序号排序
            workOrderData.sort((a, b) -> {
@@ -1202,6 +1216,36 @@
                
                statList.addAll(processList);
            }
        }
        
        // 处理没有关联到工艺路线的MO数据
        List<ApsPlateStandardRequireError> errorList = new ArrayList<>();
        for (Map<String, Object> moData : allMoData) {
            String workOrderNo = moData.get("mo").toString();
            // 如果该工单没有被处理过，说明没有关联到工艺路线
            if (!processedMoSet.contains(workOrderNo)) {
                ApsPlateStandardRequireError error = ApsPlateStandardRequireError.builder()
                        .id(Long.valueOf(IdUtils.fastSimpleUUID().hashCode()))
                        .batchNumber(batchNumber)
                        .requireId(IdUtil.getSnowflakeNextId())
                        .docNum(workOrderNo)
                        .itemNum(moData.get("material_code").toString())
                        .orgCode(moData.get("factory").toString())
                        .message("标准工艺路线不存在")
                        .delFlag("0")
                        .build();
                
                // 设置基类属性
                error.setCreateBy(SecurityUtils.getUsername());
                error.setCreateTime(truncateToSeconds(DateUtils.getNowDate()));
                
                errorList.add(error);
            }
        }
        
        // 批量插入异常数据
        if (!errorList.isEmpty()) {
            apsPlateStandardRequireErrorMapper.batchInsert(errorList);
        }
        
        // 批量插入数据
@@ -1316,10 +1360,18 @@
        String timeGranularity = params.containsKey("timeGranularity") ? 
                (String) params.get("timeGranularity") : "day"; // 默认为"日"粒度
        
        // 获取row维度的聚合字段 - 默认为工序名称(processName)
        String rowGroupBy = params.containsKey("rowGroupBy") ? 
                (String) params.get("rowGroupBy") : "processName";
        
        // 确定分组维度 - 工厂、专业、车间
        boolean groupByPlant = params.containsKey("groupByPlant") && Boolean.TRUE.equals(params.get("groupByPlant"));
        boolean groupByMajor = params.containsKey("groupByMajor") && Boolean.TRUE.equals(params.get("groupByMajor"));
        boolean groupByWorkshop = params.containsKey("groupByWorkshop") && Boolean.TRUE.equals(params.get("groupByWorkshop"));
        // 如果rowGroupBy已经是某个维度，则该维度不需要再次分组
        if ("plant".equals(rowGroupBy)) groupByPlant = false;
        if ("major".equals(rowGroupBy)) groupByMajor = false;
        if ("workshop".equals(rowGroupBy)) groupByWorkshop = false;
        
        // 构建查询条件
        Map<String, Object> queryParams = new HashMap<>();
@@ -1444,31 +1496,35 @@
        }
        
        // 在Service层完成聚合
        // 使用组合key来实现多维度分组（工序名 + 可选的工厂/专业/车间）
        // 使用组合key来实现多维度分组（动态rowGroupBy字段 + 可选的工厂/专业/车间）
        Map<String, Map<String, Object>> groupInfoMap = new HashMap<>();
        Map<String, Map<String, BigDecimal>> groupTimeDataMap = new HashMap<>();
        
        // 遍历原始数据，按多维度分组进行聚合
        for (Map<String, Object> data : rawData) {
            String processName = getStringValue(data, "processName");
            if (processName == null) {
                log.warn("跳过处理：工序名称为null");
            // 获取行分组字段值
            String rowGroupValue = getStringValue(data, rowGroupBy);
            if (rowGroupValue == null || rowGroupValue.trim().isEmpty()) {
                log.warn("跳过处理：{} 字段值为空", rowGroupBy);
                continue;
            }
            
            // 获取工序名称（用于日志和后续处理）
            String processName = getStringValue(data, "processName");
            
            // 处理开工日期
            Date processPlanStartDay = (Date) data.get("processPlanStartDay");
            if (processPlanStartDay == null) {
                log.warn("跳过处理：计划开工日为null, processName={}", processName);
                log.warn("跳过处理：计划开工日为null, {}={}", rowGroupBy, rowGroupValue);
                continue;
            }
            
            // 构建分组键 - 基于工序名和可选的其他维度
            // 构建分组键 - 基于row分组字段和可选的其他维度
            String plant = getStringValue(data, "plant");
            String major = getStringValue(data, "major");
            String workshop = getStringValue(data, "workshop");
            
            StringBuilder groupKeyBuilder = new StringBuilder(processName);
            StringBuilder groupKeyBuilder = new StringBuilder(rowGroupValue);
            
            // 根据用户选择的分组维度添加到分组键
            if (groupByPlant && plant != null) {
@@ -1486,10 +1542,11 @@
            // 记录分组的基本信息（只记录一次）
            if (!groupInfoMap.containsKey(groupKey)) {
                Map<String, Object> groupInfo = new HashMap<>();
                groupInfo.put("processName", processName);
                groupInfo.put(rowGroupBy, rowGroupValue);
                groupInfo.put("plant", plant);
                groupInfo.put("major", major);
                groupInfo.put("workshop", workshop);
                groupInfo.put("processName", processName);
                groupInfoMap.put(groupKey, groupInfo);
            }
            
@@ -1521,22 +1578,27 @@
        
        // 构建最终返回的数据结构
        for (String groupKey : groupInfoMap.keySet()) {
            Map<String, Object> processEntry = new HashMap<>();
            Map<String, Object> processDetail = new HashMap<>();
            Map<String, Object> rowEntry = new HashMap<>();
            Map<String, Object> rowDetail = new HashMap<>();
            
            // 获取该分组的基本信息
            Map<String, Object> groupInfo = groupInfoMap.get(groupKey);
            String processName = (String) groupInfo.get("processName");
            String rowGroupValue = (String) groupInfo.get(rowGroupBy);
            
            // 添加工序基本信息
            // 添加分组基本信息
            if (groupByPlant) {
                processDetail.put("plant", groupInfo.get("plant"));
                rowDetail.put("plant", groupInfo.get("plant"));
            }
            if (groupByMajor) {
                processDetail.put("major", groupInfo.get("major"));
                rowDetail.put("major", groupInfo.get("major"));
            }
            if (groupByWorkshop) {
                processDetail.put("workshop", groupInfo.get("workshop"));
                rowDetail.put("workshop", groupInfo.get("workshop"));
            }
            
            // 保留工序名称信息，以便前端展示
            if (!"processName".equals(rowGroupBy)) {
                rowDetail.put("processName", groupInfo.get("processName"));
            }
            
            // 添加时间数据
@@ -1558,13 +1620,14 @@
                timeDataList.add(pointData);
            }
            
            processDetail.put("timeData", timeDataList);
            processEntry.put(processName, processDetail);
            plantTable.add(processEntry);
            rowDetail.put("timeData", timeDataList);
            rowEntry.put(rowGroupValue, rowDetail);
            plantTable.add(rowEntry);
        }
        

        result.put("plantTable", plantTable);
        result.put("timePoints", timePoints);
        result.put("rowGroupBy", rowGroupBy);
        
        return result;
    }