重构completion-comparison接口：xAxis改为周期标签，data改为各周期聚合完成数（美兰）

年：[去年总数, 当年总数]，仅同比
季度/月：[去年同期, 上期, 当期]，同比+环比

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

airport-admin/src/main/java/com/sundot/airport/web/controller/exam/DailyExamComparisonController.java

@@ -21,9 +21,7 @@ import org.springframework.web.bind.annotation.RestController;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.sql.Date;
-import java.text.SimpleDateFormat;
 import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -31,11 +29,13 @@ import java.util.stream.Collectors;
  * 抽问抽答完成趋势对比接口（PC管理端，美兰4级架构）
  * STATION（安检站）> BRIGADE（大队）> MANAGER（主管）> 班组
  *
- * 返回当前周期的时间序列趋势数据（同 /completion-trend），
- * 同时在每条 series 上附加 yoyRate（同比）和 chainRatio（环比）。
+ * xAxis 为周期标签，每条 series 的 data 为各周期聚合完成数：
+ *   YEAR    → [去年总数, 当年总数]               xAxis: ["2025年","2026年"]
+ *   QUARTER → [去年同季度, 上季度, 当季度]        xAxis: ["2025年第1季度","2025年第4季度","2026年第1季度"]
+ *   MONTH   → [去年同月, 上月, 当月]              xAxis: ["2025年3月","2026年2月","2026年3月"]
  *
- * yoyRate  = (本期总数 - 去年同期总数) / 去年同期总数 × 100
- * chainRatio = (本期总数 - 上期总数) / 上期总数 × 100（仅 QUARTER/MONTH）
+ * 同比 yoyRate   = (当期 - 去年同期) / 去年同期 × 100
+ * 环比 chainRatio = (当期 - 上期)   / 上期     × 100（仅 QUARTER/MONTH）
  */
 @RestController
 @RequestMapping("/v1/cs/app/daily-exam")
@@ -43,6 +43,8 @@ public class DailyExamComparisonController {
 
     private static final Logger log = LoggerFactory.getLogger(DailyExamComparisonController.class);
 
+    private static final String[] QUARTER_NAMES = {"第一", "第二", "第三", "第四"};
+
     @Autowired
     private DailyTaskMapper dailyTaskMapper;
 
@@ -89,23 +91,18 @@ public class DailyExamComparisonController {
                 return HttpResult.success(noShow);
             }
 
-            int curYear = (year != null) ? year : LocalDate.now().getYear();
-            int curQuarter = (quarter != null) ? quarter : ((LocalDate.now().getMonthValue() - 1) / 3 + 1);
-            int curMonth = (month != null) ? month : LocalDate.now().getMonthValue();
-
-            // 当前周期
-            LocalDate[] currentRange = resolveDateRange(dateRangeQueryType, curYear, curQuarter, curMonth);
-            // 去年同期（用于计算同比）
-            LocalDate[] yoyRange = resolveDateRange(dateRangeQueryType, curYear - 1, curQuarter, curMonth);
-            // 上一期（用于计算环比，仅 QUARTER/MONTH）
-            LocalDate[] prevRange = buildPrevRange(dateRangeQueryType, curYear, curQuarter, curMonth);
+            LocalDate today = LocalDate.now();
+            int curYear = (year != null) ? year : today.getYear();
+            int curQuarter = (quarter != null) ? quarter : ((today.getMonthValue() - 1) / 3 + 1);
+            int curMonth = (month != null) ? month : today.getMonthValue();
 
-            boolean byMonth = "YEAR".equals(dateRangeQueryType);
-            List<String> xAxis = buildXAxis(currentRange[0], currentRange[1], byMonth);
+            List<String> xAxis = buildXAxisLabels(dateRangeQueryType, curYear, curQuarter, curMonth);
+            List<LocalDate[]> periods = buildPeriods(dateRangeQueryType, curYear, curQuarter, curMonth);
+            boolean hasChain = !"YEAR".equals(dateRangeQueryType);
 
-            List<Map<String, Object>> series = buildComparisonSeries(
-                    scopeType, scopeId, xAxis, currentRange, yoyRange, prevRange,
-                    byMonth, isStation, isBrigade, isManager, userDeptId, loginUser);
+            List<Map<String, Object>> series = buildSeries(
+                    scopeType, scopeId, xAxis, periods, hasChain,
+                    isStation, isBrigade, isManager, userDeptId, loginUser);
 
             Map<String, Object> result = new LinkedHashMap<>();
             result.put("show", true);
@@ -119,291 +116,275 @@ public class DailyExamComparisonController {
         }
     }
 
+    // -------------------------------------------------------------------------
+    // xAxis 标签
+    // -------------------------------------------------------------------------
+
     /**
-     * 计算上一期日期范围（QUARTER/MONTH）；YEAR 返回 null（无环比）
+     * YEAR    → ["2025年", "2026年"]
+     * QUARTER → ["2025年第1季度", "2025年第4季度", "2026年第1季度"]
+     * MONTH   → ["2025年3月", "2026年2月", "2026年3月"]
      */
-    private LocalDate[] buildPrevRange(String type, int year, int quarter, int month) {
-        if ("YEAR".equals(type)) return null;
-        if ("QUARTER".equals(type)) {
-            int prevQ = quarter - 1;
-            int prevYear = year;
-            if (prevQ < 1) { prevQ = 4; prevYear = year - 1; }
-            return resolveDateRange("QUARTER", prevYear, prevQ, month);
+    private List<String> buildXAxisLabels(String type, int year, int quarter, int month) {
+        List<String> labels = new ArrayList<>();
+        switch (type == null ? "MONTH" : type) {
+            case "YEAR":
+                labels.add((year - 1) + "年");
+                labels.add(year + "年");
+                break;
+            case "QUARTER": {
+                labels.add((year - 1) + "年" + QUARTER_NAMES[quarter - 1] + "季度");
+                int prevQ = quarter - 1, prevYear = year;
+                if (prevQ < 1) { prevQ = 4; prevYear = year - 1; }
+                labels.add(prevYear + "年" + QUARTER_NAMES[prevQ - 1] + "季度");
+                labels.add(year + "年" + QUARTER_NAMES[quarter - 1] + "季度");
+                break;
+            }
+            default: {
+                labels.add((year - 1) + "年" + month + "月");
+                int prevM = month - 1, prevYear = year;
+                if (prevM < 1) { prevM = 12; prevYear = year - 1; }
+                labels.add(prevYear + "年" + prevM + "月");
+                labels.add(year + "年" + month + "月");
+                break;
+            }
         }
-        // MONTH
-        int prevM = month - 1;
-        int prevYear = year;
-        if (prevM < 1) { prevM = 12; prevYear = year - 1; }
-        return resolveDateRange("MONTH", prevYear, quarter, prevM);
+        return labels;
     }
 
+    // -------------------------------------------------------------------------
+    // 周期日期范围
+    // -------------------------------------------------------------------------
+
     /**
-     * 构建 series 列表：每条 series 含当前周期趋势数据 + yoyRate + chainRatio
+     * 返回各周期日期范围（顺序与 xAxis 对应）
+     * YEAR    → [去年全年, 今年全年]           (size=2)
+     * QUARTER → [去年同季度, 上季度, 当季度]    (size=3)
+     * MONTH   → [去年同月, 上月, 当月]          (size=3)
      */
-    private List<Map<String, Object>> buildComparisonSeries(
+    private List<LocalDate[]> buildPeriods(String type, int year, int quarter, int month) {
+        List<LocalDate[]> periods = new ArrayList<>();
+        switch (type == null ? "MONTH" : type) {
+            case "YEAR":
+                periods.add(yearRange(year - 1));
+                periods.add(yearRange(year));
+                break;
+            case "QUARTER": {
+                periods.add(quarterRange(year - 1, quarter));
+                int prevQ = quarter - 1, prevYear = year;
+                if (prevQ < 1) { prevQ = 4; prevYear = year - 1; }
+                periods.add(quarterRange(prevYear, prevQ));
+                periods.add(quarterRange(year, quarter));
+                break;
+            }
+            default: {
+                periods.add(monthRange(year - 1, month));
+                int prevM = month - 1, prevYear = year;
+                if (prevM < 1) { prevM = 12; prevYear = year - 1; }
+                periods.add(monthRange(prevYear, prevM));
+                periods.add(monthRange(year, month));
+                break;
+            }
+        }
+        return periods;
+    }
+
+    private LocalDate[] yearRange(int y) {
+        return new LocalDate[]{LocalDate.of(y, 1, 1), LocalDate.of(y, 12, 31)};
+    }
+
+    private LocalDate[] quarterRange(int y, int q) {
+        LocalDate start = LocalDate.of(y, (q - 1) * 3 + 1, 1);
+        return new LocalDate[]{start, start.plusMonths(3).minusDays(1)};
+    }
+
+    private LocalDate[] monthRange(int y, int m) {
+        LocalDate start = LocalDate.of(y, m, 1);
+        return new LocalDate[]{start, start.withDayOfMonth(start.lengthOfMonth())};
+    }
+
+    // -------------------------------------------------------------------------
+    // series 构建
+    // -------------------------------------------------------------------------
+
+    private List<Map<String, Object>> buildSeries(
             String scopeType, Long scopeId,
-            List<String> xAxis, LocalDate[] currentRange, LocalDate[] yoyRange, LocalDate[] prevRange,
-            boolean byMonth, boolean isStation, boolean isBrigade, boolean isManager,
+            List<String> xAxis, List<LocalDate[]> periods, boolean hasChain,
+            boolean isStation, boolean isBrigade, boolean isManager,
             Long userDeptId, LoginUser loginUser) {
 
+        int currentIdx = periods.size() - 1;
+
         if ("MANAGER".equals(scopeType) && scopeId != null) {
-            List<DailyTask> current = queryTasksByDepartmentId(scopeId, currentRange[0], currentRange[1]);
-            String name = current.stream().map(DailyTask::getDtDepartmentName)
-                    .filter(Objects::nonNull).findFirst().orElse("主管" + scopeId);
-            int yoyCount = countCompleted(queryTasksByDepartmentId(scopeId, yoyRange[0], yoyRange[1]));
-            Integer prevCount = prevRange != null
-                    ? countCompleted(queryTasksByDepartmentId(scopeId, prevRange[0], prevRange[1])) : null;
+            List<Integer> counts = countByPeriods(periods, r -> countCompletedByDepartmentId(scopeId, r[0], r[1]));
             return Collections.singletonList(
-                    buildSeriesItem(name, scopeId, null, xAxis, current, byMonth, yoyCount, prevCount));
+                    buildSeriesItem(getDeptName(scopeId), scopeId, null, counts, currentIdx, hasChain));
 
         } else if ("USER".equals(scopeType) && scopeId != null) {
-            List<DailyTask> current = queryTasksByUserId(scopeId, currentRange[0], currentRange[1]);
-            String name = current.stream().map(DailyTask::getDtUserName)
-                    .filter(Objects::nonNull).findFirst().orElse("用户" + scopeId);
-            int yoyCount = countCompleted(queryTasksByUserId(scopeId, yoyRange[0], yoyRange[1]));
-            Integer prevCount = prevRange != null
-                    ? countCompleted(queryTasksByUserId(scopeId, prevRange[0], prevRange[1])) : null;
+            List<Integer> counts = countByPeriods(periods, r -> countCompletedByUserId(scopeId, r[0], r[1]));
             return Collections.singletonList(
-                    buildSeriesItem(name, null, scopeId, xAxis, current, byMonth, yoyCount, prevCount));
+                    buildSeriesItem("用户" + scopeId, null, scopeId, counts, currentIdx, hasChain));
 
         } else if ("BRIGADE".equals(scopeType) && scopeId != null) {
-            return buildBrigadeSeries(scopeId, xAxis, currentRange, yoyRange, prevRange, byMonth);
+            return buildBrigadeSeriesList(scopeId, periods, hasChain, currentIdx);
 
         } else {
             Long stationDeptId = ("STATION".equals(scopeType) && scopeId != null) ? scopeId : userDeptId;
             if (isStation || "STATION".equals(scopeType)) {
-                return buildStationSeries(stationDeptId, xAxis, currentRange, yoyRange, prevRange, byMonth);
+                return buildStationSeriesList(stationDeptId, periods, hasChain, currentIdx);
             } else if (isBrigade) {
-                return buildBrigadeSeries(userDeptId, xAxis, currentRange, yoyRange, prevRange, byMonth);
+                return buildBrigadeSeriesList(userDeptId, periods, hasChain, currentIdx);
             } else {
-                // 主管：单条 series
+                // 主管：本主管室单条 series
                 String deptName = loginUser.getUser().getDept() != null
                         ? loginUser.getUser().getDept().getDeptName() : "本主管";
-                List<DailyTask> current = queryTasksByDepartmentId(userDeptId, currentRange[0], currentRange[1]);
-                int yoyCount = countCompleted(queryTasksByDepartmentId(userDeptId, yoyRange[0], yoyRange[1]));
-                Integer prevCount = prevRange != null
-                        ? countCompleted(queryTasksByDepartmentId(userDeptId, prevRange[0], prevRange[1])) : null;
+                List<Integer> counts = countByPeriods(periods,
+                        r -> countCompletedByDepartmentId(userDeptId, r[0], r[1]));
                 return Collections.singletonList(
-                        buildSeriesItem(deptName, userDeptId, null, xAxis, current, byMonth, yoyCount, prevCount));
+                        buildSeriesItem(deptName, userDeptId, null, counts, currentIdx, hasChain));
             }
         }
     }
 
     /**
-     * 站长视角：按大队分组，各大队各一条 series + 全站汇总
+     * 站长视角：各大队独立 series + 全站汇总
      */
-    private List<Map<String, Object>> buildStationSeries(Long stationDeptId,
-                                                          List<String> xAxis,
-                                                          LocalDate[] currentRange,
-                                                          LocalDate[] yoyRange,
-                                                          LocalDate[] prevRange,
-                                                          boolean byMonth) {
+    private List<Map<String, Object>> buildStationSeriesList(
+            Long stationDeptId, List<LocalDate[]> periods, boolean hasChain, int currentIdx) {
+
         List<SysDept> subDepts = sysDeptMapper.selectChildrenDeptById(stationDeptId);
         if (subDepts == null) subDepts = Collections.emptyList();
-
-        // 大队（站的直接下级）
-        List<SysDept> brigadeDepts = subDepts.stream()
+        List<SysDept> brigades = subDepts.stream()
                 .filter(d -> stationDeptId.equals(d.getParentId()) && "0".equals(d.getDelFlag()))
                 .collect(Collectors.toList());
 
         List<Map<String, Object>> series = new ArrayList<>();
-        List<DailyTask> stationCurrentAll = new ArrayList<>();
-        int stationYoyTotal = 0;
-        int stationPrevTotal = 0;
-
-        for (SysDept brigade : brigadeDepts) {
-            List<DailyTask> current = queryTasksByBrigadeId(brigade.getDeptId(), currentRange[0], currentRange[1]);
-            int yoyCount = countCompletedByBrigadeId(brigade.getDeptId(), yoyRange[0], yoyRange[1]);
-            int prevCount = prevRange != null
-                    ? countCompletedByBrigadeId(brigade.getDeptId(), prevRange[0], prevRange[1]) : 0;
-
-            stationCurrentAll.addAll(current);
-            stationYoyTotal += yoyCount;
-            stationPrevTotal += prevCount;
-
-            series.add(buildSeriesItem(brigade.getDeptName(), brigade.getDeptId(), null,
-                    xAxis, current, byMonth, yoyCount, prevRange != null ? prevCount : null));
+        int[] stationTotals = new int[periods.size()];
+
+        for (SysDept brigade : brigades) {
+            List<Integer> counts = countByPeriods(periods,
+                    r -> countCompletedByBrigadeId(brigade.getDeptId(), r[0], r[1]));
+            for (int i = 0; i < counts.size(); i++) stationTotals[i] += counts.get(i);
+            series.add(buildSeriesItem(brigade.getDeptName(), brigade.getDeptId(), null, counts, currentIdx, hasChain));
         }
 
-        // 全站汇总 series
-        int finalYoyTotal = stationYoyTotal;
-        Integer finalPrevTotal = prevRange != null ? stationPrevTotal : null;
-        series.add(buildSeriesItem("全站", null, null, xAxis, stationCurrentAll, byMonth,
-                finalYoyTotal, finalPrevTotal));
+        List<Integer> totalCounts = new ArrayList<>();
+        for (int c : stationTotals) totalCounts.add(c);
+        series.add(buildSeriesItem("全站", null, null, totalCounts, currentIdx, hasChain));
         return series;
     }
 
     /**
-     * 大队视角：按主管分组，各主管各一条 series
+     * 大队视角：各主管独立 series
      */
-    private List<Map<String, Object>> buildBrigadeSeries(Long brigadeId,
-                                                          List<String> xAxis,
-                                                          LocalDate[] currentRange,
-                                                          LocalDate[] yoyRange,
-                                                          LocalDate[] prevRange,
-                                                          boolean byMonth) {
+    private List<Map<String, Object>> buildBrigadeSeriesList(
+            Long brigadeId, List<LocalDate[]> periods, boolean hasChain, int currentIdx) {
+
         List<SysDept> subDepts = sysDeptMapper.selectChildrenDeptById(brigadeId);
         if (subDepts == null) subDepts = Collections.emptyList();
-
-        List<SysDept> managerDepts = subDepts.stream()
+        List<SysDept> managers = subDepts.stream()
                 .filter(d -> brigadeId.equals(d.getParentId()) && "0".equals(d.getDelFlag()))
                 .collect(Collectors.toList());
 
         List<Map<String, Object>> series = new ArrayList<>();
-        for (SysDept manager : managerDepts) {
-            List<DailyTask> current = queryTasksByDepartmentId(manager.getDeptId(), currentRange[0], currentRange[1]);
-            int yoyCount = countCompleted(queryTasksByDepartmentId(manager.getDeptId(), yoyRange[0], yoyRange[1]));
-            Integer prevCount = prevRange != null
-                    ? countCompleted(queryTasksByDepartmentId(manager.getDeptId(), prevRange[0], prevRange[1])) : null;
-            series.add(buildSeriesItem(manager.getDeptName(), manager.getDeptId(), null,
-                    xAxis, current, byMonth, yoyCount, prevCount));
+        for (SysDept manager : managers) {
+            List<Integer> counts = countByPeriods(periods,
+                    r -> countCompletedByDepartmentId(manager.getDeptId(), r[0], r[1]));
+            series.add(buildSeriesItem(manager.getDeptName(), manager.getDeptId(), null, counts, currentIdx, hasChain));
         }
         return series;
     }
 
+    // -------------------------------------------------------------------------
+    // series item 构建
+    // -------------------------------------------------------------------------
+
     /**
-     * 构建单条 series：趋势数据来自当前周期，yoyRate/chainRatio 由聚合总数计算
+     * 构建单条 series
+     *
+     * @param counts     各周期完成数，顺序与 xAxis 对应
+     * @param currentIdx 当期在 counts 中的下标（最后一个）
+     * @param hasChain   是否计算环比
      */
     private Map<String, Object> buildSeriesItem(String name, Long deptId, Long userId,
-                                                 List<String> xAxis, List<DailyTask> currentTasks,
-                                                 boolean byMonth, int yoyBaseCount, Integer prevCount) {
-        List<Integer> data = buildSeriesData(xAxis, currentTasks, byMonth);
-        int currentTotal = data.stream().mapToInt(Integer::intValue).sum();
+                                                 List<Integer> counts, int currentIdx, boolean hasChain) {
+        int currentVal = counts.get(currentIdx);
+        int yoyVal = counts.get(0);
+        Integer prevVal = hasChain ? counts.get(1) : null;
 
         Map<String, Object> s = new LinkedHashMap<>();
         s.put("name", name);
         if (deptId != null) s.put("deptId", deptId);
         if (userId != null) s.put("userId", userId);
-        s.put("data", data);
-        s.put("yoyRate", calcRate(currentTotal, yoyBaseCount));
-        s.put("chainRatio", prevCount != null ? calcRate(currentTotal, prevCount) : null);
+        s.put("data", counts);
+        s.put("yoyRate", calcRate(currentVal, yoyVal));
+        s.put("chainRatio", prevVal != null ? calcRate(currentVal, prevVal) : null);
         return s;
     }
 
-    /**
-     * 将任务列表按时间维度汇聚，对齐到 xAxis
-     */
-    private List<Integer> buildSeriesData(List<String> xAxis, List<DailyTask> tasks, boolean byMonth) {
-        SimpleDateFormat sdf = new SimpleDateFormat(byMonth ? "yyyy-MM" : "yyyy-MM-dd");
-        Map<String, Long> countMap = tasks.stream()
-                .filter(t -> "COMPLETED".equals(t.getDtStatus()) && t.getDtBusinessDate() != null)
-                .collect(Collectors.groupingBy(
-                        t -> sdf.format(t.getDtBusinessDate()),
-                        Collectors.counting()));
-        List<Integer> result = new ArrayList<>();
-        for (String label : xAxis) {
-            result.add(countMap.getOrDefault(label, 0L).intValue());
-        }
-        return result;
+    // -------------------------------------------------------------------------
+    // 统计辅助
+    // -------------------------------------------------------------------------
+
+    @FunctionalInterface
+    interface PeriodCounter {
+        int count(LocalDate[] range);
     }
 
-    /**
-     * 生成 X 轴标签：YEAR→每月(yyyy-MM)；QUARTER/MONTH→每天(yyyy-MM-dd)
-     */
-    private List<String> buildXAxis(LocalDate start, LocalDate end, boolean byMonth) {
-        List<String> xAxis = new ArrayList<>();
-        if (byMonth) {
-            LocalDate cursor = start.withDayOfMonth(1);
-            LocalDate endMonth = end.withDayOfMonth(1);
-            while (!cursor.isAfter(endMonth)) {
-                xAxis.add(cursor.format(DateTimeFormatter.ofPattern("yyyy-MM")));
-                cursor = cursor.plusMonths(1);
-            }
-        } else {
-            LocalDate cursor = start;
-            while (!cursor.isAfter(end)) {
-                xAxis.add(cursor.toString());
-                cursor = cursor.plusDays(1);
-            }
+    private List<Integer> countByPeriods(List<LocalDate[]> periods, PeriodCounter counter) {
+        List<Integer> result = new ArrayList<>();
+        for (LocalDate[] range : periods) {
+            result.add(counter.count(range));
         }
-        return xAxis;
+        return result;
     }
 
-    /**
-     * 计算变化率百分比；base=0 时返回 null
-     */
-    private BigDecimal calcRate(int current, int base) {
-        if (base == 0) return null;
-        return BigDecimal.valueOf(current - base)
-                .multiply(BigDecimal.valueOf(100))
-                .divide(BigDecimal.valueOf(base), 2, RoundingMode.HALF_UP);
+    private int countCompletedByDepartmentId(Long deptId, LocalDate start, LocalDate end) {
+        LambdaQueryWrapper<DailyTask> w = new LambdaQueryWrapper<>();
+        w.eq(DailyTask::getDtDepartmentId, deptId);
+        w.eq(DailyTask::getDtStatus, "COMPLETED");
+        w.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
+        w.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
+        w.eq(DailyTask::getDelStatus, 0);
+        return Math.toIntExact(dailyTaskMapper.selectCount(w));
     }
 
-    private int countCompleted(List<DailyTask> tasks) {
-        return (int) tasks.stream().filter(t -> "COMPLETED".equals(t.getDtStatus())).count();
+    private int countCompletedByUserId(Long userId, LocalDate start, LocalDate end) {
+        LambdaQueryWrapper<DailyTask> w = new LambdaQueryWrapper<>();
+        w.eq(DailyTask::getDtUserId, userId);
+        w.eq(DailyTask::getDtStatus, "COMPLETED");
+        w.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
+        w.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
+        w.eq(DailyTask::getDelStatus, 0);
+        return Math.toIntExact(dailyTaskMapper.selectCount(w));
     }
 
-    /**
-     * 查询大队下所有主管的任务（通过大队子部门的 dtDepartmentId）
-     */
-    private List<DailyTask> queryTasksByBrigadeId(Long brigadeId, LocalDate start, LocalDate end) {
+    private int countCompletedByBrigadeId(Long brigadeId, LocalDate start, LocalDate end) {
         List<SysDept> subDepts = sysDeptMapper.selectChildrenDeptById(brigadeId);
         if (subDepts == null) subDepts = Collections.emptyList();
         Set<Long> managerIds = subDepts.stream()
                 .filter(d -> brigadeId.equals(d.getParentId()) && "0".equals(d.getDelFlag()))
                 .map(SysDept::getDeptId)
                 .collect(Collectors.toSet());
-        if (managerIds.isEmpty()) return Collections.emptyList();
-        LambdaQueryWrapper<DailyTask> wrapper = new LambdaQueryWrapper<>();
-        wrapper.in(DailyTask::getDtDepartmentId, managerIds);
-        wrapper.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
-        wrapper.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
-        wrapper.eq(DailyTask::getDelStatus, 0);
-        return dailyTaskMapper.selectList(wrapper);
+        if (managerIds.isEmpty()) return 0;
+        LambdaQueryWrapper<DailyTask> w = new LambdaQueryWrapper<>();
+        w.in(DailyTask::getDtDepartmentId, managerIds);
+        w.eq(DailyTask::getDtStatus, "COMPLETED");
+        w.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
+        w.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
+        w.eq(DailyTask::getDelStatus, 0);
+        return Math.toIntExact(dailyTaskMapper.selectCount(w));
     }
 
-    private int countCompletedByBrigadeId(Long brigadeId, LocalDate start, LocalDate end) {
-        return countCompleted(queryTasksByBrigadeId(brigadeId, start, end));
-    }
-
-    private LocalDate[] resolveDateRange(String type, Integer year, Integer quarter, Integer month) {
-        LocalDate today = LocalDate.now();
-        int y = (year != null) ? year : today.getYear();
-        LocalDate start, end;
-        switch (type == null ? "MONTH" : type) {
-            case "YEAR":
-                start = LocalDate.of(y, 1, 1);
-                end = LocalDate.of(y, 12, 31);
-                break;
-            case "QUARTER":
-                int q = (quarter != null) ? quarter : 1;
-                start = LocalDate.of(y, (q - 1) * 3 + 1, 1);
-                end = start.plusMonths(3).minusDays(1);
-                break;
-            case "MONTH":
-            default:
-                int m = (month != null) ? month : today.getMonthValue();
-                start = LocalDate.of(y, m, 1);
-                end = start.withDayOfMonth(start.lengthOfMonth());
-                break;
-        }
-        return new LocalDate[]{start, end};
+    private String getDeptName(Long deptId) {
+        SysDept dept = sysDeptMapper.selectById(deptId);
+        return dept != null ? dept.getDeptName() : "部门" + deptId;
     }
 
-    private List<DailyTask> queryTasksByDeptIds(Set<Long> deptIds, LocalDate start, LocalDate end) {
-        LambdaQueryWrapper<DailyTask> wrapper = new LambdaQueryWrapper<>();
-        wrapper.in(DailyTask::getDtDeptId, deptIds);
-        wrapper.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
-        wrapper.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
-        wrapper.eq(DailyTask::getDelStatus, 0);
-        return dailyTaskMapper.selectList(wrapper);
-    }
-
-    private List<DailyTask> queryTasksByDepartmentId(Long departmentId, LocalDate start, LocalDate end) {
-        LambdaQueryWrapper<DailyTask> wrapper = new LambdaQueryWrapper<>();
-        wrapper.eq(DailyTask::getDtDepartmentId, departmentId);
-        wrapper.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
-        wrapper.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
-        wrapper.eq(DailyTask::getDelStatus, 0);
-        return dailyTaskMapper.selectList(wrapper);
-    }
-
-    private List<DailyTask> queryTasksByUserId(Long userId, LocalDate start, LocalDate end) {
-        LambdaQueryWrapper<DailyTask> wrapper = new LambdaQueryWrapper<>();
-        wrapper.eq(DailyTask::getDtUserId, userId);
-        wrapper.ge(DailyTask::getDtBusinessDate, Date.valueOf(start));
-        wrapper.le(DailyTask::getDtBusinessDate, Date.valueOf(end));
-        wrapper.eq(DailyTask::getDelStatus, 0);
-        return dailyTaskMapper.selectList(wrapper);
+    private BigDecimal calcRate(int current, int base) {
+        if (base == 0) return null;
+        return BigDecimal.valueOf(current - base)
+                .multiply(BigDecimal.valueOf(100))
+                .divide(BigDecimal.valueOf(base), 2, RoundingMode.HALF_UP);
     }
 }