Merge remote-tracking branch 'origin/dev' into dev

zhanghl

2025-05-23 0de06ac0a530227080e9b9b4c7560d4e809fed1e

Merge remote-tracking branch 'origin/dev' into dev

 aps-modules/aps-core/src/main/java/com/aps/core/mapper/ApsGasPipelineCapacityPlanMapper.java

@@ -3,6 +3,7 @@
import com.aps.core.domain.ApsGasPipelineCapacityPlan;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

@@ -32,6 +33,23 @@
    public List<ApsGasPipelineCapacityPlan> selectApsGasPipelineCapacityPlanList(ApsGasPipelineCapacityPlan apsGasPipelineCapacityPlan);

    /**
     * 查询设计产能数据 - 专用于接口二功能
     * 
     * @param processName 工序名称
     * @param year 年份
     * @param month 月份
     * @param major 专业
     * @param orgCode 工厂代码
     * @return 气体管路产能规划集合
     */
    public List<ApsGasPipelineCapacityPlan> selectDesignCapacityForInterface2(
            @Param("processName") String processName,
            @Param("year") String year,
            @Param("month") String month,
            @Param("major") String major,
            @Param("orgCode") String orgCode);

    /**
     * 新增气体管路产能规划
     * 
     * @param apsGasPipelineCapacityPlan 气体管路产能规划

 aps-modules/aps-core/src/main/java/com/aps/core/mapper/ApsGasPipingRouteStatMapper.java

@@ -122,4 +122,12 @@
     * @return 所有手工气体工单数据
     */
    public List<Map<String, Object>> selectAllMoData();

    /**
     * 查询基础统计数据（不包含时间限制）
     * 
     * @param params 查询参数（不包含时间范围参数）
     * @return 基础统计数据列表
     */
    public List<Map<String, Object>> selectBaseStatData(Map<String, Object> params);
}

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

@@ -1489,9 +1489,61 @@
        // 查询原始数据（不依赖数据库聚合）
        List<Map<String, Object>> rawData = apsGasPipingRouteStatMapper.selectRawStatData(queryParams);
        
        // 如果没有查询到原始数据，但需要返回所有工序/车间的数据
        if (rawData.isEmpty()) {
            // 创建没有时间限制的基础查询参数
            Map<String, Object> baseParams = new HashMap<>(queryParams);
            baseParams.remove("yearStart");
            baseParams.remove("monthStart");
            baseParams.remove("yearEnd");
            baseParams.remove("monthEnd");
            
            // 直接从aps_gas_piping_route_stat表查询所有可能的工序和车间
            List<Map<String, Object>> baseData = apsGasPipingRouteStatMapper.selectBaseStatData(baseParams);
            
            // 为每个工序/车间创建基于时间的空数据
            for (Map<String, Object> data : baseData) {
                String rowGroupValue = getStringValue(data, rowGroupBy);
                if (rowGroupValue == null || rowGroupValue.trim().isEmpty()) continue;
                
                Map<String, Object> rowEntry = new HashMap<>();
                Map<String, Object> rowDetail = new HashMap<>();
                
                // 添加基本信息
                String plant = getStringValue(data, "plant");
                String major = getStringValue(data, "major");
                String workshop = getStringValue(data, "workshop");
                
                if (groupByPlant) rowDetail.put("plant", plant);
                if (groupByMajor) rowDetail.put("major", major);
                if (groupByWorkshop) rowDetail.put("workshop", workshop);
                
                // 处理工序名称 - 如果rowGroupBy为workshop，需要添加processName字段
                if ("workshop".equals(rowGroupBy)) {
                    String processName = getStringValue(data, "processName");
                    rowDetail.put("processName", processName != null ? processName : "");
                }
                
                // 为每个时间点创建零值数据
                List<Map<String, Object>> timeDataList = new ArrayList<>();
                for (String timePoint : timePoints) {
                    Map<String, Object> pointData = new HashMap<>();
                    pointData.put("planDay", timePoint);
                    pointData.put("requireTimes", BigDecimal.ZERO);
                    pointData.put("designTimes", BigDecimal.ZERO); 
                    pointData.put("capacityLoad", BigDecimal.ZERO);
                    timeDataList.add(pointData);
                }
                
                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;
        }
        
@@ -1499,6 +1551,8 @@
        // 使用组合key来实现多维度分组（动态rowGroupBy字段 + 可选的工厂/专业/车间）
        Map<String, Map<String, Object>> groupInfoMap = new HashMap<>();
        Map<String, Map<String, BigDecimal>> groupTimeDataMap = new HashMap<>();
        // 存储每个groupKey对应的processName集合
        Map<String, Set<String>> groupProcessNamesMap = new HashMap<>();
        
        // 遍历原始数据，按多维度分组进行聚合
        for (Map<String, Object> data : rawData) {
@@ -1550,6 +1604,14 @@
                groupInfoMap.put(groupKey, groupInfo);
            }
            
            // 收集processName
            if (processName != null && !processName.trim().isEmpty()) {
                if (!groupProcessNamesMap.containsKey(groupKey)) {
                    groupProcessNamesMap.put(groupKey, new HashSet<>());
                }
                groupProcessNamesMap.get(groupKey).add(processName);
            }
            
            // 计算时间点Key
            String timeKey;
            LocalDate planStartLocalDate = processPlanStartDay.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
@@ -1596,8 +1658,17 @@
                rowDetail.put("workshop", groupInfo.get("workshop"));
            }
            
            // 处理processName - 如果rowGroupBy为workshop，则将所有processName用分号连接
            if ("workshop".equals(rowGroupBy)) {
                Set<String> processNames = groupProcessNamesMap.getOrDefault(groupKey, new HashSet<>());
                if (!processNames.isEmpty()) {
                    String joinedProcessNames = String.join(";", processNames);
                    rowDetail.put("processName", joinedProcessNames);
                } else {
                    rowDetail.put("processName", groupInfo.get("processName"));
                }
            } else if (!"processName".equals(rowGroupBy)) {
            // 保留工序名称信息，以便前端展示
            if (!"processName".equals(rowGroupBy)) {
                rowDetail.put("processName", groupInfo.get("processName"));
            }
            
@@ -1608,13 +1679,13 @@
            for (String timePoint : timePoints) {
                Map<String, Object> pointData = new HashMap<>();
                pointData.put("planDay", timePoint);
                pointData.put("designTimes", 0); // 设计工时暂时给0
                
                // 获取该时间点的需求工时，如果不存在则设为0
                BigDecimal requireTimes = timeMap.getOrDefault(timePoint, BigDecimal.ZERO);
                pointData.put("requireTimes", requireTimes);
                
                // 计算产能负荷（暂时为0）
                // 设计工时和产能负荷稍后计算
                pointData.put("designTimes", 0);
                pointData.put("capacityLoad", 0);
                
                timeDataList.add(pointData);
@@ -1625,6 +1696,160 @@
            plantTable.add(rowEntry);
        }

        // 在返回前查询设计产能数据并计算产能负荷
        for (Map<String, Object> rowEntry : plantTable) {
            for (String rowKey : rowEntry.keySet()) {
                Map<String, Object> rowDetail = (Map<String, Object>) rowEntry.get(rowKey);
                List<Map<String, Object>> timeDataList = (List<Map<String, Object>>) rowDetail.get("timeData");
                
                // 获取基本信息
                String plant = rowDetail.containsKey("plant") ? (String) rowDetail.get("plant") : null;
                String major = rowDetail.containsKey("major") ? (String) rowDetail.get("major") : null;
                String workshop = rowDetail.containsKey("workshop") ? (String) rowDetail.get("workshop") : null;
                
                // 处理不同的rowGroupBy情况
                if ("workshop".equals(rowGroupBy) && rowDetail.containsKey("processName")) {
                    // 情况1: 按workshop聚合，需要拆分processName字段
                    String processNamesStr = (String) rowDetail.get("processName");
                    String[] processNames = processNamesStr.split(";");
                    
                    // 优化查询 - 创建缓存，按月份缓存查询结果
                    // Key: year-month-processName, Value: 查询结果列表
                    Map<String, List<ApsGasPipelineCapacityPlan>> capacityPlanCache = new HashMap<>();
                    
                    // 遍历每个时间点
                    for (Map<String, Object> timeData : timeDataList) {
                        String planDay = (String) timeData.get("planDay");
                        BigDecimal requireTimes = new BigDecimal(timeData.get("requireTimes").toString());
                        BigDecimal totalDesignTimes = BigDecimal.ZERO;
                        
                        // 拆分年月日
                        String[] dateParts = planDay.split("-");
                        String year = dateParts[0];
                        String month = dateParts[1];
                        // 统一month格式为整数字符串，去掉前导零
                        month = String.valueOf(Integer.parseInt(month));
                        String yearMonth = year + "-" + month;
                        
                        // 累加多个工序的设计产能
                        for (String processName : processNames) {
                            // 构建缓存键
                            String cacheKey = yearMonth + "-" + processName.trim();
                            
                            // 从缓存获取或查询数据
                            List<ApsGasPipelineCapacityPlan> capacityPlans;
                            if (capacityPlanCache.containsKey(cacheKey)) {
                                capacityPlans = capacityPlanCache.get(cacheKey);
                            } else {
                                // 使用专用查询方法查询设计产能数据
                                // 按文档要求：根据process_name和plant去aps_gas_pipeline_capacity_plan表中查询
                                capacityPlans = apsGasPipelineCapacityPlanMapper.selectDesignCapacityForInterface2(
                                        processName.trim(), year, month, null, plant);
                                
                                // 将结果存入缓存
                                capacityPlanCache.put(cacheKey, capacityPlans);
                            }
                            
                            // 累加设计产能值
                            for (ApsGasPipelineCapacityPlan plan : capacityPlans) {
                                if ("day".equalsIgnoreCase(timeGranularity)) {
                                    // 日粒度使用日产出数量
                                    if (plan.getDayProduceAllNum() != null) {
                                        totalDesignTimes = totalDesignTimes.add(plan.getDayProduceAllNum());
                                    }
                                } else {
                                    // 月粒度使用月产出总数量
                                    if (plan.getMonthProduceAllNum() != null) {
                                        totalDesignTimes = totalDesignTimes.add(plan.getMonthProduceAllNum());
                                    }
                                }
                            }
                        }
                        
                        // 更新设计工时
                        timeData.put("designTimes", totalDesignTimes);
                        
                        // 计算产能负荷 = 需求产能/设计产能×100%
                        if (totalDesignTimes.compareTo(BigDecimal.ZERO) > 0) {
                            BigDecimal capacityLoad = requireTimes
                                    .divide(totalDesignTimes, 2, RoundingMode.HALF_UP)
                                    .multiply(new BigDecimal(100));
                            timeData.put("capacityLoad", capacityLoad);
                        } else {
                            timeData.put("capacityLoad", 0);
                        }
                    }
                } else {
                    // 情况2: 按processName或其他字段聚合
                    String processName = rowDetail.containsKey("processName") ? 
                            (String) rowDetail.get("processName") : rowKey;
                    
                    // 优化查询 - 创建缓存，按月份缓存查询结果
                    Map<String, List<ApsGasPipelineCapacityPlan>> capacityPlanCache = new HashMap<>();
                    
                    // 遍历每个时间点
                    for (Map<String, Object> timeData : timeDataList) {
                        String planDay = (String) timeData.get("planDay");
                        BigDecimal requireTimes = new BigDecimal(timeData.get("requireTimes").toString());
                        
                        // 拆分年月日
                        String[] dateParts = planDay.split("-");
                        String year = dateParts[0];
                        String month = dateParts[1];
                        // 统一month格式为整数字符串，去掉前导零
                        month = String.valueOf(Integer.parseInt(month));
                        String yearMonth = year + "-" + month;
                        
                        // 构建缓存键
                        String cacheKey = yearMonth + "-" + processName;
                        
                        // 从缓存获取或查询数据
                        List<ApsGasPipelineCapacityPlan> capacityPlans;
                        if (capacityPlanCache.containsKey(cacheKey)) {
                            capacityPlans = capacityPlanCache.get(cacheKey);
                        } else {
                            // 使用专用查询方法查询设计产能数据
                            // 按文档要求：根据process_name和plant去aps_gas_pipeline_capacity_plan表中查询
                            capacityPlans = apsGasPipelineCapacityPlanMapper.selectDesignCapacityForInterface2(
                                    processName, year, month, null, plant);
                            
                            // 将结果存入缓存
                            capacityPlanCache.put(cacheKey, capacityPlans);
                        }
                        
                        // 累加设计产能值
                        BigDecimal totalDesignTimes = BigDecimal.ZERO;
                        for (ApsGasPipelineCapacityPlan plan : capacityPlans) {
                            if ("day".equalsIgnoreCase(timeGranularity)) {
                                // 日粒度使用日产出数量
                                if (plan.getDayProduceAllNum() != null) {
                                    totalDesignTimes = totalDesignTimes.add(plan.getDayProduceAllNum());
                                }
                            } else {
                                // 月粒度使用月产出总数量
                                if (plan.getMonthProduceAllNum() != null) {
                                    totalDesignTimes = totalDesignTimes.add(plan.getMonthProduceAllNum());
                                }
                            }
                        }
                        
                        // 更新设计工时
                        timeData.put("designTimes", totalDesignTimes);
                        
                        // 计算产能负荷 = 需求产能/设计产能×100%
                        if (totalDesignTimes.compareTo(BigDecimal.ZERO) > 0) {
                            BigDecimal capacityLoad = requireTimes
                                    .divide(totalDesignTimes, 2, RoundingMode.HALF_UP)
                                    .multiply(new BigDecimal(100));
                            timeData.put("capacityLoad", capacityLoad);
                        } else {
                            timeData.put("capacityLoad", 0);
                        }
                    }
                }
            }
        }

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

 aps-modules/aps-core/src/main/resources/mapper/core/ApsGasPipelineCapacityPlanMapper.xml

@@ -146,4 +146,23 @@
                   and org_code = #{factory}
                   and major = #{major}
    </delete>
    
    <!-- 查询设计产能数据 - 专用于接口二功能 -->
    <select id="selectDesignCapacityForInterface2" resultMap="ApsGasPipelineCapacityPlanResult">
        <include refid="selectApsGasPipelineCapacityPlanVo"/>
        <where>
            <if test="processName != null and processName != ''">
                and process_name = #{processName}
            </if>
            <if test="year != null and year != ''">
                and year = #{year}
            </if>
            <if test="month != null and month != ''">
                and CAST(month AS INTEGER) = CAST(#{month} AS INTEGER)
            </if>
            <if test="orgCode != null and orgCode != ''">
                and org_code = #{orgCode}
            </if>
        </where>
    </select>
</mapper>

 aps-modules/aps-core/src/main/resources/mapper/core/ApsGasPipingRouteStatMapper.xml

@@ -413,4 +413,43 @@
        FROM aps_gas_pipeline_mo
    </select>

    <!-- 查询基础统计数据（不包含时间限制），用于获取所有可能的工序名和车间 -->
    <select id="selectBaseStatData" parameterType="java.util.Map" resultType="java.util.Map">
        SELECT DISTINCT
            process_name AS "processName",
            plant AS "plant",
            major AS "major",
            workshop AS "workshop"
        FROM aps_gas_piping_route_stat
        <where>
            <if test="plants != null and plants.size() > 0">
                AND plant IN
                <foreach collection="plants" item="item" open="(" separator="," close=")">
                    #{item}
                </foreach>
            </if>
            <if test="plant != null and plant != ''">
                AND plant = #{plant}
            </if>
            <if test="majors != null and majors.size() > 0">
                AND major IN
                <foreach collection="majors" item="item" open="(" separator="," close=")">
                    #{item}
                </foreach>
            </if>
            <if test="major != null and major != ''">
                AND major = #{major}
            </if>
            <if test="workshops != null and workshops.size() > 0">
                AND workshop IN
                <foreach collection="workshops" item="item" open="(" separator="," close=")">
                    #{item}
                </foreach>
            </if>
            <if test="workshop != null and workshop != ''">
                AND workshop = #{workshop}
            </if>
        </where>
    </select>

</mapper>