autumn/jsowell-charger-web
1
0
Fork 0
mirror of https://codeup.aliyun.com/67c68d4e484ca2f0a13ac3c1/ydc/jsowell-charger-web.git synced 2026-04-21 19:45:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' into dev-zza

Browse Source
This commit is contained in:
Lemon
2025-03-27 08:40:10 +08:00
parent bcbb4514d3 399d119d92
commit f7aecd1c31
12 changed files with 785 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java
View File

@@ -550,4 +550,11 @@ public interface OrderBasicInfoService{
* @return
*/
List<UserFrequentedStationInfo> queryUserFrequentedStation(String memberId);
/**
* 通过订单编号列表查询订单信息
* @param orderCodeList
* @return
*/
List<AfterSettleOrderDTO> queryAfterSettleOrderDTOList(List<String> orderCodeList);
}

3
jsowell-pile/src/main/java/com/jsowell/pile/service/PileMsgRecordService.java
View File

@@ -4,6 +4,7 @@ import com.jsowell.common.core.page.PageResponse;
import com.jsowell.pile.domain.PileMsgRecord;
import com.jsowell.pile.dto.QueryPileDTO;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
@@ -29,4 +30,6 @@ public interface PileMsgRecordService {
String generateDescription(PileMsgRecord pileMsgRecord);
List<PileMsgRecord> getPileFeedListV2(String pileSn, String frameType, Date startTime, Date endTime);
List<PileMsgRecord> getPileFeedListV2(String pileSn, String frameType, LocalDateTime startTime, LocalDateTime endTime);
}

8
jsowell-pile/src/main/java/com/jsowell/pile/service/PileRemoteService.java
View File

@@ -285,6 +285,14 @@ public class PileRemoteService {
log.warn("获取计费模板信息, 通过模板id:{}查询计费模板为null", dto.getTemplateId());
return false;
}
// 会员优惠计费模板不发布
if (Constants.ONE.equals(billingTemplateVO.getMemberFlag())) {
return false;
}
// 电单车计费模板不发布
if (Constants.TWO.equals(billingTemplateVO.getDeviceType())) {
return false;
}
// 更新计费模板的发布时间
PileBillingTemplate pileBillingTemplate = new PileBillingTemplate();
pileBillingTemplate.setId(Long.valueOf(billingTemplateVO.getTemplateId()));

18
jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java
View File

@@ -7,8 +7,8 @@ import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.huifu.adapay.core.exception.BaseAdaPayException;
import com.jsowell.adapay.common.DivMember;
import com.jsowell.adapay.dto.PaymentConfirmParam;
import com.jsowell.adapay.common.PaymentConfirmInfo;
import com.jsowell.adapay.dto.PaymentConfirmParam;
import com.jsowell.adapay.dto.QueryConfirmReverseDTO;
import com.jsowell.adapay.dto.QueryPaymentConfirmDTO;
import com.jsowell.adapay.dto.SplitData;
@@ -17,7 +17,6 @@ import com.jsowell.adapay.response.*;
import com.jsowell.adapay.service.AdapayService;
import com.jsowell.adapay.vo.OrderSplitResult;
import com.jsowell.adapay.vo.PaymentInfo;
import com.jsowell.common.YouDianUtils;
import com.jsowell.common.constant.CacheConstants;
import com.jsowell.common.constant.Constants;
import com.jsowell.common.core.domain.vo.AuthorizedDeptVO;
@@ -30,7 +29,6 @@ import com.jsowell.common.enums.MemberWalletEnum;
import com.jsowell.common.enums.adapay.AdapayPayChannelEnum;
import com.jsowell.common.enums.adapay.AdapayStatusEnum;
import com.jsowell.common.enums.adapay.MerchantDelayModeEnum;
import com.jsowell.common.enums.ebike.EBikeStopReasonEnum;
import com.jsowell.common.enums.thirdparty.ThirdPartyOperatorIdEnum;
import com.jsowell.common.enums.thirdparty.ThirdPlatformTypeEnum;
import com.jsowell.common.enums.ykc.*;
@@ -41,7 +39,6 @@ import com.jsowell.common.util.id.IdUtils;
import com.jsowell.common.util.id.SnowflakeIdWorker;
import com.jsowell.common.util.spring.SpringUtils;
import com.jsowell.pile.domain.*;
import com.jsowell.pile.domain.ebike.deviceupload.EBikeMessageCmd03;
import com.jsowell.pile.dto.*;
import com.jsowell.pile.dto.nanrui.NRQueryOrderDTO;
import com.jsowell.pile.dto.ningxiajiaotou.NXJTQueryOrdersInfoDTO;
@@ -1914,10 +1911,12 @@ public class OrderBasicInfoServiceImpl implements OrderBasicInfoService {
return null;
}
// 如果是余额支付, 校验消费金额+ 退款金额 = 支付金额
// 如果是余额支付, 校验消费金额 - 折扣金额 + 退款金额 = 支付金额
if (StringUtils.equals(orderBasicInfo.getPayMode(), "1")) {
if (orderConsumeAmount.add(orderRefundAmount).compareTo(orderPayAmount) != 0) {
logger.info("realTimeOrderSplit-订单:{}, payMode:{}, 支付金额与消费金额+退款金额不相等", afterSettleOrderDTO.getOrderCode(), orderBasicInfo.getPayMode());
// 订单折扣金额 = 电费折扣金额 + 服务费折扣金额
BigDecimal orderDiscountAmount = afterSettleOrderDTO.getOrderElectricityDiscountAmount().add(afterSettleOrderDTO.getOrderServiceDiscountAmount());
if (orderConsumeAmount.subtract(orderDiscountAmount).add(orderRefundAmount).compareTo(orderPayAmount) != 0) {
logger.info("realTimeOrderSplit-订单:{}, payMode:{}, 支付金额与消费金额-折扣金额+退款金额不相等", afterSettleOrderDTO.getOrderCode(), orderBasicInfo.getPayMode());
return null;
}
}
@@ -4968,5 +4967,10 @@ public class OrderBasicInfoServiceImpl implements OrderBasicInfoService {
return orderBasicInfoMapper.queryUserFrequentedStation(memberId, startTime, endTime);
}
@Override
public List<AfterSettleOrderDTO> queryAfterSettleOrderDTOList(List<String> orderCodeList) {
return null;
}
}

7
jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileMsgRecordServiceImpl.java
View File

@@ -6,6 +6,7 @@ import com.github.pagehelper.PageInfo;
import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode;
import com.jsowell.common.core.page.PageResponse;
import com.jsowell.common.util.BytesUtil;
import com.jsowell.common.util.DateUtils;
import com.jsowell.common.util.StringUtils;
import com.jsowell.common.util.YKCUtils;
import com.jsowell.pile.domain.OrderBasicInfo;
@@ -18,6 +19,7 @@ import com.jsowell.pile.vo.web.PileCommunicationLogVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@@ -126,6 +128,11 @@ public class PileMsgRecordServiceImpl implements PileMsgRecordService {
return pileMsgRecordMapper.getPileFeedListV2(pileSn, frameType, createTime, updateTime);
}
@Override
public List<PileMsgRecord> getPileFeedListV2(String pileSn, String frameType, LocalDateTime startTime, LocalDateTime endTime) {
return this.getPileFeedListV2(pileSn, frameType, DateUtils.localDateTime2Date(startTime), DateUtils.localDateTime2Date(endTime));
}
/**
* 解析登录报文
* @param jsonMsg

461
jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/AbstractProgramLogic.java
View File

@@ -207,14 +207,14 @@ public abstract class AbstractProgramLogic implements InitializingBean {
* 专用方法，其他地方如果要用请仔细检查
* 【公共方法】
*/
protected void returnUpdateOrderBasicInfo(OrderBasicInfo orderBasicInfo, TransactionRecordsData data) {
public void returnUpdateOrderBasicInfo(OrderBasicInfo orderBasicInfo, TransactionRecordsData data) {
// 订单编号
String orderCode = orderBasicInfo.getOrderCode();
// 消费金额就是订单总金额/交易记录传过来的消费金额, 四舍五入保留两位小数
BigDecimal orderAmount = new BigDecimal(data.getConsumptionAmount()).setScale(2, RoundingMode.HALF_UP);
// 付款金额 - 实际消费金额，如果有剩余，需要走退款操作 当使用余额支付时payAmount = principalPay + giftPay
BigDecimal payAmount = orderBasicInfo.getPayAmount();
logger.info("结算订单:【{}】, 支付金额:{}, 消费金额:{}", orderCode, payAmount, orderAmount);
// logger.info("结算订单:【{}】, 支付金额:{}, 消费金额:{}", orderCode, payAmount, orderAmount);
// 有时候充电桩到达金额停止充电会多出一点金额，比如实际需要充50元的电，充电桩传来的消费金额为50.01元，在后台记录的时候需要舍去
if (orderAmount.compareTo(payAmount) > 0) {
@@ -229,6 +229,7 @@ public abstract class AbstractProgramLogic implements InitializingBean {
|| OrderPayModeEnum.PAYMENT_OF_PRINCIPAL_BALANCE.getValue().equals(orderBasicInfo.getPayMode())) {
// 白名单支付所消费的金额，都属于虚拟金额，不参与结算对账
virtualAmount = new BigDecimal(orderAmount.toString());
// logger.info("结算订单:【{}】, 虚拟金额为:{}, 白名单支付所消费的金额，都属于虚拟金额，不参与结算对账", orderCode, virtualAmount);
}
// 退款金额 = 支付金额 - 订单消费金额 剩余需要退回的金额 residue
@@ -236,6 +237,8 @@ public abstract class AbstractProgramLogic implements InitializingBean {
// 结算金额 = 消费金额 - 虚拟金额 - 优惠金额
BigDecimal settleAmount = orderAmount.subtract(virtualAmount);
logger.info("结算订单:【{}】, 支付金额:{}, 消费金额:{}, 虚拟金额:{}, 结算金额:{}, 退款金额:{}",
orderCode, payAmount, orderAmount, virtualAmount, settleAmount, residue);
// 把交易记录中的用电量，金额等信息 更新到orderBasicInfo和orderDetail
orderBasicInfo.setVirtualAmount(virtualAmount); // 虚拟金额
@@ -273,7 +276,8 @@ public abstract class AbstractProgramLogic implements InitializingBean {
*
* @return 查询并更新过数据的orderDetail
*/
protected OrderDetail returnUpdateOrderDetail(OrderBasicInfo orderBasicInfo, TransactionRecordsData data) {
public OrderDetail returnUpdateOrderDetail(OrderBasicInfo orderBasicInfo, TransactionRecordsData data) {
logger.info("start更新订单详情:【{}】, orderBasicInfo:{}, TransactionRecordsData:{}", orderBasicInfo.getOrderCode(), JSON.toJSONString(orderBasicInfo), JSON.toJSONString(data));
String orderCode = orderBasicInfo.getOrderCode();
BigDecimal orderAmount = orderBasicInfo.getOrderAmount();
// 更新订单详情 查询订单详情 修改订单数据
@@ -293,22 +297,32 @@ public abstract class AbstractProgramLogic implements InitializingBean {
: BigDecimal.ZERO;
orderDetail.setSharpUsedElectricity(sharpUsedElectricity);
if (sharpUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
if (data.getSharpPrice() != null) {
orderDetail.setSharpPrice(new BigDecimal(data.getSharpPrice()));
}
if (data.getSharpAmount() != null) {
orderDetail.setSharpAmount(new BigDecimal(data.getSharpAmount()));
}
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getSharpElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal sharpElectricityAmount = orderDetail.getSharpElectricityPrice()
.multiply(sharpUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(sharpElectricityAmount);
BigDecimal electricityAmount = electricityPrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getSharpServicePrice();
// 计算该时段服务费
BigDecimal sharpServiceAmount = orderDetail.getSharpServicePrice()
.multiply(sharpUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(sharpServiceAmount);
BigDecimal serviceAmount = servicePrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setSharpPrice(price);
orderDetail.setSharpAmount(amount);
logger.info("更新订单详情:【{}】, 当前为尖时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, sharpUsedElectricity, amount, electricityAmount, serviceAmount, data.getSharpPrice(), data.getSharpAmount());
}
// 峰时段用电量
@@ -317,22 +331,33 @@ public abstract class AbstractProgramLogic implements InitializingBean {
: BigDecimal.ZERO;
orderDetail.setPeakUsedElectricity(peakUsedElectricity);
if (peakUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
if (data.getPeakPrice() != null) {
orderDetail.setPeakPrice(new BigDecimal(data.getPeakPrice()));
}
if (data.getPeakAmount() != null) {
orderDetail.setPeakAmount(new BigDecimal(data.getPeakAmount()));
}
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getPeakElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal peakElectricityAmount = orderDetail.getPeakElectricityPrice()
.multiply(peakUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(peakElectricityAmount);
BigDecimal electricityAmount = electricityPrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getPeakServicePrice();
// 计算该时段服务费
BigDecimal peakServiceAmount = orderDetail.getPeakServicePrice()
.multiply(peakUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(peakServiceAmount);
BigDecimal serviceAmount = servicePrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setPeakPrice(price);
orderDetail.setPeakAmount(amount);
logger.info("更新订单详情:【{}】, 当前为峰时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, peakUsedElectricity, amount, electricityAmount, serviceAmount, data.getPeakPrice(), data.getPeakAmount());
}
// 平时段用电量
@@ -341,22 +366,33 @@ public abstract class AbstractProgramLogic implements InitializingBean {
: BigDecimal.ZERO;
orderDetail.setFlatUsedElectricity(flatUsedElectricity);
if (flatUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
if (data.getFlatPrice() != null) {
orderDetail.setFlatPrice(new BigDecimal(data.getFlatPrice()));
}
if (data.getFlatAmount() != null) {
orderDetail.setFlatAmount(new BigDecimal(data.getFlatAmount()));
}
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getFlatElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal flatElectricityAmount = orderDetail.getFlatElectricityPrice()
.multiply(flatUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(flatElectricityAmount);
BigDecimal electricityAmount = electricityPrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getFlatServicePrice();
// 计算该时段服务费
BigDecimal flatServiceAmount = orderDetail.getFlatServicePrice()
.multiply(flatUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(flatServiceAmount);
BigDecimal serviceAmount = servicePrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setFlatPrice(price);
orderDetail.setFlatAmount(amount);
logger.info("更新订单详情:【{}】, 当前为平时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, flatUsedElectricity, amount, electricityAmount, serviceAmount, data.getFlatPrice(), data.getFlatAmount());
}
// 谷时段用电量
@@ -365,27 +401,44 @@ public abstract class AbstractProgramLogic implements InitializingBean {
: BigDecimal.ZERO;
orderDetail.setValleyUsedElectricity(valleyUsedElectricity);
if (valleyUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
if (data.getValleyPrice() != null) {
orderDetail.setValleyPrice(new BigDecimal(data.getValleyPrice()));
}
if (data.getValleyAmount() != null) {
orderDetail.setValleyAmount(new BigDecimal(data.getValleyAmount()));
}
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getValleyElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal valleyElectricityAmount = orderDetail.getValleyElectricityPrice()
.multiply(valleyUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(valleyElectricityAmount);
BigDecimal electricityAmount = electricityPrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getValleyServicePrice();
// 计算该时段服务费
BigDecimal valleyServiceAmount = orderDetail.getValleyServicePrice()
.multiply(valleyUsedElectricity)
.setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(valleyServiceAmount);
BigDecimal serviceAmount = servicePrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setValleyPrice(price);
orderDetail.setValleyAmount(amount);
logger.info("更新订单详情:【{}】, 当前为谷时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, valleyUsedElectricity, amount, electricityAmount, serviceAmount, data.getValleyPrice(), data.getValleyAmount());
}
// 平台计算的总消费金额 平台计算总电费金额 + 平台计算总服务费金额
BigDecimal computeTotalAmount = totalElectricityAmount.add(totalServiceAmount);
// 如果算出来的 电费金额 + 服务费金额 != 总消费金额，则电费金额等于总消费金额 - 服务费金额
if (totalElectricityAmount.add(totalServiceAmount).compareTo(orderAmount) != 0) {
totalElectricityAmount = orderAmount.subtract(totalServiceAmount);
if (computeTotalAmount.compareTo(orderAmount) != 0) {
// 2025年3月26日15点50分, 订单金额以平台计算为主，所以注释掉, 并打印日志说明
// totalElectricityAmount = orderAmount.subtract(totalServiceAmount);
logger.info("平台计算出电费金额:{}, 服务费金额:{}, 汇总:{}, 交易记录传来的金额:{}", totalElectricityAmount, totalServiceAmount, computeTotalAmount, orderAmount);
orderAmount = computeTotalAmount;
}
// 电费总金额
@@ -393,24 +446,218 @@ public abstract class AbstractProgramLogic implements InitializingBean {
// 服务费总金额
orderDetail.setTotalServiceAmount(totalServiceAmount);
// 尖峰平谷用电量汇总
BigDecimal sumUsedElectricity = sharpUsedElectricity.add(peakUsedElectricity)
.add(flatUsedElectricity).add(valleyUsedElectricity);
BigDecimal sumUsedElectricity = sharpUsedElectricity.add(peakUsedElectricity).add(flatUsedElectricity).add(valleyUsedElectricity);
// data中的总用电量
BigDecimal totalElectricity = new BigDecimal(StringUtils.isBlank(data.getTotalElectricity()) ? Constants.ZERO : data.getTotalElectricity());
// if (sumUsedElectricity.compareTo(totalElectricity) != 0) {
// // 汇总数据和data中数据不相等，取汇总的数据
// totalElectricity = sumUsedElectricity;
// }
// totalElectricity = sumUsedElectricity与totalElectricity, 取最大的值
// sumUsedElectricity与totalElectricity对比, 取最大的值
orderDetail.setTotalUsedElectricity(totalElectricity.max(sumUsedElectricity));
// 订单总金额
orderDetail.setTotalOrderAmount(orderAmount);
// 更新订单主表中的总消费金额和退款金额
orderBasicInfo.setOrderAmount(orderAmount);
orderBasicInfo.setRefundAmount(orderBasicInfo.getPayAmount().subtract(orderAmount));
logger.info("end更新订单详情:【{}】, 电费总金额:{}, 服务费总金额:{}, 总用电量:{}, 订单总金额:{}", orderCode, totalElectricityAmount, totalServiceAmount, orderDetail.getTotalUsedElectricity(), orderAmount);
} catch (Exception e) {
logger.error("orderCode:{}, 设置订单详情参数发生异常", orderCode, e);
}
return orderDetail;
}
/**
* 更新订单主表和订单详情中的各种金额
* 只交易记录中的耗电量, 其他金额都以平台计算为主
* @param data 交易记录数据
* @param orderBasicInfo 订单基础信息
* @param orderDetail 订单详情
*/
public void updateOrderBasicInfoAndOrderDetail(TransactionRecordsData data, OrderBasicInfo orderBasicInfo, OrderDetail orderDetail) {
// 订单编号
String orderCode = orderBasicInfo.getOrderCode();
// 订单支付金额
BigDecimal payAmount = orderBasicInfo.getPayAmount();
// data中的消费金额 精确到小数点后四位，包含电费、 服务费
BigDecimal dataOrderAmount = new BigDecimal(data.getConsumptionAmount()).setScale(2, RoundingMode.HALF_UP);
// data中的总用电量
BigDecimal totalElectricity = new BigDecimal(StringUtils.isBlank(data.getTotalElectricity()) ? Constants.ZERO : data.getTotalElectricity());
// 总电费金额
BigDecimal totalElectricityAmount = BigDecimal.ZERO;
// 总服务费金额
BigDecimal totalServiceAmount = BigDecimal.ZERO;
// 尖时段用电量
BigDecimal sharpUsedElectricity = StringUtils.isNotBlank(data.getSharpUsedElectricity()) ? new BigDecimal(data.getSharpUsedElectricity()) : BigDecimal.ZERO;
if (sharpUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getSharpElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal electricityAmount = electricityPrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getSharpServicePrice();
// 计算该时段服务费 = 服务费单价 x 用电量
BigDecimal serviceAmount = servicePrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setSharpPrice(price);
orderDetail.setSharpAmount(amount);
logger.info("updateOrderBasicInfoAndOrderDetail:【{}】, 当前为尖时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, sharpUsedElectricity, amount, electricityAmount, serviceAmount, data.getSharpPrice(), data.getSharpAmount());
}
// 峰时段用电量
BigDecimal peakUsedElectricity = StringUtils.isNotBlank(data.getPeakUsedElectricity()) ? new BigDecimal(data.getPeakUsedElectricity()) : BigDecimal.ZERO;
if (peakUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getPeakElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal electricityAmount = electricityPrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getPeakServicePrice();
// 计算该时段服务费 = 服务费单价 x 用电量
BigDecimal serviceAmount = servicePrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setPeakPrice(price);
orderDetail.setPeakAmount(amount);
logger.info("updateOrderBasicInfoAndOrderDetail:【{}】, 当前为峰时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, peakUsedElectricity, amount, electricityAmount, serviceAmount, data.getPeakPrice(), data.getPeakAmount());
}
// 平时段用电量
BigDecimal flatUsedElectricity = StringUtils.isNotBlank(data.getFlatUsedElectricity()) ? new BigDecimal(data.getFlatUsedElectricity()) : BigDecimal.ZERO;
if (flatUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getFlatElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal electricityAmount = electricityPrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getFlatServicePrice();
// 计算该时段服务费 = 服务费单价 x 用电量
BigDecimal serviceAmount = servicePrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setFlatPrice(price);
orderDetail.setFlatAmount(amount);
logger.info("updateOrderBasicInfoAndOrderDetail:【{}】, 当前为平时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, flatUsedElectricity, amount, electricityAmount, serviceAmount, data.getFlatPrice(), data.getFlatAmount());
}
// 谷时段用电量
BigDecimal valleyUsedElectricity = StringUtils.isNotBlank(data.getValleyUsedElectricity()) ? new BigDecimal(data.getValleyUsedElectricity()) : BigDecimal.ZERO;
if (valleyUsedElectricity.compareTo(BigDecimal.ZERO) > 0) {
// 该时段电费单价
BigDecimal electricityPrice = orderDetail.getValleyElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal electricityAmount = electricityPrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
// 该时段服务费单价
BigDecimal servicePrice = orderDetail.getValleyServicePrice();
// 计算该时段服务费 = 服务费单价 x 用电量
BigDecimal serviceAmount = servicePrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
totalServiceAmount = totalServiceAmount.add(serviceAmount);
// 该时段单价 = 电费单价 + 服务费单价
BigDecimal price = electricityPrice.add(servicePrice);
// 该时段金额 = 该时段电费 + 该时段服务费
BigDecimal amount = electricityAmount.add(serviceAmount);
orderDetail.setValleyPrice(price);
orderDetail.setValleyAmount(amount);
logger.info("updateOrderBasicInfoAndOrderDetail:【{}】, 当前为谷时段, 时段单价:{}(电费单价:{}+服务费单价:{}), 耗电量:{}, 平台计算该时段消费金额:{}(电费:{}+服务费:{}), 桩传的单价:{}, 桩传的金额:{}",
orderCode, price, electricityPrice, servicePrice, valleyUsedElectricity, amount, electricityAmount, serviceAmount, data.getValleyPrice(), data.getValleyAmount());
}
// 尖峰平谷用电量汇总
BigDecimal sumUsedElectricity = sharpUsedElectricity.add(peakUsedElectricity).add(flatUsedElectricity).add(valleyUsedElectricity);
// 平台计算的总消费金额 平台计算总电费金额 + 平台计算总服务费金额
BigDecimal computeTotalAmount = totalElectricityAmount.add(totalServiceAmount);
// 如果算出来的 电费金额 + 服务费金额 != 总消费金额，则电费金额等于总消费金额 - 服务费金额
if (computeTotalAmount.compareTo(dataOrderAmount) != 0) {
// 2025年3月26日15点50分, 订单金额以平台计算为主，所以注释掉, 并打印日志说明
// totalElectricityAmount = dataOrderAmount.subtract(totalServiceAmount);
logger.info("updateOrderBasicInfoAndOrderDetail平台计算出电费金额:{}, 服务费金额:{}, 汇总:{}, 交易记录传来的金额:{}", totalElectricityAmount, totalServiceAmount, computeTotalAmount, dataOrderAmount);
dataOrderAmount = computeTotalAmount;
}
// 虚拟金额 指订单消费中不参与结算的部分
BigDecimal virtualAmount = BigDecimal.ZERO;
if (OrderPayModeEnum.PAYMENT_OF_WHITELIST.getValue().equals(orderBasicInfo.getPayMode())
|| OrderPayModeEnum.PAYMENT_OF_PRINCIPAL_BALANCE.getValue().equals(orderBasicInfo.getPayMode())) {
// 白名单支付所消费的金额，都属于虚拟金额，不参与结算对账
virtualAmount = new BigDecimal(dataOrderAmount.toString());
logger.info("updateOrderBasicInfoAndOrderDetail结算订单:【{}】, 虚拟金额为:{}, 白名单支付所消费的金额，都属于虚拟金额，不参与结算对账", orderCode, virtualAmount);
}
// 有时候充电桩到达金额停止充电会多出一点金额，比如实际需要充50元的电，充电桩传来的消费金额为50.01元，在后台记录的时候需要舍去
if (dataOrderAmount.compareTo(payAmount) > 0) {
logger.info("updateOrderBasicInfoAndOrderDetail结算订单:【{}】充电桩传来的消费金额:【{}】大于付款金额:【{}】, 消费金额设置为付款金额相等数据", orderCode, dataOrderAmount, payAmount);
dataOrderAmount = payAmount;
}
// 退款金额 = 支付金额 - 订单消费金额 剩余需要退回的金额 residue
BigDecimal refundAmount = payAmount.subtract(dataOrderAmount);
/*
orderBasicInfo需要更新的字段
*/
orderBasicInfo.setOrderStatus(OrderStatusEnum.ORDER_COMPLETE.getValue());
orderBasicInfo.setOrderAmount(dataOrderAmount); // 订单消费金额
orderBasicInfo.setRefundAmount(refundAmount); // 订单退款金额
orderBasicInfo.setVirtualAmount(virtualAmount); // 虚拟金额
orderBasicInfo.setSettleAmount(dataOrderAmount.subtract(virtualAmount)); // 结算金额 = 消费金额 - 虚拟金额
orderBasicInfo.setReason(data.getStopReasonMsg()); // 充电停止原因
if (Objects.isNull(orderBasicInfo.getSettlementTime())) {
// 如果结算时间为空，设置当前时间为结算时间
orderBasicInfo.setSettlementTime(DateUtils.getNowDate()); // 结算时间
}
updateSOC(orderBasicInfo);
/*
orderDetail需要更新的字段
*/
orderDetail.setSharpUsedElectricity(sharpUsedElectricity); // 尖时段用电量
orderDetail.setPeakUsedElectricity(peakUsedElectricity); // 峰时段用电量
orderDetail.setFlatUsedElectricity(flatUsedElectricity); // 平时段用电量
orderDetail.setValleyUsedElectricity(valleyUsedElectricity); // 谷时段用电量
orderDetail.setTotalElectricityAmount(totalElectricityAmount); // 电费总金额
orderDetail.setTotalServiceAmount(totalServiceAmount); // 服务费总金额
// sumUsedElectricity与totalElectricity对比, 取最大的值
orderDetail.setTotalUsedElectricity(totalElectricity.max(sumUsedElectricity));
orderDetail.setTotalOrderAmount(dataOrderAmount); // 订单总金额
logger.info("end updateOrderBasicInfoAndOrderDetail:【{}】, 电费总金额:{}, 服务费总金额:{}, 总用电量:{}, 订单总金额:{}", orderCode, totalElectricityAmount, totalServiceAmount, orderDetail.getTotalUsedElectricity(), dataOrderAmount);
}
private void updateSOC(OrderBasicInfo orderBasicInfo) {
if (StringUtils.isBlank(orderBasicInfo.getStartSoc()) || StringUtils.isBlank(orderBasicInfo.getEndSoc())) {
try {
Map<String, String> socMap = YKCUtils.getSOCMap(orderBasicInfo.getTransactionCode());
if (Objects.nonNull(socMap)) {
if (StringUtils.isBlank(orderBasicInfo.getStartSoc())) {
orderBasicInfo.setStartSoc(socMap.get("startSoc"));
}
if (StringUtils.isBlank(orderBasicInfo.getEndSoc())) {
orderBasicInfo.setEndSoc(socMap.get("endSoc"));
}
}
} catch (Exception e) {
logger.error("获取订单充电开始结束SOC失败:{}", e.getMessage());
}
}
}
/**
* 获取更新数据后的orderDetail对象(给第三方平台结算订单用)
@@ -653,14 +900,14 @@ public abstract class AbstractProgramLogic implements InitializingBean {
* @param orderBasicInfo 订单主表
* @param orderDetail 订单详情
*/
protected void calculateOrderDiscountsV2(OrderBasicInfo orderBasicInfo, OrderDetail orderDetail) {
public void calculateOrderDiscountsV2(OrderBasicInfo orderBasicInfo, OrderDetail orderDetail) {
String memberId = orderBasicInfo.getMemberId(); // 会员id
String stationId = orderBasicInfo.getStationId(); // 站点id
String merchantId = orderBasicInfo.getMerchantId(); // 运营商id
String orderCode = orderBasicInfo.getOrderCode(); // 订单号
if (orderDetail == null) {
logger.info("计算订单折扣V2, OrderDetail为空(orderCode:{}, transactionCode:{}), 直接返回!",
orderBasicInfo.getOrderCode(), orderBasicInfo.getTransactionCode());
logger.info("计算订单折扣V2, OrderDetail为空(orderCode:{}, transactionCode:{}), 直接返回!", orderCode, orderBasicInfo.getTransactionCode());
return;
}
@@ -681,8 +928,8 @@ public abstract class AbstractProgramLogic implements InitializingBean {
MemberDiscountVO memberDiscountVO = memberGroupService.queryMemberDiscountV2(merchantId, stationId, memberId);
if (memberDiscountVO == null) {
// 如果没有优惠，则优惠后金额 等于优惠前金额
afterDiscountServiceAmount = orderDetail.getTotalServiceAmount();
afterDiscountElectricityAmount = orderDetail.getTotalElectricityAmount();
afterDiscountServiceAmount = orderDetail.getTotalServiceAmount();
} else {
// 集团会员的订单，记录集团编号
orderBasicInfo.setGroupCode(memberDiscountVO.getGroupCode());
@@ -693,69 +940,70 @@ public abstract class AbstractProgramLogic implements InitializingBean {
// 尖时段用电量
BigDecimal sharpUsedElectricity = orderDetail.getSharpUsedElectricity();
if (sharpUsedElectricity != null) {
// 计算该时段电费单价
BigDecimal electricityPrice = billingTemplateVO.getSharpElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal sharpElectricityAmount = billingTemplateVO.getSharpElectricityPrice()
.multiply(sharpUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal electricityAmount = electricityPrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
// 计算该时段服务费单价
BigDecimal servicePrice = billingTemplateVO.getSharpServicePrice();
// 计算该时段服务费
BigDecimal sharpServiceAmount = billingTemplateVO.getSharpServicePrice()
.multiply(sharpUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal serviceAmount = servicePrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(sharpElectricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(sharpServiceAmount);
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
// logger.info("计算订单折扣V2:【{}】, 当前为尖时段, 电费单价:{}, 服务费单价:{}, 耗电量:{}, 平台计算该时段消费金额:{}, 桩传的单价:{}, 桩传的金额:{}");
}
// 峰时段用电量
BigDecimal peakUsedElectricity = orderDetail.getPeakUsedElectricity();
if (peakUsedElectricity != null) {
// 计算该时段电费单价
BigDecimal electricityPrice = billingTemplateVO.getPeakElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal peakElectricityAmount = billingTemplateVO.getPeakElectricityPrice()
.multiply(peakUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal electricityAmount = electricityPrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
// 计算该时段服务费
BigDecimal peakServiceAmount = billingTemplateVO.getPeakServicePrice()
.multiply(peakUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal servicePrice = billingTemplateVO.getPeakServicePrice();
// 计算该时段服务费 = 服务费单价 x 用电量
BigDecimal serviceAmount = servicePrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(peakElectricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(peakServiceAmount);
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
}
// 平时段用电量
BigDecimal flatUsedElectricity = orderDetail.getFlatUsedElectricity();
if (flatUsedElectricity != null) {
// 计算该时段电费单价
BigDecimal electricityPrice = billingTemplateVO.getFlatElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal flatElectricityAmount = billingTemplateVO.getFlatElectricityPrice()
.multiply(flatUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal electricityAmount = electricityPrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
// 计算该时段服务费单价
BigDecimal servicePrice = billingTemplateVO.getFlatServicePrice();
// 计算该时段服务费
BigDecimal flatServiceAmount = billingTemplateVO.getFlatServicePrice()
.multiply(flatUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal serviceAmount = servicePrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(flatElectricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(flatServiceAmount);
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
}
// 谷时段用电量
BigDecimal valleyUsedElectricity = orderDetail.getValleyUsedElectricity();
if (valleyUsedElectricity != null) {
// 计算该时段电费单价
BigDecimal electricityPrice = billingTemplateVO.getValleyElectricityPrice();
// 计算该时段电费 = 电费单价 x 用电量
BigDecimal valleyElectricityAmount = billingTemplateVO.getValleyElectricityPrice()
.multiply(valleyUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal electricityAmount = electricityPrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
// 计算该时段服务费单价
BigDecimal servicePrice = billingTemplateVO.getValleyServicePrice();
// 计算该时段服务费
BigDecimal valleyServiceAmount = billingTemplateVO.getValleyServicePrice()
.multiply(valleyUsedElectricity)
.setScale(2, RoundingMode.DOWN);
BigDecimal serviceAmount = servicePrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
// 汇总
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(valleyElectricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(valleyServiceAmount);
afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
}
// 计算优惠了多少钱
@@ -763,6 +1011,9 @@ public abstract class AbstractProgramLogic implements InitializingBean {
electricityAmountDiscount = originalTotalElectricityAmount.subtract(afterDiscountElectricityAmount);
// 服务费折扣金额 = 优惠前服务费 - 优惠后服务费
serviceAmountDiscount = originalTotalServiceAmount.subtract(afterDiscountServiceAmount);
logger.info("计算订单折扣, orderCode:{}, 原始电费金额:{}, 折扣后电费金额:{}, 电费折扣金额:{}, 原始服务费金额:{}, 折扣后服务费金额:{}, 服务费折扣金额:{}",
orderCode, originalTotalElectricityAmount, afterDiscountElectricityAmount, electricityAmountDiscount, originalTotalServiceAmount, afterDiscountServiceAmount, serviceAmountDiscount);
}
/*
@@ -791,7 +1042,7 @@ public abstract class AbstractProgramLogic implements InitializingBean {
// 服务费折扣金额(服务费便宜了多少钱)
orderDetail.setDiscountServiceAmount(serviceAmountDiscount);
logger.info("计算订单折扣, orderCode:{}, memberId:{}, 订单折扣金额:{}, 电费折扣金额:{}, 服务费折扣金额:{}, 优惠后总消费金额:{}",
orderBasicInfo.getOrderCode(), memberId, discountAmount, electricityAmountDiscount, serviceAmountDiscount, totalConsumeAmount);
orderCode, memberId, discountAmount, electricityAmountDiscount, serviceAmountDiscount, totalConsumeAmount);
}
/**

88
jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/DelayMerchantProgramLogic.java
View File

@@ -454,8 +454,7 @@ public class DelayMerchantProgramLogic extends AbstractProgramLogic {
/**
* 订单结算/结算订单逻辑/订单结算逻辑
*/
@Override
public void settleOrder(TransactionRecordsData data, OrderBasicInfo orderBasicInfo) {
public void settleOrderOld(TransactionRecordsData data, OrderBasicInfo orderBasicInfo) {
logger.info("【{}】-结算订单start data:{}, orderBasicInfo:{}", this.getClass().getSimpleName(), data.toString(), JSON.toJSONString(orderBasicInfo));
// 判断订单状态
if (StringUtils.equals(orderBasicInfo.getOrderStatus(), OrderStatusEnum.ORDER_COMPLETE.getValue())) {
@@ -493,14 +492,14 @@ public class DelayMerchantProgramLogic extends AbstractProgramLogic {
.orderCode(orderBasicInfo.getOrderCode())
.merchantId(orderBasicInfo.getMerchantId())
.stationId(orderBasicInfo.getStationId())
.orderPayAmount(orderBasicInfo.getPayAmount())
.orderConsumeAmount(orderBasicInfo.getOrderAmount())
.orderSettleAmount(orderBasicInfo.getSettleAmount())
.orderElectricityAmount(orderDetail.getTotalElectricityAmount())
.orderElectricityDiscountAmount(orderDetail.getDiscountElectricityAmount())
.orderServiceAmount(orderDetail.getTotalServiceAmount())
.orderServiceDiscountAmount(orderDetail.getDiscountServiceAmount())
.orderRefundAmount(orderBasicInfo.getRefundAmount())
.orderPayAmount(orderBasicInfo.getPayAmount()) // 支付金额
.orderConsumeAmount(orderBasicInfo.getOrderAmount()) // 消费金额
.orderSettleAmount(orderBasicInfo.getSettleAmount()) // 结算金额
.orderElectricityAmount(orderDetail.getTotalElectricityAmount()) // 电费金额
.orderElectricityDiscountAmount(orderDetail.getDiscountElectricityAmount()) // 电费折扣金额
.orderServiceAmount(orderDetail.getTotalServiceAmount()) // 服务费金额
.orderServiceDiscountAmount(orderDetail.getDiscountServiceAmount()) // 服务费折扣金额
.orderRefundAmount(orderBasicInfo.getRefundAmount()) // 退款金额
.build();
rabbitTemplate.convertAndSend(RabbitConstants.YKC_EXCHANGE_NAME, RabbitConstants.QUEUE_CHARGE_ORDER_DATA, afterSettleOrderDTO);
@@ -524,6 +523,75 @@ public class DelayMerchantProgramLogic extends AbstractProgramLogic {
orderBasicInfo.getOrderCode(), orderBasicInfo.getTransactionCode(), JSON.toJSONString(dto));
}
/**
* 订单结算/结算订单逻辑/订单结算逻辑
*/
@Override
public void settleOrder(TransactionRecordsData data, OrderBasicInfo orderBasicInfo) {
logger.info("【{}】-结算订单V2start data:{}, orderBasicInfo:{}", this.getClass().getSimpleName(), data.toString(), JSON.toJSONString(orderBasicInfo));
// 判断订单状态
if (StringUtils.equals(orderBasicInfo.getOrderStatus(), OrderStatusEnum.ORDER_COMPLETE.getValue())) {
logger.info("结算订单V2:{}, 是订单完成状态", orderBasicInfo.getOrderCode());
return;
}
// 获取更新数据后的orderBasicInfo对象
// returnUpdateOrderBasicInfo(orderBasicInfo, data);
// 获取更新数据后的orderDetail对象/更新订单详情 查询订单详情 修改订单数据
// OrderDetail orderDetail = returnUpdateOrderDetail(orderBasicInfo, data);
// 查询订单详情
OrderDetail orderDetail = orderBasicInfoService.getOrderDetailByOrderCode(orderBasicInfo.getOrderCode());
// 计算订单各种金额
updateOrderBasicInfoAndOrderDetail(data, orderBasicInfo, orderDetail);
// 计算订单折扣
calculateOrderDiscountsV2(orderBasicInfo, orderDetail);
// 更新数据库
OrderTransactionDTO dto = new OrderTransactionDTO();
dto.setOrderBasicInfo(orderBasicInfo);
dto.setOrderDetail(orderDetail);
transactionService.doUpdateOrder(dto);
// 组装after参数
AfterSettleOrderDTO afterSettleOrderDTO = AfterSettleOrderDTO.builder()
.orderCode(orderBasicInfo.getOrderCode())
.merchantId(orderBasicInfo.getMerchantId())
.stationId(orderBasicInfo.getStationId())
.orderPayAmount(orderBasicInfo.getPayAmount()) // 支付金额
.orderConsumeAmount(orderBasicInfo.getOrderAmount()) // 消费金额
.orderSettleAmount(orderBasicInfo.getSettleAmount()) // 结算金额
.orderElectricityAmount(orderDetail.getTotalElectricityAmount()) // 电费金额
.orderElectricityDiscountAmount(orderDetail.getDiscountElectricityAmount()) // 电费折扣金额
.orderServiceAmount(orderDetail.getTotalServiceAmount()) // 服务费金额
.orderServiceDiscountAmount(orderDetail.getDiscountServiceAmount()) // 服务费折扣金额
.orderRefundAmount(orderBasicInfo.getRefundAmount()) // 退款金额
.build();
rabbitTemplate.convertAndSend(RabbitConstants.YKC_EXCHANGE_NAME, RabbitConstants.QUEUE_CHARGE_ORDER_DATA, afterSettleOrderDTO);
// 将卡/vin状态解锁
if (!StringUtils.equals("0000000000000000", data.getLogicCard())) {
cardStatusUnlocked(orderBasicInfo.getLogicCard());
}
// 如果是vin启动，将启动锁定状态改为正常
if (StringUtils.equals(data.getTransactionIdentifier(), "05")) {
vinStatusUnlocked(data.getVinCode());
}
// 发送停止充电订阅消息
sendMsg(orderBasicInfo);
// 从redis中取出实时记录保存到表中
realTimeMonitorDataRedis2DB(orderBasicInfo.getTransactionCode(), orderBasicInfo.getOrderCode());
logger.info("结算订单V2end! orderCode:{}, transactionCode:{}, OrderTransactionDTO:{}",
orderBasicInfo.getOrderCode(), orderBasicInfo.getTransactionCode(), JSON.toJSONString(dto));
}
@Override
public void settleOrderForEBike(EBikeMessageCmd03 message, OrderBasicInfo orderBasicInfo) {
// 判断订单状态

1
jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/NotDelayMerchantProgramLogic.java
View File

@@ -421,6 +421,7 @@ public class NotDelayMerchantProgramLogic extends AbstractProgramLogic {
logger.info("结算订单end:{} OrderTransactionDTO:{}", orderBasicInfo.getOrderCode(), JSON.toJSONString(dto));
}
@Override
public void settleOrderForEBike(EBikeMessageCmd03 message, OrderBasicInfo orderBasicInfo) {