明星电力充电桩
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
longz
2026-08-05 5121ec0181a05bcb46fdcb82551a0d38dfdfe346 
 ruoyi-service/ruoyi-order/src/main/java/com/ruoyi/order/controller/TChargingOrderController.java


@@ -58,6 +58,7 @@


import com.ruoyi.order.dto.MyChargingOrderList;


import com.ruoyi.order.dto.OrderEvaluateVo;


import com.ruoyi.order.dto.*;


import com.ruoyi.order.mapper.TChargingOrderMapper;


import com.ruoyi.order.export.PayOrderExport;


import com.ruoyi.order.export.EnterpriseChargingDetailExport;


import com.ruoyi.order.service.*;


@@ -102,6 +103,9 @@


import java.time.format.DateTimeFormatter;


import java.util.*;


import java.util.List;


import java.util.concurrent.CompletableFuture;


import java.util.concurrent.ExecutorService;


import java.util.concurrent.Executors;


import java.util.stream.Collectors;




import com.ruoyi.common.core.utils.DateUtils;


@@ -195,54 +199,89 @@


    @Resource


    private SysUserRoleClient sysUserRoleClient;




    @Resource


    private TChargingOrderMapper chargingOrderMapper;




    /** 尖峰平谷反查分块 id 上限：MyCat/druid 对 IN 列表的解析路由成本随 id 数非线性增长


     *  （实测 500 个约 5s、5000 个 70s+ 触发读超时；100 个内约 0.2s/块，约 2ms/个）。 */


    private static final int PHASE_ID_BATCH_SIZE = 100;


    /** 尖峰平谷分块反查并发度：46k id 实测 ~20s，典型加盟商 <3s（串行 5000/块 >70s 读超时）。 */


    private static final ExecutorService PHASE_QUERY_EXECUTOR = Executors.newFixedThreadPool(16);




    @GetMapping("/reservationRecommendation")


    @ApiOperation(value = "获取站点预约充电推荐时段", tags = {"管理后台-充电桩信息"})


    public R<ReservationRecommendationVO> getReservationRecommendation(@RequestParam Integer siteId) {


        return R.ok(chargingOrderService.getReservationRecommendation(siteId));


    }




    /** 小程序加盟商看板：站点范围始终从登录账号绑定关系解析。 */


    /** 小程序加盟商看板：站点范围始终从登录账号绑定关系解析。聚合查询下推到分片，避免全量拉订单。 */


    @PostMapping("/app/franchisee/charge-data")


    public R<Map<String, Object>> franchiseeChargeData(@RequestBody(required = false) Map<String, Object> params) {


        List<TChargingOrder> orders = franchiseeOrders(params);


        List<Integer> siteIds = franchiseeSiteIds(params);


        LocalDateTime[] range = franchiseeRange(params);


        List<FranchiseeDayStat> dayStats = franchiseeDayStats(siteIds, range);


        Map<String, Object> summary = new LinkedHashMap<>();


        summary.put("orderAmountWan", sum(orders, TChargingOrder::getOrderAmount).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));


        summary.put("serviceFeeWan", sum(orders, TChargingOrder::getServiceCharge).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));


        summary.put("chargingPowerWan", sum(orders, TChargingOrder::getChargingCapacity).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));


        summary.put("chargingAmount", sum(orders, TChargingOrder::getPaymentAmount));


        summary.put("chargingOrderCount", orders.size());


        summary.put("powerUtilizationRate", observedPowerUtilization(orders));


        summary.put("demandPowerSatisfactionRate", demandPowerSatisfaction(orders));


        summary.put("orderAmountWan", sum(dayStats, FranchiseeDayStat::getOrderAmount).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));


        summary.put("serviceFeeWan", sum(dayStats, FranchiseeDayStat::getServiceFee).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));


        summary.put("chargingPowerWan", sum(dayStats, FranchiseeDayStat::getCapacity).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));


        summary.put("chargingAmount", sum(dayStats, FranchiseeDayStat::getOrderAmountEffective));


        summary.put("chargingOrderCount", dayStats.stream().mapToLong(stat -> numberValue(stat.getOrderCount())).sum());


        summary.put("powerUtilizationRate", observedPowerUtilization(dayStats));


        summary.put("demandPowerSatisfactionRate", demandPowerSatisfaction(dayStats));


        Map<String, Object> result = new LinkedHashMap<>();


        result.put("summary", summary);


        result.put("keyDataLine", franchiseeDailyTrend(orders, range, "订单金额", order -> firstNonNull(order.getOrderAmount(), order.getPaymentAmount())));


        result.put("keyDataRing", franchiseePhaseRing(orders));


        result.put("orderStats", franchiseeOrderTrend(orders, range));


        result.put("efficiency", franchiseeEfficiencyTrend(orders, range));


        result.put("powerDistribution", franchiseePowerDistribution(orders));


        result.put("keyDataLine", franchiseeDailyTrend(dayStats, range, "订单金额", FranchiseeDayStat::getOrderAmountEffective));


        result.put("keyDataRing", franchiseePhaseRing(siteIds, range));


        result.put("orderStats", franchiseeOrderTrend(dayStats, range));


        result.put("efficiency", franchiseeEfficiencyTrend(dayStats, range));


        result.put("powerDistribution", franchiseePowerDistribution(siteIds, range));


        return R.ok(result);


    }




    @PostMapping("/app/franchisee/income")


    public R<Map<String, Object>> franchiseeIncome(@RequestBody(required = false) Map<String, Object> params) {


        List<Integer> siteIds = franchiseeSiteIds(params);


        LocalDate firstMonth = YearMonth.now().minusMonths(5).atDay(1);


        LocalDate nextMonth = YearMonth.now().plusMonths(1).atDay(1);


        List<TChargingOrder> orders = franchiseeOrders(siteIds, firstMonth.atStartOfDay(), nextMonth.atStartOfDay());


        List<SixChargingDto> sixChargingDtos;


        if (siteIds.isEmpty()) {


            // 无授权站点：返回近6月全零骨架，避免空 IN 导致全站点统计


            sixChargingDtos = generateLastSixMonths(LocalDate.now());


        } else {


            // 与后台 数据分析-平台总收入分析 电站收入分析口径一致：历史月读结算账单、当月补原始订单


            LocalDate sixBefore = PreviousSixMonths.get();


            List<SixChargingDto> chargingDtos = chargingOrderService.charge(sixBefore, siteIds, false);


            LocalDate statisticsEndMonth = resolveStatisticsEndMonth(LocalDate.now(), chargingDtos);


            sixChargingDtos = generateLastSixMonths(statisticsEndMonth);


            for (SixChargingDto sixChargingDto : sixChargingDtos) {


                for (SixChargingDto chargingDto : chargingDtos) {


                    if (sixChargingDto.getMonth().equals(chargingDto.getMonth())) {


                        BeanUtils.copyProperties(chargingDto, sixChargingDto);


                    }


                }


            }


        }


        BigDecimal electricity = sixChargingDtos.stream()


                .filter(Objects::nonNull)


                .map(SixChargingDto::getElectrovalence)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        BigDecimal service = sixChargingDtos.stream()


                .filter(Objects::nonNull)


                .map(SixChargingDto::getServiceCharge)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add);


        Map<String, Object> result = new LinkedHashMap<>();


        result.put("totalIncome", sum(orders, TChargingOrder::getPaymentAmount));


        result.put("electricityFee", sum(orders, TChargingOrder::getElectrovalence));


        result.put("serviceFee", sum(orders, TChargingOrder::getServiceCharge));


        result.put("incomeColumn", franchiseeIncomeTrend(orders, firstMonth, 6));


        result.put("totalIncome", electricity.add(service));


        result.put("electricityFee", electricity);


        result.put("serviceFee", service);


        result.put("incomeColumn", franchiseeIncomeTrendFromSix(sixChargingDtos));


        List<Map<String, Object>> incomePie = new ArrayList<>();


        Map<String, Object> electricityItem = new LinkedHashMap<>();


        electricityItem.put("name", "充电费");


        electricityItem.put("value", sum(orders, TChargingOrder::getElectrovalence));


        electricityItem.put("value", electricity);


        incomePie.add(electricityItem);


        Map<String, Object> serviceItem = new LinkedHashMap<>();


        serviceItem.put("name", "服务费");


        serviceItem.put("value", sum(orders, TChargingOrder::getServiceCharge));


        serviceItem.put("value", service);


        incomePie.add(serviceItem);


        result.put("incomePie", incomePie);


        return R.ok(result);


@@ -253,10 +292,14 @@


        Partner partner = franchiseePartner();


        List<Integer> siteIds = partner == null ? Collections.emptyList() : franchiseeSiteIds(params, partner.getId());


        LocalDateTime[] range = franchiseeRange(params);


        List<TChargingOrder> orders = franchiseeOrders(siteIds, range[0], range[1]).stream()


                .filter(order -> Objects.equals(order.getStatus(), 5))


                .collect(Collectors.toList());


        Set<Long> users = orders.stream().map(TChargingOrder::getAppUserId).filter(Objects::nonNull).collect(Collectors.toSet());


        List<FranchiseeUserAgg> aggs = franchiseeUserAggs(siteIds, range);


        Map<LocalDate, Set<Long>> chargingUsersByDay = new LinkedHashMap<>();


        for (FranchiseeUserAgg agg : aggs) {


            if (agg == null || agg.getAppUserId() == null || agg.getStatDay() == null) {


                continue;


            }


            chargingUsersByDay.computeIfAbsent(agg.getStatDay(), key -> new HashSet<>()).add(agg.getAppUserId());


        }


        List<TPartnerAppUser> relations = Collections.emptyList();


        if (partner != null && partner.getId() != null) {


            R<List<TPartnerAppUser>> relationResult = partnerClient.getBoundAppUserRelations(partner.getId());


@@ -264,9 +307,10 @@


                relations = relationResult.getData();


            }


        }


        FranchiseeUserStatistics.Result userStatistics = FranchiseeUserStatistics.calculate(


                orders, relations, range[0], range[1]);


        FranchiseeUserStatistics.Result userStatistics = FranchiseeUserStatistics.calculateByUserDays(


                chargingUsersByDay, relations, range[0], range[1]);




        Set<Long> users = aggs.stream().map(FranchiseeUserAgg::getAppUserId).filter(Objects::nonNull).collect(Collectors.toSet());


        List<TAppUser> appUsers = Collections.emptyList();


        if (!users.isEmpty()) {


            R<List<TAppUser>> userResult = appUserClient.getUserByIds(new ArrayList<>(users));


@@ -275,7 +319,7 @@


        Map<Long, TAppUser> userMap = appUsers.stream().filter(user -> user.getId() != null)


                .collect(Collectors.toMap(TAppUser::getId, user -> user, (left, right) -> left));




        List<Long> carIds = orders.stream().map(TChargingOrder::getAppUserCarId).filter(Objects::nonNull).distinct().collect(Collectors.toList());


        List<Long> carIds = aggs.stream().map(FranchiseeUserAgg::getAppUserCarId).filter(Objects::nonNull).distinct().collect(Collectors.toList());


        List<TAppUserCar> cars = Collections.emptyList();


        if (!carIds.isEmpty()) {


            R<List<TAppUserCar>> carResult = appUserCarClient.getCarByIds(carIds);


@@ -286,18 +330,18 @@


        Map<String, Object> result = new LinkedHashMap<>();


        result.put("summary", userStatistics.getSummary());


        result.put("userStats", userStatistics.getTrend());


        result.put("userTags", franchiseeUserTags(orders));


        result.put("userTags", franchiseeUserTags(aggs));


        Map<Integer, String> vipNames = new HashMap<>();


        R<List<TVip>> vipResult = vipClient.getAllVip();


        if (vipResult != null && vipResult.getData() != null) vipResult.getData().forEach(vip -> vipNames.put(vip.getId(), vip.getName()));


        result.put("memberType", franchiseeMemberTypes(appUsers, vipNames));


        result.put("corpRank", franchiseeCompanyRank(orders, userMap));


        result.put("corpRank", franchiseeCompanyRank(aggs, userMap));


        result.put("evaluation", evaluation.get("summary"));


        result.put("goodTags", evaluation.get("goodTags"));


        result.put("badTags", evaluation.get("badTags"));


        result.put("traffic", franchiseeTraffic(orders));


        result.put("vehicleClass", franchiseeOrderCarGroup(orders, cars, TAppUserCar::getVehicleUse, "未知用途", 5));


        result.put("vehicleBrand", franchiseeOrderCarGroup(orders, cars, TAppUserCar::getVehicleBrand, "其他", 5));


        result.put("traffic", franchiseeTraffic(siteIds, range));


        result.put("vehicleClass", franchiseeOrderCarGroup(aggs, cars, TAppUserCar::getVehicleUse, "未知用途", 5));


        result.put("vehicleBrand", franchiseeOrderCarGroup(aggs, cars, TAppUserCar::getVehicleBrand, "其他", 5));


        return R.ok(result);


    }




@@ -305,38 +349,93 @@


    public R<Map<String, Object>> franchiseeOperation(@RequestBody(required = false) Map<String, Object> params) {


        Map<String, Object> result = new LinkedHashMap<>();


        List<Integer> siteIds = franchiseeSiteIds(params);


        List<TChargingPile> piles = Collections.emptyList();


        if (!siteIds.isEmpty()) { R<List<TChargingPile>> pileResult = chargingPileClient.getChargingPileBySiteIds(siteIds); if (pileResult != null && pileResult.getData() != null) piles = pileResult.getData(); }


        List<TChargingGun> guns = Collections.emptyList();


        List<Integer> pileIds = piles.stream().map(TChargingPile::getId).filter(Objects::nonNull).collect(Collectors.toList());


        if (!pileIds.isEmpty()) {


            GetChargingGunByChargingPileIdsVo query = new GetChargingGunByChargingPileIdsVo(); query.setChargingPileIds(pileIds);


            R<List<TChargingGun>> gunResult = chargingGunClient.getChargingGunByChargingPileIds(query);


            if (gunResult != null && gunResult.getData() != null) guns = gunResult.getData();


        LocalDateTime[] range = franchiseeRange(params);


        ChargingStatisticsQueryDto query = new ChargingStatisticsQueryDto();


        String dateType = params == null ? "today" : String.valueOf(params.getOrDefault("dateType", "today"));


        int dayType = "week".equals(dateType) ? 2 : "month".equals(dateType) ? 3 : "year".equals(dateType) ? 4 : "custom".equals(dateType) ? 5 : 1;


        query.setDayType(dayType);


        if (dayType == 5) {


            query.setStartTime(range[0].toLocalDate());


            query.setEndTime(range[1].toLocalDate().minusDays(1));


        }


        BigDecimal total = BigDecimal.valueOf(guns.size());


        BigDecimal available = BigDecimal.valueOf(guns.stream().filter(this::isAvailableGun).count());


        BigDecimal fault = countGuns(guns, 7), offline = countGuns(guns, 1);


        List<TChargingOrder> operationOrders = franchiseeOrders(params);


        BigDecimal powerSatisfaction = demandPowerSatisfaction(operationOrders);


        Map<String, Object> summary = new LinkedHashMap<>(); summary.put("availableRate", rate(available, total)); summary.put("faultRate", rate(fault, total)); summary.put("offlineRate", rate(offline, total)); summary.put("powerSatisfactionRate", powerSatisfaction);


        result.put("summary", summary); result.put("dcCharts", operationCharts(guns, operationOrders, true)); result.put("acCharts", operationCharts(guns, operationOrders, false));




        List<Map<String, Object>> dcAvailable = safeList(chargingOrderService.equipmentUserType1(siteIds, query));


        List<Map<String, Object>> acAvailable = safeList(chargingOrderService.equipmentUserType2(siteIds, query));


        List<Map<String, Object>> dcFault = safeList(chargingOrderService.equipmentMapbroke1(siteIds, query));


        List<Map<String, Object>> acFault = safeList(chargingOrderService.equipmentMapbroke2(siteIds, query));


        List<Map<String, Object>> dcOffline = safeList(chargingOrderService.equipmentMapOut1(siteIds, query));


        List<Map<String, Object>> acOffline = safeList(chargingOrderService.equipmentMapOut2(siteIds, query));


        List<Map<String, Object>> dcSatisfaction = safeList(chargingOrderService.needElec(siteIds, query));


        List<Map<String, Object>> acSatisfaction = safeList(chargingOrderService.needElec1(siteIds, query));


        normalizeOperationPercents(dcAvailable);


        normalizeOperationPercents(acAvailable);


        normalizeOperationPercents(dcFault);


        normalizeOperationPercents(acFault);


        normalizeOperationPercents(dcOffline);


        normalizeOperationPercents(acOffline);


        normalizeOperationPercents(dcSatisfaction);


        normalizeOperationPercents(acSatisfaction);




        Map<String, Object> summary = new LinkedHashMap<>();


        summary.put("availableRate", calculateAveragePercent(dcAvailable, acAvailable));


        summary.put("faultRate", calculateAveragePercent(dcFault, acFault));


        summary.put("offlineRate", calculateAveragePercent(dcOffline, acOffline));


        summary.put("powerSatisfactionRate", calculateAveragePercent(dcSatisfaction, acSatisfaction));


        result.put("summary", summary);


        result.put("dcCharts", Arrays.asList(


                operationChart(dcAvailable, "可用率"),


                operationChart(dcFault, "故障率"),


                operationChart(dcOffline, "离网率"),


                operationChart(dcSatisfaction, "需求电流满足率")));


        result.put("acCharts", Arrays.asList(


                operationChart(acAvailable, "可用率"),


                operationChart(acFault, "故障率"),


                operationChart(acOffline, "离网率"),


                operationChart(acSatisfaction, "需求电流满足率")));


        return R.ok(result);


    }




    private List<TChargingOrder> franchiseeOrders(Map<String, Object> params) {


        List<Integer> siteIds = franchiseeSiteIds(params);


        if (siteIds.isEmpty()) return Collections.emptyList();


        LocalDateTime[] range = franchiseeRange(params);


        return franchiseeOrders(siteIds, range[0], range[1]);


    private Map<String, Object> operationChart(List<Map<String, Object>> rows, String name) {


        List<String> categories = rows.stream().map(row -> {


            String gunName = row.get("name") == null ? "" : String.valueOf(row.get("name"));


            return StringUtils.isBlank(gunName) ? "未命名充电枪" : gunName;


        }).collect(Collectors.toList());


        List<Object> values = rows.stream().map(row -> row.getOrDefault("percent", "0")).collect(Collectors.toList());


        Map<String, Object> chart = new LinkedHashMap<>();


        chart.put("categories", categories);


        Map<String, Object> series = new LinkedHashMap<>();


        series.put("name", name);


        series.put("data", values);


        chart.put("series", Collections.singletonList(series));


        return chart;


    }




    private List<TChargingOrder> franchiseeOrders(List<Integer> siteIds, LocalDateTime start, LocalDateTime end) {


        if (siteIds == null || siteIds.isEmpty()) return Collections.emptyList();


        LambdaQueryWrapper<TChargingOrder> query = Wrappers.lambdaQuery(TChargingOrder.class).in(TChargingOrder::getSiteId, siteIds).eq(TChargingOrder::getDelFlag, 0).eq(TChargingOrder::getRechargePaymentStatus, 2);


        if (start != null) query.ge(TChargingOrder::getEndTime, start);


        if (end != null) query.lt(TChargingOrder::getEndTime, end);


        return chargingOrderService.list(query);


    private void normalizeOperationPercents(List<Map<String, Object>> rows) {


        for (Map<String, Object> row : rows) {


            Object raw = row.get("percent");


            try {


                BigDecimal percent = raw == null ? BigDecimal.ZERO : new BigDecimal(String.valueOf(raw));


                row.put("percent", percent.abs().toPlainString());


            } catch (NumberFormatException ignored) {


                row.put("percent", "0");


            }


        }


    }




    /** 加盟商看板按日聚合（siteIds 为空直接返回空，避免空 IN）。 */


    private List<FranchiseeDayStat> franchiseeDayStats(List<Integer> siteIds, LocalDateTime[] range) {


        if (siteIds == null || siteIds.isEmpty() || range == null || range[0] == null || range[1] == null) {


            return Collections.emptyList();


        }


        return chargingOrderMapper.franchiseeDayStats(siteIds, range[0], range[1]);


    }




    /** 加盟商看板用户维度聚合（仅已结束订单；siteIds 为空直接返回空）。 */


    private List<FranchiseeUserAgg> franchiseeUserAggs(List<Integer> siteIds, LocalDateTime[] range) {


        if (siteIds == null || siteIds.isEmpty() || range == null || range[0] == null || range[1] == null) {


            return Collections.emptyList();


        }


        return chargingOrderMapper.franchiseeUserAggs(siteIds, range[0], range[1]);


    }




    private List<Integer> franchiseeSiteIds(Map<String, Object> params) {


@@ -363,9 +462,9 @@


        return siteIds;


    }




    private List<Map<String, Object>> franchiseeUserTags(List<TChargingOrder> orders) {


        Set<Long> userIds = orders.stream()


                .map(TChargingOrder::getAppUserId)


    private List<Map<String, Object>> franchiseeUserTags(List<FranchiseeUserAgg> aggs) {


        Set<Long> userIds = aggs.stream()


                .map(FranchiseeUserAgg::getAppUserId)


                .filter(Objects::nonNull)


                .collect(Collectors.toSet());


        if (userIds.isEmpty()) {


@@ -374,23 +473,23 @@


        R<List<TUserTag>> tagResult = userTagClient.getAllUserTag();


        List<TUserTag> tags = tagResult == null || tagResult.getData() == null


                ? Collections.emptyList() : tagResult.getData();


        // 单次批量拉取全部用户标签关系（t_app_user_tag 分片键 app_user_id 精确路由），


        // 避免原先 标签×用户 双层循环逐个远程调用导致接口 40s+。


        R<List<TAppUserTag>> relationResult = appUserTagClient.listByUserIds(new ArrayList<>(userIds));


        List<TAppUserTag> relations = relationResult == null || relationResult.getData() == null


                ? Collections.emptyList() : relationResult.getData();


        Map<Integer, Set<Long>> usersByTag = relations.stream()


                .filter(relation -> relation.getUserTagId() != null && relation.getAppUserId() != null)


                .collect(Collectors.groupingBy(TAppUserTag::getUserTagId,


                        Collectors.mapping(TAppUserTag::getAppUserId, Collectors.toSet())));


        Map<String, Long> counts = new LinkedHashMap<>();


        for (TUserTag tag : tags) {


            if (tag == null || tag.getId() == null || StringUtils.isBlank(tag.getName())) {


                continue;


            }


            long count = 0;


            for (Long userId : userIds) {


                TAppUserTag query = new TAppUserTag();


                query.setAppUserId(userId);


                query.setUserTagId(tag.getId());


                R<TAppUserTag> userTagResult = appUserTagClient.getUserTag(query);


                if (userTagResult != null && userTagResult.getData() != null) {


                    count++;


                }


            }


            if (count > 0) {


                counts.put(tag.getName(), count);


            Set<Long> taggedUsers = usersByTag.get(tag.getId());


            if (taggedUsers != null && !taggedUsers.isEmpty()) {


                counts.put(tag.getName(), (long) taggedUsers.size());


            }


        }


        return counts.entrySet().stream()


@@ -408,12 +507,12 @@


        return result;


    }




    private Map<String, Object> franchiseeCompanyRank(List<TChargingOrder> orders, Map<Long, TAppUser> userMap) {


    private Map<String, Object> franchiseeCompanyRank(List<FranchiseeUserAgg> aggs, Map<Long, TAppUser> userMap) {


        Map<Integer, BigDecimal> totals = new HashMap<>();


        orders.forEach(order -> {


            TAppUser user = userMap.get(order.getAppUserId());


        aggs.forEach(agg -> {


            TAppUser user = userMap.get(agg.getAppUserId());


            if (user != null && user.getCompanyId() != null) {


                totals.merge(user.getCompanyId(), value(order.getChargingCapacity()), BigDecimal::add);


                totals.merge(user.getCompanyId(), value(agg.getCapacity()), BigDecimal::add);


            }


        });


        List<Map.Entry<Integer, BigDecimal>> sorted = totals.entrySet().stream()


@@ -451,22 +550,22 @@


        result.put("goodTags", safeList(orderEvaluateService.goodTop(siteIds))); result.put("badTags", safeList(orderEvaluateService.badTop(siteIds))); return result;


    }




    private List<Map<String, Object>> franchiseeTraffic(List<TChargingOrder> orders) {


        Map<String, Long> counts = orders.stream().collect(Collectors.groupingBy(order -> {


            String source = order.getTripartitePlatformName(); return source == null || source.isEmpty() ? "明星充电" : source;


        }, Collectors.counting()));


        return counts.entrySet().stream().map(entry -> namedCount(entry.getKey(), entry.getValue())).collect(Collectors.toList());


    private List<Map<String, Object>> franchiseeTraffic(List<Integer> siteIds, LocalDateTime[] range) {


        if (siteIds == null || siteIds.isEmpty() || range == null || range[0] == null || range[1] == null) {


            return Collections.emptyList();


        }


        List<Map<String, Object>> result = new ArrayList<>();


        chargingOrderMapper.franchiseeTrafficStats(siteIds, range[0], range[1]).forEach(stat -> {


            if (stat == null || stat.getOrderCount() == null || stat.getOrderCount() == 0) {


                return;


            }


            String source = stat.getSource() == null || stat.getSource().isEmpty() ? "明星充电" : stat.getSource();


            result.add(namedCount(source, stat.getOrderCount()));


        });


        return result;


    }




    private List<Map<String, Object>> franchiseeCarGroup(List<TAppUserCar> cars, java.util.function.Function<TAppUserCar, String> getter, String emptyName, int limit) {


        Map<String, Long> counts = cars.stream().collect(Collectors.groupingBy(car -> {


            String value = getter.apply(car); return value == null || value.trim().isEmpty() ? emptyName : value;


        }, Collectors.counting()));


        return counts.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).limit(limit)


                .map(entry -> namedCount(entry.getKey(), entry.getValue())).collect(Collectors.toList());


    }




    private List<Map<String, Object>> franchiseeOrderCarGroup(List<TChargingOrder> orders,


    private List<Map<String, Object>> franchiseeOrderCarGroup(List<FranchiseeUserAgg> aggs,


                                                               List<TAppUserCar> cars,


                                                               java.util.function.Function<TAppUserCar, String> getter,


                                                               String emptyName,


@@ -474,11 +573,15 @@


        Map<Long, TAppUserCar> carsById = cars.stream()


                .filter(car -> car.getId() != null)


                .collect(Collectors.toMap(TAppUserCar::getId, car -> car, (left, right) -> left));


        Map<String, Long> counts = orders.stream().collect(Collectors.groupingBy(order -> {


            TAppUserCar car = carsById.get(order.getAppUserCarId());


        Map<String, Long> counts = new HashMap<>();


        aggs.forEach(agg -> {


            if (agg == null || agg.getOrderCount() == null) {


                return;


            }


            TAppUserCar car = agg.getAppUserCarId() == null ? null : carsById.get(agg.getAppUserCarId());


            String value = car == null ? null : getter.apply(car);


            return value == null || value.trim().isEmpty() ? emptyName : value;


        }, Collectors.counting()));


            counts.merge(value == null || value.trim().isEmpty() ? emptyName : value, agg.getOrderCount(), Long::sum);


        });


        return counts.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).limit(limit)


                .map(entry -> namedCount(entry.getKey(), entry.getValue())).collect(Collectors.toList());


    }


@@ -497,7 +600,7 @@


    private BigDecimal countGuns(List<TChargingGun> guns, int status) { return BigDecimal.valueOf(guns.stream().filter(gun -> Objects.equals(gun.getStatus(), status)).count()); }


    private boolean isAvailableGun(TChargingGun gun) { return gun.getStatus() != null && gun.getStatus() >= 2 && gun.getStatus() <= 6; }


    private BigDecimal rate(BigDecimal numerator, BigDecimal denominator) { return denominator.signum() == 0 ? BigDecimal.ZERO : numerator.multiply(BigDecimal.valueOf(100)).divide(denominator, 2, RoundingMode.HALF_UP); }


    private List<Map<String, Object>> operationCharts(List<TChargingGun> guns, List<TChargingOrder> orders, boolean dc) {


    private List<Map<String, Object>> operationCharts(List<TChargingGun> guns, Map<Integer, FranchiseeGunSat> gunSatMap, boolean dc) {


        List<TChargingGun> selected = guns.stream().filter(gun -> dc ? Objects.equals(gun.getType(), 4) : gun.getType() != null && gun.getType() >= 1 && gun.getType() <= 3).collect(Collectors.toList());


        List<Map<String, Object>> charts = new ArrayList<>();


        String[] keys = {"availableRate", "faultRate", "offlineRate", "powerSatisfactionRate"}; int[] statuses = {0, 7, 1, 0};


@@ -507,12 +610,20 @@


            List<String> categories = selected.stream().map(TChargingGun::getName).map(name -> name == null ? "未命名充电枪" : name).collect(Collectors.toList());


            final int metricIndex = i;


            List<BigDecimal> values = selected.stream().map(gun -> metricIndex == 3


                    ? demandPowerSatisfaction(orders.stream().filter(order -> Objects.equals(order.getChargingGunId(), gun.getId())).collect(Collectors.toList()))


                    ? gunSatisfaction(gunSatMap, gun.getId())


                    : BigDecimal.valueOf(metricIndex == 0 ? (isAvailableGun(gun) ? 100 : 0) : (Objects.equals(gun.getStatus(), status) ? 100 : 0))).collect(Collectors.toList());


            chart.put("categories", categories);


            Map<String, Object> series = new LinkedHashMap<>(); series.put("name", names[i]); series.put("data", values); chart.put("series", Collections.singletonList(series)); charts.add(chart);


        }


        return charts;


    }




    private BigDecimal gunSatisfaction(Map<Integer, FranchiseeGunSat> gunSatMap, Integer gunId) {


        FranchiseeGunSat sat = gunId == null ? null : gunSatMap.get(gunId);


        if (sat == null || sat.getSatCount() == null || sat.getSatCount() == 0) {


            return BigDecimal.ZERO;


        }


        return value(sat.getSatSum()).divide(BigDecimal.valueOf(sat.getSatCount()), 2, RoundingMode.HALF_UP);


    }




    private LocalDateTime[] franchiseeRange(Map<String, Object> params) {


@@ -535,81 +646,168 @@


        return new LocalDateTime[]{today.atStartOfDay(), today.plusDays(1).atStartOfDay()};


    }




    private BigDecimal sum(List<TChargingOrder> orders, java.util.function.Function<TChargingOrder, BigDecimal> getter) { return orders.stream().map(getter).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add); }


    private BigDecimal firstNonNull(BigDecimal first, BigDecimal second) { return first != null ? first : value(second); }


    private <T> BigDecimal sum(List<T> items, java.util.function.Function<T, BigDecimal> getter) { return items.stream().map(getter).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add); }


    private BigDecimal value(BigDecimal value) { return value == null ? BigDecimal.ZERO : value; }


    private Map<String, Object> franchiseeTrend(List<TChargingOrder> orders, String name, java.util.function.Function<TChargingOrder, BigDecimal> getter) { Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", Collections.singletonList(LocalDate.now().toString())); Map<String, Object> series = new LinkedHashMap<>(); series.put("name", name); series.put("data", Collections.singletonList(sum(orders, getter))); chart.put("series", new ArrayList<>(Collections.singletonList(series))); return chart; }


    private Map<String, Object> franchiseeDailyTrend(List<TChargingOrder> orders, LocalDateTime[] range, String name, java.util.function.Function<TChargingOrder, BigDecimal> getter) {


    private Map<LocalDate, FranchiseeDayStat> dayStatByDay(List<FranchiseeDayStat> stats) {


        return stats.stream().filter(stat -> stat != null && stat.getStatDay() != null)


                .collect(Collectors.toMap(FranchiseeDayStat::getStatDay, stat -> stat, (left, right) -> left));


    }


    private Map<String, Object> franchiseeDailyTrend(List<FranchiseeDayStat> stats, LocalDateTime[] range, String name, java.util.function.Function<FranchiseeDayStat, BigDecimal> getter) {


        Map<LocalDate, FranchiseeDayStat> byDay = dayStatByDay(stats);


        List<String> categories = new ArrayList<>(); List<BigDecimal> data = new ArrayList<>();


        LocalDate start = range[0] == null ? LocalDate.now() : range[0].toLocalDate();


        LocalDate end = range[1] == null ? start.plusDays(1) : range[1].toLocalDate();


        for (LocalDate day = start; day.isBefore(end); day = day.plusDays(1)) {


            categories.add(day.toString().substring(5));


            LocalDateTime dayStart = day.atStartOfDay(), dayEnd = day.plusDays(1).atStartOfDay();


            data.add(sum(orders.stream().filter(order -> order.getEndTime() != null && !order.getEndTime().isBefore(dayStart) && order.getEndTime().isBefore(dayEnd)).collect(Collectors.toList()), getter));


            FranchiseeDayStat stat = byDay.get(day);


            data.add(stat == null ? BigDecimal.ZERO : value(getter.apply(stat)));


        }


        Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", categories);


        Map<String, Object> series = new LinkedHashMap<>(); series.put("name", name); series.put("data", data); chart.put("series", new ArrayList<>(Collections.singletonList(series))); return chart;


    }


    private Map<String, Object> franchiseeOrderTrend(List<TChargingOrder> orders, LocalDateTime[] range) {


        Map<String, Object> chart = franchiseeDailyTrend(orders, range, "充电金额", order -> firstNonNull(order.getPaymentAmount(), order.getOrderAmount()));


    private Map<String, Object> franchiseeOrderTrend(List<FranchiseeDayStat> stats, LocalDateTime[] range) {


        if (franchiseeUseMonthlyTrend(range)) {


            return franchiseeMonthlyOrderTrend(stats, range);


        }


        Map<String, Object> chart = franchiseeDailyTrend(stats, range, "充电金额", FranchiseeDayStat::getOrderAmountEffective);


        ((List<Map<String, Object>>) chart.get("series")).get(0).put("type", "column");


        Map<LocalDate, FranchiseeDayStat> byDay = dayStatByDay(stats);


        List<BigDecimal> countData = new ArrayList<>(); List<String> categories = (List<String>) chart.get("categories");


        LocalDate start = range[0] == null ? LocalDate.now() : range[0].toLocalDate();


        for (int i = 0; i < categories.size(); i++) { LocalDate day = start.plusDays(i); LocalDateTime dayStart = day.atStartOfDay(), dayEnd = day.plusDays(1).atStartOfDay(); countData.add(BigDecimal.valueOf(orders.stream().filter(order -> order.getEndTime() != null && !order.getEndTime().isBefore(dayStart) && order.getEndTime().isBefore(dayEnd)).count())); }


        for (int i = 0; i < categories.size(); i++) { LocalDate day = start.plusDays(i); FranchiseeDayStat stat = byDay.get(day); countData.add(BigDecimal.valueOf(stat == null ? 0L : numberValue(stat.getOrderCount()))); }


        Map<String, Object> countSeries = new LinkedHashMap<>(); countSeries.put("name", "充电订单"); countSeries.put("data", countData); countSeries.put("type", "line"); countSeries.put("style", "curve"); countSeries.put("index", 1); ((List<Map<String, Object>>) chart.get("series")).add(countSeries); return chart;


    }


    private Map<String, Object> franchiseePhaseRing(List<TChargingOrder> orders) {




    /** Ranges longer than 31 days use monthly buckets so the mobile chart stays readable. */


    private boolean franchiseeUseMonthlyTrend(LocalDateTime[] range) {


        if (range == null || range.length < 2 || range[0] == null || range[1] == null) {


            return false;


        }


        return range[0].toLocalDate().plusDays(31).isBefore(range[1].toLocalDate());


    }




    private Map<String, Object> franchiseeMonthlyOrderTrend(List<FranchiseeDayStat> stats, LocalDateTime[] range) {


        Map<YearMonth, List<FranchiseeDayStat>> statsByMonth = stats.stream()


                .filter(stat -> stat != null && stat.getStatDay() != null)


                .collect(Collectors.groupingBy(stat -> YearMonth.from(stat.getStatDay())));


        LocalDate start = range[0].toLocalDate();


        LocalDate end = range[1].toLocalDate();


        YearMonth firstMonth = YearMonth.from(start);


        YearMonth lastMonth = YearMonth.from(end.minusDays(1));


        List<String> categories = new ArrayList<>();


        List<BigDecimal> amountData = new ArrayList<>();


        List<BigDecimal> countData = new ArrayList<>();


        for (YearMonth month = firstMonth; !month.isAfter(lastMonth); month = month.plusMonths(1)) {


            List<FranchiseeDayStat> monthStats = statsByMonth.getOrDefault(month, Collections.emptyList());


            categories.add(month.toString());


            amountData.add(sum(monthStats, FranchiseeDayStat::getOrderAmountEffective));


            countData.add(BigDecimal.valueOf(monthStats.stream().mapToLong(stat -> numberValue(stat.getOrderCount())).sum()));


        }


        Map<String, Object> amountSeries = new LinkedHashMap<>(); amountSeries.put("name", "充电金额"); amountSeries.put("data", amountData); amountSeries.put("type", "column");


        Map<String, Object> countSeries = new LinkedHashMap<>(); countSeries.put("name", "充电订单"); countSeries.put("data", countData); countSeries.put("type", "line"); countSeries.put("style", "curve"); countSeries.put("index", 1);


        Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", categories); chart.put("series", new ArrayList<>(Arrays.asList(amountSeries, countSeries))); return chart;


    }


    private Map<String, Object> franchiseePhaseRing(List<Integer> siteIds, LocalDateTime[] range) {


        Map<Integer, BigDecimal> phase = new LinkedHashMap<>(); phase.put(1, BigDecimal.ZERO); phase.put(2, BigDecimal.ZERO); phase.put(3, BigDecimal.ZERO); phase.put(4, BigDecimal.ZERO);


        List<Long> ids = orders.stream().map(TChargingOrder::getId).filter(Objects::nonNull).collect(Collectors.toList());


        if (!ids.isEmpty()) { chargingOrderAccountingStrategyService.lambdaQuery().in(TChargingOrderAccountingStrategy::getChargingOrderId, ids).list().forEach(item -> phase.computeIfPresent(item.getType(), (key, total) -> total.add(value(item.getChargingCapacity())))); }


        if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {


            List<Long> ids = chargingOrderMapper.franchiseeOrderIds(siteIds, range[0], range[1]);


            if (!ids.isEmpty()) {


                // 分块并行反查 strategy 表（分片键 charging_order_id）：MyCat 按 id 路由成本约 2ms/个，


                // 串行 5000/块在大范围下 70s+ 读超时；100/块 × 16 线程实测 46k id 约 20s（代理并发吞吐有限）。


                List<CompletableFuture<Void>> futures = new ArrayList<>();


                for (int from = 0; from < ids.size(); from += PHASE_ID_BATCH_SIZE) {


                    List<Long> chunk = ids.subList(from, Math.min(from + PHASE_ID_BATCH_SIZE, ids.size()));


                    futures.add(CompletableFuture.runAsync(() -> {


                        List<FranchiseePhaseStat> items = chargingOrderMapper.franchiseePhaseStatsByOrderIds(chunk);


                        if (items != null) {


                            synchronized (phase) {


                                items.forEach(item -> {


                                    if (item != null && item.getType() != null) {


                                        phase.computeIfPresent(item.getType(), (key, total) -> total.add(value(item.getCapacity())));


                                    }


                                });


                            }


                        }


                    }, PHASE_QUERY_EXECUTOR));


                }


                CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();


            }


        }


        String[] names = {"尖", "峰", "平", "谷"}; List<Map<String, Object>> data = new ArrayList<>();


        for (int i = 1; i <= 4; i++) { Map<String, Object> item = new LinkedHashMap<>(); item.put("name", names[i - 1]); item.put("value", phase.get(i)); data.add(item); }


        Map<String, Object> chart = new LinkedHashMap<>(); chart.put("series", Collections.singletonList(Collections.singletonMap("data", data))); return chart;


    }


    private Map<String, Object> franchiseeEfficiencyTrend(List<TChargingOrder> orders, LocalDateTime[] range) {


        Map<String, Object> chart = franchiseeDailyTrend(orders, range, "功率", order -> value(order.getChargingPower() == null ? order.getPower() : order.getChargingPower()));


        List<BigDecimal> powerData = new ArrayList<>(), utilization = new ArrayList<>(); List<String> categories = (List<String>) chart.get("categories");


    private Map<String, Object> franchiseeEfficiencyTrend(List<FranchiseeDayStat> stats, LocalDateTime[] range) {


        Map<LocalDate, FranchiseeDayStat> byDay = dayStatByDay(stats);


        List<String> categories = new ArrayList<>();


        List<BigDecimal> powerData = new ArrayList<>(), utilization = new ArrayList<>();


        LocalDate start = range[0] == null ? LocalDate.now() : range[0].toLocalDate();


        for (int i = 0; i < categories.size(); i++) { LocalDate day = start.plusDays(i); LocalDateTime dayStart = day.atStartOfDay(), dayEnd = day.plusDays(1).atStartOfDay(); List<TChargingOrder> dayOrders = orders.stream().filter(order -> order.getEndTime() != null && !order.getEndTime().isBefore(dayStart) && order.getEndTime().isBefore(dayEnd)).collect(Collectors.toList()); powerData.add(averagePower(dayOrders)); utilization.add(observedPowerUtilization(dayOrders)); }


        ((List<Map<String, Object>>) chart.get("series")).get(0).put("data", powerData);


        Map<String, Object> utilizationSeries = new LinkedHashMap<>(); utilizationSeries.put("name", "功率利用率"); utilizationSeries.put("data", utilization); ((List<Map<String, Object>>) chart.get("series")).add(utilizationSeries); return chart;


        LocalDate end = range[1] == null ? start.plusDays(1) : range[1].toLocalDate();


        for (LocalDate day = start; day.isBefore(end); day = day.plusDays(1)) {


            categories.add(day.toString().substring(5));


            FranchiseeDayStat stat = byDay.get(day);


            powerData.add(stat == null ? BigDecimal.ZERO : averagePower(stat));


            utilization.add(observedPowerUtilization(stat == null ? Collections.emptyList() : Collections.singletonList(stat)));


        }


        Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", categories);


        Map<String, Object> powerSeries = new LinkedHashMap<>(); powerSeries.put("name", "功率"); powerSeries.put("data", powerData);


        Map<String, Object> utilizationSeries = new LinkedHashMap<>(); utilizationSeries.put("name", "功率利用率"); utilizationSeries.put("data", utilization);


        chart.put("series", new ArrayList<>(Arrays.asList(powerSeries, utilizationSeries))); return chart;


    }


    private BigDecimal averagePower(List<TChargingOrder> orders) {


        List<BigDecimal> powers = orders.stream().map(order -> order.getChargingPower() == null ? order.getPower() : order.getChargingPower()).filter(Objects::nonNull).collect(Collectors.toList());


        return powers.isEmpty() ? BigDecimal.ZERO : powers.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(powers.size()), 2, RoundingMode.HALF_UP);


    private BigDecimal averagePower(FranchiseeDayStat stat) {


        if (stat == null || stat.getPowerCount() == null || stat.getPowerCount() == 0 || stat.getTotalPower() == null) {


            return BigDecimal.ZERO;


        }


        return stat.getTotalPower().divide(BigDecimal.valueOf(stat.getPowerCount()), 2, RoundingMode.HALF_UP);


    }


    private BigDecimal observedPowerUtilization(List<TChargingOrder> orders) {


        List<BigDecimal> powers = orders.stream().map(order -> order.getChargingPower() == null ? order.getPower() : order.getChargingPower()).filter(Objects::nonNull).filter(power -> power.signum() > 0).collect(Collectors.toList());


        if (powers.isEmpty()) return BigDecimal.ZERO; BigDecimal maximum = powers.stream().max(BigDecimal::compareTo).orElse(BigDecimal.ZERO);


        return maximum.signum() == 0 ? BigDecimal.ZERO : powers.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(powers.size()), 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100)).divide(maximum, 2, RoundingMode.HALF_UP);


    private BigDecimal observedPowerUtilization(List<FranchiseeDayStat> stats) {


        BigDecimal sum = stats.stream().map(FranchiseeDayStat::getUtilPowerSum).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add);


        long count = stats.stream().mapToLong(stat -> numberValue(stat.getUtilPowerCount())).sum();


        if (count == 0) return BigDecimal.ZERO;


        BigDecimal maximum = stats.stream().map(FranchiseeDayStat::getMaxPower).filter(Objects::nonNull).max(BigDecimal::compareTo).orElse(BigDecimal.ZERO);


        if (maximum.signum() == 0) return BigDecimal.ZERO;


        return sum.divide(BigDecimal.valueOf(count), 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100)).divide(maximum, 2, RoundingMode.HALF_UP);


    }


    private BigDecimal demandPowerSatisfaction(List<TChargingOrder> orders) {


        List<TChargingOrder> valid = orders.stream().filter(order -> order.getCurrent() != null && order.getNeedElec() != null && order.getNeedElec().signum() > 0).collect(Collectors.toList());


        if (valid.isEmpty()) return BigDecimal.ZERO;


        BigDecimal total = valid.stream().map(order -> order.getCurrent().multiply(BigDecimal.valueOf(100)).divide(order.getNeedElec(), 4, RoundingMode.HALF_UP).min(BigDecimal.valueOf(100))).reduce(BigDecimal.ZERO, BigDecimal::add);


        return total.divide(BigDecimal.valueOf(valid.size()), 2, RoundingMode.HALF_UP);


    private BigDecimal demandPowerSatisfaction(List<FranchiseeDayStat> stats) {


        BigDecimal total = stats.stream().map(FranchiseeDayStat::getElecSatSum).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add);


        long count = stats.stream().mapToLong(stat -> numberValue(stat.getElecSatCount())).sum();


        if (count == 0) return BigDecimal.ZERO;


        return total.divide(BigDecimal.valueOf(count), 2, RoundingMode.HALF_UP);


    }


    private Map<String, Object> franchiseePowerDistribution(List<TChargingOrder> orders) {


    private Map<String, Object> franchiseePowerDistribution(List<Integer> siteIds, LocalDateTime[] range) {


        String[] names = {"0-30kW", "30-60kW", "60-120kW", "120-300kW", "300kW以上"}; long[] counts = new long[5];


        orders.forEach(order -> { BigDecimal power = order.getChargingPower() == null ? order.getPower() : order.getChargingPower(); if (power == null) return; double value = power.doubleValue(); int index = value < 30 ? 0 : value < 60 ? 1 : value < 120 ? 2 : value < 300 ? 3 : 4; counts[index]++; });


        if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {


            chargingOrderMapper.franchiseePowerBuckets(siteIds, range[0], range[1]).forEach(bucket -> {


                if (bucket != null && bucket.getBucket() != null && bucket.getBucket() >= 0 && bucket.getBucket() < 5) {


                    counts[bucket.getBucket()] += numberValue(bucket.getOrderCount());


                }


            });


        }


        List<Map<String, Object>> data = new ArrayList<>(); for (int i = 0; i < names.length; i++) { Map<String, Object> item = new LinkedHashMap<>(); item.put("name", names[i]); item.put("value", counts[i]); data.add(item); }


        return Collections.singletonMap("series", Collections.singletonList(Collections.singletonMap("data", data)));


    }


    private Map<String, Object> franchiseeIncomeTrend(List<TChargingOrder> orders, LocalDate firstMonth, int monthCount) {


    /** 收支分析近6月柱状图：与后台 电站收入分析 一致（历史月结算账单 + 当月原始订单）。 */


    private Map<String, Object> franchiseeIncomeTrendFromSix(List<SixChargingDto> months) {


        List<String> categories = new ArrayList<>();


        List<BigDecimal> electricity = new ArrayList<>(), service = new ArrayList<>();


        for (int i = 0; i < monthCount; i++) {


            YearMonth month = YearMonth.from(firstMonth).plusMonths(i);


            categories.add(String.format("%02d月", month.getMonthValue()));


            LocalDateTime start = month.atDay(1).atStartOfDay(), end = month.plusMonths(1).atDay(1).atStartOfDay();


            electricity.add(sum(orders.stream().filter(o -> o.getEndTime() != null && !o.getEndTime().isBefore(start) && o.getEndTime().isBefore(end)).collect(Collectors.toList()), TChargingOrder::getElectrovalence));


            service.add(sum(orders.stream().filter(o -> o.getEndTime() != null && !o.getEndTime().isBefore(start) && o.getEndTime().isBefore(end)).collect(Collectors.toList()), TChargingOrder::getServiceCharge));


        for (SixChargingDto month : months) {


            if (month == null) {


                continue;


            }


            categories.add(month.getMonth() + "月");


            electricity.add(month.getElectrovalence() == null ? BigDecimal.ZERO : month.getElectrovalence());


            service.add(month.getServiceCharge() == null ? BigDecimal.ZERO : month.getServiceCharge());


        }


        Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", categories);


        Map<String, Object> electricitySeries = new LinkedHashMap<>(); electricitySeries.put("name", "充电费"); electricitySeries.put("data", electricity);


        Map<String, Object> serviceSeries = new LinkedHashMap<>(); serviceSeries.put("name", "服务费"); serviceSeries.put("data", service);


        chart.put("series", new ArrayList<>(Arrays.asList(electricitySeries, serviceSeries))); return chart;


        Map<String, Object> chart = new LinkedHashMap<>();


        chart.put("categories", categories);


        Map<String, Object> electricitySeries = new LinkedHashMap<>();


        electricitySeries.put("name", "充电费");


        electricitySeries.put("data", electricity);


        Map<String, Object> serviceSeries = new LinkedHashMap<>();


        serviceSeries.put("name", "服务费");


        serviceSeries.put("data", service);


        chart.put("series", new ArrayList<>(Arrays.asList(electricitySeries, serviceSeries)));


        return chart;


    }






@@ -1671,11 +1869,18 @@


    public R<List<SixChargingDto>> charge(Integer siteId, Integer partnerId) {


        Long userId = tokenService.getLoginUser().getUserid();


        SysUser sysUser = sysUserClient.getSysUser(userId).getData();


        boolean partnerView = isPartnerView(sysUser);


        List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);


        LocalDate sixBefore = PreviousSixMonths.get();


        //通过siteIds进行sql查询统计


        List<SixChargingDto> chargingDtos = chargingOrderService.charge(sixBefore, siteIds, false);


        return R.ok(buildLastSixMonths(siteIds, false));


    }




    /**


     * 近6月+当月电站收入：历史月读结算账单、当月补原始订单。


     * 与「电站收入分析」图表、底部数据分类及加盟商收支同口径。


     */


    private List<SixChargingDto> buildLastSixMonths(List<Integer> siteIds, boolean partnerView) {


        LocalDate sixBefore = PreviousSixMonths.get();


        List<SixChargingDto> chargingDtos = chargingOrderService.charge(sixBefore, siteIds, partnerView);


        LocalDate statisticsEndMonth = resolveStatisticsEndMonth(LocalDate.now(), chargingDtos);


        List<SixChargingDto> sixChargingDtos = generateLastSixMonths(statisticsEndMonth);


        for (SixChargingDto sixChargingDto : sixChargingDtos) {


@@ -1686,9 +1891,7 @@


            }




        }




        return R.ok(sixChargingDtos);




        return sixChargingDtos;


    }






@@ -1826,19 +2029,33 @@


        SysUser sysUser = sysUserClient.getSysUser(userId).getData();


        boolean partnerView = isPartnerView(sysUser);


        List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);


        Map<String,Object>  map = chargingOrderService.countAll(siteIds, false);


        if (map == null) {


            map = new HashMap<String,Object>();


        }


        LocalDate sixBefore = PreviousSixMonths.get();


        Map<String,Object> map = new HashMap<String,Object>();


        // 电费/服务费与上方「电站收入分析」图表同口径：近6月结算账单 + 当月原始订单，保证底部合计=图表6个月相加


        List<SixChargingDto> sixChargingDtos = buildLastSixMonths(siteIds, false);


        map.put("electrovalence", sixChargingDtos.stream()


                .filter(Objects::nonNull)


                .map(SixChargingDto::getElectrovalence)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add));


        map.put("service_charge", sixChargingDtos.stream()


                .filter(Objects::nonNull)


                .map(SixChargingDto::getServiceCharge)


                .filter(Objects::nonNull)


                .reduce(BigDecimal.ZERO, BigDecimal::add));


        // 合作商分成/三方平台分佣按近6月结算口径统计（与图表月份窗口一致）


        Map<String,Object> sub = chargingOrderService.countAll(siteIds, false, sixBefore);


        map.put("commission_amount", sub == null ? BigDecimal.ZERO : sub.get("commission_amount"));


        map.put("sharing_amount", sub == null ? BigDecimal.ZERO : sub.get("sharing_amount"));


        boolean platformVisible = !partnerView;


        if(platformVisible){


            R<BigDecimal> parkingAmountResult = parkingLotClient.getRecordAmount(siteIds);


            R<BigDecimal> parkingAmountResult = parkingLotClient.getRecordAmount(siteIds, sixBefore.toString());


            BigDecimal data = parkingAmountResult == null || parkingAmountResult.getData() == null


                    ? BigDecimal.ZERO : parkingAmountResult.getData();


            map.put("parkingAmount",data);


            BigDecimal data1 =   shoppingOrderService.getSumAmount();


            BigDecimal data1 =   shoppingOrderService.getSumAmount(sixBefore);


            map.put("shopAmount",data1);


            BigDecimal data2 =   vipOrderService.getSumAmout();


            BigDecimal data2 =   vipOrderService.getSumAmout(sixBefore);


            map.put("vipAmount",data2);


        }else{


            map.put("parkingAmount",0);