质控分析报告-勤务组织

airport-admin/src/main/java/com/sundot/airport/web/controller/quality/QualificationLevelStatsController.java

@@ -0,0 +1,319 @@
+package com.sundot.airport.web.controller.quality;
+
+import com.sundot.airport.common.core.controller.BaseController;
+import com.sundot.airport.common.core.domain.AjaxResult;
+import com.sundot.airport.common.core.domain.entity.SysDept;
+import com.sundot.airport.common.core.domain.entity.SysUser;
+import com.sundot.airport.common.enums.DeptTypeEnum;
+import com.sundot.airport.common.utils.DeptUtils;
+import com.sundot.airport.item.domain.dto.QualificationLevelStatsDTO;
+import com.sundot.airport.system.domain.QualificationLevelConverter;
+import com.sundot.airport.system.domain.portrait.QualificationStats;
+import com.sundot.airport.system.mapper.portrait.QualificationLevelIndicatorMapper;
+import com.sundot.airport.system.service.ISysDeptService;
+import com.sundot.airport.system.service.ISysUserService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * 资质等级统计控制器
+ * 提供资质等级统计的API接口
+ *
+ * @author wangxx
+ */
+@Api(tags = "资质等级统计")
+@RestController
+@RequestMapping("/statistics/qualification")
+public class QualificationLevelStatsController extends BaseController {
+
+    @Autowired
+    private QualificationLevelIndicatorMapper qualificationLevelMapper;
+
+    @Autowired
+    private ISysDeptService sysDeptService;
+
+    @Autowired
+    private ISysUserService sysUserService;
+
+
+    /**
+     * 固定的资质等级列表（一级到五级）
+     */
+    private static final List<String> QUALIFICATION_LEVELS = Arrays.asList(
+            "一级", "二级", "三级", "四级", "五级"
+    );
+
+    /**
+     * 获取饼状图数据（全站资质等级分布）
+     */
+    @ApiOperation("获取饼状图数据")
+    @GetMapping("/pie-chart")
+    public AjaxResult getPieChartData() {
+
+        try {
+            Long topSiteId = DeptUtils.getTopSiteId(sysDeptService.selectDeptById(getDeptId()));
+            if (topSiteId == null) {
+                return AjaxResult.error("无法找到有效的站点信息");
+            }
+
+            List<Long> siteUserIds = getAllUserIdsUnderSite(topSiteId);
+            if (siteUserIds.isEmpty()) {
+                return AjaxResult.success("获取成功", new QualificationLevelStatsDTO.PieChartData());
+            }
+
+
+            QualificationLevelStatsDTO.PieChartData pieChart = calculatePieChartData(siteUserIds);
+            return AjaxResult.success("获取成功", pieChart);
+
+        } catch (Exception e) {
+            logger.error("获取饼状图数据失败", e);
+            return AjaxResult.error("获取饼状图数据失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 获取柱状图数据（各大队资质等级分布）
+     */
+    @ApiOperation("获取柱状图数据")
+    @GetMapping("/bar-chart")
+    public AjaxResult getBarChartData() {
+
+        try {
+            Long topSiteId = DeptUtils.getTopSiteId(sysDeptService.selectDeptById(getDeptId()));
+            if (topSiteId == null) {
+                return AjaxResult.error("无法找到有效的站点信息");
+            }
+
+            QualificationLevelStatsDTO.BarChartData barChart = calculateBarChartDataOptimized(topSiteId);
+            return AjaxResult.success("获取成功", barChart);
+
+        } catch (Exception e) {
+            logger.error("获取柱状图数据失败", e);
+            return AjaxResult.error("获取柱状图数据失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 计算饼状图数据（全站范围资质等级分布）
+     */
+    private QualificationLevelStatsDTO.PieChartData calculatePieChartData(List<Long> userIds) {
+        QualificationLevelStatsDTO.PieChartData pieChart = new QualificationLevelStatsDTO.PieChartData();
+
+        // 查询资质等级统计（暂不考虑时间参数，后续可根据需要扩展）
+        List<QualificationStats> statsList = qualificationLevelMapper.queryOrgQualificationLevelStats(userIds, null);
+
+        // 转换为分布数据
+        List<QualificationLevelStatsDTO.LevelDistribution> distributions = new ArrayList<>();
+        int totalPersons = 0;
+
+        // 统计实际存在的等级数据
+        Map<String, QualificationStats> statsMap = statsList.stream()
+                .collect(Collectors.toMap(
+                        stat -> QualificationLevelConverter.toDisplay(stat.getLevelName()),
+                        s -> s
+                ));
+
+        // 按固定顺序处理所有等级
+        for (String levelName : QUALIFICATION_LEVELS) {
+            QualificationLevelStatsDTO.LevelDistribution distribution = new QualificationLevelStatsDTO.LevelDistribution();
+            distribution.setLevelName(levelName);
+
+            QualificationStats stats = statsMap.get(levelName);
+            if (stats != null) {
+                distribution.setCount(stats.getCount());
+                distribution.setPercentage(new BigDecimal(stats.getPercentage()).setScale(2, RoundingMode.HALF_UP));
+                totalPersons += stats.getCount();
+            } else {
+                // 该等级无人
+                distribution.setCount(0);
+                distribution.setPercentage(BigDecimal.ZERO);
+            }
+
+            distributions.add(distribution);
+        }
+
+        pieChart.setData(distributions);
+        pieChart.setTotalPersons(totalPersons);
+
+        return pieChart;
+    }
+
+    /**
+     * 计算柱状图数据（各大队资质等级分布）
+     */
+    private QualificationLevelStatsDTO.BarChartData calculateBarChartDataOptimized(Long siteId) {
+        QualificationLevelStatsDTO.BarChartData barChart = new QualificationLevelStatsDTO.BarChartData();
+
+        // 获取站点下的所有大队
+        List<SysDept> brigades = getBrigadesUnderSite(siteId);
+        if (brigades.isEmpty()) {
+            barChart.setBrigades(new ArrayList<>());
+            return barChart;
+        }
+
+        // 批量获取所有大队的用户ID
+        Map<Long, List<Long>> deptUserIdsMap = batchGetUserIdsByBrigades(brigades);
+
+        // 批量查询所有大队的资质统计数据
+        Map<Long, List<QualificationStats>> deptStatsMap = batchQueryQualificationStats(deptUserIdsMap);
+
+        // 构建大队数据
+        List<QualificationLevelStatsDTO.BrigadeData> deptDataList = brigades.stream()
+                .map(dept -> {
+                    QualificationLevelStatsDTO.BrigadeData deptData = new QualificationLevelStatsDTO.BrigadeData();
+                    deptData.setDeptId(dept.getDeptId());
+                    deptData.setDeptName(dept.getDeptName());
+
+                    List<QualificationStats> deptStats = deptStatsMap.get(dept.getDeptId());
+                    if (deptStats != null && !deptStats.isEmpty()) {
+                        List<QualificationLevelStatsDTO.LevelCount> levelCounts = convertToLevelCounts(deptStats);
+                        deptData.setLevelCounts(levelCounts);
+                    } else {
+                        // 大队无用户或无统计数据，初始化为空数据
+                        List<QualificationLevelStatsDTO.LevelCount> emptyCounts = QUALIFICATION_LEVELS.stream()
+                                .map(level -> {
+                                    QualificationLevelStatsDTO.LevelCount count = new QualificationLevelStatsDTO.LevelCount();
+                                    count.setLevelName(level);
+                                    count.setCount(0);
+                                    return count;
+                                })
+                                .collect(Collectors.toList());
+                        deptData.setLevelCounts(emptyCounts);
+                    }
+
+                    return deptData;
+                })
+                .collect(Collectors.toList());
+
+        barChart.setBrigades(deptDataList);
+        return barChart;
+    }
+
+    /**
+     * 批量获取大队用户ID映射
+     */
+    private Map<Long, List<Long>> batchGetUserIdsByBrigades(List<SysDept> brigades) {
+        Map<Long, List<Long>> deptUserIdsMap = new HashMap<>();
+
+        for (SysDept dept : brigades) {
+            List<Long> deptUserIds = getAllUserIdsUnderDept(dept.getDeptId());
+            deptUserIdsMap.put(dept.getDeptId(), deptUserIds);
+        }
+
+        return deptUserIdsMap;
+    }
+
+    /**
+     * 批量查询资质统计数据
+     */
+    private Map<Long, List<QualificationStats>> batchQueryQualificationStats(Map<Long, List<Long>> deptUserIdsMap) {
+        Map<Long, List<QualificationStats>> deptStatsMap = new HashMap<>();
+
+        // 过滤掉没有用户的大队
+        Map<Long, List<Long>> validDeptUserIdsMap = deptUserIdsMap.entrySet().stream()
+                .filter(entry -> !entry.getValue().isEmpty())
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        if (validDeptUserIdsMap.isEmpty()) {
+            return deptStatsMap;
+        }
+
+        for (Map.Entry<Long, List<Long>> entry : validDeptUserIdsMap.entrySet()) {
+            Long deptId = entry.getKey();
+            List<Long> userIds = entry.getValue();
+            List<QualificationStats> stats = qualificationLevelMapper.queryOrgQualificationLevelStats(userIds, null);
+            deptStatsMap.put(deptId, stats);
+        }
+
+        return deptStatsMap;
+    }
+
+    /**
+     * 将资质统计转换为等级人数数据
+     */
+    private List<QualificationLevelStatsDTO.LevelCount> convertToLevelCounts(List<QualificationStats> statsList) {
+        Map<String, Integer> countMap = statsList.stream()
+                .collect(Collectors.toMap(QualificationStats::getLevelName, QualificationStats::getCount));
+
+        return QUALIFICATION_LEVELS.stream()
+                .map(level -> {
+                    String levelName = QualificationLevelConverter.toDatabase(level);
+                    QualificationLevelStatsDTO.LevelCount count = new QualificationLevelStatsDTO.LevelCount();
+                    count.setLevelName(level);
+                    count.setCount(countMap.getOrDefault(levelName, 0));
+                    return count;
+                })
+                .collect(Collectors.toList());
+    }
+
+
+    /**
+     * 获取站点下的所有用户ID
+     */
+    private List<Long> getAllUserIdsUnderSite(Long siteId) {
+        List<Long> userIds = new ArrayList<>();
+
+        // 获取站点本身及其下属部门
+        List<SysDept> allDepts = sysDeptService.selectChildrenDeptById(siteId);
+        allDepts.add(0, sysDeptService.selectDeptById(siteId)); // 添加站点本身
+
+        // 获取各部门下的用户
+        for (SysDept dept : allDepts) {
+            if (Objects.nonNull(dept)) {
+                List<Long> deptUserIds = sysUserService.selectUserByDeptId(dept.getDeptId()).stream()
+                        .map(SysUser::getUserId)
+                        .collect(Collectors.toList());
+                userIds.addAll(deptUserIds);
+            }
+        }
+
+        return userIds.stream().distinct().collect(Collectors.toList());
+    }
+
+    /**
+     * 获取站点下的所有大队
+     */
+    private List<SysDept> getBrigadesUnderSite(Long siteId) {
+        List<SysDept> children = sysDeptService.selectChildrenDeptById(siteId);
+        return children.stream()
+                .filter(dept -> DeptTypeEnum.BRIGADE.getCode().equals(dept.getDeptType()))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 获取部门下的所有用户ID
+     */
+    private List<Long> getAllUserIdsUnderDept(Long deptId) {
+        List<Long> userIds = new ArrayList<>();
+
+        // 获取部门本身及其下属部门
+        List<SysDept> allDepts = sysDeptService.selectChildrenDeptById(deptId);
+        allDepts.add(0, sysDeptService.selectDeptById(deptId)); // 添加部门本身
+
+        // 获取各部门下的用户
+        for (SysDept dept : allDepts) {
+            List<Long> deptUserIds = sysUserService.selectUserByDeptId(dept.getDeptId()).stream()
+                    .map(SysUser::getUserId)
+                    .collect(Collectors.toList());
+            userIds.addAll(deptUserIds);
+        }
+
+        return userIds.stream().distinct().collect(Collectors.toList());
+    }
+
+
+}

airport-admin/src/main/java/com/sundot/airport/web/controller/quality/SimpleAttendancePersonController.java

@@ -0,0 +1,467 @@
+package com.sundot.airport.web.controller.quality;
+
+import com.sundot.airport.attendance.calculator.AttendancePersonCountCalculator;
+import com.sundot.airport.attendance.calculator.BrigadeAttendancePersonCountCalculator;
+import com.sundot.airport.attendance.dto.AttendanceTrendDataDTO;
+import com.sundot.airport.common.core.domain.entity.SysDept;
+import com.sundot.airport.attendance.dto.AttendancePersonStatsDTO;
+import com.sundot.airport.common.enums.DeptTypeEnum;
+import com.sundot.airport.common.statistics.*;
+import com.sundot.airport.common.utils.DeptUtils;
+import com.sundot.airport.common.utils.StringUtils;
+import com.sundot.airport.system.service.ISysDeptService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.sundot.airport.common.utils.SecurityUtils.getDeptId;
+
+/**
+ * 出勤人次控制器
+ * 根据时间维度返回总体+大队的人次数据
+ */
+@Api(tags = "出勤人次")
+@RestController
+@RequestMapping("/quality/attendance")
+public class SimpleAttendancePersonController {
+
+    @Autowired
+    private AttendancePersonCountCalculator overallCalculator; // 全站计算器
+
+    @Autowired
+    private BrigadeAttendancePersonCountCalculator deptCalculator; // 大队计算器
+
+    @Autowired
+    private MultiModelIndicatorCalculator multiModelIndicatorCalculator;
+
+    @Autowired
+    private ISysDeptService deptService;
+
+
+    /**
+     * 出勤人次分析
+     */
+    @ApiOperation("出勤人次分析")
+    @PostMapping("/calculate")
+    public List<AttendancePersonStatsDTO> calculateStatistics(@RequestBody IndicatorCalculationParams params) {
+        List<AttendancePersonStatsDTO> results = new ArrayList<>();
+
+        // 获取当前用户所在站点ID
+        Long topSiteId = DeptUtils.getTopSiteId(deptService.selectDeptById(getDeptId()));
+        List<SysDept> brigadesUnderSite = getBrigadesUnderSite(topSiteId);
+        brigadesUnderSite.add(deptService.selectDeptById(topSiteId));
+        brigadesUnderSite.forEach(dept -> {
+            results.add(createAttendancePersonStats(dept, params));
+        });
+
+        return results;
+    }
+
+    /**
+     * 出勤人次趋势数据
+     * 根据时间维度参数动态生成柱状图数据
+     * 支持月度（同比+环比）、季度（同比）、年度（同比）等多种展示方式
+     *
+     * @param params 时间维度参数（年、季度、月等）
+     * @return 趋势数据列表
+     */
+    @ApiOperation("出勤人次趋势数据")
+    @PostMapping("/trend-data")
+    public List<AttendanceTrendDataDTO> getTrendData(@RequestBody IndicatorCalculationParams params) {
+        List<AttendanceTrendDataDTO> results = new ArrayList<>();
+
+        // 根据时间维度类型决定展示策略
+        if (params.getMonth() != null) {
+            // 月度：展示当前月、上月、去年同期（同比+环比）
+            results.addAll(generateMonthlyTrendData(params));
+        } else if (params.getQuarter() != null) {
+            // 季度：展示当前季度和去年同期
+            results.addAll(generateQuarterlyTrendData(params));
+        } else if (params.getYear() != null) {
+            // 年度：仅展示当前年和去年（仅同比）
+            results.addAll(generateYearlyTrendData(params));
+        } else {
+            // 默认按月度处理
+            results.addAll(generateMonthlyTrendData(params));
+        }
+
+        return results;
+    }
+
+    /**
+     * 生成月度趋势数据（同比+环比）
+     * 展示：当前月、上月、去年同期
+     */
+    private List<AttendanceTrendDataDTO> generateMonthlyTrendData(IndicatorCalculationParams params) {
+        List<AttendanceTrendDataDTO> results = new ArrayList<>();
+
+        // 获取当前用户所在站点ID
+        Long topSiteId = DeptUtils.getTopSiteId(deptService.selectDeptById(getDeptId()));
+        List<SysDept> stationAndThreeDepts = getBrigadesUnderSite(topSiteId);
+        stationAndThreeDepts.add(deptService.selectDeptById(topSiteId));
+
+
+        // 计算当前月数据
+        List<AttendancePersonStatsDTO> currentList = calculateDeptStats(stationAndThreeDepts, params);
+
+        // 计算上月数据
+        IndicatorCalculationParams lastMonthParams = createLastMonthParams(params);
+        List<AttendancePersonStatsDTO> lastMonthList = calculateDeptStats(stationAndThreeDepts, lastMonthParams);
+
+        // 计算去年同期数据
+        IndicatorCalculationParams lastYearParams = createLastYearParams(params);
+        List<AttendancePersonStatsDTO> lastYearList = calculateDeptStats(stationAndThreeDepts, lastYearParams);
+
+
+        // 构造柱状图数据
+        AttendanceTrendDataDTO currentData = createTrendDataPoint(getMonthLabel(params), currentList);
+        AttendanceTrendDataDTO lastMonthData = createTrendDataPoint(getLastMonthLabel(params), lastMonthList);
+        AttendanceTrendDataDTO lastYearData = createTrendDataPoint(getLastYearMonthLabel(params), lastYearList);
+
+        results.add(lastYearData);
+        results.add(lastMonthData);
+        results.add(currentData);
+
+        return results;
+    }
+
+    /**
+     * 生成季度趋势数据（同比+环比）
+     * 展示：当前季度、上季度、去年同期季度
+     */
+    private List<AttendanceTrendDataDTO> generateQuarterlyTrendData(IndicatorCalculationParams params) {
+        List<AttendanceTrendDataDTO> results = new ArrayList<>();
+        // 获取当前用户所在站点ID
+        Long topSiteId = DeptUtils.getTopSiteId(deptService.selectDeptById(getDeptId()));
+        List<SysDept> stationAndThreeDepts = getBrigadesUnderSite(topSiteId);
+        stationAndThreeDepts.add(deptService.selectDeptById(topSiteId));
+        // 计算当前季度数据
+        List<AttendancePersonStatsDTO> currentList = calculateDeptStats(stationAndThreeDepts, params);
+
+        // 计算上季度数据
+        IndicatorCalculationParams lastQuarterParams = createLastQuarterParams(params);
+        List<AttendancePersonStatsDTO> lastQuarterList = calculateDeptStats(stationAndThreeDepts, lastQuarterParams);
+
+        // 计算去年同期季度数据
+        IndicatorCalculationParams lastYearParams = createLastYearParams(params);
+        List<AttendancePersonStatsDTO> lastYearList = calculateDeptStats(stationAndThreeDepts, lastYearParams);
+
+        // 构造柱状图数据
+        AttendanceTrendDataDTO currentData = createTrendDataPoint(getQuarterLabel(params), currentList);
+        AttendanceTrendDataDTO lastQuarterData = createTrendDataPoint(getLastQuarterLabel(params), lastQuarterList);
+        AttendanceTrendDataDTO lastYearData = createTrendDataPoint(getLastYearQuarterLabel(params), lastYearList);
+
+        results.add(lastYearData);
+        results.add(lastQuarterData);
+        results.add(currentData);
+        return results;
+    }
+
+    /**
+     * 生成年度趋势数据（仅同比）
+     * 展示：当前年、去年
+     */
+    private List<AttendanceTrendDataDTO> generateYearlyTrendData(IndicatorCalculationParams params) {
+        List<AttendanceTrendDataDTO> results = new ArrayList<>();
+        // 获取当前用户所在站点ID
+        Long topSiteId = DeptUtils.getTopSiteId(deptService.selectDeptById(getDeptId()));
+        List<SysDept> stationAndThreeDepts = getBrigadesUnderSite(topSiteId);
+        stationAndThreeDepts.add(deptService.selectDeptById(topSiteId));
+        // 计算当前年数据
+        List<AttendancePersonStatsDTO> currentList = calculateDeptStats(stationAndThreeDepts, params);
+
+        // 计算去年数据
+        IndicatorCalculationParams lastYearParams = createLastYearParams(params);
+        List<AttendancePersonStatsDTO> lastYearList = calculateDeptStats(stationAndThreeDepts, lastYearParams);
+
+        // 构造柱状图数据
+        AttendanceTrendDataDTO currentData = createTrendDataPoint(params.getYear() + "年", currentList);
+        AttendanceTrendDataDTO lastYearData = createTrendDataPoint((params.getYear() - 1) + "年", lastYearList);
+        results.add(lastYearData);
+        results.add(currentData);
+
+
+        return results;
+    }
+
+    /**
+     * 计算部门统计数据
+     */
+    private List<AttendancePersonStatsDTO> calculateDeptStats(List<SysDept> depts, IndicatorCalculationParams params) {
+        List<AttendancePersonStatsDTO> results = new ArrayList<>();
+        depts.forEach(dept -> {
+            results.add(createAttendancePersonStats(dept, params));
+        });
+        return results;
+    }
+
+    /**
+     * 创建趋势数据点
+     */
+    private AttendanceTrendDataDTO createTrendDataPoint(String timeLabel, List<AttendancePersonStatsDTO> dataList) {
+        AttendanceTrendDataDTO data = new AttendanceTrendDataDTO();
+        data.setTimeLabel(timeLabel);
+        data.setOverall(getStationValue(dataList));
+        data.setData1(getDeptValue(dataList, "安检一大队"));
+        data.setData2(getDeptValue(dataList, "安检二大队"));
+        data.setData3(getDeptValue(dataList, "安检三大队"));
+        data.setData4(getDeptValue(dataList, "安检综合大队"));
+        return data;
+    }
+
+    /**
+     * 获取季度标签
+     */
+    private String getQuarterLabel(IndicatorCalculationParams params) {
+        if (params.getYear() != null && params.getQuarter() != null) {
+            return params.getYear() + "年第" + params.getQuarter() + "季度";
+        }
+        return "当前季度";
+    }
+
+    /**
+     * 获取上季度标签
+     */
+    private String getLastQuarterLabel(IndicatorCalculationParams params) {
+        if (params.getYear() != null && params.getQuarter() != null) {
+            int lastQuarter = params.getQuarter() - 1;
+            int year = params.getYear();
+            if (lastQuarter <= 0) {
+                lastQuarter = 4;
+                year = year - 1;
+            }
+            return year + "年第" + lastQuarter + "季度";
+        }
+        return "上季度";
+    }
+
+    /**
+     * 获取去年季度标签
+     */
+    private String getLastYearQuarterLabel(IndicatorCalculationParams params) {
+        if (params.getYear() != null && params.getQuarter() != null) {
+            return (params.getYear() - 1) + "年第" + params.getQuarter() + "季度";
+        }
+        return "去年同期季度";
+    }
+
+    /**
+     * 月度标签
+     */
+    private String getMonthLabel(IndicatorCalculationParams params) {
+        if (params.getYear() != null && params.getMonth() != null) {
+            return params.getYear() + "年" + params.getMonth() + "月";
+        }
+        return "当前月度";
+    }
+
+    /**
+     * 获取上月标签
+     */
+    private String getLastMonthLabel(IndicatorCalculationParams params) {
+        if (params.getYear() != null && params.getMonth() != null) {
+            int lastMonth = params.getMonth() - 1;
+            int year = params.getYear();
+            if (lastMonth <= 0) {
+                lastMonth = 12;
+                year = year - 1;
+            }
+            return year + "年" + lastMonth + "月";
+        }
+        return "上月";
+    }
+
+    /**
+     * 获取去年本月度标签
+     */
+    private String getLastYearMonthLabel(IndicatorCalculationParams params) {
+        if (params.getYear() != null && params.getMonth() != null) {
+            return (params.getYear() - 1) + "年" + params.getMonth() + "月";
+        }
+        return "去年同期月度";
+    }
+
+
+    /**
+     * 创建出勤人次统计对象
+     */
+    private AttendancePersonStatsDTO createAttendancePersonStats(SysDept sysDept, IndicatorCalculationParams params) {
+        AttendancePersonStatsDTO result = new AttendancePersonStatsDTO();
+        result.setDeptId(sysDept.getDeptId());
+        result.setDeptName(sysDept.getDeptName());
+        result.setDeptType(sysDept.getDeptType());
+        try {
+            IndicatorCalculationParams calcParams = new IndicatorCalculationParams();
+            calcParams.setDeptId(sysDept.getDeptId());
+            calcParams.setYear(params.getYear());
+            calcParams.setQuarter(params.getQuarter());
+            calcParams.setMonth(params.getMonth());
+            calcParams.setStartTime(params.getStartTime());
+            calcParams.setEndTime(params.getEndTime());
+            calcParams.setChainRatio(params.getChainRatio());
+            calcParams.setYearOnYear(params.getYearOnYear());
+
+            IndicatorCalculationResult currentResult;
+            if (sysDept.getDeptType().equals(DeptTypeEnum.STATION.getCode())) {
+                currentResult = multiModelIndicatorCalculator.calculateWithRatio(overallCalculator, calcParams);
+            } else {
+                currentResult = multiModelIndicatorCalculator.calculateWithRatio(deptCalculator, calcParams);
+            }
+
+            if ("SUCCESS".equals(currentResult.getStatus())) {
+                result.setCurrentValue(currentResult.getValue());
+                result.setBaselineValue(currentResult.getBaselineValue());
+
+                boolean showChainRatio = params.getChainRatio() != null && params.getChainRatio();
+                boolean showYearOnYear = params.getYearOnYear() != null && params.getYearOnYear();
+
+                if (params.getYear() != null && params.getQuarter() == null && params.getMonth() == null) {
+                    showChainRatio = false;
+                }
+
+                if (showYearOnYear && currentResult.getYearOnYearValue() != null) {
+                    result.setYearOnYearValue(currentResult.getYearOnYearValue());
+                    result.setYearOnYearDirection(getDirectionText(currentResult.getYearOnYearValue()));
+                    result.setYearOnYearTimeDimension((TimeDimensionParams) currentResult.getExtraInfo().get("yearOnYear"));
+                }
+
+                if (showChainRatio && currentResult.getChainRatioValue() != null) {
+                    result.setChainRatioValue(currentResult.getChainRatioValue());
+                    result.setChainRatioDirection(getDirectionText(currentResult.getChainRatioValue()));
+                    result.setChainTimeDimension((TimeDimensionParams) currentResult.getExtraInfo().get("chain"));
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        return result;
+    }
+
+    /**
+     * 创建上月参数
+     */
+    private IndicatorCalculationParams createLastMonthParams(IndicatorCalculationParams originalParams) {
+        IndicatorCalculationParams params = new IndicatorCalculationParams();
+        params.setYear(originalParams.getYear());
+        params.setQuarter(originalParams.getQuarter());
+        params.setMonth(originalParams.getMonth());
+        params.setStartTime(originalParams.getStartTime());
+        params.setEndTime(originalParams.getEndTime());
+        params.setChainRatio(false);
+        params.setYearOnYear(false);
+
+        // 计算上月
+        if (params.getMonth() != null) {
+            int lastMonth = params.getMonth() - 1;
+            int year = params.getYear();
+            if (lastMonth <= 0) {
+                lastMonth = 12;
+                year = year - 1;
+            }
+            params.setMonth(lastMonth);
+            params.setYear(year);
+        }
+
+        return params;
+    }
+
+    /**
+     * 创建上季度参数
+     */
+    private IndicatorCalculationParams createLastQuarterParams(IndicatorCalculationParams originalParams) {
+        IndicatorCalculationParams params = new IndicatorCalculationParams();
+        params.setYear(originalParams.getYear());
+        params.setQuarter(originalParams.getQuarter());
+        params.setMonth(originalParams.getMonth());
+        params.setStartTime(originalParams.getStartTime());
+        params.setEndTime(originalParams.getEndTime());
+        params.setChainRatio(false);
+        params.setYearOnYear(false);
+
+        // 计算上季度
+        if (params.getQuarter() != null) {
+            int lastQuarter = params.getQuarter() - 1;
+            int year = params.getYear();
+            if (lastQuarter <= 0) {
+                lastQuarter = 4;
+                year = year - 1;
+            }
+            params.setQuarter(lastQuarter);
+            params.setYear(year);
+        }
+
+        return params;
+    }
+
+
+    /**
+     * 创建去年同期参数
+     */
+    private IndicatorCalculationParams createLastYearParams(IndicatorCalculationParams originalParams) {
+        IndicatorCalculationParams params = new IndicatorCalculationParams();
+        params.setYear(originalParams.getYear());
+        params.setQuarter(originalParams.getQuarter());
+        params.setMonth(originalParams.getMonth());
+        params.setStartTime(originalParams.getStartTime());
+        params.setEndTime(originalParams.getEndTime());
+        params.setChainRatio(false);
+        params.setYearOnYear(false);
+
+        // 计算去年同期
+        if (params.getYear() != null) {
+            params.setYear(params.getYear() - 1);
+        }
+
+        return params;
+    }
+
+    /**
+     * 获取站点值
+     */
+    private BigDecimal getStationValue(List<AttendancePersonStatsDTO> list) {
+        return list.stream()
+                .filter(dto -> DeptTypeEnum.STATION.getCode().equals(dto.getDeptType()))
+                .findFirst()
+                .map(AttendancePersonStatsDTO::getCurrentValue)
+                .orElse(BigDecimal.ZERO);
+    }
+
+    /**
+     * 获取指定大队的值
+     */
+    private BigDecimal getDeptValue(List<AttendancePersonStatsDTO> list, String deptName) {
+        return list.stream()
+                .filter(dto -> DeptTypeEnum.BRIGADE.getCode().equals(dto.getDeptType())
+                        && deptName.equals(dto.getDeptName()))
+                .findFirst()
+                .map(AttendancePersonStatsDTO::getCurrentValue)
+                .orElse(BigDecimal.ZERO);
+    }
+
+    /**
+     * 获取方向文本：上升 或 下降
+     */
+    private String getDirectionText(String growthRate) {
+        if (StringUtils.isEmpty(growthRate)) return "";
+        if (growthRate.equals("--")) return "上升";
+        return new BigDecimal(growthRate).compareTo(BigDecimal.ZERO) >= 0 ? "上升" : "下降";
+    }
+
+
+    /**
+     * 获取站点下的所有大队
+     */
+    private List<SysDept> getBrigadesUnderSite(Long siteId) {
+        List<SysDept> children = deptService.selectChildrenDeptById(siteId);
+        return children.stream()
+                .filter(dept -> DeptTypeEnum.BRIGADE.getCode().equals(dept.getDeptType()))
+                .collect(Collectors.toList());
+    }
+
+}

airport-attendance/src/main/java/com/sundot/airport/attendance/calculator/AttendancePersonCountCalculator.java

@@ -0,0 +1,63 @@
+package com.sundot.airport.attendance.calculator;
+
+import com.sundot.airport.attendance.domain.AttendanceRecord;
+import com.sundot.airport.attendance.mapper.AttendanceRecordMapper;
+import com.sundot.airport.common.enums.IndicatorTypeEnum;
+import com.sundot.airport.common.statistics.AbstractIndicatorCalculator;
+import com.sundot.airport.common.statistics.IndicatorCalculationParams;
+import com.sundot.airport.common.statistics.TimeDimensionProcessor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * 出勤人次计算器
+ * 计算全站出勤人次统计
+ */
+@Component
+public class AttendancePersonCountCalculator extends AbstractIndicatorCalculator<BigDecimal> {
+
+    @Autowired
+    private AttendanceRecordMapper attendanceRecordMapper;
+
+    @Autowired
+    private TimeDimensionProcessor timeDimensionProcessor;
+
+    @Override
+    public BigDecimal calculate(IndicatorCalculationParams params) {
+        // 确保时间范围已计算
+        timeDimensionProcessor.calculateTimeRange(params);
+
+        // 查询全站出勤记录
+        AttendanceRecord record = new AttendanceRecord();
+        record.setAttendanceDateStart(params.getStartTime());
+        record.setAttendanceDateEnd(params.getEndTime());
+
+        // 查询考勤记录
+        List<AttendanceRecord> records = attendanceRecordMapper.selectAttendanceRecordList(record);
+
+        // 返回出勤人次（去重后的用户数量）
+        return new BigDecimal(records.stream()
+                .map(AttendanceRecord::getUserId)
+                .distinct()
+                .count());
+    }
+
+    @Override
+    public String getIndicatorType() {
+        return IndicatorTypeEnum.ATTENDANCE_PERSONS.getCode();
+    }
+
+    @Override
+    public String getIndicatorName() {
+        return IndicatorTypeEnum.ATTENDANCE_PERSONS.getName();
+    }
+
+    @Override
+    public String getIndicatorDescription() {
+        return "全站出勤人次统计";
+    }
+
+}

airport-attendance/src/main/java/com/sundot/airport/attendance/calculator/BrigadeAttendancePersonCountCalculator.java

@@ -0,0 +1,66 @@
+package com.sundot.airport.attendance.calculator;
+
+import com.sundot.airport.attendance.domain.AttendanceRecord;
+import com.sundot.airport.attendance.mapper.AttendanceRecordMapper;
+import com.sundot.airport.common.enums.IndicatorTypeEnum;
+import com.sundot.airport.common.statistics.AbstractIndicatorCalculator;
+import com.sundot.airport.common.statistics.IndicatorCalculationParams;
+import com.sundot.airport.common.statistics.TimeDimensionProcessor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * 科室出勤人次计算器
+ * 计算指定科室的出勤人次统计
+ */
+@Component
+public class BrigadeAttendancePersonCountCalculator extends AbstractIndicatorCalculator<BigDecimal> {
+
+    @Autowired
+    private AttendanceRecordMapper attendanceRecordMapper;
+
+    @Autowired
+    private TimeDimensionProcessor timeDimensionProcessor;
+
+    @Override
+    public BigDecimal calculate(IndicatorCalculationParams params) {
+
+        timeDimensionProcessor.calculateTimeRange(params);
+
+        // 查询指定大队的出勤记录
+        AttendanceRecord record = new AttendanceRecord();
+        if (params.getDeptId() != null) {
+            // 根据大队ID查询
+            record.setBrigadeCode(params.getDeptId().toString());
+        }
+        record.setAttendanceDateStart(params.getStartTime());
+        record.setAttendanceDateEnd(params.getEndTime());
+
+        // 查询考勤记录
+        List<AttendanceRecord> records = attendanceRecordMapper.selectAttendanceRecordList(record);
+
+        // 返回科室出勤人次（去重后的用户数量）
+        return new BigDecimal(records.stream()
+                .map(AttendanceRecord::getUserId)
+                .distinct()
+                .count());
+    }
+
+    @Override
+    public String getIndicatorType() {
+        return IndicatorTypeEnum.DEPARTMENT_ATTENDANCE_PERSONS.getCode();
+    }
+
+    @Override
+    public String getIndicatorName() {
+        return IndicatorTypeEnum.DEPARTMENT_ATTENDANCE_PERSONS.getName();
+    }
+
+    @Override
+    public String getIndicatorDescription() {
+        return "科室出勤人次统计";
+    }
+}

airport-attendance/src/main/java/com/sundot/airport/attendance/dto/AttendancePersonStatsDTO.java

@@ -0,0 +1,50 @@
+package com.sundot.airport.attendance.dto;
+
+import com.sundot.airport.common.statistics.TimeDimensionParams;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 出勤人次统计DTO
+ * 用于返回出勤人次分析的统计数据
+ */
+@Data
+public class AttendancePersonStatsDTO {
+
+    @ApiModelProperty("部门ID")
+    private Long deptId;
+
+    @ApiModelProperty("部门名称")
+    private String deptName;
+
+    @ApiModelProperty("部门类型")
+    private String deptType;
+
+    @ApiModelProperty("当前值")
+    private BigDecimal currentValue;
+
+    @ApiModelProperty("环比值")
+    private String chainRatioValue;
+
+    @ApiModelProperty("同比值")
+    private String yearOnYearValue;
+
+    @ApiModelProperty("环比方向（上升/下降）")
+    private String chainRatioDirection;
+
+    @ApiModelProperty("同比方向（上升/下降）")
+    private String yearOnYearDirection;
+
+    @ApiModelProperty("基准值")
+    private BigDecimal baselineValue;
+
+    @ApiModelProperty("环比时间维度")
+    private TimeDimensionParams chainTimeDimension;
+
+    @ApiModelProperty("同比时间维度")
+    private TimeDimensionParams yearOnYearTimeDimension;
+
+
+}

airport-attendance/src/main/java/com/sundot/airport/attendance/dto/AttendanceTrendDataDTO.java

@@ -0,0 +1,32 @@
+package com.sundot.airport.attendance.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 出勤趋势数据DTO
+ * 用于返回同比环比趋势数据
+ */
+@Data
+public class AttendanceTrendDataDTO {
+
+    @ApiModelProperty("时间标签")
+    private String timeLabel;
+
+    @ApiModelProperty("总体数据")
+    private BigDecimal overall;
+
+    @ApiModelProperty("安检一大队")
+    private BigDecimal data1;
+
+    @ApiModelProperty("安检二大队")
+    private BigDecimal data2;
+
+    @ApiModelProperty("安检三大队")
+    private BigDecimal data3;
+
+    @ApiModelProperty("安检综合大队")
+    private BigDecimal data4;
+}

airport-common/src/main/java/com/sundot/airport/common/enums/IndicatorTypeEnum.java

@@ -0,0 +1,41 @@
+package com.sundot.airport.common.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 指标类型枚举
+ * 定义系统中所有的指标类型
+ */
+@Getter
+@AllArgsConstructor
+public enum IndicatorTypeEnum {
+    ATTENDANCE_PERSONS("attendance_persons", "出勤人次"),
+    DEPARTMENT_ATTENDANCE_PERSONS("department_attendance_persons", "科室出勤人次"),
+    ;
+
+    /**
+     * 指标类型编码
+     */
+    private final String code;
+
+    /**
+     * 指标类型名称
+     */
+    private final String name;
+
+    /**
+     * 根据编码获取枚举
+     *
+     * @param code 编码
+     * @return 枚举值
+     */
+    public static IndicatorTypeEnum getByCode(String code) {
+        for (IndicatorTypeEnum type : values()) {
+            if (type.code.equals(code)) {
+                return type;
+            }
+        }
+        return null;
+    }
+}

airport-common/src/main/java/com/sundot/airport/common/statistics/AbstractIndicatorCalculator.java

@@ -0,0 +1,59 @@
+package com.sundot.airport.common.statistics;
+
+
+/**
+ * 抽象指标计算器
+ * 提供指标计算器的通用实现
+ */
+public abstract class AbstractIndicatorCalculator<T> implements IndicatorCalculator<T> {
+
+    /**
+     * 获取专用参数对象
+     *
+     * @param params 计算参数
+     * @return 专用参数对象
+     */
+    protected Object getSpecificParams(IndicatorCalculationParams params) {
+        return params.getSpecificParams();
+    }
+
+    /**
+     * 获取专用参数对象并转换为指定类型
+     *
+     * @param params 计算参数
+     * @param clazz  类型
+     * @return 专用参数对象
+     */
+    protected <R> R getSpecificParams(IndicatorCalculationParams params, Class<R> clazz) {
+        Object value = getSpecificParams(params);
+        if (value != null && clazz.isInstance(value)) {
+            return clazz.cast(value);
+        }
+        return null;
+    }
+
+    /**
+     * 获取上下文参数对象
+     *
+     * @param params 计算参数
+     * @return 上下文参数对象
+     */
+    protected Object getContextParams(IndicatorCalculationParams params) {
+        return params.getContextParams();
+    }
+
+    /**
+     * 获取上下文参数对象并转换为指定类型
+     *
+     * @param params 计算参数
+     * @param clazz  类型
+     * @return 上下文参数对象
+     */
+    protected <R> R getContextParams(IndicatorCalculationParams params, Class<R> clazz) {
+        Object value = getContextParams(params);
+        if (value != null && clazz.isInstance(value)) {
+            return clazz.cast(value);
+        }
+        return null;
+    }
+}

airport-common/src/main/java/com/sundot/airport/common/statistics/IndicatorCalculationParams.java

@@ -0,0 +1,48 @@
+package com.sundot.airport.common.statistics;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * 指标计算参数
+ * 继承时间维度参数，并添加通用的计算参数
+ */
+@Data
+public class IndicatorCalculationParams extends TimeDimensionParams {
+
+    /**
+     * 指标类型
+     */
+    @ApiModelProperty(value = "指标类型")
+    private String indicatorType;
+
+    /**
+     * 模块名称
+     */
+    @ApiModelProperty(value = "模块名称")
+    private String moduleName;
+
+    /**
+     * 部门ID
+     */
+    @ApiModelProperty(value = "部门ID")
+    private Long deptId;
+
+    /**
+     * 用户ID
+     */
+    @ApiModelProperty(value = "用户ID")
+    private Long userId;
+
+    /**
+     * 专用参数对象
+     */
+    @ApiModelProperty(value = "专用参数对象")
+    private Object specificParams;
+
+    /**
+     * 计算上下文参数对象
+     */
+    @ApiModelProperty(value = "计算上下文参数对象")
+    private Object contextParams;
+}

airport-common/src/main/java/com/sundot/airport/common/statistics/IndicatorCalculationResult.java

@@ -0,0 +1,85 @@
+package com.sundot.airport.common.statistics;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.util.Map;
+
+/**
+ * 指标计算结果
+ */
+@Data
+public class IndicatorCalculationResult {
+
+    /**
+     * 指标类型
+     */
+    private String indicatorType;
+
+    /**
+     * 指标名称
+     */
+    private String indicatorName;
+
+    /**
+     * 指标值
+     */
+    private BigDecimal value;
+
+    /**
+     * 环比值
+     */
+    private String chainRatioValue;
+
+    /**
+     * 同比值
+     */
+    private String yearOnYearValue;
+
+    /**
+     * 基准值（用于环比、同比计算的参考值）
+     */
+    private BigDecimal baselineValue;
+
+    /**
+     * 时间维度信息
+     */
+    private String timeDimensionInfo;
+
+    /**
+     * 额外信息
+     */
+    private Map<String, Object> extraInfo;
+
+    /**
+     * 计算状态
+     */
+    private String status;
+
+
+    /**
+     * 错误信息
+     */
+    private String errorMessage;
+
+    public static IndicatorCalculationResult success(BigDecimal value) {
+        IndicatorCalculationResult result = new IndicatorCalculationResult();
+        result.setValue(value);
+        result.setStatus("SUCCESS");
+        return result;
+    }
+
+    public static IndicatorCalculationResult success(BigDecimal value, String chainRatioValue, String yearOnYearValue) {
+        IndicatorCalculationResult result = success(value);
+        result.setChainRatioValue(chainRatioValue);
+        result.setYearOnYearValue(yearOnYearValue);
+        return result;
+    }
+
+    public static IndicatorCalculationResult error(String errorMessage) {
+        IndicatorCalculationResult result = new IndicatorCalculationResult();
+        result.setErrorMessage(errorMessage);
+        result.setStatus("ERROR");
+        return result;
+    }
+}

airport-common/src/main/java/com/sundot/airport/common/statistics/IndicatorCalculator.java

@@ -0,0 +1,37 @@
+package com.sundot.airport.common.statistics;
+
+/**
+ * 指标计算器接口
+ * 定义指标计算的基本操作
+ */
+public interface IndicatorCalculator<T> {
+
+    /**
+     * 计算指标值
+     *
+     * @param params 计算参数
+     * @return 指标计算结果
+     */
+    T calculate(IndicatorCalculationParams params);
+
+    /**
+     * 获取指标类型
+     *
+     * @return 指标类型标识
+     */
+    String getIndicatorType();
+
+    /**
+     * 获取指标名称
+     *
+     * @return 指标名称
+     */
+    String getIndicatorName();
+
+    /**
+     * 获取指标描述
+     *
+     * @return 指标描述
+     */
+    String getIndicatorDescription();
+}

airport-common/src/main/java/com/sundot/airport/common/statistics/MultiModelIndicatorCalculator.java

@@ -0,0 +1,188 @@
+package com.sundot.airport.common.statistics;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 多模型指标计算器
+ * 支持多种指标类型的计算，包括环比和同比
+ */
+@Component
+public class MultiModelIndicatorCalculator {
+
+    @Autowired
+    private TimeDimensionProcessor timeDimensionProcessor;
+
+    /**
+     * 计算指标，支持环比和同比
+     *
+     * @param calculator 指标计算器
+     * @param params     计算参数
+     * @return 指标计算结果
+     */
+    public IndicatorCalculationResult calculateWithRatio(IndicatorCalculator<?> calculator,
+                                                         IndicatorCalculationParams params) {
+        // 首先计算当前指标值
+        Object currentValue = calculator.calculate(params);
+        BigDecimal currentDecimalValue = convertToBigDecimal(currentValue);
+
+        IndicatorCalculationResult result = new IndicatorCalculationResult();
+        result.setIndicatorType(calculator.getIndicatorType());
+        result.setIndicatorName(calculator.getIndicatorName());
+        result.setValue(currentDecimalValue);
+
+        // 设置时间维度信息
+        StringBuilder timeInfo = new StringBuilder();
+        if (params.getYear() != null) {
+            timeInfo.append(params.getYear()).append("年");
+            if (params.getQuarter() != null) {
+                timeInfo.append(params.getQuarter()).append("季度");
+            } else if (params.getMonth() != null) {
+                timeInfo.append(params.getMonth()).append("月");
+            }
+        } else if (params.getStartTime() != null && params.getEndTime() != null) {
+            timeInfo.append(params.getStartTime()).append("至").append(params.getEndTime());
+        }
+        result.setTimeDimensionInfo(timeInfo.toString());
+
+        // 根据时间维度决定计算哪些比率
+        boolean needChainRatio = params.getChainRatio() != null && params.getChainRatio();
+        boolean needYearOnYear = params.getYearOnYear() != null && params.getYearOnYear();
+
+        // 当选择年度时，只计算同比
+        if (params.getYear() != null && params.getQuarter() == null && params.getMonth() == null) {
+            needChainRatio = false;
+        }
+
+        // 计算环比
+        if (needChainRatio) {
+            try {
+                // 计算环比时间范围
+                TimeDimensionParams chainRatioParams = timeDimensionProcessor.calculateChainRatioTimeRange(
+                        params, params.getComparePeriods());
+
+                // 创建环比参数
+                IndicatorCalculationParams chainRatioCalcParams = new IndicatorCalculationParams();
+                chainRatioCalcParams.setStartTime(chainRatioParams.getStartTime());
+                chainRatioCalcParams.setEndTime(chainRatioParams.getEndTime());
+                chainRatioCalcParams.setYear(chainRatioParams.getYear());
+                chainRatioCalcParams.setQuarter(chainRatioParams.getQuarter());
+                chainRatioCalcParams.setMonth(chainRatioParams.getMonth());
+                chainRatioCalcParams.setIndicatorType(params.getIndicatorType());
+                chainRatioCalcParams.setModuleName(params.getModuleName());
+                chainRatioCalcParams.setDeptId(params.getDeptId());
+                chainRatioCalcParams.setUserId(params.getUserId());
+                chainRatioCalcParams.setSpecificParams(params.getSpecificParams());
+                chainRatioCalcParams.setContextParams(params.getContextParams());
+
+                // 计算环比基准值
+                Object chainRatioValue = calculator.calculate(chainRatioCalcParams);
+                BigDecimal chainRatioDecimalValue = convertToBigDecimal(chainRatioValue);
+
+                // 计算环比增长率
+                String chainRatioGrowth = calculateRatioGrowth(currentDecimalValue, chainRatioDecimalValue);
+                result.setChainRatioValue(chainRatioGrowth);
+                result.setBaselineValue(chainRatioDecimalValue);
+                Map<String, Object> extraInfo = new HashMap<>();
+                extraInfo.put("chainRatio", chainRatioParams);
+                result.setExtraInfo(extraInfo);
+            } catch (Exception e) {
+                result.setErrorMessage("环比计算失败: " + e.getMessage());
+            }
+        }
+
+        // 计算同比
+        if (needYearOnYear) {
+            try {
+                // 计算同比时间范围
+                TimeDimensionParams yearOnYearParams = timeDimensionProcessor.calculateYearOnYearTimeRange(params);
+
+                // 创建同比参数
+                IndicatorCalculationParams yearOnYearCalcParams = new IndicatorCalculationParams();
+                yearOnYearCalcParams.setStartTime(yearOnYearParams.getStartTime());
+                yearOnYearCalcParams.setEndTime(yearOnYearParams.getEndTime());
+                yearOnYearCalcParams.setYear(yearOnYearParams.getYear());
+                yearOnYearCalcParams.setQuarter(yearOnYearParams.getQuarter());
+                yearOnYearCalcParams.setMonth(yearOnYearParams.getMonth());
+                yearOnYearCalcParams.setIndicatorType(params.getIndicatorType());
+                yearOnYearCalcParams.setModuleName(params.getModuleName());
+                yearOnYearCalcParams.setDeptId(params.getDeptId());
+                yearOnYearCalcParams.setUserId(params.getUserId());
+                yearOnYearCalcParams.setSpecificParams(params.getSpecificParams());
+                yearOnYearCalcParams.setContextParams(params.getContextParams());
+
+                // 计算同比基准值
+                Object yearOnYearValue = calculator.calculate(yearOnYearCalcParams);
+                BigDecimal yearOnYearDecimalValue = convertToBigDecimal(yearOnYearValue);
+
+                // 计算同比增长率
+                String yearOnYearGrowth = calculateRatioGrowth(currentDecimalValue, yearOnYearDecimalValue);
+                result.setYearOnYearValue(yearOnYearGrowth);
+                Map<String, Object> extraInfo = new HashMap<>();
+                extraInfo.put("yearOnYear", yearOnYearParams);
+                result.setExtraInfo(extraInfo);
+            } catch (Exception e) {
+                result.setErrorMessage("同比计算失败: " + e.getMessage());
+            }
+        }
+
+        result.setStatus("SUCCESS");
+        return result;
+    }
+
+    /**
+     * 计算比率增长
+     *
+     * @param current  当前值
+     * @param baseline 基准值
+     * @return 增长率
+     */
+    private String calculateRatioGrowth(BigDecimal current, BigDecimal baseline) {
+        if (baseline == null || baseline.compareTo(BigDecimal.ZERO) == 0) {
+            if (current != null && current.compareTo(BigDecimal.ZERO) > 0) {
+                return "--";
+            }
+            return BigDecimal.ZERO.toString();
+        }
+
+        if (current == null) {
+            current = BigDecimal.ZERO;
+        }
+
+        // 计算增长率: (当前值 - 基准值) / 基准值 * 100%
+        return current.subtract(baseline)
+                .divide(baseline, 4, BigDecimal.ROUND_HALF_UP)
+                .multiply(new BigDecimal("100"))
+                .setScale(2, BigDecimal.ROUND_HALF_UP).toString();
+    }
+
+    /**
+     * 将对象转换为BigDecimal
+     *
+     * @param obj 待转换对象
+     * @return BigDecimal值
+     */
+    private BigDecimal convertToBigDecimal(Object obj) {
+        if (obj == null) {
+            return BigDecimal.ZERO;
+        }
+
+        if (obj instanceof BigDecimal) {
+            return (BigDecimal) obj;
+        } else if (obj instanceof Number) {
+            return new BigDecimal(obj.toString());
+        } else if (obj instanceof String) {
+            try {
+                return new BigDecimal((String) obj);
+            } catch (NumberFormatException e) {
+                return BigDecimal.ZERO;
+            }
+        } else {
+            return BigDecimal.ZERO;
+        }
+    }
+}

airport-item/src/main/java/com/sundot/airport/item/domain/dto/QualificationLevelStatsDTO.java

@@ -0,0 +1,210 @@
+package com.sundot.airport.item.domain.dto;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * 资质等级统计DTO
+ *
+ * @author wangxx
+ */
+@ApiModel("资质等级统计DTO")
+@Data
+public class QualificationLevelStatsDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 饼状图数据 - 全站范围内五个资质等级的人数占比分布
+     */
+    @ApiModelProperty("饼状图数据 - 全站资质等级分布")
+    private PieChartData pieChart;
+
+    /**
+     * 柱状图数据 - 各大队下五个资质等级的实际人数分布
+     */
+    @ApiModelProperty("柱状图数据 - 各大队资质等级分布")
+    private BarChartData barChart;
+
+    /**
+     * 趋势分析数据 - 支持年、季、月维度的时间趋势分析
+     */
+    @ApiModelProperty("趋势分析数据")
+    private TrendAnalysisData trendAnalysis;
+
+    /**
+     * 饼状图数据类
+     */
+    @ApiModel("饼状图数据")
+    @Data
+    public static class PieChartData implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 数据项列表
+         */
+        @ApiModelProperty("资质等级分布数据")
+        private List<LevelDistribution> data;
+
+        /**
+         * 总人数
+         */
+        @ApiModelProperty("总人数")
+        private Integer totalPersons;
+    }
+
+    /**
+     * 柱状图数据类
+     */
+    @ApiModel("柱状图数据")
+    @Data
+    public static class BarChartData implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 大队列表
+         */
+        @ApiModelProperty("大队数据列表")
+        private List<BrigadeData> brigades;
+    }
+
+    /**
+     * 资质等级分布数据项
+     */
+    @ApiModel("资质等级分布数据项")
+    @Data
+    public static class LevelDistribution implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 资质等级名称
+         */
+        @ApiModelProperty("资质等级")
+        private String levelName;
+
+        /**
+         * 人数
+         */
+        @ApiModelProperty("人数")
+        private Integer count;
+
+        /**
+         * 占比
+         */
+        @ApiModelProperty("占比(%)")
+        private BigDecimal percentage;
+    }
+
+    /**
+     * 大队数据
+     */
+    @ApiModel("大队数据")
+    @Data
+    public static class BrigadeData implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 大队ID
+         */
+        @ApiModelProperty("大队ID")
+        private Long deptId;
+
+        /**
+         * 大队名称
+         */
+        @ApiModelProperty("大队名称")
+        private String deptName;
+
+        /**
+         * 各等级人数数据
+         */
+        @ApiModelProperty("各等级人数数据")
+        private List<LevelCount> levelCounts;
+    }
+
+    /**
+     * 等级人数数据
+     */
+    @ApiModel("等级人数数据")
+    @Data
+    public static class LevelCount implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 资质等级名称
+         */
+        @ApiModelProperty("资质等级")
+        private String levelName;
+
+        /**
+         * 人数
+         */
+        @ApiModelProperty("人数")
+        private Integer count;
+    }
+
+    /**
+     * 趋势分析数据类
+     */
+    @ApiModel("趋势分析数据")
+    @Data
+    public static class TrendAnalysisData implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 时间维度标识（年/季/月）
+         */
+        @ApiModelProperty("时间维度标识")
+        private String timeDimension;
+
+        /**
+         * 时间点列表
+         */
+        @ApiModelProperty("时间点列表")
+        private List<String> timePoints;
+
+        /**
+         * 各等级趋势数据
+         */
+        @ApiModelProperty("各等级趋势数据")
+        private List<LevelTrendData> levelTrends;
+
+        /**
+         * 总人数趋势数据
+         */
+        @ApiModelProperty("总人数趋势数据")
+        private List<Integer> totalPersonsTrend;
+    }
+
+    /**
+     * 等级趋势数据
+     */
+    @ApiModel("等级趋势数据")
+    @Data
+    public static class LevelTrendData implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * 资质等级名称
+         */
+        @ApiModelProperty("资质等级")
+        private String levelName;
+
+        /**
+         * 人数趋势数据
+         */
+        @ApiModelProperty("人数趋势数据")
+        private List<Integer> countTrend;
+
+        /**
+         * 占比趋势数据
+         */
+        @ApiModelProperty("占比趋势数据(%)")
+        private List<BigDecimal> percentageTrend;
+    }
+}

airport-system/src/main/java/com/sundot/airport/system/domain/QualificationLevelConverter.java

@@ -0,0 +1,65 @@
+package com.sundot.airport.system.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 资质等级枚举转换工具类
+ * 处理数据库存储的枚举值与前端显示的中文之间的转换
+ *
+ * @author wangxx
+ */
+public class QualificationLevelConverter {
+
+    /**
+     * 数据库枚举值到中文显示的映射
+     */
+    private static final Map<String, String> DB_TO_DISPLAY = new HashMap<>();
+
+    /**
+     * 中文显示到数据库枚举值的映射
+     */
+    private static final Map<String, String> DISPLAY_TO_DB = new HashMap<>();
+
+    static {
+        // 初始化映射关系
+        DB_TO_DISPLAY.put("LEVEL_ONE", "一级");
+        DB_TO_DISPLAY.put("LEVEL_TWO", "二级");
+        DB_TO_DISPLAY.put("LEVEL_THREE", "三级");
+        DB_TO_DISPLAY.put("LEVEL_FOUR", "四级");
+        DB_TO_DISPLAY.put("LEVEL_FIVE", "五级");
+
+        // 反向映射
+        for (Map.Entry<String, String> entry : DB_TO_DISPLAY.entrySet()) {
+            DISPLAY_TO_DB.put(entry.getValue(), entry.getKey());
+        }
+    }
+
+    /**
+     * 将数据库枚举值转换为中文显示
+     *
+     * @param dbValue 数据库存储的枚举值（如 LEVEL_ONE）
+     * @return 中文显示（如 一级）
+     */
+    public static String toDisplay(String dbValue) {
+        if (dbValue == null || dbValue.trim().isEmpty()) {
+            return "";
+        }
+        return DB_TO_DISPLAY.getOrDefault(dbValue.toUpperCase(), dbValue);
+    }
+
+    /**
+     * 将中文显示转换为数据库枚举值
+     *
+     * @param displayValue 中文显示（如 一级）
+     * @return 数据库枚举值（如 LEVEL_ONE）
+     */
+    public static String toDatabase(String displayValue) {
+        if (displayValue == null || displayValue.trim().isEmpty()) {
+            return "";
+        }
+        return DISPLAY_TO_DB.getOrDefault(displayValue, displayValue);
+    }
+
+
+}