修改bug

puzhibing

5 小时以前 976ff3fe092ee2f9515013dbfab77d25b2944b75

 ruoyi-service/ruoyi-order/src/main/java/com/ruoyi/order/controller/TChargingOrderController.java

@@ -10,6 +10,7 @@
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.time.*;
import java.util.concurrent.TimeUnit;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -42,6 +43,7 @@
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.order.api.dto.ChargingStatisticeDTO;
import com.ruoyi.order.api.dto.DeviceStartChargingDTO;
import com.ruoyi.order.api.model.*;
import com.ruoyi.order.api.query.ChargingOrderQuery;
import com.ruoyi.common.core.dto.MongoChargingOrderQuery;
@@ -128,6 +130,10 @@

    @Resource
    private TChargingOrderService chargingOrderService;
    @Resource
    private TCardChargingOrderService cardChargingOrderService;
    @Resource
    private TVinChargingOrderService vinChargingOrderService;
    @Autowired
    private TokenService tokenService;
    @Autowired
@@ -219,19 +225,24 @@
        List<Integer> siteIds = franchiseeSiteIds(params);
        LocalDateTime[] range = franchiseeRange(params);
        List<FranchiseeDayStat> dayStats = franchiseeDayStats(siteIds, range);
        List<Map<String, Object>> managementOrderStats = franchiseeManagementOrderStats(siteIds, range);
        Map<String, Object> summary = new LinkedHashMap<>();
        summary.put("orderAmountWan", sum(dayStats, FranchiseeDayStat::getOrderAmount).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));
        BigDecimal incomeWan = franchiseeIncomeWan(dayStats);
        BigDecimal totalChargingCapacityWan = sum(dayStats, FranchiseeDayStat::getCapacity).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP);
        summary.put("incomeWan", incomeWan);
        summary.put("orderAmountWan", incomeWan);
        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::getPaymentAmount));
        summary.put("chargingOrderCount", dayStats.stream().mapToLong(stat -> numberValue(stat.getOrderCount())).sum());
        summary.put("totalChargingCapacityWan", totalChargingCapacityWan);
        summary.put("chargingPowerWan", totalChargingCapacityWan);
        summary.put("chargingAmount", sumManagementOrderField(managementOrderStats, "paymoney"));
        summary.put("chargingOrderCount", sumManagementOrderField(managementOrderStats, "orderCount").longValue());
        summary.put("powerUtilizationRate", observedPowerUtilization(dayStats));
        summary.put("demandPowerSatisfactionRate", demandPowerSatisfaction(dayStats));
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("summary", summary);
        result.put("keyDataLine", franchiseeDailyTrend(dayStats, range, "订单金额", FranchiseeDayStat::getOrderAmountEffective));
        result.put("keyDataLine", franchiseeDailyTrend(dayStats, range, "收入合计", FranchiseeDayStat::getChargingIncome));
        result.put("keyDataRing", franchiseePhaseRing(siteIds, range));
        result.put("orderStats", franchiseeOrderTrend(dayStats, range));
        result.put("orderStats", franchiseeManagementOrderTrend(managementOrderStats));
        result.put("efficiency", franchiseeEfficiencyTrend(dayStats, range));
        result.put("powerDistribution", franchiseePowerDistribution(siteIds, range));
        return R.ok(result);
@@ -273,17 +284,59 @@
        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", electricity);
        incomePie.add(electricityItem);
        Map<String, Object> serviceItem = new LinkedHashMap<>();
        serviceItem.put("name", "服务费");
        serviceItem.put("value", service);
        incomePie.add(serviceItem);
        result.put("incomePie", incomePie);
        // 电站收入占比：口径与后台 /six/circle 一致（近6月结算账单按站点分组，电费+服务费-三方佣金）
        result.put("incomePie", franchiseeIncomePieBySite(siteIds));
        return R.ok(result);
    }

    /** 加盟商看板"电站收入占比"：复用 /six/circle 统计口径，按金额降序返回站点占比列表 */
    private List<Map<String, Object>> franchiseeIncomePieBySite(List<Integer> siteIds) {
        List<Map<String, Object>> incomePie = new ArrayList<>();
        if (siteIds == null || siteIds.isEmpty()) {
            return incomePie;
        }
        List<SixCircleDto> circleDtos = chargingOrderService.circle(siteIds, PreviousSixMonths.get(), false);
        if (circleDtos == null || circleDtos.isEmpty()) {
            return incomePie;
        }
        // 站点名批量映射，避免逐个远程调用
        Map<Integer, String> siteNameMap = new HashMap<>();
        R<List<Site>> siteResult = siteClient.getSiteAll();
        List<Site> sites = siteResult == null ? null : siteResult.getData();
        if (sites != null) {
            for (Site site : sites) {
                if (site != null && site.getId() != null) {
                    siteNameMap.put(site.getId(), site.getName());
                }
            }
        }
        circleDtos.sort((a, b) -> {
            BigDecimal amountA = a == null || a.getPaymentAmount() == null ? BigDecimal.ZERO : a.getPaymentAmount();
            BigDecimal amountB = b == null || b.getPaymentAmount() == null ? BigDecimal.ZERO : b.getPaymentAmount();
            return amountB.compareTo(amountA);
        });
        // 总额用于计算各站点占比，name+value 为服务端拼好的饼图标签文本（站点名 xx.x%）
        BigDecimal total = BigDecimal.ZERO;
        for (SixCircleDto dto : circleDtos) {
            if (dto != null && dto.getPaymentAmount() != null) {
                total = total.add(dto.getPaymentAmount());
            }
        }
        for (SixCircleDto dto : circleDtos) {
            if (dto == null || dto.getSiteId() == null || dto.getPaymentAmount() == null) {
                continue;
            }
            Map<String, Object> item = new LinkedHashMap<>();
            String name = siteNameMap.getOrDefault(dto.getSiteId(), "电站" + dto.getSiteId());
            item.put("name", name);
            item.put("value", dto.getPaymentAmount());
            String percent = total.compareTo(BigDecimal.ZERO) > 0
                    ? dto.getPaymentAmount().multiply(BigDecimal.valueOf(100)).divide(total, 1, RoundingMode.HALF_UP).toPlainString()
                    : "0.0";
            item.put("name+value", name + " " + percent + "%");
            incomePie.add(item);
        }
        return incomePie;
    }

    @PostMapping("/app/franchisee/user")
@@ -300,12 +353,12 @@
            chargingUsersByDay.computeIfAbsent(agg.getStatDay(), key -> new HashSet<>()).add(agg.getAppUserId());
        }
        Map<LocalDate, Long> newUsersByDay = new LinkedHashMap<>();
        if (range != null && range[0] != null && range[1] != null) {
            List<FranchiseeNewUserStat> newUserStats = chargingOrderMapper.franchiseeNewUserStats(range[0], range[1]);
            if (newUserStats != null) {
                for (FranchiseeNewUserStat stat : newUserStats) {
                    if (stat != null && stat.getStatDay() != null && stat.getUserCount() != null) {
                        newUsersByDay.put(stat.getStatDay(), stat.getUserCount());
        if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {
            List<FranchiseeUserFirstCharge> firstCharges = chargingOrderMapper.franchiseeUserFirstChargedDays(siteIds, range[0], range[1]);
            if (firstCharges != null) {
                for (FranchiseeUserFirstCharge fc : firstCharges) {
                    if (fc != null && fc.getAppUserId() != null && fc.getFirstChargedDay() != null) {
                        newUsersByDay.merge(fc.getFirstChargedDay(), 1L, Long::sum);
                    }
                }
            }
@@ -400,9 +453,8 @@

    private Map<String, Object> operationChart(List<Map<String, Object>> rows, String name) {
        List<String> categories = rows.stream().map(row -> {
            String siteName = row.get("siteName") == null ? "" : String.valueOf(row.get("siteName"));
            String gunName = row.get("name") == null ? "" : String.valueOf(row.get("name"));
            return siteName + gunName;
            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<>();
@@ -650,6 +702,13 @@
        return new LocalDateTime[]{today.atStartOfDay(), today.plusDays(1).atStartOfDay()};
    }

    static BigDecimal franchiseeIncomeWan(List<FranchiseeDayStat> stats) {
        return stats.stream().map(FranchiseeDayStat::getChargingIncome)
                .map(value -> value == null ? BigDecimal.ZERO : value)
                .reduce(BigDecimal.ZERO, BigDecimal::add)
                .divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP);
    }

    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<LocalDate, FranchiseeDayStat> dayStatByDay(List<FranchiseeDayStat> stats) {
@@ -669,48 +728,52 @@
        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<FranchiseeDayStat> stats, LocalDateTime[] range) {
        if (franchiseeUseMonthlyTrend(range)) {
            return franchiseeMonthlyOrderTrend(stats, range);
    private List<Map<String, Object>> franchiseeManagementOrderStats(List<Integer> siteIds, LocalDateTime[] range) {
        if (siteIds == null || siteIds.isEmpty() || range == null || range.length < 2
                || range[0] == null || range[1] == null || !range[1].isAfter(range[0])) {
            return Collections.emptyList();
        }
        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); 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;
    }

    /** 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));
        LocalDate end = range[1].minusNanos(1).toLocalDate();
        return safeList(chargingOrderService.getByDate(start, end, siteIds));
    }

    private BigDecimal sumManagementOrderField(List<Map<String, Object>> stats, String field) {
        return safeList(stats).stream()
                .map(row -> decimalValue(row == null ? null : row.get(field)))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    private BigDecimal decimalValue(Object value) {
        if (value == null) return BigDecimal.ZERO;
        try {
            return new BigDecimal(String.valueOf(value));
        } catch (NumberFormatException ignored) {
            return BigDecimal.ZERO;
        }
    }

    private Map<String, Object> franchiseeManagementOrderTrend(List<Map<String, Object>> stats) {
        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()));
        for (Map<String, Object> row : safeList(stats)) {
            if (row == null) continue;
            categories.add(String.valueOf(row.get("time")));
            amountData.add(decimalValue(row.get("paymoney")));
            countData.add(decimalValue(row.get("orderCount")));
        }
        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;
        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);
        if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {
@@ -1122,6 +1185,7 @@


    @ResponseBody
    @RequiresPermissions(value = {"/paymentOrder/refund", "/paymentOrder/refund/select"}, logical = Logical.OR)
    @PostMapping(value = "/pay/order/refund")
    @ApiOperation(value = "退款", tags = {"管理后台-支付订单-订单信息"})
    public R refund(@RequestBody PayOrderRefundDto payOrderQueryDto) {
@@ -1218,6 +1282,7 @@


    @ResponseBody
    @RequiresPermissions(value = {"/paymentOrder/refund", "/paymentOrder/refund/select"}, logical = Logical.OR)
    @GetMapping(value = "/pay/order/refund/detail")
    @ApiOperation(value = "退款信息", tags = {"管理后台-支付订单-订单信息"})
    public R refundDetail(Long orderId, Integer type) {
@@ -1238,6 +1303,7 @@
    }

    @ResponseBody
    @RequiresPermissions(value = {"/paymentOrder/order"}, logical = Logical.OR)
    @GetMapping(value = "/pay/order/charging")
    @ApiOperation(value = "充电信息", tags = {"管理后台-支付订单-订单信息"})
    public R<PayOrderChargingInfo> refundDetail(Long orderId) {
@@ -1269,6 +1335,7 @@
    }

    @ResponseBody
    @RequiresPermissions(value = {"/paymentOrder/order"}, logical = Logical.OR)
    @GetMapping(value = "/pay/order/charging/details")
    @ApiOperation(value = "充电明细", tags = {"管理后台-支付订单-订单信息"})
    public R<List<TChargingOrderAccountingStrategy>> chargingDetail(Long orderId) {
@@ -1419,6 +1486,8 @@
        chargingOrderInfoVO.setCdVoltage(byId.getVoltage()!=null?byId.getVoltage().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
        chargingOrderInfoVO.setSurplus(byId.getTotalElectricity()!=null?byId.getTotalElectricity().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
        chargingOrderInfoVO.setTotalPower(byId.getPower()!=null?byId.getPower().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
        chargingOrderInfoVO.setVin(byId.getActualVin());
        chargingOrderInfoVO.setActualVin(byId.getActualVin());
        if (byId.getAppUserCarId()!=null){
            TAppUserCar data = appUserCarClient.getCarById(byId.getAppUserCarId()+"").getData();
            if (data!=null){
@@ -1722,14 +1791,21 @@
    }
    
    /**
     * 远程启动充电应答
     * 远程启动充电应答（按订单号前缀路由：SD=刷卡订单，VD=VIN订单，其余=普通订单）
     * @param message
     */
    @ResponseBody
    @PostMapping(value = "/startChargeSuccessfully")
    public void startChargeSuccessfully(@RequestBody PlatformStartChargingReplyMessageVO message){
        log.info("-------------------远程启动充电请求应答-------------------：" + message);
        chargingOrderService.startChargeSuccessfully(message);
        String orderCode = message == null ? null : message.getTransaction_serial_number();
        if (isCardOrder(orderCode)) {
            cardChargingOrderService.cardStartChargeSuccessfully(message);
        } else if (isVinOrder(orderCode)) {
            vinChargingOrderService.vinStartChargeSuccessfully(message);
        } else {
            chargingOrderService.startChargeSuccessfully(message);
        }
    }
    
    
@@ -1796,6 +1872,12 @@
    
    
    
    /**
     * 安全检测等待窗口（秒）：设备在此时长内未上报有效安全检测时，前端按「未插枪」提示用户，
     * 超时订单由启动超时兜底任务自动取消，避免订单永久停留在启动中状态。
     */
    private static final long STARTUP_WAIT_SECONDS = 90L;

    @ResponseBody
    @GetMapping(value = "/preChargeCheck/{id}")
    @ApiOperation(value = "获取安全检测数据", tags = {"小程序-扫一扫"})
@@ -1805,10 +1887,17 @@
    public AjaxResult<PreChargeCheck> preChargeCheck(@PathVariable Integer id) {
        String key = "AQJC_" + id;
        PreChargeCheck cacheObject = redisService.getCacheObject(key);
        if(null != cacheObject){
            if(LocalDateTime.now().minusMinutes(1).isAfter(cacheObject.getAddTime())){
                redisService.deleteObject(key);
                cacheObject = null;
        if (null != cacheObject) {
            LocalDateTime addTime = cacheObject.getAddTime();
            // 等待安全检测超出窗口且启动指令尚未下发时，按「未插枪」提示前端；
            // 缓存必须保留：设备安全检测上报依赖该缓存推进启动，删除会导致订单永久卡在启动中
            if (Integer.valueOf(1).equals(cacheObject.getStartupSuccess())
                    && !Boolean.TRUE.equals(cacheObject.getStartCommandSent())
                    && null != addTime
                    && LocalDateTime.now().isAfter(addTime.plusSeconds(STARTUP_WAIT_SECONDS))) {
                cacheObject.setStartupSuccess(3);
                cacheObject.setFailureCause(5);
                redisService.setCacheObject(key, cacheObject, 24L, TimeUnit.HOURS);
            }
        }
        return AjaxResult.success(cacheObject);
@@ -1837,28 +1926,53 @@
    })
    public AjaxResult stopCharging(@PathVariable String id) {
        log.info("小程序主动发起停止充电，订单ID：{}", id);
        // VIN 码充电订单路由：VD 订单存于 t_vin_charging_order，不在 t_charging_order；
        // VD 表存在该 ID 订单时优先走 VIN 停充（内部按状态返回准确的“不能重复操作/还未开始充电”），
        // 其余情况回落普通停充。雪花 ID 两表同源生成，撞号概率可忽略
        TVinChargingOrder vinOrder = null;
        try {
            vinOrder = vinChargingOrderService.getById(Long.valueOf(id));
        } catch (NumberFormatException ignored) {
            // 非数字订单ID，按普通停充处理
        }
        if (vinOrder != null) {
            return vinChargingOrderService.stopChargingByApplet(id);
        }
        return chargingOrderService.stopCharging(id);
    }
    
    
    /**
     * 停止充电应答处理逻辑
     * 停止充电应答处理逻辑（普通订单原逻辑 + VIN订单按枪兜底确认）
     * @param platformStopChargingReply
     */
    @PostMapping("/terminateSuccessfulResponse")
    public void terminateSuccessfulResponse(@RequestBody PlatformStopChargingReplyVO platformStopChargingReply){
        log.info("-------------------远程停止充电请求应答-------------------：" + platformStopChargingReply);
        // VIN订单平台停止应答兜底（按枪定位停止中订单，内部自带空判断，不影响普通订单处理）
        try {
            vinChargingOrderService.vinTerminateStopByReply(platformStopChargingReply);
        } catch (Exception ex) {
            log.error("VIN订单停止应答处理异常：", ex);
        }
        chargingOrderService.terminateSuccessfulResponse(platformStopChargingReply);
    }
    
    


    /**
     * 停止充电返回账单后计算费用
     * 停止充电返回账单后计算费用（按订单号前缀路由：SD=刷卡订单，VD=VIN订单，其余=普通订单）
     * @param vo
     */
    @PostMapping("/endChargeBillingCharge")
    public R endChargeBillingCharge(@RequestBody TransactionRecordMessageVO vo){
        log.info("-------------------停止充电返回账单后计算费用及修改业务状态-------------------：" + vo);
        String orderCode = vo == null ? null : vo.getTransaction_serial_number();
        if (isCardOrder(orderCode)) {
            return cardChargingOrderService.cardEndChargeBillingCharge(vo);
        }
        if (isVinOrder(orderCode)) {
            return vinChargingOrderService.vinEndChargeBillingCharge(vo);
        }
        return chargingOrderService.endChargeBillingCharge(vo);
    }

@@ -2080,7 +2194,7 @@
        boolean partnerView = isPartnerView(sysUser);
        List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);
        LocalDate sixBefore = PreviousSixMonths.get();
        return R.ok(chargingOrderService.payTypeCircle(sixBefore, siteIds, false));
        return R.ok(chargingOrderService.payTypeCircle(sixBefore, siteIds, partnerView));
    }

    private boolean isPartnerView(SysUser sysUser) {
@@ -2237,29 +2351,145 @@
    }
    
    /**
     * 处理充电订单实时监控数据相关的业务逻辑
     * 处理充电订单实时监控数据相关的业务逻辑（按订单号前缀路由）
     * @param query
     */
    @PostMapping("/chargeMonitoring")
    public void chargeMonitoring(@RequestBody UploadRealTimeMonitoringDataQuery query){
        chargingOrderService.chargeMonitoring(query);
        String orderCode = query == null ? null : query.getTransaction_serial_number();
        if (isCardOrder(orderCode)) {
            cardChargingOrderService.cardChargeMonitoring(query);
        } else if (isVinOrder(orderCode)) {
            vinChargingOrderService.vinChargeMonitoring(query);
        } else {
            chargingOrderService.chargeMonitoring(query);
        }
    }
    /**
     * 通过流水号查询订单
     * 通过流水号查询订单（统一前缀路由：SD=刷卡订单，VD=VIN订单，其余=普通订单）
     * <p>设备链路（实时监控/BMS需求/交易记录确认等）统一经此按订单号前缀取三类订单，
     * SD/VD 订单实体继承自 TChargingOrder，字段兼容直接返回。</p>
     * @param code
     * @return
     */
    @PostMapping(value = "/getOrderByCode/{code}")
    public R<TChargingOrder> getOrderByCode(@PathVariable("code") String code){
        TChargingOrder one = chargingOrderService.getOne(Wrappers.lambdaQuery(TChargingOrder.class)
                .eq(TChargingOrder::getCode, code));
        TChargingOrder one;
        if (isCardOrder(code)) {
            one = cardChargingOrderService.getCardOrderByCode(code);
        } else if (isVinOrder(code)) {
            one = vinChargingOrderService.getVinOrderByCode(code);
        } else {
            one = chargingOrderService.getOne(Wrappers.lambdaQuery(TChargingOrder.class)
                    .eq(TChargingOrder::getCode, code));
        }
        if (one == null) {
            return R.ok(null);
        }
        one.setIdStr(one.getId().toString());
        return R.ok(one);
    }
    
    
    
    

    @PostMapping("/updateHandshakeVin")
    public R<Boolean> updateHandshakeVin(@RequestParam("orderCode") String orderCode,
                                         @RequestParam("vin") String vin) {
        if (StringUtils.isEmpty(orderCode)) {
            return R.ok(false);
        }
        boolean updated;
        if (orderCode.startsWith("CD")) {
            updated = StringUtils.isNotEmpty(vin) && chargingOrderService.update(Wrappers.<TChargingOrder>lambdaUpdate()
                    .eq(TChargingOrder::getCode, orderCode)
                    .set(TChargingOrder::getActualVin, vin));
        } else if (orderCode.startsWith("SD")) {
            // SD/VD：VIN 为空也进入握手处理（状态推进必达）；服务内部仅非空回写 VIN，且仅状态=启动中(2)才推进
            updated = cardChargingOrderService.handleHandshakeVin(orderCode, vin);
        } else if (orderCode.startsWith("VD")) {
            updated = vinChargingOrderService.handleHandshakeVin(orderCode, vin);
        } else {
            log.warn("握手VIN回写失败，未知订单类型：{}", orderCode);
            return R.ok(false);
        }
        return R.ok(updated);
    }

    /**
     * 设备链路订单号前缀判断：SD=刷卡充电订单
     */
    private boolean isCardOrder(String orderCode) {
        return orderCode != null && orderCode.startsWith("SD");
    }

    /**
     * 设备链路订单号前缀判断：VD=VIN码充电订单
     */
    private boolean isVinOrder(String orderCode) {
        return orderCode != null && orderCode.startsWith("VD");
    }

    /**
     * 设备主动发起充电（刷卡/VIN码）鉴权建单统一入口。
     * <p>协议 start_method：1=刷卡（创建SD订单），2=账号启动（暂不支持），3=VIN码（创建VD订单）。</p>
     */
    @PostMapping("/inner/device-start-charging")
    public R<DeviceStartChargingVO> deviceStartCharging(@RequestBody DeviceStartChargingDTO dto) {
        if (dto == null || dto.getStartMethod() == null) {
            log.warn("[设备启动] 缺少启动方式，拒绝建单 dto={}", dto);
            return R.ok(DeviceStartChargingVO.fail(null));
        }
        DeviceStartChargingVO result;
        switch (dto.getStartMethod()) {
            case 1:
                result = cardChargingOrderService.startCardCharging(dto);
                break;
            case 3:
                result = vinChargingOrderService.startVinCharging(dto);
                break;
            case 2:
                // 账号启动暂不支持（协议无对应失败码，按最接近的“账户不存在”返回）
                log.warn("[设备启动] 账号启动方式暂不支持 pile={} account={}", dto.getChargingPileCode(), dto.getAccount());
                result = DeviceStartChargingVO.fail(1);
                break;
            default:
                log.warn("[设备启动] 未知启动方式 startMethod={} pile={} gun={}",
                        dto.getStartMethod(), dto.getChargingPileCode(), dto.getChargingGunCode());
                result = DeviceStartChargingVO.fail(null);
                break;
        }
        return R.ok(result);
    }

    /**
     * 内部接口：统计公司名下进行中充电订单数（三表合计，状态 2=启动中/3=充电中/4=停止中，
     * 账户模式切换：分配→共享 前校验使用）
     */
    @PostMapping("/inner/count-active-by-company")
    public R<Integer> countActiveByCompany(@RequestParam("companyId") Integer companyId) {
        if (companyId == null) {
            return R.ok(0);
        }
        try {
            List<Integer> activeStatuses = Arrays.asList(2, 3, 4);
            long count = 0L;
            count += chargingOrderService.lambdaQuery()
                    .eq(TChargingOrder::getCompanyId, companyId)
                    .in(TChargingOrder::getStatus, activeStatuses)
                    .count();
            count += cardChargingOrderService.lambdaQuery()
                    .eq(TCardChargingOrder::getCompanyId, companyId)
                    .in(TCardChargingOrder::getStatus, activeStatuses)
                    .count();
            count += vinChargingOrderService.lambdaQuery()
                    .eq(TVinChargingOrder::getCompanyId, companyId)
                    .in(TVinChargingOrder::getStatus, activeStatuses)
                    .count();
            return R.ok((int) count);
        } catch (RuntimeException ex) {
            log.error("统计公司进行中充电订单失败：companyId={}", companyId, ex);
            return R.fail("统计公司进行中充电订单失败:" + ex.getMessage());
        }
    }

    @RequiresPermissions(value = {"/chargingOperationAnalysis"}, logical = Logical.OR)
    @ResponseBody
    @PostMapping(value = "/charging/statistics")
@@ -3184,25 +3414,37 @@


    /**
     * 硬件充电结束后的处理逻辑
     * 硬件充电结束后的处理逻辑（按订单号前缀路由，结束方式2=设备自动结束）
     * @param code
     */
    @PostMapping("/endCharge")
    public void endCharge(@RequestParam("code") String code){
        log.info(code + "：-------------------充电桩自动结束充电-------------------");
        chargingOrderService.endCharge(code, 2);
        if (isCardOrder(code)) {
            cardChargingOrderService.cardEndCharge(code, 2);
        } else if (isVinOrder(code)) {
            vinChargingOrderService.vinEndCharge(code, 2);
        } else {
            chargingOrderService.endCharge(code, 2);
        }
    }



    /**
     * 硬件异常结束充电后的处理逻辑
     * 硬件异常结束充电后的处理逻辑（按订单号前缀路由，结束方式0=异常终止）
     * @param code
     */
    @PostMapping("/excelEndCharge")
    public void excelEndCharge(@RequestParam("code") String code){
        log.info(code + "：-------------------充电异常，停止充电-------------------");
        chargingOrderService.excelEndCharge(code);
        if (isCardOrder(code)) {
            cardChargingOrderService.cardEndCharge(code, 0);
        } else if (isVinOrder(code)) {
            vinChargingOrderService.vinEndCharge(code, 0);
        } else {
            chargingOrderService.excelEndCharge(code);
        }
    }