明星电力充电桩
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
puzhibing
2026-09-15 262eb0096f28537c2859f79cdfa466092dc4f898 
 ruoyi-service/ruoyi-order/src/main/java/com/ruoyi/order/service/impl/TVinChargingOrderServiceImpl.java


@@ -1,46 +1,132 @@


package com.ruoyi.order.service.impl;




import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.ruoyi.account.api.feignClient.AppUserClient;


import com.ruoyi.account.api.feignClient.VinManagementClient;


import com.ruoyi.account.api.model.TAppUser;


import com.ruoyi.account.api.model.TVinManagement;


import com.ruoyi.chargingPile.api.dto.GetSiteListDTO;


import com.ruoyi.chargingPile.api.feignClient.AccountingStrategyClient;


import com.ruoyi.chargingPile.api.feignClient.AccountingStrategyDetailClient;


import com.ruoyi.chargingPile.api.feignClient.ChargingGunClient;


import com.ruoyi.chargingPile.api.feignClient.ChargingPileClient;


import com.ruoyi.chargingPile.api.feignClient.SiteClient;


import com.ruoyi.chargingPile.api.model.Site;


import com.ruoyi.chargingPile.api.model.TAccountingStrategy;


import com.ruoyi.chargingPile.api.model.TAccountingStrategyDetail;


import com.ruoyi.chargingPile.api.model.TChargingGun;


import com.ruoyi.chargingPile.api.model.TChargingPile;


import com.ruoyi.chargingPile.api.vo.GetChargingGunByCode;


import com.ruoyi.common.core.domain.R;


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


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


import com.ruoyi.common.core.utils.bean.BeanUtils;


import com.ruoyi.common.core.web.domain.AjaxResult;


import com.ruoyi.common.core.web.page.PageInfo;


import com.ruoyi.common.security.service.TokenService;


import com.ruoyi.integration.api.feignClient.ChargingMessageClient;


import com.ruoyi.integration.api.feignClient.ChengDuJianGuanClient;


import com.ruoyi.integration.api.feignClient.SendMessageClient;


import com.ruoyi.integration.api.model.PlatformStopCharging;


import com.ruoyi.integration.api.model.UploadRealTimeMonitoringData;


import com.ruoyi.integration.api.vo.ChargingOrderVo;


import com.ruoyi.integration.api.vo.NotificationConnectorChargeStatusVo;


import com.ruoyi.order.api.dto.DeviceStartChargingDTO;


import com.ruoyi.order.api.model.TVinAccountingStrategyDetailOrder;


import com.ruoyi.order.api.model.TVinAccountingStrategyOrder;


import com.ruoyi.order.api.model.TVinChargingOrder;


import com.ruoyi.order.api.model.TVinChargingOrderAccountingStrategy;


import com.ruoyi.order.api.query.UploadRealTimeMonitoringDataQuery;


import com.ruoyi.order.api.query.VinChargingOrderQuery;


import com.ruoyi.order.api.vo.ChargingOrderVO;


import com.ruoyi.order.api.vo.DeviceStartChargingVO;


import com.ruoyi.order.api.vo.PlatformStartChargingReplyMessageVO;


import com.ruoyi.order.api.vo.PlatformStopChargingReplyVO;


import com.ruoyi.order.api.vo.TransactionRecordMessageVO;


import com.ruoyi.order.api.vo.VinChargingStatusVO;


import com.ruoyi.order.dto.MyVinChargingOrderList;


import com.ruoyi.order.mapper.TVinChargingOrderMapper;


import com.ruoyi.order.service.TVinAccountingStrategyDetailOrderService;


import com.ruoyi.order.service.TVinAccountingStrategyOrderService;


import com.ruoyi.order.service.TVinChargingOrderAccountingStrategyService;


import com.ruoyi.order.service.TVinChargingOrderService;


import com.ruoyi.order.util.TransactionStageParser;


import com.ruoyi.order.util.mongodb.service.UploadRealTimeMonitoringDataService;


import org.redisson.api.RLock;


import org.redisson.api.RedissonClient;


import org.slf4j.Logger;


import org.slf4j.LoggerFactory;


import org.springframework.stereotype.Service;


import org.springframework.transaction.support.TransactionTemplate;




import javax.annotation.Resource;


import java.math.BigDecimal;


import java.math.RoundingMode;


import java.text.SimpleDateFormat;


import java.time.LocalDateTime;


import java.time.ZoneId;


import java.time.format.DateTimeFormatter;


import java.time.format.DateTimeFormatterBuilder;


import java.time.format.DateTimeParseException;


import java.time.temporal.ChronoField;


import java.time.temporal.ChronoUnit;


import java.util.ArrayList;


import java.util.Collections;


import java.util.Comparator;


import java.util.Date;


import java.util.HashMap;


import java.util.List;


import java.util.Map;


import java.util.Objects;


import java.util.Optional;


import java.util.concurrent.TimeUnit;


import java.util.stream.Collectors;




@Service


public class TVinChargingOrderServiceImpl extends ServiceImpl<TVinChargingOrderMapper, TVinChargingOrder>


        implements TVinChargingOrderService {




    private static final Logger log = LoggerFactory.getLogger(TVinChargingOrderServiceImpl.class);




    /** VD 订单号前缀（设备VIN码充电） */


    private static final String ORDER_CODE_PREFIX_VD = "VD";


    /** 订单状态：启动中 */


    private static final int ORDER_STATUS_STARTING = 2;


    /** 订单状态：充电中 */


    private static final int ORDER_STATUS_CHARGING = 3;


    /** 订单状态：停止中 */


    private static final int ORDER_STATUS_STOPPING = 4;


    /** 订单状态：已结束 */


    private static final int ORDER_STATUS_FINISHED = 5;


    /** 订单状态：启动失败（沿用 t_charging_order 枚举约定：-1 为负值语义，前端按 status<0 渲染） */


    private static final int ORDER_STATUS_START_FAILED = -1;


    /** 充电枪状态：充电中 */


    private static final int GUN_STATUS_CHARGING = 4;


    /** 充电枪状态：空闲 */


    private static final int GUN_STATUS_IDLE = 2;


    /** VD 建单枪锁前缀（桩+枪维度，防同枪并发建单，文档13.2） */


    private static final String LOCK_VD_START_GUN = "VD_START_GUN:";


    /** VD 建单VIN锁前缀（VIN ID维度，防同VIN多枪并发启动，文档13.2） */


    private static final String LOCK_VD_START_VIN = "VD_START_VIN:";


    /** VD 结算锁前缀（订单号维度，防并发重复结算，文档13.3） */


    private static final String LOCK_VD_SETTLE = "VD_SETTLE:";


    /** VD 启动中超时阈值（分钟）：超时未收到启动成功应答则关单 */


    private static final int VD_STARTING_TIMEOUT_MINUTES = 30;


    /** VD 充电中超时阈值（小时）：超时未收到交易记录则兜底结算 */


    private static final int VD_CHARGING_TIMEOUT_HOURS = 24;


    /** 列表/详情回填 VIN 信息时，单次批量远程查询的最大 ids 数量 */


    private static final int VIN_BACKFILL_BATCH_SIZE = 500;




    @Resource


    private TokenService tokenService;


    @Resource


    private ChargingMessageClient chargingMessageClient;


    @Resource


    private ChengDuJianGuanClient chengDuJianGuanClient;


    @Resource


    private VinManagementClient vinManagementClient;


    @Resource


    private AppUserClient appUserClient;


    @Resource


    private SiteClient siteClient;


    @Resource


@@ -51,6 +137,20 @@


    private SendMessageClient sendMessageClient;


    @Resource


    private UploadRealTimeMonitoringDataService monitoringDataService;


    @Resource


    private AccountingStrategyClient accountingStrategyClient;


    @Resource


    private AccountingStrategyDetailClient accountingStrategyDetailClient;


    @Resource


    private TVinAccountingStrategyOrderService vinAccountingStrategyOrderService;


    @Resource


    private TVinAccountingStrategyDetailOrderService vinAccountingStrategyDetailOrderService;


    @Resource


    private TVinChargingOrderAccountingStrategyService vinChargingOrderAccountingStrategyService;


    @Resource


    private TransactionTemplate transactionTemplate;


    @Resource


    private RedissonClient redissonClient;




    @Override


    public PageInfo<ChargingOrderVO> pageList(VinChargingOrderQuery query) {


@@ -68,6 +168,81 @@


    }




    @Override


    public PageInfo<MyVinChargingOrderList> pageAppletOrders(Integer pageCurr, Integer pageSize) {


        int current = pageCurr == null || pageCurr < 1 ? 1 : pageCurr;


        int size = pageSize == null || pageSize < 1 ? 10 : Math.min(pageSize, 100);


        PageInfo<MyVinChargingOrderList> page = new PageInfo<>(current, size);


        if (tokenService.getLoginUserApplet() == null || tokenService.getLoginUserApplet().getUserId() == null) {


            page.setTotal(0);


            page.setRecords(Collections.emptyList());


            return page;


        }


        Long appUserId = tokenService.getLoginUserApplet().getUserId();


        R<List<Long>> vinIdResponse = vinManagementClient.getVinIdsByAppUserId(appUserId);


        List<Long> vinIds = vinIdResponse == null ? Collections.emptyList()


                : Optional.ofNullable(vinIdResponse.getData()).orElse(Collections.emptyList());


        if (vinIds.isEmpty()) {


            page.setTotal(0);


            page.setRecords(Collections.emptyList());


            return page;


        }


        long total = baseMapper.countAppletOrders(vinIds);


        page.setTotal(total);


        List<MyVinChargingOrderList> records = total == 0 ? Collections.emptyList()


                : baseMapper.pageAppletOrders(vinIds, (long) (current - 1) * size, size);


        fillAppletExtra(records);


        page.setRecords(records);


        return page;


    }




    @Override


    public Map<String, Object> appletDetail(Long chargingOrderId) {


        TVinChargingOrder order = getAuthorizedAppletOrder(chargingOrderId);


        if (order == null) {


            return Collections.emptyMap();


        }


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


        result.put("id", String.valueOf(order.getId()));


        result.put("chargingGunId", order.getChargingGunId());


        result.put("code", order.getCode());


        result.put("createTime", order.getCreateTime() == null ? null


                : order.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));


        result.put("status", order.getStatus());


        result.put("licensePlate", order.getPlateNum());


        result.put("startTime", toEpochMilli(order.getStartTime()));


        result.put("endTime", toEpochMilli(order.getEndTime()));


        result.put("orderAmount", order.getOrderAmount());


        result.put("paymentAmount", order.getPaymentAmount());


        result.put("rechargeAmount", order.getRechargeAmount());


        result.put("couponDiscountAmount", order.getCouponDiscountAmount());


        result.put("vipDiscountAmount", order.getVipDiscountAmount());


        result.put("refundAmount", order.getRefundAmount());


        result.put("electricMoney", order.getElectrovalence());


        result.put("serviceMoney", order.getServiceCharge());


        result.put("totalElectricQuantity", order.getChargingCapacity());


        result.put("stageCost", baseMapper.accountingStrategyList(order.getId()));


        result.put("actionable", 0);


        result.put("isAppeal", 0);




        Site site = getSite(order.getSiteId());


        result.put("title", site == null ? "未知电站" : site.getName());


        TChargingGun gun = getGun(order.getChargingGunId());


        result.put("chargeMode", gun == null ? null : gun.getChargeMode());


        result.put("name", gun == null ? null : gun.getName());


        fillAppletMonitoring(result, order.getCode());


        return result;


    }




    @Override


    public List<VinChargingStatusVO> getChargingVinStatus(List<Long> vinIds) {


        if (vinIds == null || vinIds.isEmpty()) {


            return Collections.emptyList();


        }


        List<Long> distinctVinIds = vinIds.stream().filter(Objects::nonNull).distinct().collect(Collectors.toList());


        return distinctVinIds.isEmpty() ? Collections.emptyList() : baseMapper.getChargingVinStatus(distinctVinIds);


    }




    @Override


    public List<ChargingOrderVO> exportList(VinChargingOrderQuery query) {


        setAuthSiteIds(query);


        long total = baseMapper.count(query);


@@ -80,6 +255,7 @@


            result.addAll(batch);


        }


        fillExtra(result);


        fillRealtimeData(result);


        return result;


    }




@@ -99,11 +275,19 @@


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


        result.put("id", order.getId() == null ? null : String.valueOf(order.getId()));


        result.put("code", order.getCode());


        result.put("vin", order.getActualVin());


        // 订单VIN快照为空时回填 VIN 管理登记值（历史订单无快照），前端按 actualVin → expectedVin → vin 取值


        TVinManagement vinRecord = order.getVinId() == null ? null


                : loadVinRecords(Collections.singletonList(order.getVinId())).get(order.getVinId());


        String vinCode = StringUtils.isEmpty(order.getActualVin()) ? order.getExpectedVin() : order.getActualVin();


        if (StringUtils.isEmpty(vinCode) && vinRecord != null) {


            vinCode = vinRecord.getVin();


        }


        result.put("vin", vinCode);


        result.put("actualVin", order.getActualVin());


        result.put("expectedVin", order.getExpectedVin());


        result.put("plateNum", order.getPlateNum());


        result.put("phone", order.getPhone());


        result.put("plateNum", StringUtils.isEmpty(order.getPlateNum()) && vinRecord != null


                ? vinRecord.getPlateNumber() : order.getPlateNum());


        result.put("phone", resolvePhone(order.getPhone(), order.getAppUserId(), vinRecord));


        result.put("status", order.getStatus());


        result.put("siteId", order.getSiteId());


        result.put("chargingPileId", order.getChargingPileId());


@@ -220,6 +404,104 @@


                .orElse(Collections.emptyList()).stream().map(GetSiteListDTO::getId).collect(Collectors.toList());


    }




    private TVinChargingOrder getAuthorizedAppletOrder(Long chargingOrderId) {


        if (chargingOrderId == null || tokenService.getLoginUserApplet() == null


                || tokenService.getLoginUserApplet().getUserId() == null) {


            return null;


        }


        TVinChargingOrder order = getById(chargingOrderId);


        if (order == null || order.getVinId() == null) {


            return null;


        }


        R<List<Long>> response = vinManagementClient.getVinIdsByAppUserId(


                tokenService.getLoginUserApplet().getUserId());


        List<Long> vinIds = response == null ? Collections.emptyList()


                : Optional.ofNullable(response.getData()).orElse(Collections.emptyList());


        return vinIds.contains(order.getVinId()) ? order : null;


    }




    private Long toEpochMilli(LocalDateTime time) {


        return time == null ? null : time.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();


    }




    private Site getSite(Integer siteId) {


        if (siteId == null) {


            return null;


        }


        R<List<Site>> response = siteClient.getSiteByIds(Collections.singletonList(siteId));


        List<Site> sites = response == null ? Collections.emptyList()


                : Optional.ofNullable(response.getData()).orElse(Collections.emptyList());


        return sites.stream().findFirst().orElse(null);


    }




    private TChargingGun getGun(Integer gunId) {


        if (gunId == null) {


            return null;


        }


        R<TChargingGun> response = chargingGunClient.getChargingGunById(gunId);


        return response == null ? null : response.getData();


    }




    private void fillAppletMonitoring(Map<String, Object> result, String orderCode) {


        List<UploadRealTimeMonitoringData> dataList = orderCode == null ? Collections.emptyList()


                : monitoringDataService.getDataByOrderCode(orderCode);


        if (dataList == null || dataList.isEmpty()) {


            result.put("currentAndVoltage", Collections.emptyList());


            result.put("power", Collections.emptyList());


            return;


        }


        SimpleDateFormat formatter = new SimpleDateFormat("HH:mm");


        Map<String, UploadRealTimeMonitoringData> minuteData = new java.util.LinkedHashMap<>();


        for (UploadRealTimeMonitoringData data : dataList) {


            if (data != null && data.getCreate_time() != null) {


                minuteData.putIfAbsent(formatter.format(data.getCreate_time()), data);


            }


        }


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


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


        for (Map.Entry<String, UploadRealTimeMonitoringData> entry : minuteData.entrySet()) {


            UploadRealTimeMonitoringData data = entry.getValue();


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


            currentItem.put("time", entry.getKey());


            currentItem.put("electricity", data.getOutput_current());


            currentItem.put("voltage", data.getOutput_voltage());


            currentAndVoltage.add(currentItem);




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


            powerItem.put("time", entry.getKey());


            powerItem.put("soc", data.getSoc());


            BigDecimal outputPower = data.getOutput_current() == null || data.getOutput_voltage() == null ? null


                    : data.getOutput_current().multiply(data.getOutput_voltage())


                    .divide(new BigDecimal("1000"), 2, RoundingMode.HALF_DOWN);


            powerItem.put("power", outputPower);


            power.add(powerItem);


        }


        result.put("currentAndVoltage", currentAndVoltage);


        result.put("power", power);


    }




    private void fillAppletExtra(List<MyVinChargingOrderList> list) {


        if (list == null || list.isEmpty()) {


            return;


        }


        List<Integer> siteIds = list.stream().map(MyVinChargingOrderList::getSiteId)


                .filter(Objects::nonNull).distinct().collect(Collectors.toList());


        List<Integer> gunIds = list.stream().map(MyVinChargingOrderList::getChargingGunId)


                .filter(Objects::nonNull).distinct().collect(Collectors.toList());


        Map<Integer, Site> sites = siteIds.isEmpty() ? Collections.emptyMap()


                : Optional.ofNullable(siteClient.getSiteByIds(siteIds).getData()).orElse(Collections.emptyList()).stream()


                .collect(Collectors.toMap(Site::getId, item -> item, (a, b) -> a));


        Map<Integer, TChargingGun> guns = gunIds.isEmpty() ? Collections.emptyMap()


                : Optional.ofNullable(chargingGunClient.getChargingGunByIds(gunIds).getData()).orElse(Collections.emptyList()).stream()


                .collect(Collectors.toMap(TChargingGun::getId, item -> item, (a, b) -> a));


        for (MyVinChargingOrderList item : list) {


            Site site = sites.get(item.getSiteId());


            item.setTitle(site == null ? "未知电站" : site.getName());


            TChargingGun gun = guns.get(item.getChargingGunId());


            item.setName(gun == null ? null : gun.getName());


        }


    }




    private void fillExtra(List<ChargingOrderVO> list) {


        if (list == null || list.isEmpty()) {


            return;


@@ -255,5 +537,801 @@


            item.setPlatformIncome(BigDecimal.ZERO);


            item.setPartnerIncome(BigDecimal.ZERO);


        }


        fillVinInfoAndPhone(list);


    }




    /**


     * 回填 VIN 码/车牌号/手机号：订单快照为空时取 VIN 管理登记值（历史订单无快照），


     * 手机号再以 App 用户当前手机号兜底。远程调用失败仅跳过回填，不影响列表其他字段。


     */


    private void fillVinInfoAndPhone(List<ChargingOrderVO> list) {


        if (list == null || list.isEmpty()) {


            return;


        }


        List<Long> vinIds = list.stream().map(ChargingOrderVO::getVinId)


                .filter(Objects::nonNull).distinct().collect(Collectors.toList());


        Map<Long, TVinManagement> vinRecords = loadVinRecords(vinIds);


        for (ChargingOrderVO item : list) {


            TVinManagement vinRecord = item.getVinId() == null ? null : vinRecords.get(item.getVinId());


            if (vinRecord == null) {


                continue;


            }


            if (StringUtils.isEmpty(item.getVin())) {


                item.setVin(vinRecord.getVin());


            }


            if (StringUtils.isEmpty(item.getPlateNum())) {


                item.setPlateNum(vinRecord.getPlateNumber());


            }


            if (StringUtils.isEmpty(item.getPhone())) {


                item.setPhone(vinRecord.getPhone());


            }


        }


        List<Long> appUserIds = list.stream()


                .filter(item -> StringUtils.isEmpty(item.getPhone()) && item.getAppUserId() != null)


                .map(ChargingOrderVO::getAppUserId).distinct().collect(Collectors.toList());


        if (appUserIds.isEmpty()) {


            return;


        }


        Map<Long, String> userPhones = loadAppUserPhones(appUserIds);


        for (ChargingOrderVO item : list) {


            if (StringUtils.isEmpty(item.getPhone()) && item.getAppUserId() != null) {


                String phone = userPhones.get(item.getAppUserId());


                if (StringUtils.isNotEmpty(phone)) {


                    item.setPhone(phone);


                }


            }


        }


    }




    /** 手机号回填优先级：订单值 → VIN 记录手机号 → App 用户当前手机号 */


    private String resolvePhone(String phone, Long appUserId, TVinManagement vinRecord) {


        if (StringUtils.isNotEmpty(phone)) {


            return phone;


        }


        if (vinRecord != null && StringUtils.isNotEmpty(vinRecord.getPhone())) {


            return vinRecord.getPhone();


        }


        if (appUserId == null) {


            return null;


        }


        return loadAppUserPhones(Collections.singletonList(appUserId)).get(appUserId);


    }




    /** 按 VIN 记录ID批量查询，每批 {@link #VIN_BACKFILL_BATCH_SIZE} 个，失败返回已取到的数据 */


    private Map<Long, TVinManagement> loadVinRecords(List<Long> vinIds) {


        Map<Long, TVinManagement> result = new HashMap<>();


        if (vinIds == null || vinIds.isEmpty()) {


            return result;


        }


        for (int index = 0; index < vinIds.size(); index += VIN_BACKFILL_BATCH_SIZE) {


            List<Long> batch = vinIds.subList(index, Math.min(index + VIN_BACKFILL_BATCH_SIZE, vinIds.size()));


            try {


                R<List<TVinManagement>> response = vinManagementClient.getVinByIds(new ArrayList<>(batch));


                if (response == null || response.getData() == null) {


                    continue;


                }


                for (TVinManagement record : response.getData()) {


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


                        result.putIfAbsent(record.getId(), record);


                    }


                }


            } catch (Exception e) {


                log.warn("[VD回填] 批量查询VIN记录失败 ids={}", batch, e);


            }


        }


        return result;


    }




    /** 按 App 用户ID批量查询当前手机号，每批 {@link #VIN_BACKFILL_BATCH_SIZE} 个，失败返回已取到的数据 */


    private Map<Long, String> loadAppUserPhones(List<Long> appUserIds) {


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


        for (int index = 0; index < appUserIds.size(); index += VIN_BACKFILL_BATCH_SIZE) {


            List<Long> batch = appUserIds.subList(index, Math.min(index + VIN_BACKFILL_BATCH_SIZE, appUserIds.size()));


            try {


                R<List<TAppUser>> response = appUserClient.getUserByIds(new ArrayList<>(batch));


                if (response == null || response.getData() == null) {


                    continue;


                }


                for (TAppUser user : response.getData()) {


                    if (user != null && user.getId() != null && StringUtils.isNotEmpty(user.getPhone())) {


                        result.putIfAbsent(user.getId(), user.getPhone());


                    }


                }


            } catch (Exception e) {


                log.warn("[VD回填] 批量查询App用户手机号失败 ids={}", batch, e);


            }


        }


        return result;


    }




    private void fillRealtimeData(List<ChargingOrderVO> list) {


        for (ChargingOrderVO item : list) {


            if (item.getCode() == null || item.getCode().trim().isEmpty()) {


                continue;


            }


            UploadRealTimeMonitoringData data = monitoringDataService.getLastDataById(item.getCode());


            if (data == null) {


                continue;


            }


            item.setChargeCurrent(data.getOutput_current());


            item.setChargeVoltage(data.getOutput_voltage());


            BigDecimal power = data.getPower();


            if (power == null && data.getOutput_current() != null && data.getOutput_voltage() != null) {


                power = data.getOutput_current().multiply(data.getOutput_voltage())


                        .divide(new BigDecimal(1000), 2, BigDecimal.ROUND_HALF_UP);


            }


            item.setChargePower(power);


        }


    }




    // ===== 设备侧VIN码充电链路（V0.2 VIN码充电） =====




    @Override


    public DeviceStartChargingVO startVinCharging(DeviceStartChargingDTO dto) {


        if (dto == null || StringUtils.isEmpty(dto.getChargingPileCode())


                || StringUtils.isEmpty(dto.getChargingGunCode()) || StringUtils.isEmpty(dto.getAccount())) {


            return DeviceStartChargingVO.fail(9);


        }


        // 并发防护（文档13.2）：桩+枪维度分布式锁，抢不到说明同枪并发启动，快速失败


        RLock gunLock = redissonClient.getLock(LOCK_VD_START_GUN + dto.getChargingPileCode() + ":" + dto.getChargingGunCode());


        try {


            if (!gunLock.tryLock(0, 30, TimeUnit.SECONDS)) {


                return DeviceStartChargingVO.fail(10);


            }


            // 1. 充电枪校验


            GetChargingGunByCode gunQuery = new GetChargingGunByCode();


            gunQuery.setCharging_pile_code(dto.getChargingPileCode());


            gunQuery.setCharging_gun_code(dto.getChargingGunCode());


            TChargingGun gun = chargingGunClient.getChargingGunByCode(gunQuery).getData();


            if (gun == null) {


                return DeviceStartChargingVO.fail(5);


            }


            if (gun.getStatus() != null && gun.getStatus() == GUN_STATUS_CHARGING) {


                return DeviceStartChargingVO.fail(10);


            }


            TChargingPile pile = gun.getChargingPileId() == null ? null


                    : chargingPileClient.getChargingPileById(gun.getChargingPileId()).getData();


            Site site = gun.getSiteId() == null ? null


                    : Optional.ofNullable(siteClient.getSiteByIds(Collections.singletonList(gun.getSiteId())).getData())


                            .orElse(Collections.emptyList()).stream().findFirst().orElse(null);




            // 2. VIN反序解析与绑定校验（协议要求VIN码反序上送）


            String vin = new StringBuilder(dto.getAccount().trim()).reverse().toString();


            TVinManagement vinRecord = vinManagementClient.getVinByCode(vin).getData();


            if (vinRecord == null) {


                return DeviceStartChargingVO.fail(9);


            }


            if (vinRecord.getStatus() == null || vinRecord.getStatus() != 1) {


                return DeviceStartChargingVO.fail(2);


            }




            // 并发防护（文档13.2）：VIN ID维度锁，防同VIN多枪并发建单


            RLock vinLock = redissonClient.getLock(LOCK_VD_START_VIN + vinRecord.getId());


            boolean vinLocked = false;


            try {


                vinLocked = vinLock.tryLock(0, 30, TimeUnit.SECONDS);


                if (!vinLocked) {


                    return DeviceStartChargingVO.fail(10);


                }


                // 3. 建单（状态2 启动中）


                TVinChargingOrder order = new TVinChargingOrder();


                order.setCode(ORDER_CODE_PREFIX_VD + Double.valueOf(Math.random() * 1000).intValue() + new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()));


                order.setOrderType(2);


                order.setOrderSource(1);


                order.setOrderClassification(2);


                // VD 无支付动作（后付记账模式，不执行在线支付/扣款）：payMethod 留空，


                // 不套用 CD 余额支付枚举，避免下游按支付模式误判走余额扣款逻辑


                order.setStatus(ORDER_STATUS_STARTING);


                order.setTitle("【充电桩充电】" + (pile != null && pile.getNumber() != null ? pile.getNumber() : dto.getChargingPileCode())


                        + "号桩/" + dto.getChargingGunCode() + "号枪");


                order.setSiteId(gun.getSiteId());


                order.setChargingPileId(gun.getChargingPileId());


                order.setChargingGunId(gun.getId());


                order.setVinId(vinRecord.getId());


                order.setAppUserId(vinRecord.getAppUserId());


                // VIN 码/车牌快照落库（协议上报为反序VIN，此处存解析后的正序VIN），保证列表与详情直接可见


                order.setExpectedVin(vinRecord.getVin());


                order.setActualVin(vin);


                order.setPlateNum(vinRecord.getPlateNumber());


                order.setCreateTime(LocalDateTime.now());


                save(order);




                // 4. 计费策略快照（枪策略优先，站点策略兜底）


                Integer strategyId = gun.getAccountingStrategyId() != null


                        ? gun.getAccountingStrategyId()


                        : (site == null ? null : site.getAccountingStrategyId());


                try {


                    saveStrategySnapshot(order.getId(), strategyId);


                } catch (Exception snapshotEx) {


                    log.error("[VD建单] 保存计费策略快照失败 orderId={} strategyId={}", order.getId(), strategyId, snapshotEx);


                }


                log.info("[VD建单] VIN码充电订单创建成功 code={} vinId={} gun={}", order.getCode(), vinRecord.getId(), dto.getChargingGunCode());


                return DeviceStartChargingVO.success(order.getCode(), null);


            } finally {


                if (vinLocked && vinLock.isHeldByCurrentThread()) {


                    vinLock.unlock();


                }


            }


        } catch (InterruptedException ie) {


            Thread.currentThread().interrupt();


            log.error("[VD建单] 建单锁获取被中断 pile={} gun={}", dto.getChargingPileCode(), dto.getChargingGunCode(), ie);


            return DeviceStartChargingVO.fail(null);


        } catch (Exception e) {


            log.error("[VD建单] VIN码充电启动异常 pile={} gun={} account={}",


                    dto.getChargingPileCode(), dto.getChargingGunCode(), dto.getAccount(), e);


            return DeviceStartChargingVO.fail(null);


        } finally {


            if (gunLock.isHeldByCurrentThread()) {


                gunLock.unlock();


            }


        }


    }




    /**


     * 保存VIN订单计费策略快照（主表 + 明细表）


     */


    private void saveStrategySnapshot(Long orderId, Integer strategyId) {


        if (strategyId == null) {


            return;


        }


        TAccountingStrategy strategy = accountingStrategyClient.getAccountingStrategyById(strategyId).getData();


        List<TAccountingStrategyDetail> details = accountingStrategyDetailClient.getListByAccountingStrategyId(strategyId).getData();


        if (strategy == null || details == null || details.isEmpty()) {


            return;


        }


        TVinAccountingStrategyOrder strategyOrder = new TVinAccountingStrategyOrder();


        BeanUtils.copyProperties(strategy, strategyOrder);


        strategyOrder.setChargingOrderId(orderId);


        vinAccountingStrategyOrderService.save(strategyOrder);


        List<TVinAccountingStrategyDetailOrder> detailOrders = new ArrayList<>();


        for (TAccountingStrategyDetail detail : details) {


            TVinAccountingStrategyDetailOrder detailOrder = new TVinAccountingStrategyDetailOrder();


            BeanUtils.copyProperties(detail, detailOrder);


            detailOrder.setChargingOrderId(orderId);


            detailOrders.add(detailOrder);


        }


        vinAccountingStrategyDetailOrderService.saveBatch(detailOrders);


    }




    @Override


    public TVinChargingOrder getVinOrderByCode(String code) {


        if (StringUtils.isEmpty(code)) {


            return null;


        }


        return getOne(new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TVinChargingOrder>()


                .eq(TVinChargingOrder::getCode, code)


                .last("limit 1"));


    }




    @Override


    public void vinStartChargeSuccessfully(PlatformStartChargingReplyMessageVO vo) {


        if (vo == null || StringUtils.isEmpty(vo.getTransaction_serial_number())) {


            return;


        }


        TVinChargingOrder order = getVinOrderByCode(vo.getTransaction_serial_number());


        if (order == null) {


            return;


        }


        // 只有启动中订单可消费启动应答，防止迟到消息复活已关闭/已结束订单


        if (!Integer.valueOf(ORDER_STATUS_STARTING).equals(order.getStatus())) {


            return;


        }


        if (vo.getStartup_result() != null && vo.getStartup_result() == 1) {


            boolean updated = lambdaUpdate()


                    .eq(TVinChargingOrder::getId, order.getId())


                    .eq(TVinChargingOrder::getStatus, ORDER_STATUS_STARTING)


                    .set(TVinChargingOrder::getStatus, ORDER_STATUS_CHARGING)


                    .set(TVinChargingOrder::getStartTime, LocalDateTime.now())


                    .update();


            if (!updated) {


                return;


            }


            updateGunStatusQuietly(order, GUN_STATUS_CHARGING, "启动成功");


            log.info("[VD启动] VIN订单进入充电中 code={}", order.getCode());


            order.setStatus(ORDER_STATUS_CHARGING);


            pushRegulatoryAsync(order, true, false);


        } else {


            closeTimeoutStartingOrder(order);


            log.warn("[VD启动] VIN订单启动失败关闭 code={} result={}", order.getCode(), vo.getStartup_result());


        }


    }




    @Override


    public boolean handleHandshakeVin(String orderCode, String vin) {


        if (StringUtils.isEmpty(orderCode)) {


            return false;


        }


        TVinChargingOrder order = getVinOrderByCode(orderCode);


        if (order == null) {


            log.warn("[VD握手] 订单不存在 code={}", orderCode);


            return false;


        }


        TVinChargingOrder update = new TVinChargingOrder();


        update.setId(order.getId());


        boolean needUpdate = false;


        if (StringUtils.isNotEmpty(vin)) {


            update.setActualVin(vin);


            needUpdate = true;


        }


        boolean advanced = order.getStatus() != null && order.getStatus() == ORDER_STATUS_STARTING;


        if (advanced) {


            update.setStatus(ORDER_STATUS_CHARGING);


            if (order.getStartTime() == null) {


                update.setStartTime(LocalDateTime.now());


            }


            needUpdate = true;


        }


        if (!needUpdate) {


            return true;


        }


        boolean updated;


        if (advanced) {


            updated = update(update, new com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<TVinChargingOrder>()


                    .eq(TVinChargingOrder::getId, order.getId())


                    .eq(TVinChargingOrder::getStatus, ORDER_STATUS_STARTING));


        } else {


            updated = updateById(update);


        }


        if (advanced && updated) {


            updateGunStatusQuietly(order, GUN_STATUS_CHARGING, "握手恢复");


            order.setStatus(ORDER_STATUS_CHARGING);


            pushRegulatoryAsync(order, true, false);


            log.info("[VD握手] 握手推进订单进入充电中 code={}", orderCode);


        }


        return updated;


    }




    @Override


    public void vinChargeMonitoring(UploadRealTimeMonitoringDataQuery query) {


        if (query == null || StringUtils.isEmpty(query.getTransaction_serial_number())) {


            return;


        }


        TVinChargingOrder order = getVinOrderByCode(query.getTransaction_serial_number());


        if (order == null) {


            return;


        }


        // 只接收启动中/充电中的监控数据，禁止迟到数据复活终态订单


        if (!Integer.valueOf(ORDER_STATUS_STARTING).equals(order.getStatus())


                && !Integer.valueOf(ORDER_STATUS_CHARGING).equals(order.getStatus())) {


            return;


        }


        TVinChargingOrder update = new TVinChargingOrder();


        update.setId(order.getId());


        boolean starting = Integer.valueOf(ORDER_STATUS_STARTING).equals(order.getStatus());


        if (starting) {


            update.setStatus(ORDER_STATUS_CHARGING);


            if (order.getStartTime() == null) {


                update.setStartTime(LocalDateTime.now());


            }


        }


        if (query.getOutput_current() != null && query.getOutput_current().compareTo(BigDecimal.ZERO) != 0


                && query.getOutput_voltage() != null) {


            BigDecimal power = query.getOutput_current().multiply(query.getOutput_voltage())


                    .divide(new BigDecimal(1000), 2, BigDecimal.ROUND_HALF_UP);


            update.setChargingPower(power);


            update.setCurrent(query.getOutput_current());


            update.setVoltage(query.getOutput_voltage());


            update.setPower(power);


            update.setNeedElec(query.getOutput_current());


            TChargingGun gun = new TChargingGun();


            gun.setId(order.getChargingGunId());


            gun.setChargingPower(power);


            chargingGunClient.updateChargingGunById(gun);


        }


        if (query.getCharging_degree() != null) {


            update.setChargingCapacity(query.getCharging_degree());


            update.setElectricity(query.getCharging_degree());


        }


        boolean updated = update(update, new com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<TVinChargingOrder>()


                .eq(TVinChargingOrder::getId, order.getId())


                .in(TVinChargingOrder::getStatus, ORDER_STATUS_STARTING, ORDER_STATUS_CHARGING));


        if (starting && updated) {


            updateGunStatusQuietly(order, GUN_STATUS_CHARGING, "实时数据恢复");


        }


    }




    @Override


    public void vinEndCharge(String orderCode, Integer endMode) {


        if (StringUtils.isEmpty(orderCode)) {


            return;


        }


        TVinChargingOrder order = getVinOrderByCode(orderCode);


        if (order == null) {


            return;


        }


        TVinChargingOrder update = new TVinChargingOrder();


        update.setId(order.getId());


        update.setEndMode(endMode);


        updateById(update);


        pushRegulatoryAsync(order, false, false);


    }




    @Override


    public R vinEndChargeBillingCharge(TransactionRecordMessageVO vo) {


        String code = vo == null ? null : vo.getTransaction_serial_number();


        log.info("[VD结算] 收到交易记录 code={}", code);


        if (StringUtils.isEmpty(code)) {


            return R.fail("交易记录缺少交易流水号");


        }


        // 结算锁（文档13.3 统一结算入口第一层）：订单号维度，防并发/重复账单同时进入结算；


        // 抢不到锁说明正在结算，按重复账单语义返回成功；锁内仍有状态幂等第二层兜底


        RLock settleLock = redissonClient.getLock(LOCK_VD_SETTLE + code);


        try {


            if (!settleLock.tryLock(5, 60, TimeUnit.SECONDS)) {


                log.warn("[VD结算] 并发结算进行中，跳过重复账单 code={}", code);


                return R.ok("重复账单，结算处理中");


            }


            return doVinEndChargeBillingCharge(vo, code);


        } catch (InterruptedException ie) {


            Thread.currentThread().interrupt();


            return R.fail("结算锁获取被中断：" + code);


        } finally {


            if (settleLock.isHeldByCurrentThread()) {


                settleLock.unlock();


            }


        }


    }




    /**


     * VD 结算实际执行体（调用前须持有订单号结算锁）


     */


    private R doVinEndChargeBillingCharge(TransactionRecordMessageVO vo, String code) {


        TVinChargingOrder order = getVinOrderByCode(code);


        if (order == null) {


            return R.fail("VIN码充电订单不存在：" + code);


        }


        if (order.getStatus() != null && order.getStatus() == ORDER_STATUS_FINISHED) {


            log.warn("[VD结算] 重复账单跳过 code={}", code);


            return R.ok("重复账单，已按首次账单结算");


        }


        if (order.getStatus() != null && order.getStatus() == ORDER_STATUS_START_FAILED) {


            return R.ok("订单已关闭，跳过结算");


        }




        List<TransactionStageParser.PeriodElectricity> reportedPeriods =


                TransactionStageParser.parsePeriodElectricity(vo);


        BigDecimal totalElectricity = reportedPeriods.stream()


                .map(TransactionStageParser.PeriodElectricity::getElectricity)


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


        if (totalElectricity.compareTo(BigDecimal.ZERO) <= 0 && vo.getTotal_electricity() != null) {


            totalElectricity = vo.getTotal_electricity();


        }




        List<TVinAccountingStrategyDetailOrder> snapshots = new ArrayList<>(vinAccountingStrategyDetailOrderService


                .lambdaQuery().eq(TVinAccountingStrategyDetailOrder::getChargingOrderId, order.getId())


                .list());


        snapshots.removeIf(item -> item.getType() == null);


        snapshots.sort(Comparator.comparing(TVinAccountingStrategyDetailOrder::getStartTime,


                Comparator.nullsLast(String::compareTo)));




        BigDecimal electrovalenceTotal = BigDecimal.ZERO;


        BigDecimal serviceChargeTotal = BigDecimal.ZERO;


        List<TVinChargingOrderAccountingStrategy> details = new ArrayList<>();


        // 严格对齐 CD：遍历按 start_time 排序后的策略，第 N 段只读取该策略类型对应的 chargeN。


        for (int snapshotIndex = 0; snapshotIndex < snapshots.size(); snapshotIndex++) {


            TVinAccountingStrategyDetailOrder snapshot = snapshots.get(snapshotIndex);


            BigDecimal capacity = TransactionStageParser.getPeriodElectricity(


                    vo, snapshot.getType(), snapshotIndex + 1);


            if (capacity == null || capacity.compareTo(BigDecimal.ZERO) <= 0) {


                continue;


            }


            BigDecimal electricPrice = snapshot.getElectrovalence() == null ? BigDecimal.ZERO : snapshot.getElectrovalence();


            BigDecimal servicePrice = snapshot.getServiceCharge() == null ? BigDecimal.ZERO : snapshot.getServiceCharge();


            BigDecimal originalServicePrice = snapshot.getCostServiceCharge() == null


                    ? BigDecimal.ZERO : snapshot.getCostServiceCharge();


            BigDecimal electricAmount = capacity.multiply(electricPrice).setScale(2, BigDecimal.ROUND_HALF_UP);


            BigDecimal serviceAmount = capacity.multiply(servicePrice).setScale(2, BigDecimal.ROUND_HALF_UP);


            BigDecimal originalServiceAmount = capacity.multiply(originalServicePrice).setScale(2, BigDecimal.ROUND_HALF_UP);


            electrovalenceTotal = electrovalenceTotal.add(electricAmount);


            serviceChargeTotal = serviceChargeTotal.add(serviceAmount);




            TVinChargingOrderAccountingStrategy detail = new TVinChargingOrderAccountingStrategy();


            detail.setChargingOrderId(order.getId());


            detail.setType(snapshot.getType());


            detail.setElectrovalence(electricPrice);


            detail.setServiceCharge(servicePrice);


            detail.setCostServiceCharge(originalServicePrice);


            detail.setChargingCapacity(capacity);


            detail.setPeriodElectricPrice(electricAmount);


            detail.setPeriodServicePrice(serviceAmount);


            detail.setPeriodOriginalServicePrice(originalServiceAmount);


            if (snapshot != null) {


                // 计费策略明细id：快照id（IdType.INPUT复制自原明细 id），与CD结算口径一致


                detail.setAccountingStrategyDetailId(snapshot.getId());


                // 时段位：与 CD 充电 TaskUtil.endOrder 同口径，截取快照时段的 HH:mm


                // （snapshot 已为 HH:mm；split 兜底兼容上游拼接的 yyyy-MM-dd HH:mm 情形）


                detail.setStartTime(splitPeriodHourMinute(snapshot.getStartTime()));


                detail.setEndTime(splitPeriodHourMinute(snapshot.getEndTime()));


            }


            // 首次添加时间：结算落库时刻（CD结算同口径）


            detail.setCreateTime(LocalDateTime.now());


            details.add(detail);


        }


        if (snapshots.isEmpty()) {


            log.error("[VD结算] 订单无计费策略快照，按0价结算并需人工核对 code={} totalElectricity={}", code, totalElectricity);


        }


        // 首段使用订单实际开始时间；订单尚未写入结束时间时，末段使用交易记录设备结束时间。


        LocalDateTime settlementStartTime = order.getStartTime() != null


                ? order.getStartTime() : parseDeviceTime(vo.getStart_time(), null);


        LocalDateTime settlementEndTime = parseDeviceTime(vo.getEnd_time(), order.getEndTime());


        if (!details.isEmpty()) {


            DateTimeFormatter hhmm = DateTimeFormatter.ofPattern("HH:mm");


            if (settlementStartTime != null) {


                details.get(0).setStartTime(settlementStartTime.format(hhmm));


            }


            if (settlementEndTime != null) {


                details.get(details.size() - 1).setEndTime(settlementEndTime.format(hhmm));


            }


        }


        BigDecimal orderAmount = electrovalenceTotal.add(serviceChargeTotal);


        // lambda 引用要求有效final，拷贝最终值


        final BigDecimal totalElec = totalElectricity;


        final BigDecimal elecTotal = electrovalenceTotal;


        final BigDecimal svcTotal = serviceChargeTotal;


        final BigDecimal startSoc = getMonitoringSocQuietly(code, "asc");


        final BigDecimal endSoc = getMonitoringSocQuietly(code, "desc");




        // 本地事务：写计费明细 + 更新订单（状态5；VD后付记账模式，不做账户扣款）


        transactionTemplate.execute(status -> {


            vinChargingOrderAccountingStrategyService.lambdaUpdate()


                    .eq(TVinChargingOrderAccountingStrategy::getChargingOrderId, order.getId())


                    .remove();


            if (!details.isEmpty()) {


                vinChargingOrderAccountingStrategyService.saveBatch(details);


            }


            TVinChargingOrder update = new TVinChargingOrder();


            update.setId(order.getId());


            update.setTotalElectricity(totalElec);


            update.setChargingCapacity(totalElec);


            update.setElectrovalence(elecTotal);


            update.setServiceCharge(svcTotal);


            update.setOrderAmount(orderAmount);


            update.setPaymentAmount(orderAmount);


            if (startSoc != null) {


                update.setStartSoc(startSoc);


            }


            if (endSoc != null) {


                update.setEndSoc(endSoc);


            }


            update.setEndTime(parseDeviceTime(vo.getEnd_time(), LocalDateTime.now()));


            if (order.getStartTime() == null) {


                update.setStartTime(parseDeviceTime(vo.getStart_time(), null));


            }


            update.setStatus(ORDER_STATUS_FINISHED);


            if (order.getEndMode() == null) {


                update.setEndMode(1);


            }


            updateById(update);


            return true;


        });




        // 复位充电枪


        resetGunQuietly(order);


        // 推送成都监管（结算完成推枪状态 + 订单信息，与 CD 结算链路一致）


        pushRegulatoryAsync(order, false, true);


        log.info("[VD结算] 完成 code={} totalElectricity={} electrovalence={} serviceCharge={} amount={}",


                code, totalElectricity, electrovalenceTotal, serviceChargeTotal, orderAmount);


        return R.ok();


    }




    @Override


    public TVinChargingOrder getLatestStoppingByGunId(Integer gunId) {


        if (gunId == null) {


            return null;


        }


        return getOne(new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TVinChargingOrder>()


                .eq(TVinChargingOrder::getChargingGunId, gunId)


                .eq(TVinChargingOrder::getStatus, ORDER_STATUS_STOPPING)


                .orderByDesc(TVinChargingOrder::getId)


                .last("limit 1"));


    }




    @Override


    public void vinTerminateStopByReply(PlatformStopChargingReplyVO vo) {


        // stopCharging 已前置更新状态4/结束方式1，此处仅兜底确认（幂等）


        if (vo == null) {


            return;


        }


        TChargingGun gun = null;


        try {


            GetChargingGunByCode gunQuery = new GetChargingGunByCode();


            gunQuery.setCharging_pile_code(vo.getCharging_pile_code());


            gunQuery.setCharging_gun_code(vo.getCharging_gun_code());


            gun = chargingGunClient.getChargingGunByCode(gunQuery).getData();


        } catch (Exception ex) {


            log.error("[VD停止] 查询充电枪失败 pile={} gun={}", vo.getCharging_pile_code(), vo.getCharging_gun_code(), ex);


            return;


        }


        if (gun == null) {


            return;


        }


        TVinChargingOrder order = getLatestStoppingByGunId(gun.getId());


        if (order == null) {


            return;


        }


        TVinChargingOrder update = new TVinChargingOrder();


        update.setId(order.getId());


        update.setEndMode(1);


        updateById(update);


        log.info("[VD停止] 平台停止应答兜底确认 code={}", order.getCode());


    }




    /**


     * 异步推送监管平台（复用 CD 约定：充电中推平台订单状态 pushOrderStatus、成都监管推枪状态


     * notificationConnectorChargeStatus / 结算完成推订单信息 notificationOrderInfo）；


     * 推送失败仅告警不阻断主流程；单元测试环境 client 未注入时静默跳过


     */


    private void pushRegulatoryAsync(TVinChargingOrder order, boolean pushOrderStatus, boolean pushOrderInfo) {


        if (chargingMessageClient == null && chengDuJianGuanClient == null) {


            return;


        }


        new Thread(() -> {


            try {


                if (pushOrderStatus && chargingMessageClient != null) {


                    ChargingOrderVo chargingOrderVo = new ChargingOrderVo();


                    // 与 CD 一致使用 Spring BeanUtils（本类 ruoyi BeanUtils 同名，故用全限定名）


                    org.springframework.beans.BeanUtils.copyProperties(order, chargingOrderVo);


                    chargingMessageClient.pushOrderStatus(chargingOrderVo);


                }


                if (chengDuJianGuanClient != null) {


                    NotificationConnectorChargeStatusVo statusVo = new NotificationConnectorChargeStatusVo();


                    statusVo.setOrderCode(order.getCode());


                    statusVo.setChargingGunId(order.getChargingGunId());


                    chengDuJianGuanClient.notificationConnectorChargeStatus(statusVo);


                    if (pushOrderInfo) {


                        chengDuJianGuanClient.notificationOrderInfo(statusVo);


                    }


                }


            } catch (Exception ex) {


                log.error("[VD监管] 推送监管平台失败 code={}", order.getCode(), ex);


            }


        }, "VD-Regulatory-Push").start();


    }




    private void resetGunQuietly(TVinChargingOrder order) {


        updateGunStatusQuietly(order, GUN_STATUS_IDLE, "复位");


    }




    private boolean updateGunStatusQuietly(TVinChargingOrder order, int status, String scene) {


        if (order.getChargingGunId() == null) {


            return true;


        }


        try {


            R<TChargingGun> queryResult = chargingGunClient.getChargingGunById(order.getChargingGunId());


            TChargingGun gun = queryResult == null ? null : queryResult.getData();


            if (queryResult == null || queryResult.getCode() != R.SUCCESS || gun == null) {


                log.error("[VD资源] {}查询充电枪失败 code={} gunId={}", scene, order.getCode(), order.getChargingGunId());


                return false;


            }


            gun.setStatus(status);


            R<String> result = chargingGunClient.updateChargingGunById(gun);


            if (result == null || result.getCode() != R.SUCCESS) {


                log.error("[VD资源] {}更新充电枪失败 code={} gunId={} msg={}", scene, order.getCode(),


                        order.getChargingGunId(), result == null ? "null" : result.getMsg());


                return false;


            }


            return true;


        } catch (Exception ex) {


            log.error("[VD资源] {}更新充电枪异常 code={} gunId={}", scene, order.getCode(), order.getChargingGunId(), ex);


            return false;


        }


    }




    /**


     * 容错读取订单最早/最新监控记录的 SOC；Mongo 数据缺失或查询异常不阻断主结算流程。


     */


    private BigDecimal getMonitoringSocQuietly(String code, String sort) {


        if (monitoringDataService == null) {


            return null;


        }


        try {


            UploadRealTimeMonitoringData monitoringData = monitoringDataService.getDataByOrderCode(code, sort);


            return monitoringData == null || monitoringData.getSoc() == null


                    ? null : BigDecimal.valueOf(monitoringData.getSoc().longValue());


        } catch (Exception ex) {


            log.error("[VD结算] 查询监控SOC失败 code={} sort={}", code, sort, ex);


            return null;


        }


    }




    private LocalDateTime parseDeviceTime(String value, LocalDateTime fallback) {


        if (StringUtils.isEmpty(value)) {


            return fallback;


        }


        DateTimeFormatter formatter = new DateTimeFormatterBuilder()


                .appendPattern("yyyy-MM-dd HH:mm:ss")


                .optionalStart().appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).optionalEnd()


                .toFormatter();


        try {


            return LocalDateTime.parse(value.trim().replace('T', ' '), formatter);


        } catch (DateTimeParseException ex) {


            log.warn("[VD结算] 设备时间格式异常 value={}", value);


            return fallback;


        }


    }




    /**


     * 截取快照时段位 HH:mm（对齐 CD 充电 TaskUtil.endOrder 中 detailOrder.getStartTime().split(" ")[1]）：


     * 1) snapshot 已为 HH:mm 直接返回；


     * 2) 若被上游拼接为 yyyy-MM-dd HH:mm:ss / yyyy-MM-dd HH:mm 等带日期格式，按空格 split 取末段。


     */


    private static String splitPeriodHourMinute(String value) {


        if (value == null) {


            return null;


        }


        String trimmed = value.trim();


        if (trimmed.isEmpty()) {


            return trimmed;


        }


        int spaceIdx = trimmed.lastIndexOf(' ');


        return spaceIdx < 0 ? trimmed : trimmed.substring(spaceIdx + 1);


    }




    // ===== 定时补偿（文档13.3：异常断电/补账场景，走统一结算入口） =====




    @Override


    public List<TVinChargingOrder> listTimeoutStartingOrders() {


        return lambdaQuery()


                .eq(TVinChargingOrder::getStatus, ORDER_STATUS_STARTING)


                .lt(TVinChargingOrder::getCreateTime, LocalDateTime.now().minusMinutes(VD_STARTING_TIMEOUT_MINUTES))


                .list();


    }




    @Override


    public List<TVinChargingOrder> listTimeoutChargingOrders() {


        return lambdaQuery()


                .in(TVinChargingOrder::getStatus, ORDER_STATUS_CHARGING, ORDER_STATUS_STOPPING)


                .list();


    }




    @Override


    public void closeTimeoutStartingOrder(TVinChargingOrder order) {


        TVinChargingOrder update = new TVinChargingOrder();


        update.setStatus(ORDER_STATUS_START_FAILED);


        update.setEndMode(0);


        update.setEndTime(LocalDateTime.now());


        boolean closed = update(update, new com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<TVinChargingOrder>()


                .eq(TVinChargingOrder::getId, order.getId())


                .eq(TVinChargingOrder::getStatus, ORDER_STATUS_STARTING));


        if (!closed) {


            log.info("[VD补偿] 启动超时关单跳过，订单状态已变化 code={}", order.getCode());


            return;


        }


        resetGunQuietly(order);


        pushRegulatoryAsync(order, false, false);


        log.warn("[VD补偿] 启动超时关单 code={} vinId={} gunId={}", order.getCode(), order.getVinId(), order.getChargingGunId());


    }




    @Override


    public void compensationSettle(TVinChargingOrder order) {


        // 无设备交易记录：以订单累计电量构造全平段账单，复用统一结算入口


        // （结算锁/状态幂等/枪复位全部复用，满足文档13.3"所有路径汇聚同一结算入口"）


        BigDecimal capacity = order.getChargingCapacity() != null ? order.getChargingCapacity()


                : Optional.ofNullable(order.getElectricity()).orElse(BigDecimal.ZERO);


        int flatPeriodIndex = resolveCompensationFlatPeriodIndex(order.getId());


        TransactionRecordMessageVO vo = new TransactionRecordMessageVO();


        vo.setTransaction_serial_number(order.getCode());


        TransactionStageParser.setPeriodElectricity(vo, 3, flatPeriodIndex, capacity);


        vo.setTotal_electricity(capacity);


        log.warn("[VD补偿] 充电超时兜底结算 code={} 按平段计价 periodIndex={} capacity={}",


                order.getCode(), flatPeriodIndex, capacity);


        vinEndChargeBillingCharge(vo);


    }




    private int resolveCompensationFlatPeriodIndex(Long orderId) {


        List<TVinAccountingStrategyDetailOrder> snapshots = Optional.ofNullable(vinAccountingStrategyDetailOrderService


                        .lambdaQuery().eq(TVinAccountingStrategyDetailOrder::getChargingOrderId, orderId).list())


                .orElse(Collections.emptyList()).stream()


                .filter(item -> item.getType() != null)


                .sorted(Comparator.comparing(TVinAccountingStrategyDetailOrder::getStartTime,


                        Comparator.nullsLast(String::compareTo)))


                .collect(Collectors.toList());


        for (int i = 0; i < snapshots.size(); i++) {


            if (Integer.valueOf(3).equals(snapshots.get(i).getType())) {


                return i + 1;


            }


        }


        log.error("[VD补偿] 订单计费策略无平段，回退构造 flat_charge1 orderId={}", orderId);


        return 1;


    }


}