修改bug

puzhibing

6 小时以前 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;
@@ -1484,7 +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.getVin());
        chargingOrderInfoVO.setVin(byId.getActualVin());
        chargingOrderInfoVO.setActualVin(byId.getActualVin());
        if (byId.getAppUserCarId()!=null){
            TAppUserCar data = appUserCarClient.getCarById(byId.getAppUserCarId()+"").getData();
            if (data!=null){
@@ -1788,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);
        }
    }
    
    
@@ -1862,6 +1872,12 @@
    
    
    
    /**
     * 安全检测等待窗口（秒）：设备在此时长内未上报有效安全检测时，前端按「未插枪」提示用户，
     * 超时订单由启动超时兜底任务自动取消，避免订单永久停留在启动中状态。
     */
    private static final long STARTUP_WAIT_SECONDS = 90L;

    @ResponseBody
    @GetMapping(value = "/preChargeCheck/{id}")
    @ApiOperation(value = "获取安全检测数据", tags = {"小程序-扫一扫"})
@@ -1871,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);
@@ -1903,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);
    }

@@ -2303,22 +2351,41 @@
    }
    
    /**
     * 处理充电订单实时监控数据相关的业务逻辑
     * 处理充电订单实时监控数据相关的业务逻辑（按订单号前缀路由）
     * @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);
    }
@@ -2326,32 +2393,103 @@
    @PostMapping("/updateHandshakeVin")
    public R<Boolean> updateHandshakeVin(@RequestParam("orderCode") String orderCode,
                                         @RequestParam("vin") String vin) {
        if (StringUtils.isEmpty(orderCode) || StringUtils.isEmpty(vin)) {
        if (StringUtils.isEmpty(orderCode)) {
            return R.ok(false);
        }
        boolean updated;
        if (orderCode.startsWith("CD")) {
            updated = chargingOrderService.update(Wrappers.<TChargingOrder>lambdaUpdate()
            updated = StringUtils.isNotEmpty(vin) && chargingOrderService.update(Wrappers.<TChargingOrder>lambdaUpdate()
                    .eq(TChargingOrder::getCode, orderCode)
                    .set(TChargingOrder::getVin, vin));
                    .set(TChargingOrder::getActualVin, vin));
        } else if (orderCode.startsWith("SD")) {
            updated = cardChargingOrderService.update(Wrappers.<TCardChargingOrder>lambdaUpdate()
                    .eq(TCardChargingOrder::getCode, orderCode)
                    .set(TCardChargingOrder::getVin, vin));
            // SD/VD：VIN 为空也进入握手处理（状态推进必达）；服务内部仅非空回写 VIN，且仅状态=启动中(2)才推进
            updated = cardChargingOrderService.handleHandshakeVin(orderCode, vin);
        } else if (orderCode.startsWith("VD")) {
            updated = vinChargingOrderService.update(Wrappers.<TVinChargingOrder>lambdaUpdate()
                    .eq(TVinChargingOrder::getCode, orderCode)
                    .set(TVinChargingOrder::getVin, vin));
            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")
@@ -3276,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);
        }
    }