package com.ruoyi.order.service.impl;
|
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.account.api.dto.ChargingCardAuthDTO;
|
import com.ruoyi.account.api.dto.ChargingCardDeductDTO;
|
import com.ruoyi.account.api.feignClient.AppUserCarClient;
|
import com.ruoyi.account.api.feignClient.ChargingCardClient;
|
import com.ruoyi.account.api.model.TAppUserCar;
|
import com.ruoyi.account.api.model.TChargingCard;
|
import com.ruoyi.account.api.model.TCompanyAllocateRecord;
|
import com.ruoyi.account.api.vo.ChargingCardDeductVO;
|
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.dto.GetSiteListDTO;
|
import com.ruoyi.chargingPile.api.dto.TBillingTemplateDTO;
|
import com.ruoyi.chargingPile.api.model.TAccountingStrategy;
|
import com.ruoyi.chargingPile.api.model.TAccountingStrategyDetail;
|
import com.ruoyi.chargingPile.api.model.TBillingTemplateDetail;
|
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.order.api.dto.DeviceStartChargingDTO;
|
import com.ruoyi.order.api.model.TCardAccountingStrategyDetailOrder;
|
import com.ruoyi.order.api.model.TCardAccountingStrategyOrder;
|
import com.ruoyi.order.api.model.TCardChargingOrder;
|
import com.ruoyi.order.api.model.TCardChargingOrderAccountingStrategy;
|
import com.ruoyi.order.api.query.CardBalanceDetailQuery;
|
import com.ruoyi.order.api.query.CardChargingOrderQuery;
|
import com.ruoyi.order.api.query.UploadRealTimeMonitoringDataQuery;
|
import com.ruoyi.order.api.vo.CardBalanceDetailVO;
|
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.TransactionRecordMessageVO;
|
import com.ruoyi.order.mapper.TCardChargingOrderMapper;
|
import com.ruoyi.order.service.TCardAccountingStrategyDetailOrderService;
|
import com.ruoyi.order.service.TCardAccountingStrategyOrderService;
|
import com.ruoyi.order.service.TCardChargingOrderAccountingStrategyService;
|
import com.ruoyi.order.service.TCardChargingOrderService;
|
import com.ruoyi.chargingPile.api.model.Site;
|
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.util.TransactionStageParser;
|
import com.ruoyi.order.util.mongodb.service.UploadRealTimeMonitoringDataService;
|
import com.ruoyi.other.api.domain.TFleet;
|
import com.ruoyi.other.api.domain.TGroupCompany;
|
import com.ruoyi.other.api.dto.ChargeAuthorizationDTO;
|
import com.ruoyi.other.api.dto.CompanyPreferentialDTO;
|
import com.ruoyi.other.api.feignClient.ChargeAuthorizationClient;
|
import com.ruoyi.other.api.feignClient.GroupCompanyClient;
|
import com.ruoyi.order.support.ChargeAccountSupport;
|
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.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.Comparator;
|
import java.util.Date;
|
import java.util.Collections;
|
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 TCardChargingOrderServiceImpl extends ServiceImpl<TCardChargingOrderMapper, TCardChargingOrder>
|
implements TCardChargingOrderService {
|
|
private static final Logger log = LoggerFactory.getLogger(TCardChargingOrderServiceImpl.class);
|
|
/** SD 订单号前缀（设备刷卡充电） */
|
private static final String ORDER_CODE_PREFIX_SD = "SD";
|
/** 订单状态：启动中 */
|
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;
|
/** SD 建单枪锁前缀（桩+枪维度，防同枪并发建单，文档13.2） */
|
private static final String LOCK_SD_START_GUN = "SD_START_GUN:";
|
/** SD 建单卡锁前缀（卡ID维度，防同卡多枪并发启动，文档13.2） */
|
private static final String LOCK_SD_START_CARD = "SD_START_CARD:";
|
/** SD 结算锁前缀（订单号维度，防并发重复结算/扣款，文档13.3） */
|
private static final String LOCK_SD_SETTLE = "SD_SETTLE:";
|
/** SD 启动中超时阈值（分钟）：超时未收到启动成功应答则关单 */
|
private static final int SD_STARTING_TIMEOUT_MINUTES = 30;
|
/** SD 充电中超时阈值（小时）：超时未收到交易记录则兜底结算 */
|
private static final int SD_CHARGING_TIMEOUT_HOURS = 24;
|
/** 状态5未扣款扫描保护窗，避免与正在提交的扣款事务竞态 */
|
private static final int SD_DEDUCT_COMPENSATION_DELAY_MINUTES = 10;
|
/** 单轮最多检查的已结束订单数，避免大批量远程查询 */
|
private static final int SD_DEDUCT_COMPENSATION_BATCH_SIZE = 100;
|
|
@Resource
|
private TokenService tokenService;
|
@Resource
|
private ChargingMessageClient chargingMessageClient;
|
@Resource
|
private ChengDuJianGuanClient chengDuJianGuanClient;
|
@Resource
|
private SendMessageClient sendMessageClient;
|
@Resource
|
private SiteClient siteClient;
|
@Resource
|
private ChargingPileClient chargingPileClient;
|
@Resource
|
private ChargingGunClient chargingGunClient;
|
@Resource
|
private AppUserCarClient appUserCarClient;
|
@Resource
|
private UploadRealTimeMonitoringDataService uploadRealTimeMonitoringDataService;
|
@Resource
|
private ChargingCardClient chargingCardClient;
|
@Resource
|
private GroupCompanyClient groupCompanyClient;
|
@Resource
|
private ChargeAuthorizationClient chargeAuthorizationClient;
|
@Resource
|
private ChargeAccountSupport chargeAccountSupport;
|
@Resource
|
private AccountingStrategyClient accountingStrategyClient;
|
@Resource
|
private AccountingStrategyDetailClient accountingStrategyDetailClient;
|
@Resource
|
private TCardAccountingStrategyOrderService cardAccountingStrategyOrderService;
|
@Resource
|
private TCardAccountingStrategyDetailOrderService cardAccountingStrategyDetailOrderService;
|
@Resource
|
private TCardChargingOrderAccountingStrategyService cardChargingOrderAccountingStrategyService;
|
@Resource
|
private TransactionTemplate transactionTemplate;
|
@Resource
|
private RedissonClient redissonClient;
|
|
@Override
|
public PageInfo<ChargingOrderVO> pageList(CardChargingOrderQuery query) {
|
String[] timeRange = parseTimeRange(query);
|
int pageCurr = query.getPageCurr() == null || query.getPageCurr() < 1 ? 1 : query.getPageCurr();
|
int pageSize = query.getPageSize() == null || query.getPageSize() < 1 ? 50 : query.getPageSize();
|
PageInfo<ChargingOrderVO> pageInfo = new PageInfo<>(pageCurr, pageSize);
|
setAuthSiteIds(query);
|
long offset = (long) (pageCurr - 1) * pageSize;
|
long total = baseMapper.count(query, timeRange[0], timeRange[1], timeRange[2], timeRange[3]);
|
pageInfo.setTotal(total);
|
List<ChargingOrderVO> list = total == 0 ? Collections.emptyList()
|
: baseMapper.pageList(query, timeRange[0], timeRange[1], timeRange[2], timeRange[3], offset, pageSize);
|
fillPageExtra(list);
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public Map<String, Object> summary(CardChargingOrderQuery query) {
|
String[] timeRange = parseTimeRange(query);
|
setAuthSiteIds(query);
|
Map<String, Object> result = baseMapper.summary(query, timeRange[0], timeRange[1], timeRange[2], timeRange[3]);
|
if (result == null) {
|
result = new HashMap<>();
|
}
|
BigDecimal platformIncome = BigDecimal.ZERO;
|
BigDecimal partnerIncome = BigDecimal.ZERO;
|
Map<String, BigDecimal> accountingSummary = emptyAccountingSummary();
|
List<Long> orderIds = baseMapper.summaryOrderIds(query, timeRange[0], timeRange[1], timeRange[2], timeRange[3]);
|
if (orderIds != null && !orderIds.isEmpty()) {
|
int batchSize = 500;
|
for (int i = 0; i < orderIds.size(); i += batchSize) {
|
List<Long> batchIds = orderIds.subList(i, Math.min(i + batchSize, orderIds.size()));
|
Map<String, Object> shareSummary = baseMapper.shareIncomeSummaryByOrderIds(batchIds);
|
platformIncome = platformIncome.add(summaryDecimal(shareSummary, "platformIncome"));
|
partnerIncome = partnerIncome.add(summaryDecimal(shareSummary, "partnerIncome"));
|
mergeAccountingSummary(accountingSummary, baseMapper.accountingSummaryByOrderIds(batchIds));
|
}
|
}
|
result.put("platformIncome", platformIncome);
|
result.put("partnerIncome", partnerIncome);
|
result.put("platformIncomeTotal", platformIncome);
|
result.put("partnerIncomeTotal", partnerIncome);
|
result.put("capacityProportion", buildProportion(accountingSummary, "capacity"));
|
result.put("serviceProportion", buildProportion(accountingSummary, "service"));
|
result.put("electronicProportion", buildProportion(accountingSummary, "electric"));
|
return result;
|
}
|
|
private Map<String, BigDecimal> emptyAccountingSummary() {
|
Map<String, BigDecimal> summary = new HashMap<>();
|
for (String prefix : new String[]{"capacity", "service", "electric"}) {
|
summary.put(prefix + "Total", BigDecimal.ZERO);
|
for (int type = 1; type <= 4; type++) {
|
summary.put(prefix + type, BigDecimal.ZERO);
|
}
|
}
|
return summary;
|
}
|
|
private void mergeAccountingSummary(Map<String, BigDecimal> total, Map<String, Object> batch) {
|
if (batch == null) {
|
return;
|
}
|
for (String key : total.keySet()) {
|
total.put(key, total.get(key).add(summaryDecimal(batch, key)));
|
}
|
}
|
|
private BigDecimal summaryDecimal(Map<String, Object> summary, String key) {
|
if (summary == null || summary.get(key) == null) {
|
return BigDecimal.ZERO;
|
}
|
Object value = summary.get(key);
|
return value instanceof BigDecimal ? (BigDecimal) value : new BigDecimal(value.toString());
|
}
|
|
private String buildProportion(Map<String, BigDecimal> summary, String prefix) {
|
BigDecimal denominator = summary.get(prefix + "Total");
|
List<String> proportions = new ArrayList<>(4);
|
for (int type = 1; type <= 4; type++) {
|
BigDecimal percentage = denominator.signum() == 0 ? BigDecimal.ZERO
|
: summary.get(prefix + type).multiply(new BigDecimal("100"))
|
.divide(denominator, 2, RoundingMode.HALF_UP).stripTrailingZeros();
|
proportions.add(percentage.toPlainString() + "%");
|
}
|
return String.join("-", proportions);
|
}
|
|
@Override
|
public List<ChargingOrderVO> exportList(CardChargingOrderQuery query) {
|
String[] timeRange = parseTimeRange(query);
|
setAuthSiteIds(query);
|
long total = baseMapper.count(query, timeRange[0], timeRange[1], timeRange[2], timeRange[3]);
|
List<ChargingOrderVO> result = new ArrayList<>();
|
if (total == 0) {
|
return result;
|
}
|
int batchSize = 5000;
|
for (long offset = 0; offset < total; offset += batchSize) {
|
List<ChargingOrderVO> batch = baseMapper.pageList(query, timeRange[0], timeRange[1], timeRange[2], timeRange[3], offset, batchSize);
|
if (batch == null || batch.isEmpty()) {
|
break;
|
}
|
result.addAll(batch);
|
}
|
fillPageExtra(result);
|
return result;
|
}
|
|
@Override
|
public Map<String, Object> detail(Long chargingOrderId) {
|
TCardChargingOrder order = getById(chargingOrderId);
|
if (order == null) {
|
return Collections.emptyMap();
|
}
|
Map<String, Object> result = new HashMap<>();
|
result.put("id", order.getId());
|
result.put("uid", String.valueOf(order.getId()));
|
result.put("code", order.getCode());
|
result.put("cardNo", order.getCardNo());
|
result.put("status", order.getStatus());
|
result.put("siteId", order.getSiteId());
|
result.put("chargingPileId", order.getChargingPileId());
|
result.put("chargingGunId", order.getChargingGunId());
|
result.put("startTime", order.getStartTime());
|
result.put("endTime", order.getEndTime());
|
result.put("chargingCapacity", order.getChargingCapacity());
|
result.put("paymentAmount", order.getPaymentAmount());
|
result.put("electrovalence", order.getElectrovalence());
|
result.put("serviceCharge", order.getServiceCharge());
|
// 优惠金额（原始电费/服务费 - 最终，企业优惠设置改造）
|
result.put("discountElectrovalence", order.getDiscountElectrovalence());
|
result.put("discountServiceCharge", order.getDiscountServiceCharge());
|
// 账户模式/授权截止时间/申请锁定额度（刷卡链路改造）
|
result.put("accountMode", order.getAccountMode());
|
// Map 值不走实体字段上的 @JsonFormat，显式格式化，避免前端展示 ISO 格式（含 T）
|
result.put("maxEndTime", order.getMaxEndTime() == null ? null
|
: order.getMaxEndTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
|
result.put("lockedAmount", order.getLockedAmount());
|
result.put("total", defaultDecimal(order.getElectrovalence()).add(defaultDecimal(order.getServiceCharge())));
|
result.put("realTotal", order.getPaymentAmount());
|
result.put("endMode", order.getEndMode());
|
result.put("phone", order.getPhone());
|
result.put("licensePlate", order.getPlateNum());
|
// SOC 展示口径：优先展示结算回填的开始/结束 SOC；历史订单未采集时保持占位符
|
result.put("startSoc", order.getStartSoc() == null ? "-" : order.getStartSoc().toPlainString());
|
result.put("endSoc", order.getEndSoc() == null ? "-" : order.getEndSoc().toPlainString());
|
if (order.getStartTime() != null && order.getEndTime() != null) {
|
result.put("chargingSecond", ChronoUnit.SECONDS.between(order.getStartTime(), order.getEndTime()));
|
}
|
List<UploadRealTimeMonitoringData> monitoring = order.getCode() == null || order.getCode().trim().isEmpty()
|
? Collections.emptyList()
|
: uploadRealTimeMonitoringDataService.getDataByOrderCodeAsc(order.getCode());
|
if (monitoring == null) {
|
monitoring = Collections.emptyList();
|
}
|
for (UploadRealTimeMonitoringData data : monitoring) {
|
if (data.getOutput_current() != null && data.getOutput_voltage() != null) {
|
data.setPower(data.getOutput_voltage().multiply(data.getOutput_current()).divide(new BigDecimal(1000), 2, BigDecimal.ROUND_HALF_UP));
|
}
|
}
|
result.put("list", monitoring);
|
UploadRealTimeMonitoringData latest = monitoring.isEmpty() ? null : monitoring.get(monitoring.size() - 1);
|
result.put("cdElectronic", latest == null || latest.getOutput_current() == null ? "" : latest.getOutput_current().setScale(2, RoundingMode.HALF_DOWN).toPlainString());
|
result.put("cdVoltage", latest == null || latest.getOutput_voltage() == null ? "" : latest.getOutput_voltage().setScale(2, RoundingMode.HALF_DOWN).toPlainString());
|
result.put("totalPower", latest == null || latest.getPower() == null ? "" : latest.getPower().setScale(2, RoundingMode.HALF_DOWN).toPlainString());
|
result.put("surplus", latest == null || latest.getSoc() == null ? "" : String.valueOf(latest.getSoc()));
|
result.put("list1", baseMapper.accountingStrategyList(order.getId()));
|
List<Integer> siteIds = order.getSiteId() == null ? Collections.emptyList() : Collections.singletonList(order.getSiteId());
|
if (!siteIds.isEmpty()) {
|
List<Site> sites = Optional.ofNullable(siteClient.getSiteByIds(siteIds).getData()).orElse(Collections.emptyList());
|
if (!sites.isEmpty()) {
|
result.put("siteName", sites.get(0).getName());
|
result.put("siteAddress", sites.get(0).getAddress());
|
}
|
}
|
if (order.getChargingGunId() != null) {
|
TChargingGun gun = chargingGunClient.getChargingGunById(order.getChargingGunId()).getData();
|
if (gun != null) {
|
result.put("gunCode", gun.getCode());
|
result.put("terminalName", gun.getName());
|
}
|
}
|
return result;
|
}
|
|
private BigDecimal defaultDecimal(BigDecimal value) {
|
return value == null ? BigDecimal.ZERO : value;
|
}
|
|
@Override
|
public List<Map<String, Object>> balanceIncomeDetail(CardChargingOrderQuery query) {
|
return baseMapper.balanceIncomeDetail(query);
|
}
|
|
@Override
|
public List<Map<String, Object>> accountingStrategyList(Long chargingOrderId) {
|
return baseMapper.accountingStrategyList(chargingOrderId);
|
}
|
|
/**
|
* 管理后台停止刷卡充电：与 VIN 码停充口径一致，
|
* 状态推进使用条件更新（仅当前状态为充电中时生效），防止重复点击/设备回调并发。
|
*/
|
@Override
|
public AjaxResult stopCharging(String chargingOrderId, Integer chargingGunId) {
|
Long orderId;
|
try {
|
orderId = Long.valueOf(chargingOrderId);
|
} catch (NumberFormatException e) {
|
return AjaxResult.error("刷卡充电订单ID无效");
|
}
|
TCardChargingOrder order = getAuthorizedOrder(orderId);
|
if (order == null) {
|
return AjaxResult.error("刷卡充电订单不存在或无权操作");
|
}
|
if (order.getChargingGunId() == null || !order.getChargingGunId().equals(chargingGunId)) {
|
return AjaxResult.error("充电枪与订单不匹配");
|
}
|
Integer status = order.getStatus();
|
if (status == null || status != ORDER_STATUS_CHARGING) {
|
return AjaxResult.error(status != null && (status == ORDER_STATUS_STOPPING || status == ORDER_STATUS_FINISHED)
|
? "不能重复操作" : "还未开始充电");
|
}
|
TChargingGun chargingGun;
|
TChargingPile chargingPile;
|
try {
|
R<TChargingGun> gunResult = chargingGunClient.getChargingGunById(chargingGunId);
|
chargingGun = gunResult == null ? null : gunResult.getData();
|
R<TChargingPile> pileResult = order.getChargingPileId() == null ? null
|
: chargingPileClient.getChargingPileById(order.getChargingPileId());
|
chargingPile = pileResult == null ? null : pileResult.getData();
|
} catch (Exception ex) {
|
log.error("[SD停充] 管理后台停充查询设备异常 code={} gunId={}", order.getCode(), chargingGunId, ex);
|
return AjaxResult.error("查询充电设备失败");
|
}
|
if (chargingGun == null || chargingPile == null) {
|
return AjaxResult.error("未找到订单对应的充电设备");
|
}
|
boolean updated = lambdaUpdate()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_CHARGING)
|
.set(TCardChargingOrder::getStatus, ORDER_STATUS_STOPPING)
|
.set(TCardChargingOrder::getEndMode, 1)
|
.set(TCardChargingOrder::getEndTime, LocalDateTime.now())
|
.update();
|
if (!updated) {
|
return AjaxResult.error("订单状态已变化，请刷新后重试");
|
}
|
order.setStatus(ORDER_STATUS_STOPPING);
|
order.setEndMode(1);
|
PlatformStopCharging command = new PlatformStopCharging();
|
command.setCharging_pile_code(chargingPile.getCode());
|
command.setCharging_gun_code(chargingGun.getCode());
|
sendMessageClient.platformStopCharging(command);
|
log.warn("[SD停充] 管理后台主动停充 code={} gunId={}", order.getCode(), chargingGunId);
|
return AjaxResult.success();
|
}
|
|
@Override
|
public PageInfo<CardBalanceDetailVO> balanceDetailPage(CardBalanceDetailQuery query) {
|
int pageCurr = query.getPageCurr() == null || query.getPageCurr() < 1 ? 1 : query.getPageCurr();
|
int pageSize = query.getPageSize() == null || query.getPageSize() < 1 ? 50 : query.getPageSize();
|
setAuthSiteIds(query);
|
PageInfo<CardBalanceDetailVO> pageInfo = new PageInfo<>(pageCurr, pageSize);
|
long total = baseMapper.balanceDetailCount(query);
|
pageInfo.setTotal(total);
|
if (total == 0) {
|
pageInfo.setRecords(Collections.emptyList());
|
return pageInfo;
|
}
|
long offset = (long) (pageCurr - 1) * pageSize;
|
List<CardBalanceDetailVO> list = baseMapper.balanceDetailList(query, offset, pageSize);
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public Map<String, Object> balanceDetailSummary(CardBalanceDetailQuery query) {
|
setAuthSiteIds(query);
|
Map<String, Object> result = baseMapper.balanceDetailSummary(query);
|
if (result == null) {
|
result = new HashMap<>();
|
}
|
result.putIfAbsent("orderCount", 0);
|
result.putIfAbsent("incomeAmount", BigDecimal.ZERO);
|
result.putIfAbsent("expenseAmount", BigDecimal.ZERO);
|
return result;
|
}
|
|
@Override
|
public List<CardBalanceDetailVO> balanceDetailExport(CardBalanceDetailQuery query) {
|
setAuthSiteIds(query);
|
long total = baseMapper.balanceDetailCount(query);
|
if (total == 0) {
|
return new ArrayList<>();
|
}
|
List<CardBalanceDetailVO> result = new ArrayList<>();
|
int batchSize = 5000;
|
for (long offset = 0; offset < total; offset += batchSize) {
|
List<CardBalanceDetailVO> batch = baseMapper.balanceDetailList(query, offset, batchSize);
|
if (batch == null || batch.isEmpty()) {
|
break;
|
}
|
result.addAll(batch);
|
}
|
return result;
|
}
|
|
private void setAuthSiteIds(CardChargingOrderQuery query) {
|
List<Integer> siteIds = new ArrayList<>();
|
if (query.getSiteId() != null) {
|
siteIds.add(query.getSiteId());
|
} else {
|
Long userId = tokenService.getLoginUser().getUserid();
|
if (userId != null) {
|
siteIds = Optional.ofNullable(siteClient.getSiteListByUserId(userId).getData()).orElse(Collections.emptyList())
|
.stream().map(GetSiteListDTO::getId).collect(Collectors.toList());
|
}
|
}
|
if (siteIds.isEmpty()) {
|
siteIds.add(-1);
|
}
|
query.setSiteIds(siteIds);
|
}
|
|
/**
|
* 按订单ID查询并校验数据范围（订单所属站点须在当前登录用户授权站点内），与 VIN 码停充校验口径一致
|
*/
|
private TCardChargingOrder getAuthorizedOrder(Long chargingOrderId) {
|
if (chargingOrderId == null) {
|
return null;
|
}
|
TCardChargingOrder order = getById(chargingOrderId);
|
if (order == null || order.getSiteId() == null || !getAuthorizedSiteIds().contains(order.getSiteId())) {
|
return null;
|
}
|
return order;
|
}
|
|
private List<Integer> getAuthorizedSiteIds() {
|
Long userId = tokenService.getLoginUser().getUserid();
|
if (userId == null) {
|
return Collections.emptyList();
|
}
|
return Optional.ofNullable(siteClient.getSiteListByUserId(userId).getData())
|
.orElse(Collections.emptyList()).stream().map(GetSiteListDTO::getId).collect(Collectors.toList());
|
}
|
|
private void setAuthSiteIds(CardBalanceDetailQuery query) {
|
List<Integer> siteIds = new ArrayList<>();
|
Long userId = tokenService.getLoginUser().getUserid();
|
if (userId != null) {
|
siteIds = Optional.ofNullable(siteClient.getSiteListByUserId(userId).getData()).orElse(Collections.emptyList())
|
.stream().map(GetSiteListDTO::getId).collect(Collectors.toList());
|
}
|
if (siteIds.isEmpty()) {
|
siteIds.add(-1);
|
}
|
query.setSiteIds(siteIds);
|
}
|
|
private void fillElectronicProportion(List<ChargingOrderVO> list) {
|
List<Long> orderIds = list.stream().map(ChargingOrderVO::getId).filter(Objects::nonNull).collect(Collectors.toList());
|
if (orderIds.isEmpty()) {
|
return;
|
}
|
List<Map<String, Object>> capacityRows = new ArrayList<>();
|
int batchSize = 500;
|
for (int i = 0; i < orderIds.size(); i += batchSize) {
|
List<Long> batchIds = orderIds.subList(i, Math.min(i + batchSize, orderIds.size()));
|
capacityRows.addAll(Optional.ofNullable(baseMapper.capacitySummaryByOrderIds(batchIds))
|
.orElse(Collections.emptyList()));
|
}
|
Map<Long, Map<String, Object>> capacityByOrderId = capacityRows.stream()
|
.filter(item -> item.get("orderId") != null)
|
.collect(Collectors.toMap(item -> Long.valueOf(item.get("orderId").toString()), item -> item, (a, b) -> a));
|
for (ChargingOrderVO order : list) {
|
Map<String, Object> capacity = capacityByOrderId.get(order.getId());
|
Map<String, BigDecimal> summary = emptyAccountingSummary();
|
if (capacity != null) {
|
for (String key : new String[]{"capacityTotal", "capacity1", "capacity2", "capacity3", "capacity4"}) {
|
summary.put(key, summaryDecimal(capacity, key));
|
}
|
}
|
order.setElectronicProportion(buildProportion(summary, "capacity"));
|
}
|
}
|
|
private void fillPageExtra(List<ChargingOrderVO> list) {
|
if (list == null || list.isEmpty()) {
|
return;
|
}
|
fillElectronicProportion(list);
|
fillCompanyFleetNames(list);
|
List<Integer> siteIds = list.stream().map(ChargingOrderVO::getSiteId).filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
List<Integer> gunIds = list.stream().map(ChargingOrderVO::getChargingGunId).filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
List<Long> carIds = list.stream().map(ChargingOrderVO::getAppUserCarId).filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
Map<Long, TAppUserCar> cars = carIds.isEmpty() ? Collections.emptyMap()
|
: Optional.ofNullable(appUserCarClient.getCarByIds(carIds).getData()).orElse(Collections.emptyList()).stream()
|
.collect(Collectors.toMap(TAppUserCar::getId, item -> item, (a, b) -> a));
|
Map<Integer, Site> sites = 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 (ChargingOrderVO item : list) {
|
Site site = sites.get(item.getSiteId());
|
item.setSiteName(site == null ? null : site.getName());
|
TChargingGun gun = guns.get(item.getChargingGunId());
|
item.setTerminalName(gun == null ? null : gun.getName());
|
TAppUserCar car = cars.get(item.getAppUserCarId());
|
item.setVin(car == null ? null : car.getVin());
|
if (item.getStartTime() != null && item.getEndTime() != null) {
|
item.setChargingSecond(ChronoUnit.SECONDS.between(item.getStartTime(), item.getEndTime()));
|
}
|
UploadRealTimeMonitoringData monitoringData = uploadRealTimeMonitoringDataService.getLastDataById(item.getCode());
|
if (monitoringData != null) {
|
item.setChargeCurrent(monitoringData.getOutput_current());
|
item.setChargeVoltage(monitoringData.getOutput_voltage());
|
item.setChargePower(monitoringData.getPower());
|
}
|
item.setPlatformIncome(BigDecimal.ZERO);
|
item.setPartnerIncome(BigDecimal.ZERO);
|
}
|
}
|
|
/**
|
* 回填所属公司/车队名称：按订单快照 companyId/fleetId 批量远程取名（公司/车队改名后列表即时生效），
|
* 远程调用失败仅跳过回填，不影响列表其他字段。
|
*/
|
private void fillCompanyFleetNames(List<ChargingOrderVO> list) {
|
if (list == null || list.isEmpty()) {
|
return;
|
}
|
List<Integer> companyIds = list.stream().map(ChargingOrderVO::getCompanyId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
if (!companyIds.isEmpty()) {
|
Map<Integer, String> companyNames = loadCompanyNames(companyIds);
|
for (ChargingOrderVO item : list) {
|
String name = item.getCompanyId() == null ? null : companyNames.get(item.getCompanyId());
|
if (StringUtils.isNotEmpty(name)) {
|
item.setCompanyName(name);
|
}
|
}
|
}
|
List<Integer> fleetIds = list.stream().map(ChargingOrderVO::getFleetId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
if (fleetIds.isEmpty()) {
|
return;
|
}
|
Map<Integer, String> fleetNames = loadFleetNames(fleetIds);
|
for (ChargingOrderVO item : list) {
|
String name = item.getFleetId() == null ? null : fleetNames.get(item.getFleetId());
|
if (StringUtils.isNotEmpty(name)) {
|
item.setFleetName(name);
|
}
|
}
|
}
|
|
/** 批量查询公司名称，失败返回已取到的数据 */
|
private Map<Integer, String> loadCompanyNames(List<Integer> companyIds) {
|
Map<Integer, String> result = new HashMap<>();
|
try {
|
List<TGroupCompany> companies = Optional.ofNullable(groupCompanyClient.listCompaniesByIds(companyIds).getData())
|
.orElse(Collections.emptyList());
|
for (TGroupCompany company : companies) {
|
if (company != null && company.getId() != null && StringUtils.isNotEmpty(company.getName())) {
|
result.put(company.getId(), company.getName());
|
}
|
}
|
} catch (Exception e) {
|
log.warn("[SD回填] 批量查询公司名称失败 ids={}", companyIds, e);
|
}
|
return result;
|
}
|
|
/** 批量查询车队名称，失败返回已取到的数据 */
|
private Map<Integer, String> loadFleetNames(List<Integer> fleetIds) {
|
Map<Integer, String> result = new HashMap<>();
|
try {
|
List<TFleet> fleets = Optional.ofNullable(groupCompanyClient.listFleetsByIds(fleetIds).getData())
|
.orElse(Collections.emptyList());
|
for (TFleet fleet : fleets) {
|
if (fleet != null && fleet.getId() != null && StringUtils.isNotEmpty(fleet.getFleetName())) {
|
result.put(fleet.getId(), fleet.getFleetName());
|
}
|
}
|
} catch (Exception e) {
|
log.warn("[SD回填] 批量查询车队名称失败 ids={}", fleetIds, e);
|
}
|
return result;
|
}
|
|
private String[] parseTimeRange(CardChargingOrderQuery query) {
|
return new String[]{query.getStartTime1(), query.getStartTime2(), query.getEndTime1(), query.getEndTime2()};
|
}
|
|
// ===== 设备侧刷卡充电链路（V0.2 刷卡充电） =====
|
|
@Override
|
public DeviceStartChargingVO startCardCharging(DeviceStartChargingDTO dto) {
|
if (dto == null || StringUtils.isEmpty(dto.getChargingPileCode())
|
|| StringUtils.isEmpty(dto.getChargingGunCode()) || StringUtils.isEmpty(dto.getAccount())) {
|
return DeviceStartChargingVO.fail(1);
|
}
|
// 并发防护（文档13.2）：桩+枪维度分布式锁，抢不到说明同枪并发启动，快速失败
|
RLock gunLock = redissonClient.getLock(LOCK_SD_START_GUN + dto.getChargingPileCode() + ":" + dto.getChargingGunCode());
|
try {
|
if (!gunLock.tryLock(0, 30, TimeUnit.SECONDS)) {
|
return DeviceStartChargingVO.fail(10);
|
}
|
// 1. 充电枪校验（不存在->5 桩停用；充电中->10 该桩存在未结账记录）
|
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. 卡片鉴权（卡号存在性/禁用/密码条件校验在账户服务内完成）
|
ChargingCardAuthDTO authDTO = new ChargingCardAuthDTO();
|
authDTO.setCardNo(dto.getAccount().trim());
|
authDTO.setPassword(dto.getPassword());
|
R<TChargingCard> verifyResult = chargingCardClient.verifyCharging(authDTO);
|
TChargingCard card = verifyResult.getData();
|
if (card == null) {
|
return DeviceStartChargingVO.fail(mapAuthFailure(verifyResult.getMsg()));
|
}
|
// 3. 计费策略（枪策略优先，站点策略兜底）：授权校验（指定电价时段）与策略快照共用
|
Integer strategyId = gun.getAccountingStrategyId() != null
|
? gun.getAccountingStrategyId()
|
: (site == null ? null : site.getAccountingStrategyId());
|
// 3.1 账户上下文解析（企业状态、充电授权站点范围/可用时段、账户模式、可用余额、授权截止时间）
|
ChargeAccountSupport.ChargeContext chargeContext = resolveCardChargeContext(gun.getSiteId(), strategyId, card);
|
if (!chargeContext.isOk()) {
|
log.warn("[SD建单] 账户校验不通过 cardId={} gun={} reason={}", card.getId(),
|
dto.getChargingGunCode(), chargeContext.getFailReason());
|
return DeviceStartChargingVO.fail(chargeContext.getFailCode());
|
}
|
|
// 并发防护（文档13.2）：卡ID维度锁，防同卡多枪并发建单（数据库锁卡条件更新为第二道保护）
|
RLock cardLock = redissonClient.getLock(LOCK_SD_START_CARD + card.getId());
|
boolean cardLocked = false;
|
try {
|
cardLocked = cardLock.tryLock(0, 30, TimeUnit.SECONDS);
|
if (!cardLocked) {
|
return DeviceStartChargingVO.fail(4);
|
}
|
// 4. 建单（状态2 启动中）
|
TCardChargingOrder order = new TCardChargingOrder();
|
order.setCode(ORDER_CODE_PREFIX_SD + Double.valueOf(Math.random() * 1000).intValue() + new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()));
|
order.setOrderType(2);
|
order.setOrderSource(1);
|
order.setOrderClassification(2);
|
// 充电支付模式（沿用 CD payMethod 枚举：1=余额支付）：SD 全程卡余额扣款
|
order.setPayMethod(1);
|
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.setCardId(card.getId());
|
order.setCardNo(card.getCardNo());
|
// 所属公司/车队快照落库（充电卡当前归属），供订单列表/汇总/导出按公司、车队直接筛选
|
order.setCompanyId(card.getCompanyId());
|
order.setFleetId(card.getFleetId());
|
// 可用金额基数与启动剩余金额：共享模式=min(授权下发额, 企业可用余额)，分配模式=min(授权下发额, 卡可用余额)
|
order.setChargeAmount(chargeContext.getDispatchAmount());
|
order.setResidualAmount(chargeContext.getDispatchAmount());
|
// 账户模式与授权截止时间快照（锁定额度在锁定成功后回填，与 VIN 链路一致）
|
order.setAccountMode(chargeContext.getAccountMode());
|
order.setMaxEndTime(chargeContext.getMaxEndTime());
|
order.setCreateTime(LocalDateTime.now());
|
save(order);
|
|
// 5. 计费策略快照（枪策略优先，站点策略兜底，strategyId 在授权校验前已解析）：
|
// 无可用策略（未配置/已被删除、明细为空）或保存异常时无法计费，直接回滚删除订单并回告启动失败，
|
// 避免产生无策略订单（结算侧的价格兜底仅用于历史订单）
|
try {
|
if (!saveStrategySnapshot(order.getId(), strategyId)) {
|
log.warn("[SD建单] 无可用计费策略，回滚删除订单 code={} strategyId={}", order.getCode(), strategyId);
|
removeOrderWithSnapshot(order.getId());
|
return DeviceStartChargingVO.fail(null);
|
}
|
} catch (Exception snapshotEx) {
|
log.error("[SD建单] 保存计费策略快照异常，回滚删除订单 orderId={} strategyId={}", order.getId(),
|
strategyId, snapshotEx);
|
removeOrderWithSnapshot(order.getId());
|
return DeviceStartChargingVO.fail(null);
|
}
|
|
// 6. 锁定账户额度（实扣冻结：共享=企业账户，分配=卡账户；锁定失败则关单并回告余额不足）
|
if (!lockCardChargeContext(card, chargeContext)) {
|
removeOrderWithSnapshot(order.getId());
|
return DeviceStartChargingVO.fail(3);
|
}
|
// 6.1 回填锁定额度（订单列表/详情展示与结算释放使用），同步内存对象，保证后续回滚能按额度释放
|
TCardChargingOrder accountUpdate = new TCardChargingOrder();
|
accountUpdate.setId(order.getId());
|
accountUpdate.setLockedAmount(chargeContext.getDispatchAmount());
|
// 企业优惠快照落库（建单时固化，结算/补偿优先读快照，抵抗公司优惠设置后续变更）
|
chargeAccountSupport.fillPreferentialSnapshot(accountUpdate, card.getCompanyId());
|
updateById(accountUpdate);
|
order.setLockedAmount(chargeContext.getDispatchAmount());
|
|
// 7. 锁卡（条件更新：仅空闲卡可锁；失败释放账户锁定额并回滚删除订单与快照）
|
R<Boolean> lockResult = chargingCardClient.lockForCharging(card.getId(), order.getCode());
|
if (!Boolean.TRUE.equals(lockResult.getData())) {
|
log.warn("[SD建单] 锁卡失败回滚订单 code={} cardId={} msg={}", order.getCode(), card.getId(), lockResult.getMsg());
|
unlockCardChargeContextQuietly(order, "锁卡失败");
|
removeOrderWithSnapshot(order.getId());
|
return DeviceStartChargingVO.fail(4);
|
}
|
log.info("[SD建单] 刷卡充电订单创建成功 code={} cardNo={} gun={} accountMode={} lockAmount={} maxEndTime={}",
|
order.getCode(), card.getCardNo(), dto.getChargingGunCode(), chargeContext.getAccountMode(),
|
chargeContext.getDispatchAmount(), chargeContext.getMaxEndTime());
|
return DeviceStartChargingVO.success(order.getCode(), chargeContext.getDispatchAmount());
|
} finally {
|
if (cardLocked && cardLock.isHeldByCurrentThread()) {
|
cardLock.unlock();
|
}
|
}
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
log.error("[SD建单] 建单锁获取被中断 pile={} gun={}", dto.getChargingPileCode(), dto.getChargingGunCode(), ie);
|
return DeviceStartChargingVO.fail(null);
|
} catch (Exception e) {
|
log.error("[SD建单] 刷卡充电启动异常 pile={} gun={} account={}",
|
dto.getChargingPileCode(), dto.getChargingGunCode(), dto.getAccount(), e);
|
return DeviceStartChargingVO.fail(null);
|
} finally {
|
if (gunLock.isHeldByCurrentThread()) {
|
gunLock.unlock();
|
}
|
}
|
}
|
|
/**
|
* 刷卡充电账户上下文解析（与 VIN 链路同构）：
|
* 1) 企业状态校验（未归属/不存在/停用 -> 失败码2），账户模式取企业配置（默认共享）；
|
* 2) 企业充电授权校验：站点范围（超范围 -> 失败码2）、可用时段（不在时段 -> 失败码2），未配置授权按放行处理；
|
* 3) 可用余额校验（共享=企业可用余额，分配=卡可用余额，<=0 -> 失败码3）；
|
* 4) 下发金额：共享模式=min(授权下发额, 可用余额)，分配模式=卡账户余额；锁定额度与下发金额一致；授权截止时间用于监控提前停充。
|
*/
|
private ChargeAccountSupport.ChargeContext resolveCardChargeContext(Integer siteId, Integer strategyId,
|
TChargingCard card) {
|
// 1. 企业校验：刷卡充电按企业账户模式计费，卡必须归属有效企业
|
Integer companyId = card.getCompanyId();
|
if (companyId == null) {
|
return ChargeAccountSupport.ChargeContext.fail(2, "卡片未归属企业");
|
}
|
TGroupCompany company;
|
try {
|
R<TGroupCompany> companyResult = groupCompanyClient.getCompanyById(companyId);
|
company = companyResult == null ? null : companyResult.getData();
|
} catch (Exception ex) {
|
log.error("[SD建单] 查询企业失败 companyId={}", companyId, ex);
|
return ChargeAccountSupport.ChargeContext.fail(2, "企业信息查询失败");
|
}
|
if (company == null) {
|
return ChargeAccountSupport.ChargeContext.fail(2, "企业不存在");
|
}
|
if (company.getStatus() != null && company.getStatus() != 1) {
|
return ChargeAccountSupport.ChargeContext.fail(2, "企业已停用");
|
}
|
int accountMode = company.getAccountMode() == null
|
? ChargeAccountSupport.ACCOUNT_MODE_SHARED : company.getAccountMode();
|
|
// 2. 充电授权校验（站点范围 + 可用时段 + 授权截止时间）
|
ChargeAuthorizationDTO authorization = null;
|
LocalDateTime maxEndTime = null;
|
try {
|
R<ChargeAuthorizationDTO> authResult = chargeAuthorizationClient.getDetailByCompanyId(companyId);
|
authorization = authResult == null ? null : authResult.getData();
|
} catch (Exception ex) {
|
log.error("[SD建单] 查询企业充电授权失败 companyId={}", companyId, ex);
|
}
|
if (authorization != null) {
|
List<Integer> siteIds = authorization.getSiteIds();
|
if (siteIds != null && !siteIds.isEmpty() && siteId != null && !siteIds.contains(siteId)) {
|
return ChargeAccountSupport.ChargeContext.fail(2, "站点不在企业充电授权范围");
|
}
|
ChargeAccountSupport.AuthorizationWindow window =
|
chargeAccountSupport.resolveAuthorizationWindow(authorization, strategyId, companyId);
|
if (window == null) {
|
return ChargeAccountSupport.ChargeContext.fail(2, "当前时间不在企业充电授权时段");
|
}
|
maxEndTime = window.getMaxEndTime();
|
}
|
|
// 3. 可用余额校验（实扣冻结口径，可用余额<=0 不允许启动）
|
BigDecimal usable = Integer.valueOf(ChargeAccountSupport.ACCOUNT_MODE_ALLOCATED).equals(accountMode)
|
? card.getBalance() : company.getAvailableBalance();
|
usable = usable == null ? BigDecimal.ZERO : usable;
|
if (usable.compareTo(BigDecimal.ZERO) <= 0) {
|
return ChargeAccountSupport.ChargeContext.fail(3, "账户可用余额不足");
|
}
|
|
// 4. 下发金额：共享模式=min(授权下发额, 可用余额)，分配模式=卡账户余额；锁定金额与下发金额一致
|
BigDecimal dispatchAmount;
|
if (Integer.valueOf(ChargeAccountSupport.ACCOUNT_MODE_ALLOCATED).equals(accountMode)) {
|
dispatchAmount = usable;
|
} else {
|
dispatchAmount = authorization == null || authorization.getDispatchAmount() == null
|
? ChargeAccountSupport.DEFAULT_DISPATCH_AMOUNT : authorization.getDispatchAmount();
|
if (dispatchAmount.compareTo(usable) > 0) {
|
dispatchAmount = usable;
|
}
|
}
|
if (dispatchAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
return ChargeAccountSupport.ChargeContext.fail(3, "账户可用余额不足");
|
}
|
return ChargeAccountSupport.ChargeContext.ok(accountMode, dispatchAmount, maxEndTime);
|
}
|
|
/**
|
* 锁定账户额度（实扣冻结）：共享模式锁企业账户，分配模式锁卡账户；锁定失败回告余额不足
|
*/
|
private boolean lockCardChargeContext(TChargingCard card, ChargeAccountSupport.ChargeContext context) {
|
BigDecimal amount = context.getDispatchAmount();
|
try {
|
R<BigDecimal> lockResult;
|
if (Integer.valueOf(ChargeAccountSupport.ACCOUNT_MODE_ALLOCATED).equals(context.getAccountMode())) {
|
lockResult = chargingCardClient.lockBalance(card.getId(), amount);
|
} else {
|
lockResult = groupCompanyClient.lockBalance(card.getCompanyId(), amount);
|
}
|
if (lockResult == null || lockResult.getCode() != R.SUCCESS) {
|
log.warn("[SD建单] 锁定账户额度失败 cardId={} companyId={} accountMode={} amount={} msg={}",
|
card.getId(), card.getCompanyId(), context.getAccountMode(), amount,
|
lockResult == null ? "null" : lockResult.getMsg());
|
return false;
|
}
|
return true;
|
} catch (Exception ex) {
|
log.error("[SD建单] 锁定账户额度异常 cardId={} companyId={} amount={}", card.getId(), card.getCompanyId(),
|
amount, ex);
|
return false;
|
}
|
}
|
|
/**
|
* 释放账户锁定额（建单失败/回滚/关单场景）：共享=企业账户，分配=卡账户；
|
* 订单侧 lock_released 条件更新抢占，保证同一订单的锁定额在多路径/重复补偿下只释放一次；
|
* 释放失败时把标记回滚为未释放，留待补偿任务/人工重试
|
*/
|
private void unlockCardChargeContextQuietly(TCardChargingOrder order, String scene) {
|
if (order == null || order.getId() == null || order.getCompanyId() == null) {
|
return;
|
}
|
BigDecimal amount = order.getLockedAmount();
|
if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
|
return;
|
}
|
boolean claimed;
|
try {
|
claimed = lambdaUpdate()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getLockReleased, 0)
|
.set(TCardChargingOrder::getLockReleased, 1)
|
.update();
|
} catch (Exception ex) {
|
log.error("[SD建单] 抢占锁定额释放标记异常 scene={} code={}", scene, order.getCode(), ex);
|
return;
|
}
|
if (!claimed) {
|
log.info("[SD建单] 锁定额已释放，跳过重复释放 scene={} code={}", scene, order.getCode());
|
return;
|
}
|
boolean unlocked = false;
|
try {
|
R<BigDecimal> unlockResult;
|
if (Integer.valueOf(ChargeAccountSupport.ACCOUNT_MODE_ALLOCATED).equals(order.getAccountMode())) {
|
unlockResult = chargingCardClient.unlockBalance(order.getCardId(), amount);
|
} else {
|
unlockResult = groupCompanyClient.unlockBalance(order.getCompanyId(), amount);
|
}
|
unlocked = unlockResult != null && unlockResult.getCode() == R.SUCCESS;
|
if (!unlocked) {
|
log.error("[SD建单] 释放账户锁定额失败 scene={} code={} amount={} msg={}", scene, order.getCode(),
|
amount, unlockResult == null ? "null" : unlockResult.getMsg());
|
}
|
} catch (Exception ex) {
|
log.error("[SD建单] 释放账户锁定额异常 scene={} code={} amount={}", scene, order.getCode(), amount, ex);
|
}
|
if (!unlocked) {
|
lambdaUpdate()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getLockReleased, 1)
|
.set(TCardChargingOrder::getLockReleased, 0)
|
.update();
|
}
|
}
|
|
/**
|
* 回滚删除订单及其计费策略快照（建单失败场景；快照可能尚未写入，删除为幂等操作）
|
*/
|
private void removeOrderWithSnapshot(Long orderId) {
|
if (orderId == null) {
|
return;
|
}
|
try {
|
cardAccountingStrategyDetailOrderService.remove(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TCardAccountingStrategyDetailOrder>()
|
.eq(TCardAccountingStrategyDetailOrder::getChargingOrderId, orderId));
|
cardAccountingStrategyOrderService.remove(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TCardAccountingStrategyOrder>()
|
.eq(TCardAccountingStrategyOrder::getChargingOrderId, orderId));
|
} catch (Exception ex) {
|
log.error("[SD建单] 清理计费策略快照异常 orderId={}", orderId, ex);
|
}
|
removeById(orderId);
|
}
|
|
/**
|
* 保存计费策略快照（主表 + 明细表），与 CD 订单快照逻辑一致
|
*
|
* @return 是否成功写入快照（策略ID为空、策略/明细不存在或明细为空、持久化失败均返回 false，调用方需回滚建单）
|
*/
|
private boolean saveStrategySnapshot(Long orderId, Integer strategyId) {
|
if (strategyId == null) {
|
return false;
|
}
|
TAccountingStrategy strategy = accountingStrategyClient.getAccountingStrategyById(strategyId).getData();
|
List<TAccountingStrategyDetail> details = accountingStrategyDetailClient.getListByAccountingStrategyId(strategyId).getData();
|
if (strategy == null || details == null || details.isEmpty()) {
|
return false;
|
}
|
TCardAccountingStrategyOrder strategyOrder = new TCardAccountingStrategyOrder();
|
BeanUtils.copyProperties(strategy, strategyOrder);
|
strategyOrder.setChargingOrderId(orderId);
|
boolean mainSaved = cardAccountingStrategyOrderService.save(strategyOrder);
|
List<TCardAccountingStrategyDetailOrder> detailOrders = new ArrayList<>();
|
for (TAccountingStrategyDetail detail : details) {
|
TCardAccountingStrategyDetailOrder detailOrder = new TCardAccountingStrategyDetailOrder();
|
BeanUtils.copyProperties(detail, detailOrder);
|
detailOrder.setChargingOrderId(orderId);
|
detailOrders.add(detailOrder);
|
}
|
boolean detailSaved = cardAccountingStrategyDetailOrderService.saveBatch(detailOrders);
|
return mainSaved && detailSaved;
|
}
|
|
/**
|
* 账户服务鉴权失败消息 -> 协议失败原因码（1=账户不存在 2=账户冻结 7=密码错误）
|
*/
|
private Integer mapAuthFailure(String msg) {
|
if (StringUtils.isNotEmpty(msg)) {
|
if (msg.contains("密码")) {
|
return 7;
|
}
|
if (msg.contains("禁用") || msg.contains("冻结")) {
|
return 2;
|
}
|
if (msg.contains("不存在")) {
|
return 1;
|
}
|
}
|
return 1;
|
}
|
|
@Override
|
public TCardChargingOrder getCardOrderByCode(String code) {
|
if (StringUtils.isEmpty(code)) {
|
return null;
|
}
|
return getOne(new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TCardChargingOrder>()
|
.eq(TCardChargingOrder::getCode, code)
|
.last("limit 1"));
|
}
|
|
@Override
|
public void cardStartChargeSuccessfully(PlatformStartChargingReplyMessageVO vo) {
|
if (vo == null || StringUtils.isEmpty(vo.getTransaction_serial_number())) {
|
return;
|
}
|
TCardChargingOrder order = getCardOrderByCode(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(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_STARTING)
|
.set(TCardChargingOrder::getStatus, ORDER_STATUS_CHARGING)
|
.set(TCardChargingOrder::getStartTime, LocalDateTime.now())
|
.update();
|
if (!updated) {
|
return;
|
}
|
updateGunStatusQuietly(order, GUN_STATUS_CHARGING, "启动成功");
|
log.info("[SD启动] 刷卡订单进入充电中 code={}", order.getCode());
|
order.setStatus(ORDER_STATUS_CHARGING);
|
pushRegulatoryAsync(order, true, false);
|
} else {
|
closeTimeoutStartingOrder(order);
|
log.warn("[SD启动] 刷卡订单启动失败关闭 code={} result={}", order.getCode(), vo.getStartup_result());
|
}
|
}
|
|
@Override
|
public boolean handleHandshakeVin(String orderCode, String vin) {
|
if (StringUtils.isEmpty(orderCode)) {
|
return false;
|
}
|
TCardChargingOrder order = getCardOrderByCode(orderCode);
|
if (order == null) {
|
log.warn("[SD握手] 订单不存在 code={}", orderCode);
|
return false;
|
}
|
TCardChargingOrder update = new TCardChargingOrder();
|
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<TCardChargingOrder>()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::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("[SD握手] 握手推进订单进入充电中 code={}", orderCode);
|
}
|
return updated;
|
}
|
|
@Override
|
public void cardChargeMonitoring(UploadRealTimeMonitoringDataQuery query) {
|
if (query == null || StringUtils.isEmpty(query.getTransaction_serial_number())) {
|
return;
|
}
|
TCardChargingOrder order = getCardOrderByCode(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;
|
}
|
// 充电中授权时间到期主动停充（提前 AUTHORIZE_STOP_AHEAD_SECONDS 下发，规避数据传输延迟）
|
if (Integer.valueOf(ORDER_STATUS_CHARGING).equals(order.getStatus()) && needAuthorizeStop(order)) {
|
stopByAuthorizeExpired(order);
|
return;
|
}
|
TCardChargingOrder update = new TCardChargingOrder();
|
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());
|
}
|
// 剩余金额口径与 CD 一致：可用金额基数（建单写入 charge_amount） - 设备已充金额
|
if (query.getPaid_amount() != null && order.getChargeAmount() != null) {
|
update.setResidualAmount(order.getChargeAmount().subtract(query.getPaid_amount())
|
.setScale(2, RoundingMode.HALF_EVEN));
|
}
|
boolean updated = update(update, new com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<TCardChargingOrder>()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.in(TCardChargingOrder::getStatus, ORDER_STATUS_STARTING, ORDER_STATUS_CHARGING));
|
if (starting && updated) {
|
updateGunStatusQuietly(order, GUN_STATUS_CHARGING, "实时数据恢复");
|
}
|
}
|
|
/**
|
* 判断是否触发授权时间到期主动停充（提前 AUTHORIZE_STOP_AHEAD_SECONDS 秒下发，规避数据传输延迟）：
|
* 授权总时长不足固定提前量时按整个授权时长提前（启动后即触发停充），确保授权截止时间前结束充电；
|
* maxEndTime 为空（全天授权/未开启自动停充）时不介入。
|
*/
|
private boolean needAuthorizeStop(TCardChargingOrder order) {
|
LocalDateTime startTime = order.getStartTime() != null ? order.getStartTime() : order.getCreateTime();
|
return chargeAccountSupport.needAuthorizeStop(order.getMaxEndTime(), startTime);
|
}
|
|
/**
|
* 授权时间到期主动停充：复用小程序主动停充链路（状态4 + 结束方式1 + 下发停止充电命令），
|
* 状态推进使用条件更新，与设备回调/其他停充入口并发时只有一方生效
|
*/
|
private void stopByAuthorizeExpired(TCardChargingOrder order) {
|
TChargingGun gun;
|
TChargingPile pile;
|
try {
|
R<TChargingGun> gunResult = chargingGunClient.getChargingGunById(order.getChargingGunId());
|
gun = gunResult == null ? null : gunResult.getData();
|
pile = order.getChargingPileId() == null ? null
|
: Optional.ofNullable(chargingPileClient.getChargingPileById(order.getChargingPileId()).getData())
|
.orElse(null);
|
} catch (Exception ex) {
|
log.error("[SD停充] 授权到期停充查询设备异常 code={}", order.getCode(), ex);
|
return;
|
}
|
if (gun == null || pile == null) {
|
log.error("[SD停充] 授权到期停充缺少设备信息 code={} gunId={}", order.getCode(), order.getChargingGunId());
|
return;
|
}
|
boolean updated = lambdaUpdate()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_CHARGING)
|
.set(TCardChargingOrder::getStatus, ORDER_STATUS_STOPPING)
|
.set(TCardChargingOrder::getEndMode, 1)
|
.set(TCardChargingOrder::getEndTime, LocalDateTime.now())
|
.update();
|
if (!updated) {
|
return;
|
}
|
order.setStatus(ORDER_STATUS_STOPPING);
|
order.setEndMode(1);
|
PlatformStopCharging command = new PlatformStopCharging();
|
command.setCharging_pile_code(pile.getCode());
|
command.setCharging_gun_code(gun.getCode());
|
sendMessageClient.platformStopCharging(command);
|
log.warn("[SD停充] 授权时间到期主动停充 code={} maxEndTime={}", order.getCode(), order.getMaxEndTime());
|
}
|
|
@Override
|
public void cardEndCharge(String orderCode, Integer endMode) {
|
if (StringUtils.isEmpty(orderCode)) {
|
return;
|
}
|
TCardChargingOrder order = getCardOrderByCode(orderCode);
|
if (order == null) {
|
return;
|
}
|
TCardChargingOrder update = new TCardChargingOrder();
|
update.setId(order.getId());
|
update.setEndMode(endMode);
|
updateById(update);
|
pushRegulatoryAsync(order, false, false);
|
}
|
|
@Override
|
public R cardEndChargeBillingCharge(TransactionRecordMessageVO vo) {
|
String code = vo == null ? null : vo.getTransaction_serial_number();
|
log.info("[SD结算] 收到交易记录 code={}", code);
|
if (StringUtils.isEmpty(code)) {
|
return R.fail("交易记录缺少交易流水号");
|
}
|
// 结算锁（文档13.3 统一结算入口第一层）：订单号维度，防并发/重复账单同时进入结算；
|
// 抢不到锁说明正在结算，按重复账单语义返回成功；锁内仍有状态幂等与扣款唯一键两层兜底
|
RLock settleLock = redissonClient.getLock(LOCK_SD_SETTLE + code);
|
try {
|
if (!settleLock.tryLock(5, 60, TimeUnit.SECONDS)) {
|
log.warn("[SD结算] 并发结算进行中，跳过重复账单 code={}", code);
|
return R.ok("重复账单，结算处理中");
|
}
|
return doCardEndChargeBillingCharge(vo, code);
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
return R.fail("结算锁获取被中断：" + code);
|
} finally {
|
if (settleLock.isHeldByCurrentThread()) {
|
settleLock.unlock();
|
}
|
}
|
}
|
|
/**
|
* SD 结算实际执行体（调用前须持有订单号结算锁）
|
*/
|
private R doCardEndChargeBillingCharge(TransactionRecordMessageVO vo, String code) {
|
TCardChargingOrder order = getCardOrderByCode(code);
|
if (order == null) {
|
return R.fail("刷卡充电订单不存在：" + code);
|
}
|
// 幂等：已结算订单直接返回成功（重复账单/重复推送）
|
if (order.getStatus() != null && order.getStatus() == ORDER_STATUS_FINISHED) {
|
log.warn("[SD结算] 重复账单跳过 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<TCardAccountingStrategyDetailOrder> snapshots = new ArrayList<>(cardAccountingStrategyDetailOrderService
|
.lambdaQuery().eq(TCardAccountingStrategyDetailOrder::getChargingOrderId, order.getId())
|
.list());
|
snapshots.removeIf(item -> item.getType() == null);
|
snapshots.sort(Comparator.comparing(TCardAccountingStrategyDetailOrder::getStartTime,
|
Comparator.nullsLast(String::compareTo)));
|
|
// 企业优惠设置与计费模板（1=不优惠，2=服务费按比例优惠，3=按计费模板优惠单价收费）：
|
// 订单快照优先（建单时固化，策略后续变更不影响本单结算口径），快照为空的历史订单实时查询并在本事务回填
|
ChargeAccountSupport.PreferentialSnapshot preferential = chargeAccountSupport.resolvePreferential(order);
|
TBillingTemplateDTO billingTemplate = preferential == null ? null : preferential.getTemplate();
|
|
BigDecimal electrovalenceTotal = BigDecimal.ZERO;
|
BigDecimal serviceChargeTotal = BigDecimal.ZERO;
|
BigDecimal discountElectricTotal = BigDecimal.ZERO;
|
BigDecimal discountServiceTotal = BigDecimal.ZERO;
|
List<TCardChargingOrderAccountingStrategy> details = new ArrayList<>();
|
// 严格对齐 CD：遍历按 start_time 排序后的策略，第 N 段只读取该策略类型对应的 chargeN。
|
for (int snapshotIndex = 0; snapshotIndex < snapshots.size(); snapshotIndex++) {
|
TCardAccountingStrategyDetailOrder 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 originalElectricAmount = capacity.multiply(electricPrice).setScale(2, BigDecimal.ROUND_HALF_UP);
|
BigDecimal originalServiceAmount = capacity.multiply(originalServicePrice).setScale(2, BigDecimal.ROUND_HALF_UP);
|
// 优惠后的最终单价：方式2=服务费按比例优惠；方式3=电费/服务费取计费模板同阶段单价
|
BigDecimal finalElectricPrice = electricPrice;
|
BigDecimal finalServicePrice = servicePrice;
|
if (preferential != null
|
&& Integer.valueOf(ChargeAccountSupport.PREFERENTIAL_TYPE_RATE).equals(preferential.getPreferentialType())) {
|
finalServicePrice = ChargeAccountSupport.applyServiceDiscountRate(servicePrice, preferential.getServiceDiscountRate());
|
} else if (preferential != null
|
&& Integer.valueOf(ChargeAccountSupport.PREFERENTIAL_TYPE_TEMPLATE).equals(preferential.getPreferentialType())) {
|
TBillingTemplateDetail templateDetail = ChargeAccountSupport.findTemplateDetail(billingTemplate, snapshot.getType());
|
if (templateDetail == null) {
|
log.warn("[SD结算] 计费模板缺少对应阶段，该段按原价结算 code={} type={} templateId={}", code,
|
snapshot.getType(), preferential.getBillingTemplateId());
|
} else {
|
if (templateDetail.getElectrovalence() != null) {
|
finalElectricPrice = templateDetail.getElectrovalence();
|
}
|
if (templateDetail.getServiceCharge() != null) {
|
finalServicePrice = templateDetail.getServiceCharge();
|
}
|
}
|
}
|
BigDecimal electricAmount = capacity.multiply(finalElectricPrice).setScale(2, BigDecimal.ROUND_HALF_UP);
|
BigDecimal serviceAmount = capacity.multiply(finalServicePrice).setScale(2, BigDecimal.ROUND_HALF_UP);
|
BigDecimal discountElectricAmount = originalElectricAmount.subtract(electricAmount);
|
BigDecimal discountServiceAmount = originalServiceAmount.subtract(serviceAmount);
|
electrovalenceTotal = electrovalenceTotal.add(electricAmount);
|
serviceChargeTotal = serviceChargeTotal.add(serviceAmount);
|
discountElectricTotal = discountElectricTotal.add(discountElectricAmount);
|
discountServiceTotal = discountServiceTotal.add(discountServiceAmount);
|
|
TCardChargingOrderAccountingStrategy detail = new TCardChargingOrderAccountingStrategy();
|
detail.setChargingOrderId(order.getId());
|
detail.setType(snapshot.getType());
|
detail.setElectrovalence(finalElectricPrice);
|
detail.setServiceCharge(finalServicePrice);
|
detail.setCostServiceCharge(originalServicePrice);
|
detail.setChargingCapacity(capacity);
|
detail.setPeriodElectricPrice(electricAmount);
|
detail.setPeriodServicePrice(serviceAmount);
|
detail.setPeriodOriginalServicePrice(originalServiceAmount);
|
detail.setPeriodOriginalElectricPrice(originalElectricAmount);
|
detail.setPeriodDiscountElectricPrice(discountElectricAmount);
|
detail.setPeriodDiscountServicePrice(discountServiceAmount);
|
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("[SD结算] 订单无计费策略快照，按0价结算并需人工核对 code={} totalElectricity={}", code, totalElectricity);
|
}
|
// 首段使用订单实际开始时间；订单尚未写入结束时间时，末段使用交易记录设备结束时间。
|
LocalDateTime settlementStartTime = parseDeviceTime(vo.getStart_time(), order.getStartTime());
|
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 discountElecTotal = discountElectricTotal;
|
final BigDecimal discountSvcTotal = discountServiceTotal;
|
// SOC 回填（与 VIN 结算同口径）：取订单最早/最新实时监控上报，读取失败不阻断结算
|
final BigDecimal startSoc = getMonitoringSocQuietly(code, "asc");
|
final BigDecimal endSoc = getMonitoringSocQuietly(code, "desc");
|
// 剩余金额口径：可用金额基数（建单写入的 charge_amount） - 本单金额；
|
// 改造前创建的老订单无基数时以本单金额兜底（剩余金额记 0），并顺带补齐 charge_amount
|
final BigDecimal chargeBase = order.getChargeAmount() != null ? order.getChargeAmount() : orderAmount;
|
final BigDecimal residualAmount = chargeBase.subtract(orderAmount).setScale(2, RoundingMode.HALF_EVEN);
|
final ChargeAccountSupport.PreferentialSnapshot preferentialSnapshot = preferential;
|
final boolean preferentialBackfill = preferentialSnapshot != null && preferentialSnapshot.needBackfill();
|
|
// 本地事务：写计费明细 + 更新订单（状态5，允许负余额金额记录）
|
transactionTemplate.execute(status -> {
|
cardChargingOrderAccountingStrategyService.lambdaUpdate()
|
.eq(TCardChargingOrderAccountingStrategy::getChargingOrderId, order.getId())
|
.remove();
|
if (!details.isEmpty()) {
|
cardChargingOrderAccountingStrategyService.saveBatch(details);
|
}
|
TCardChargingOrder update = new TCardChargingOrder();
|
update.setId(order.getId());
|
update.setTotalElectricity(totalElec);
|
update.setChargingCapacity(totalElec);
|
update.setElectrovalence(elecTotal);
|
update.setServiceCharge(svcTotal);
|
update.setOrderAmount(orderAmount);
|
update.setPaymentAmount(orderAmount);
|
// 优惠合计（原始电费/服务费 - 最终），与 VIN 链路同口径
|
update.setDiscountElectrovalence(discountElecTotal);
|
update.setDiscountServiceCharge(discountSvcTotal);
|
// 余额支付金额（本单实际余额扣款额，供余额明细"充电余额扣款"与支付方式展示）
|
update.setBalancePayAmount(orderAmount);
|
update.setChargeAmount(chargeBase);
|
update.setResidualAmount(residualAmount);
|
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);
|
}
|
// SOC 回填：监控数据缺失/查询异常时不覆盖既有值，与 VIN 结算行为一致
|
if (startSoc != null) {
|
update.setStartSoc(startSoc);
|
}
|
if (endSoc != null) {
|
update.setEndSoc(endSoc);
|
}
|
if (preferentialBackfill) {
|
// 历史订单（快照为空）实时查询结果回填订单快照列，保证后续补偿重算口径一致
|
update.setPreferentialType(preferentialSnapshot.getPreferentialType());
|
update.setServiceDiscountRate(preferentialSnapshot.getServiceDiscountRate());
|
update.setBillingTemplateId(preferentialSnapshot.getBillingTemplateId());
|
update.setBillingTemplateSnapshot(
|
ChargeAccountSupport.serializeTemplateSnapshot(preferentialSnapshot.getTemplate()));
|
update.setPreferentialSnapshotTime(LocalDateTime.now());
|
}
|
updateById(update);
|
return true;
|
});
|
|
// 回写内存订单对象，保证结算后监管推送/日志使用最新金额字段
|
order.setChargeAmount(chargeBase);
|
order.setResidualAmount(residualAmount);
|
order.setBalancePayAmount(orderAmount);
|
order.setOrderAmount(orderAmount);
|
order.setPaymentAmount(orderAmount);
|
order.setDiscountElectrovalence(discountElectricTotal);
|
order.setDiscountServiceCharge(discountServiceTotal);
|
|
// 账户结算（实扣冻结口径）：解锁申请时锁定的额度、按实际消费扣款并退回差额，同时写分配记录消费流水；
|
// 无法确认扣款成功时回退状态4，交由补偿任务重试
|
if (!settleCardChargeAccount(order, orderAmount, code)) {
|
rollbackFinishedToStopping(order.getId(), code);
|
return R.fail("充电卡结算失败，订单已进入补偿队列");
|
}
|
|
// 结算成功后解锁卡片
|
unlockCardQuietly(order);
|
// 复位充电枪
|
resetGunQuietly(order);
|
// 推送成都监管（结算完成推枪状态 + 订单信息，与 CD 结算链路一致）
|
pushRegulatoryAsync(order, false, true);
|
log.info("[SD结算] 完成 code={} totalElectricity={} electrovalence={} serviceCharge={} amount={} discountElec={} discountSvc={}",
|
code, totalElectricity, electrovalenceTotal, serviceChargeTotal, orderAmount, discountElectricTotal,
|
discountServiceTotal);
|
return R.ok();
|
}
|
|
/**
|
* 容错读取订单最早/最新监控记录的 SOC（与 VIN 结算同口径）：
|
* Mongo 数据缺失、SOC 未上报或查询异常返回 null，不阻断主结算流程。
|
*/
|
private BigDecimal getMonitoringSocQuietly(String code, String sort) {
|
if (uploadRealTimeMonitoringDataService == null) {
|
return null;
|
}
|
try {
|
UploadRealTimeMonitoringData monitoringData = uploadRealTimeMonitoringDataService.getDataByOrderCode(code, sort);
|
return monitoringData == null || monitoringData.getSoc() == null
|
? null : BigDecimal.valueOf(monitoringData.getSoc().longValue());
|
} catch (Exception ex) {
|
log.error("[SD结算] 查询监控SOC失败 code={} sort={}", code, sort, ex);
|
return null;
|
}
|
}
|
|
/**
|
* 结算刷卡账户资金（实扣冻结口径，与 VIN 链路同构）：
|
* 1) 分配模式：解锁卡片锁定额并按实际消费扣减（允许扣成负数），差额退回卡账户；
|
* 2) 共享模式：解锁企业账户锁定额并按实际消费扣减，差额退回企业账户；
|
* 3) 写入企业额度分配记录-消费流水（按订单号+change_type 幂等）。
|
* 改造前的历史订单（无锁定金额）沿用历史扣款接口扣卡余额，保持既有行为不变。
|
*
|
* @return 是否确认结算成功（false 表示需回退状态等待补偿重试）
|
*/
|
private boolean settleCardChargeAccount(TCardChargingOrder order, BigDecimal actualAmount, String code) {
|
BigDecimal lockedAmount = order.getLockedAmount() == null ? BigDecimal.ZERO : order.getLockedAmount();
|
BigDecimal actual = actualAmount == null ? BigDecimal.ZERO : actualAmount;
|
if (actual.compareTo(BigDecimal.ZERO) <= 0 && lockedAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
log.info("[SD结算] 订单金额为0且无锁定额度，跳过账户结算 code={}", code);
|
return true;
|
}
|
boolean allocated = Integer.valueOf(ChargeAccountSupport.ACCOUNT_MODE_ALLOCATED).equals(order.getAccountMode());
|
if (lockedAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
// 历史订单（改造前无锁定金额）：沿用仅按实扣金额扣卡余额的旧接口
|
log.info("[SD结算] 订单无锁定金额，按历史扣款接口结算 code={} accountMode={}", code, order.getAccountMode());
|
return legacyCardDeduct(order, actual, code);
|
}
|
BigDecimal afterBalance;
|
try {
|
if (allocated) {
|
ChargingCardDeductDTO settleDTO = new ChargingCardDeductDTO();
|
settleDTO.setCardId(order.getCardId());
|
settleDTO.setOrderCode(code);
|
settleDTO.setAmount(actual);
|
settleDTO.setLockedAmount(lockedAmount);
|
R<ChargingCardDeductVO> settleResult = chargingCardClient.settleForCharging(settleDTO);
|
if (settleResult == null || settleResult.getCode() != R.SUCCESS || settleResult.getData() == null) {
|
log.error("[SD结算] 卡账户结算失败 code={} cardId={} locked={} actual={} msg={}", code,
|
order.getCardId(), lockedAmount, actual,
|
settleResult == null ? "null" : settleResult.getMsg());
|
return false;
|
}
|
if (settleResult.getData().isDuplicated()) {
|
log.warn("[SD结算] 卡账户结算幂等命中（重复请求不重复扣）code={}", code);
|
}
|
afterBalance = settleResult.getData().getAfterBalance();
|
} else {
|
// 共享模式：传订单号启用账户侧结算幂等（账户侧按订单号+变更类型落企业消费流水并作为已结算标记）
|
R<BigDecimal> settleResult =
|
groupCompanyClient.settleBalance(order.getCompanyId(), lockedAmount, actual,
|
code, order.getCardNo(), null, "刷卡充电结算");
|
if (settleResult == null || settleResult.getCode() != R.SUCCESS) {
|
log.error("[SD结算] 企业账户结算失败 code={} companyId={} locked={} actual={} msg={}", code,
|
order.getCompanyId(), lockedAmount, actual,
|
settleResult == null ? "null" : settleResult.getMsg());
|
return false;
|
}
|
afterBalance = settleResult.getData();
|
}
|
} catch (Exception ex) {
|
log.error("[SD结算] 账户结算异常 code={} accountMode={} locked={} actual={}", code, order.getAccountMode(),
|
lockedAmount, actual, ex);
|
return false;
|
}
|
if (allocated) {
|
// 分配模式消费流水记卡账户；共享模式消费流水已由账户侧 settleBalance 按订单号写入，避免重复记账
|
recordCardConsumeAllocate(order, actual, lockedAmount, afterBalance, code);
|
}
|
log.info("[SD结算] 账户结算完成 code={} accountMode={} locked={} actual={} balance={}", code,
|
order.getAccountMode(), lockedAmount, actual, afterBalance);
|
return true;
|
}
|
|
/**
|
* 历史订单（改造前无锁定金额）扣款：沿用原有扣卡余额接口（订单号幂等）
|
*/
|
private boolean legacyCardDeduct(TCardChargingOrder order, BigDecimal actual, String code) {
|
if (actual.compareTo(BigDecimal.ZERO) <= 0 || order.getCardId() == null) {
|
return true;
|
}
|
ChargingCardDeductDTO deductDTO = new ChargingCardDeductDTO();
|
deductDTO.setCardId(order.getCardId());
|
deductDTO.setOrderCode(code);
|
deductDTO.setAmount(actual);
|
R<ChargingCardDeductVO> deductResult;
|
try {
|
deductResult = chargingCardClient.deductForCharging(deductDTO);
|
} catch (Exception ex) {
|
log.error("[SD结算] 扣款调用异常 code={} cardId={} amount={}", code, order.getCardId(), actual, ex);
|
return false;
|
}
|
if (deductResult == null || deductResult.getCode() != R.SUCCESS || deductResult.getData() == null) {
|
log.error("[SD结算] 扣款失败 code={} cardId={} amount={} msg={}", code, order.getCardId(), actual,
|
deductResult == null ? "null" : deductResult.getMsg());
|
return false;
|
}
|
if (deductResult.getData().isDuplicated()) {
|
log.warn("[SD结算] 扣款幂等命中（重复请求不重复扣）code={}", code);
|
return true;
|
}
|
recordCardConsumeAllocate(order, actual, BigDecimal.ZERO, deductResult.getData().getAfterBalance(), code);
|
return true;
|
}
|
|
/**
|
* 写企业额度分配记录-消费流水（仅卡侧扣款场景：分配模式结算与历史订单卡扣款，记该卡账户）：
|
* 共享模式消费流水由账户侧 settleBalance 按订单号写入（同一订单号+变更类型只能有一个写入方，避免重复记账）；
|
* 消费前余额 = 结算后余额 + 实际消费 - 锁定额度（实扣冻结口径反推）；失败不影响结算主流程
|
*/
|
private void recordCardConsumeAllocate(TCardChargingOrder order, BigDecimal actual, BigDecimal lockedAmount,
|
BigDecimal afterBalance, String code) {
|
if (order.getCompanyId() == null) {
|
return;
|
}
|
BigDecimal after = afterBalance == null ? BigDecimal.ZERO : afterBalance;
|
BigDecimal before = after.add(actual).subtract(lockedAmount);
|
chargeAccountSupport.recordConsume(order.getCompanyId(), TCompanyAllocateRecord.USER_TYPE_CARD,
|
order.getCardNo(), order.getCardNo(), before, actual.negate(), code, "刷卡充电结算");
|
}
|
|
private boolean rollbackFinishedToStopping(Long orderId, String code) {
|
boolean rolledBack = lambdaUpdate()
|
.eq(TCardChargingOrder::getId, orderId)
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_FINISHED)
|
.set(TCardChargingOrder::getStatus, ORDER_STATUS_STOPPING)
|
.update();
|
if (!rolledBack) {
|
log.warn("[SD结算] 状态5回退4未命中，订单状态可能已变化 code={}", code);
|
}
|
return rolledBack;
|
}
|
|
/**
|
* 异步推送监管平台（复用 CD 约定：充电中推平台订单状态 pushOrderStatus、成都监管推枪状态
|
* notificationConnectorChargeStatus / 结算完成推订单信息 notificationOrderInfo）；
|
* 推送失败仅告警不阻断主流程；单元测试环境 client 未注入时静默跳过
|
*/
|
private void pushRegulatoryAsync(TCardChargingOrder 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("[SD监管] 推送监管平台失败 code={}", order.getCode(), ex);
|
}
|
}, "SD-Regulatory-Push").start();
|
}
|
|
private boolean unlockCardQuietly(TCardChargingOrder order) {
|
if (order.getCardId() == null) {
|
return true;
|
}
|
try {
|
R<Boolean> result = chargingCardClient.unlockForCharging(order.getCardId(), order.getCode());
|
boolean success = result != null && result.getCode() == R.SUCCESS && Boolean.TRUE.equals(result.getData());
|
if (!success) {
|
log.error("[SD资源] 解锁卡片失败 code={} cardId={} msg={}", order.getCode(), order.getCardId(),
|
result == null ? "null" : result.getMsg());
|
}
|
return success;
|
} catch (Exception ex) {
|
log.error("[SD资源] 解锁卡片异常 code={} cardId={}", order.getCode(), order.getCardId(), ex);
|
return false;
|
}
|
}
|
|
private void resetGunQuietly(TCardChargingOrder order) {
|
updateGunStatusQuietly(order, GUN_STATUS_IDLE, "复位");
|
}
|
|
private boolean updateGunStatusQuietly(TCardChargingOrder 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("[SD资源] {}查询充电枪失败 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("[SD资源] {}更新充电枪失败 code={} gunId={} msg={}", scene, order.getCode(),
|
order.getChargingGunId(), result == null ? "null" : result.getMsg());
|
return false;
|
}
|
return true;
|
} catch (Exception ex) {
|
log.error("[SD资源] {}更新充电枪异常 code={} gunId={}", scene, order.getCode(), order.getChargingGunId(), ex);
|
return false;
|
}
|
}
|
|
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("[SD结算] 设备时间格式异常 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<TCardChargingOrder> listTimeoutStartingOrders() {
|
return lambdaQuery()
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_STARTING)
|
.lt(TCardChargingOrder::getCreateTime, LocalDateTime.now().minusMinutes(SD_STARTING_TIMEOUT_MINUTES))
|
.list();
|
}
|
|
@Override
|
public List<TCardChargingOrder> listTimeoutChargingOrders() {
|
return lambdaQuery()
|
.in(TCardChargingOrder::getStatus, ORDER_STATUS_CHARGING, ORDER_STATUS_STOPPING)
|
.list();
|
}
|
|
@Override
|
public int recoverFinishedOrdersWithoutDeduct() {
|
List<TCardChargingOrder> candidates = lambdaQuery()
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_FINISHED)
|
.isNotNull(TCardChargingOrder::getCardId)
|
.gt(TCardChargingOrder::getOrderAmount, BigDecimal.ZERO)
|
.lt(TCardChargingOrder::getEndTime, LocalDateTime.now().minusMinutes(SD_DEDUCT_COMPENSATION_DELAY_MINUTES))
|
.orderByAsc(TCardChargingOrder::getEndTime)
|
.last("LIMIT " + SD_DEDUCT_COMPENSATION_BATCH_SIZE)
|
.list();
|
if (candidates.isEmpty()) {
|
return 0;
|
}
|
|
List<String> orderCodes = candidates.stream().map(TCardChargingOrder::getCode)
|
.filter(StringUtils::isNotEmpty).collect(Collectors.toList());
|
// 双判据：卡侧扣款流水（分配模式/历史卡扣款）与企业侧消费流水（共享模式），任一存在即视为已结算
|
R<List<String>> deductedResult = chargingCardClient.listDeductedOrderCodes(orderCodes);
|
if (deductedResult == null || deductedResult.getCode() != R.SUCCESS || deductedResult.getData() == null) {
|
log.error("[SD扣款补偿] 查询卡侧扣款流水失败，本轮不修改订单 msg={}",
|
deductedResult == null ? "null" : deductedResult.getMsg());
|
return 0;
|
}
|
java.util.Set<String> consumedCodes = chargeAccountSupport.listConsumedOrderCodesQuietly(orderCodes);
|
if (consumedCodes == null) {
|
log.error("[SD扣款补偿] 查询企业侧消费流水失败，本轮不修改订单");
|
return 0;
|
}
|
|
java.util.Set<String> deductedCodes = new java.util.HashSet<>(deductedResult.getData());
|
deductedCodes.addAll(consumedCodes);
|
int recovered = 0;
|
for (TCardChargingOrder candidate : candidates) {
|
if (StringUtils.isEmpty(candidate.getCode()) || deductedCodes.contains(candidate.getCode())) {
|
continue;
|
}
|
RLock settleLock = redissonClient.getLock(LOCK_SD_SETTLE + candidate.getCode());
|
try {
|
if (!settleLock.tryLock(0, 60, TimeUnit.SECONDS)) {
|
continue;
|
}
|
R<List<String>> recheck = chargingCardClient.listDeductedOrderCodes(
|
Collections.singletonList(candidate.getCode()));
|
if (recheck == null || recheck.getCode() != R.SUCCESS || recheck.getData() == null) {
|
continue;
|
}
|
// 双判据复核：任一侧查询失败或存在流水即不回退（保守处理，避免重复扣款）
|
java.util.Set<String> consumedRecheck = chargeAccountSupport.listConsumedOrderCodesQuietly(
|
Collections.singletonList(candidate.getCode()));
|
if (consumedRecheck == null || recheck.getData().contains(candidate.getCode())
|
|| consumedRecheck.contains(candidate.getCode())) {
|
continue;
|
}
|
if (rollbackFinishedToStopping(candidate.getId(), candidate.getCode())) {
|
recovered++;
|
log.warn("[SD扣款补偿] 已结束订单无扣款流水，状态回退停止中 code={}", candidate.getCode());
|
}
|
} catch (InterruptedException ex) {
|
Thread.currentThread().interrupt();
|
log.warn("[SD扣款补偿] 获取结算锁被中断 code={}", candidate.getCode());
|
break;
|
} catch (Exception ex) {
|
log.error("[SD扣款补偿] 订单处理异常，保留原状态 code={}", candidate.getCode(), ex);
|
} finally {
|
if (settleLock.isHeldByCurrentThread()) {
|
settleLock.unlock();
|
}
|
}
|
}
|
return recovered;
|
}
|
|
@Override
|
public void closeTimeoutStartingOrder(TCardChargingOrder order) {
|
TCardChargingOrder update = new TCardChargingOrder();
|
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<TCardChargingOrder>()
|
.eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_STARTING));
|
if (!closed) {
|
log.info("[SD补偿] 启动超时关单跳过，订单状态已变化 code={}", order.getCode());
|
return;
|
}
|
if (!unlockCardQuietly(order)) {
|
// 解锁失败恢复为启动中，下轮继续补偿，避免卡片永久占用
|
lambdaUpdate().eq(TCardChargingOrder::getId, order.getId())
|
.eq(TCardChargingOrder::getStatus, ORDER_STATUS_START_FAILED)
|
.set(TCardChargingOrder::getStatus, ORDER_STATUS_STARTING)
|
.set(TCardChargingOrder::getEndMode, null)
|
.set(TCardChargingOrder::getEndTime, null)
|
.update();
|
return;
|
}
|
// 释放申请时锁定的账户额度（未产生消费；失败仅告警，由人工/后续补偿核对）
|
unlockCardChargeContextQuietly(order, "启动关单");
|
resetGunQuietly(order);
|
pushRegulatoryAsync(order, false, false);
|
log.warn("[SD补偿] 启动超时关单 code={} cardId={} gunId={}", order.getCode(), order.getCardId(), order.getChargingGunId());
|
}
|
|
@Override
|
public void compensationSettle(TCardChargingOrder 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("[SD补偿] 充电超时兜底结算 code={} 按平段计价 periodIndex={} capacity={}",
|
order.getCode(), flatPeriodIndex, capacity);
|
cardEndChargeBillingCharge(vo);
|
}
|
|
private int resolveCompensationFlatPeriodIndex(Long orderId) {
|
List<TCardAccountingStrategyDetailOrder> snapshots = Optional.ofNullable(cardAccountingStrategyDetailOrderService
|
.lambdaQuery().eq(TCardAccountingStrategyDetailOrder::getChargingOrderId, orderId).list())
|
.orElse(Collections.emptyList()).stream()
|
.filter(item -> item.getType() != null)
|
.sorted(Comparator.comparing(TCardAccountingStrategyDetailOrder::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("[SD补偿] 订单计费策略无平段，回退构造 flat_charge1 orderId={}", orderId);
|
return 1;
|
}
|
}
|
