Merge branch 'dev' into dev-zza

jsowell-admin/src/main/java/com/jsowell/api/uniapp/customer/TempController.java

@@ -4,22 +4,15 @@ import com.alibaba.fastjson2.JSON;
 import com.google.common.collect.ImmutableMap;
 import com.jsowell.adapay.dto.BalancePaymentRequestDTO;
 import com.jsowell.adapay.service.AdapayService;
-import com.jsowell.common.YouDianUtils;
 import com.jsowell.common.annotation.Anonymous;
 import com.jsowell.common.core.controller.BaseController;
 import com.jsowell.common.core.domain.AjaxResult;
 import com.jsowell.common.core.domain.ykc.TransactionRecordsData;
-import com.jsowell.common.enums.ebike.EBikeStopReasonEnum;
 import com.jsowell.common.enums.ykc.ReturnCodeEnum;
 import com.jsowell.common.exception.BusinessException;
 import com.jsowell.common.response.RestApiResponse;
 import com.jsowell.common.util.DateUtils;
-import com.jsowell.common.util.SecurityUtils;
+import com.jsowell.pile.domain.*;
-import com.jsowell.pile.domain.AdapayMemberAccount;
-import com.jsowell.pile.domain.MemberPlateNumberRelation;
-import com.jsowell.pile.domain.OrderBasicInfo;
-import com.jsowell.pile.domain.PileMerchantInfo;
-import com.jsowell.pile.domain.ebike.deviceupload.EBikeMessageCmd03;
 import com.jsowell.pile.domain.ykcCommond.EBikeStartChargingCommand;
 import com.jsowell.pile.domain.ykcCommond.ReservationChargingCommand;
 import com.jsowell.pile.domain.ykcCommond.StopChargingCommand;
@@ -733,6 +726,64 @@ public class TempController extends BaseController {
         return response;
     }
 
+    /**
+     * 查询订单折扣接口
+     * http://localhost:8080/temp/queryOrderDiscount
+     */
+    @PostMapping("/queryOrderDiscount")
+    public RestApiResponse<?> queryOrderDiscount(@RequestBody QueryOrderDTO dto) {
+        RestApiResponse<?> response;
+        try {
+            OrderBasicInfo orderBasicInfo = orderBasicInfoService.getOrderInfoByOrderCode(dto.getOrderCode());
+            OrderDetail orderDetail = orderBasicInfoService.getOrderDetailByOrderCode(orderBasicInfo.getOrderCode());
+            // 计算订单折扣
+            tempService.calculateOrderDiscountsV2(orderBasicInfo, orderDetail);
+            response = new RestApiResponse<>();
+        } catch (Exception e) {
+            logger.error("查询订单折扣接口 error,", e);
+            response = new RestApiResponse<>();
+        }
+        return response;
+    }
+
+    /**
+     * 调试结算订单逻辑
+     * http://localhost:8080/temp/testSettleOrderLogic
+     */
+    @PostMapping("/testSettleOrderLogic")
+    public RestApiResponse<?> testSettleOrderLogic(@RequestBody TransactionRecordsData data) {
+        RestApiResponse<?> response;
+        try {
+            String transactionCode = data.getTransactionCode();
+            OrderBasicInfo orderBasicInfo = orderBasicInfoService.getOrderInfoByTransactionCode(transactionCode);
+            // 调试结算订单逻辑
+            tempService.testSettleOrderLogic(data, orderBasicInfo);
+            response = new RestApiResponse<>();
+        } catch (Exception e) {
+            logger.error("调试结算订单逻辑error,", e);
+            response = new RestApiResponse<>();
+        }
+        return response;
+    }
+
+    /**
+     * 调试结算订单逻辑
+     * http://localhost:8080/temp/testSettleOrderLogic
+     */
+    @PostMapping("/testSettleOrderLogicV2")
+    public RestApiResponse<?> testSettleOrderLogicV2(@RequestBody QueryOrderDTO dto) {
+        RestApiResponse<?> response;
+        try {
+            // 调试结算订单逻辑
+            tempService.testSettleOrderLogicV2(dto.getOrderCode());
+            response = new RestApiResponse<>();
+        } catch (Exception e) {
+            logger.error("调试结算订单逻辑V2error,", e);
+            response = new RestApiResponse<>();
+        }
+        return response;
+    }
+
 
     /**
      * 重试订单退款接口/重试退款按钮 (批量)

jsowell-admin/src/main/java/com/jsowell/service/TempService.java

@@ -16,6 +16,8 @@ import com.jsowell.adapay.service.AdapayService;
 import com.jsowell.adapay.vo.OrderSplitResult;
 import com.jsowell.adapay.vo.PaymentInfo;
 import com.jsowell.common.annotation.CostTime;
+import com.jsowell.common.constant.RabbitConstants;
+import com.jsowell.common.core.domain.ykc.TransactionRecordsData;
 import com.jsowell.common.core.redis.RedisCache;
 import com.jsowell.common.enums.adapay.AdapayStatusEnum;
 import com.jsowell.common.enums.ykc.*;
@@ -23,23 +25,28 @@ import com.jsowell.common.exception.BusinessException;
 import com.jsowell.common.util.DateUtils;
 import com.jsowell.common.util.StringUtils;
 import com.jsowell.pile.domain.*;
+import com.jsowell.pile.dto.AfterSettleOrderDTO;
 import com.jsowell.pile.dto.ApplyRefundDTO;
 import com.jsowell.pile.dto.QueryOrderDTO;
 import com.jsowell.pile.dto.SettleOrderReportDTO;
 import com.jsowell.pile.mapper.OrderBasicInfoMapper;
-import com.jsowell.pile.mapper.PileMsgRecordMapper;
 import com.jsowell.pile.service.*;
-import com.jsowell.pile.vo.web.ClearingBillVO;
+import com.jsowell.pile.service.programlogic.AbstractProgramLogic;
-import com.jsowell.pile.vo.web.OrderListVO;
+import com.jsowell.pile.service.programlogic.ProgramLogicFactory;
-import com.jsowell.pile.vo.web.OrderPaymentDetailVO;
+import com.jsowell.pile.transaction.dto.OrderTransactionDTO;
+import com.jsowell.pile.transaction.service.TransactionService;
+import com.jsowell.pile.vo.web.*;
 import org.apache.commons.collections4.CollectionUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -67,6 +74,15 @@ public class TempService {
     @Autowired
     private AdapayCallbackRecordService adapayCallbackRecordService;
 
+    @Autowired
+    protected TransactionService transactionService;
+
+    @Autowired
+    protected RabbitTemplate rabbitTemplate;
+
+    @Autowired
+    protected MemberGroupService memberGroupService;
+
     @Autowired
     private WxpayRefundCallbackService wxpayRefundCallbackService;
 
@@ -86,7 +102,7 @@ public class TempService {
     private MemberAdapayRecordService memberAdapayRecordService;
 
     @Autowired
-    private PileMsgRecordMapper pileMsgRecordMapper;
+    private PileMsgRecordService pileMsgRecordService;
 
     @Autowired
     private OrderDetailService orderDetailService;
@@ -110,7 +126,7 @@ public class TempService {
         // 根据充电桩编号，查询报文
         for (OrderListVO orderVO : orderListVOS) {
             String pileSn = orderVO.getPileSn();
-            List<PileMsgRecord> pileFeedList = pileMsgRecordMapper.getPileFeedList(pileSn);
+            // List<PileMsgRecord> pileFeedList = pileMsgRecordMapper.getPileFeedList(pileSn);
         }
 
         //
@@ -724,5 +740,225 @@ public class TempService {
         // 关闭未支付订单
         orderBasicInfoService.closeUnpaidOrders(unpaidOrderList);
     }
+
+    public void calculateOrderDiscountsV2(OrderBasicInfo orderBasicInfo, OrderDetail orderDetail) {
+        String orderCode = orderBasicInfo.getOrderCode();
+        String transactionCode = orderBasicInfo.getTransactionCode();
+        String memberId = orderBasicInfo.getMemberId(); // 会员id
+        String stationId = orderBasicInfo.getStationId(); // 站点id
+        String merchantId = orderBasicInfo.getMerchantId(); // 运营商id
+
+        if (orderDetail == null) {
+            logger.info("计算订单折扣V2, OrderDetail为空(orderCode:{}, transactionCode:{}), 直接返回!", orderCode, transactionCode);
+            return;
+        }
+
+        // 原始电费金额
+        BigDecimal originalTotalElectricityAmount = orderDetail.getTotalElectricityAmount();
+        // 原始服务费金额
+        BigDecimal originalTotalServiceAmount = orderDetail.getTotalServiceAmount();
+        logger.info("计算订单折扣V2, orderCode:{}, 原始电费金额:{}, 原始服务费金额:{}", orderCode, originalTotalElectricityAmount, originalTotalServiceAmount);
+        // 电费折扣金额 初始值为0
+        BigDecimal electricityAmountDiscount = BigDecimal.ZERO;
+        // 服务费折扣金额 初始值为0
+        BigDecimal serviceAmountDiscount = BigDecimal.ZERO;
+        // 优惠后电费金额 初始值为优惠前金额
+        BigDecimal afterDiscountElectricityAmount = BigDecimal.ZERO;
+        // 优惠后服务费金额 初始值为优惠前金额
+        BigDecimal afterDiscountServiceAmount = BigDecimal.ZERO;
+
+        // 查询会员在该站点享受的优惠
+        MemberDiscountVO memberDiscountVO = memberGroupService.queryMemberDiscountV2(merchantId, stationId, memberId);
+        if (memberDiscountVO == null) {
+            // 如果没有优惠，则优惠后金额 等于优惠前金额
+            afterDiscountServiceAmount = orderDetail.getTotalServiceAmount();
+            afterDiscountElectricityAmount = orderDetail.getTotalElectricityAmount();
+        } else {
+            // 集团会员的订单，记录集团编号
+            orderBasicInfo.setGroupCode(memberDiscountVO.getGroupCode());
+
+            // 集团会员的优惠计费模板
+            BillingTemplateVO billingTemplateVO = memberDiscountVO.getBillingTemplateVO();
+
+            // 尖时段用电量
+            BigDecimal sharpUsedElectricity = orderDetail.getSharpUsedElectricity();
+            if (sharpUsedElectricity != null) {
+                // 计算该时段电费 = 电费单价 x 用电量
+                BigDecimal sharpElectricityAmount = billingTemplateVO.getSharpElectricityPrice()
+                        .multiply(sharpUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+                // 计算该时段服务费
+                BigDecimal sharpServiceAmount = billingTemplateVO.getSharpServicePrice()
+                        .multiply(sharpUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+
+                // 汇总
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(sharpElectricityAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(sharpServiceAmount);
+                logger.info("计算订单折扣V2, orderCode:{}, 尖时段用电量:{}, 电费单价:{}, 电费金额:{}, 服务费单价:{}, 服务费金额:{}", orderCode, sharpUsedElectricity,
+                        billingTemplateVO.getSharpElectricityPrice(), sharpElectricityAmount, billingTemplateVO.getSharpServicePrice(), sharpServiceAmount);
+            }
+
+            // 峰时段用电量
+            BigDecimal peakUsedElectricity = orderDetail.getPeakUsedElectricity();
+            if (peakUsedElectricity != null) {
+                // 计算该时段电费 = 电费单价 x 用电量
+                BigDecimal peakElectricityAmount = billingTemplateVO.getPeakElectricityPrice()
+                        .multiply(peakUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+                // 计算该时段服务费
+                BigDecimal peakServiceAmount = billingTemplateVO.getPeakServicePrice()
+                        .multiply(peakUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+
+                // 汇总
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(peakElectricityAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(peakServiceAmount);
+                logger.info("计算订单折扣V2, orderCode:{}, 峰时段用电量:{}, 电费单价:{}, 电费金额:{}, 服务费单价:{}, 服务费金额:{}", orderCode, peakUsedElectricity,
+                        billingTemplateVO.getPeakElectricityPrice(), peakElectricityAmount, billingTemplateVO.getPeakServicePrice(), peakServiceAmount);
+            }
+
+            // 平时段用电量
+            BigDecimal flatUsedElectricity = orderDetail.getFlatUsedElectricity();
+            if (flatUsedElectricity != null) {
+                // 计算该时段电费 = 电费单价 x 用电量
+                BigDecimal flatElectricityAmount = billingTemplateVO.getFlatElectricityPrice()
+                        .multiply(flatUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+                // 计算该时段服务费
+                BigDecimal flatServiceAmount = billingTemplateVO.getFlatServicePrice()
+                        .multiply(flatUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+
+                // 汇总
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(flatElectricityAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(flatServiceAmount);
+                logger.info("计算订单折扣V2, orderCode:{}, 平时段用电量:{}, 电费单价:{}, 电费金额:{}, 服务费单价:{}, 服务费金额:{}", orderCode, flatUsedElectricity,
+                        billingTemplateVO.getFlatElectricityPrice(), flatElectricityAmount, billingTemplateVO.getFlatServicePrice(), flatServiceAmount);
+            }
+
+            // 谷时段用电量
+            BigDecimal valleyUsedElectricity = orderDetail.getValleyUsedElectricity();
+            if (valleyUsedElectricity != null) {
+                // 计算该时段电费 = 电费单价 x 用电量
+                BigDecimal valleyElectricityAmount = billingTemplateVO.getValleyElectricityPrice()
+                        .multiply(valleyUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+                // 计算该时段服务费
+                BigDecimal valleyServiceAmount = billingTemplateVO.getValleyServicePrice()
+                        .multiply(valleyUsedElectricity)
+                        .setScale(2, RoundingMode.DOWN);
+
+                // 汇总
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(valleyElectricityAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(valleyServiceAmount);
+                logger.info("计算订单折扣V2, orderCode:{}, 谷时段用电量:{}, 电费单价:{}, 电费金额:{}, 服务费单价:{}, 服务费金额:{}", orderCode, valleyUsedElectricity,
+                        billingTemplateVO.getValleyElectricityPrice(), valleyElectricityAmount, billingTemplateVO.getValleyServicePrice(), valleyServiceAmount);
+            }
+
+            // 计算优惠了多少钱
+            // 电费折扣金额 = 优惠前电费 - 优惠后电费
+            electricityAmountDiscount = originalTotalElectricityAmount.subtract(afterDiscountElectricityAmount);
+            // 服务费折扣金额 = 优惠前服务费 - 优惠后服务费
+            serviceAmountDiscount = originalTotalServiceAmount.subtract(afterDiscountServiceAmount);
+        }
+
+        /*
+        更新 数据
+         */
+        // 订单折扣金额 = 电费折扣金额 + 服务费折扣金额
+        BigDecimal discountAmount = electricityAmountDiscount.add(serviceAmountDiscount);
+        orderBasicInfo.setDiscountAmount(discountAmount);
+
+        // 更新结算金额  结算金额 = 消费金额 - 虚拟金额 - 优惠金额
+        BigDecimal newSettleAmount = orderBasicInfo.getSettleAmount().subtract(discountAmount);
+        if (newSettleAmount.compareTo(BigDecimal.ZERO) < 0) {
+            // 如果结算金额为0，减去优惠金额后为负数，还设置为0
+            newSettleAmount = BigDecimal.ZERO;
+        }
+        orderBasicInfo.setSettleAmount(newSettleAmount);
+
+        // 优惠后总消费金额 = 折扣后电费 + 折扣后服务费
+        BigDecimal totalConsumeAmount = afterDiscountServiceAmount.add(afterDiscountElectricityAmount);
+
+        // 更新退款金额 = 支付金额 - 优惠后总消费金额
+        BigDecimal refundAmount = orderBasicInfo.getPayAmount().subtract(totalConsumeAmount).setScale(2, RoundingMode.DOWN);
+        orderBasicInfo.setRefundAmount(refundAmount);
+        // 电费折扣金额(电费便宜了多少钱)
+        orderDetail.setDiscountElectricityAmount(electricityAmountDiscount);
+        // 服务费折扣金额(服务费便宜了多少钱)
+        orderDetail.setDiscountServiceAmount(serviceAmountDiscount);
+        logger.info("计算订单折扣, orderCode:{}, memberId:{}, 订单折扣金额:{}, 电费折扣金额:{}, 服务费折扣金额:{}, 优惠后总消费金额:{}",
+                orderCode, memberId, discountAmount, electricityAmountDiscount, serviceAmountDiscount, totalConsumeAmount);
+    }
+
+    public void testSettleOrderLogicV2(String orderCode) {
+        // 查询订单主表
+        OrderBasicInfo orderBasicInfo = orderBasicInfoService.getOrderInfoByOrderCode(orderCode);
+
+        LocalDateTime localDateTime = DateUtils.date2LocalDateTime(orderBasicInfo.getSettlementTime());
+        // 开始时间为localDateTime减30秒
+        LocalDateTime startTime = localDateTime.minusSeconds(30);
+        // 结束时间为localDateTime加30秒
+        LocalDateTime endTime = localDateTime.plusSeconds(30);
+        // logger.info("testSettleOrderLogicV2, orderCode:{}, settlementTime:{}, startTime:{}, endTime:{}", orderCode, orderBasicInfo.getSettlementTime(), startTime, endTime);
+        // logger.info("转换为Date类型, settlementTime:{}, startTime:{}, endTime:{}", orderBasicInfo.getSettlementTime(), DateUtils.localDateTime2Date(startTime), DateUtils.localDateTime2Date(endTime));
+        // 查询这笔订单的交易记录原始数据
+        List<PileMsgRecord> pileFeedListV2 = pileMsgRecordService.getPileFeedListV2(orderBasicInfo.getPileSn(), "0x3B", startTime, endTime);
+        // logger.info("testSettleOrderLogicV2, orderCode:{}, pileSn:{}, startTime:{}, endTime:{}, pileFeedListV2:{}",
+        //         orderCode, orderBasicInfo.getPileSn(), startTime, endTime, JSON.toJSONString(pileFeedListV2));
+        TransactionRecordsData data = null;
+        for (PileMsgRecord pileMsgRecord : pileFeedListV2) {
+            TransactionRecordsData parse = JSONObject.parseObject(pileMsgRecord.getJsonMsg(), TransactionRecordsData.class);
+            if (StringUtils.equals(parse.getTransactionCode(), orderBasicInfo.getTransactionCode())) {
+                data = parse;
+            }
+        }
+
+        logger.info("testSettleOrderLogicV2, orderCode:{}, data:{}", orderCode, JSON.toJSONString(data));
+        if (data != null) {
+            testSettleOrderLogic(data, orderBasicInfo);
+        }
+    }
+
+    public void testSettleOrderLogic(TransactionRecordsData data, OrderBasicInfo orderBasicInfo) {
+        AbstractProgramLogic programLogic = ProgramLogicFactory.getProgramLogic("1");
+
+        // 查询订单详情
+        OrderDetail orderDetail = orderBasicInfoService.getOrderDetailByOrderCode(orderBasicInfo.getOrderCode());
+
+        programLogic.updateOrderBasicInfoAndOrderDetail(data, orderBasicInfo, orderDetail);
+
+        // 计算订单折扣
+        programLogic.calculateOrderDiscountsV2(orderBasicInfo, orderDetail);
+
+        logger.info("testSettleOrderLogic, orderCode:{}, 支付金额:{}, 消费金额:{}, 折扣金额:{}, 退款金额:{}, 结算金额:{}",
+                orderBasicInfo.getOrderCode(), orderBasicInfo.getPayAmount(), orderBasicInfo.getOrderAmount(),
+                orderBasicInfo.getDiscountAmount(), orderBasicInfo.getRefundAmount(), orderBasicInfo.getSettleAmount());
+
+        // 更新数据库
+        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();
+        logger.info("testSettleOrderLogic, afterSettleOrderDTO:{}", JSON.toJSONString(afterSettleOrderDTO));
+        rabbitTemplate.convertAndSend(RabbitConstants.YKC_EXCHANGE_NAME, RabbitConstants.QUEUE_CHARGE_ORDER_DATA, afterSettleOrderDTO);
+    }
+
 }
 

jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java

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

jsowell-pile/src/main/java/com/jsowell/pile/service/PileMsgRecordService.java

@@ -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);
 }

jsowell-pile/src/main/java/com/jsowell/pile/service/PileRemoteService.java

@@ -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()));

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

@@ -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;
+    }
+
 }
 

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

@@ -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

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

@@ -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()));
+                BigDecimal electricityPrice = orderDetail.getSharpElectricityPrice();
-                }
+
-                if (data.getSharpAmount() != null) {
-                    orderDetail.setSharpAmount(new BigDecimal(data.getSharpAmount()));
-                }
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal sharpElectricityAmount = orderDetail.getSharpElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(sharpUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
-                totalElectricityAmount = totalElectricityAmount.add(sharpElectricityAmount);
+
+                // 该时段服务费单价
+                BigDecimal servicePrice = orderDetail.getSharpServicePrice();
+
                 // 计算该时段服务费
-                BigDecimal sharpServiceAmount = orderDetail.getSharpServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(sharpUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalServiceAmount = totalServiceAmount.add(serviceAmount);
-                totalServiceAmount = totalServiceAmount.add(sharpServiceAmount);
+
+                // 该时段单价 = 电费单价 + 服务费单价
+                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()));
+                BigDecimal electricityPrice = orderDetail.getPeakElectricityPrice();
-                }
+
-                if (data.getPeakAmount() != null) {
-                    orderDetail.setPeakAmount(new BigDecimal(data.getPeakAmount()));
-                }
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal peakElectricityAmount = orderDetail.getPeakElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(peakUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
-                totalElectricityAmount = totalElectricityAmount.add(peakElectricityAmount);
+
+                // 该时段服务费单价
+                BigDecimal servicePrice = orderDetail.getPeakServicePrice();
+
                 // 计算该时段服务费
-                BigDecimal peakServiceAmount = orderDetail.getPeakServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(peakUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalServiceAmount = totalServiceAmount.add(serviceAmount);
-                totalServiceAmount = totalServiceAmount.add(peakServiceAmount);
+
+                // 该时段单价 = 电费单价 + 服务费单价
+                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()));
+                BigDecimal electricityPrice = orderDetail.getFlatElectricityPrice();
-                }
+
-                if (data.getFlatAmount() != null) {
-                    orderDetail.setFlatAmount(new BigDecimal(data.getFlatAmount()));
-                }
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal flatElectricityAmount = orderDetail.getFlatElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(flatUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
-                totalElectricityAmount = totalElectricityAmount.add(flatElectricityAmount);
+
+                // 该时段服务费单价
+                BigDecimal servicePrice = orderDetail.getFlatServicePrice();
+
                 // 计算该时段服务费
-                BigDecimal flatServiceAmount = orderDetail.getFlatServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(flatUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalServiceAmount = totalServiceAmount.add(serviceAmount);
-                totalServiceAmount = totalServiceAmount.add(flatServiceAmount);
+
+                // 该时段单价 = 电费单价 + 服务费单价
+                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()));
+                BigDecimal electricityPrice = orderDetail.getValleyElectricityPrice();
-                }
+
-                if (data.getValleyAmount() != null) {
-                    orderDetail.setValleyAmount(new BigDecimal(data.getValleyAmount()));
-                }
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal valleyElectricityAmount = orderDetail.getValleyElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(valleyUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalElectricityAmount = totalElectricityAmount.add(electricityAmount);
-                totalElectricityAmount = totalElectricityAmount.add(valleyElectricityAmount);
+
+                // 该时段服务费单价
+                BigDecimal servicePrice = orderDetail.getValleyServicePrice();
+
                 // 计算该时段服务费
-                BigDecimal valleyServiceAmount = orderDetail.getValleyServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(valleyUsedElectricity)
+
-                        .setScale(2, RoundingMode.DOWN);
+                totalServiceAmount = totalServiceAmount.add(serviceAmount);
-                totalServiceAmount = totalServiceAmount.add(valleyServiceAmount);
+
+                // 该时段单价 = 电费单价 + 服务费单价
+                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) {
+            if (computeTotalAmount.compareTo(orderAmount) != 0) {
-                totalElectricityAmount = orderAmount.subtract(totalServiceAmount);
+                // 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)
+            BigDecimal sumUsedElectricity = sharpUsedElectricity.add(peakUsedElectricity).add(flatUsedElectricity).add(valleyUsedElectricity);
-                    .add(flatUsedElectricity).add(valleyUsedElectricity);
             // data中的总用电量
             BigDecimal totalElectricity = new BigDecimal(StringUtils.isBlank(data.getTotalElectricity()) ? Constants.ZERO : data.getTotalElectricity());
-            // if (sumUsedElectricity.compareTo(totalElectricity) != 0) {
+            // sumUsedElectricity与totalElectricity对比, 取最大的值
-            //     // 汇总数据和data中数据不相等，取汇总的数据
-            //     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:{}), 直接返回!",
+            logger.info("计算订单折扣V2, OrderDetail为空(orderCode:{}, transactionCode:{}), 直接返回!", orderCode, orderBasicInfo.getTransactionCode());
-                    orderBasicInfo.getOrderCode(), 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()
+                BigDecimal electricityAmount = electricityPrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(sharpUsedElectricity)
+                // 计算该时段服务费单价
-                        .setScale(2, RoundingMode.DOWN);
+                BigDecimal servicePrice = billingTemplateVO.getSharpServicePrice();
                 // 计算该时段服务费
-                BigDecimal sharpServiceAmount = billingTemplateVO.getSharpServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(sharpUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(sharpUsedElectricity)
-                        .setScale(2, RoundingMode.DOWN);
 
                 // 汇总
-                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(sharpElectricityAmount);
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
-                afterDiscountServiceAmount = afterDiscountServiceAmount.add(sharpServiceAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
+                // logger.info("计算订单折扣V2:【{}】, 当前为尖时段, 电费单价:{}, 服务费单价:{}, 耗电量:{}, 平台计算该时段消费金额:{}, 桩传的单价:{}, 桩传的金额:{}");
             }
 
             // 峰时段用电量
             BigDecimal peakUsedElectricity = orderDetail.getPeakUsedElectricity();
             if (peakUsedElectricity != null) {
+                // 计算该时段电费单价
+                BigDecimal electricityPrice = billingTemplateVO.getPeakElectricityPrice();
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal peakElectricityAmount = billingTemplateVO.getPeakElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(peakUsedElectricity)
-                        .setScale(2, RoundingMode.DOWN);
                 // 计算该时段服务费
-                BigDecimal peakServiceAmount = billingTemplateVO.getPeakServicePrice()
+                BigDecimal servicePrice = billingTemplateVO.getPeakServicePrice();
-                        .multiply(peakUsedElectricity)
+                // 计算该时段服务费 = 服务费单价 x 用电量
-                        .setScale(2, RoundingMode.DOWN);
+                BigDecimal serviceAmount = servicePrice.multiply(peakUsedElectricity).setScale(2, RoundingMode.DOWN);
 
                 // 汇总
-                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(peakElectricityAmount);
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
-                afterDiscountServiceAmount = afterDiscountServiceAmount.add(peakServiceAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
             }
 
             // 平时段用电量
             BigDecimal flatUsedElectricity = orderDetail.getFlatUsedElectricity();
             if (flatUsedElectricity != null) {
+                // 计算该时段电费单价
+                BigDecimal electricityPrice = billingTemplateVO.getFlatElectricityPrice();
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal flatElectricityAmount = billingTemplateVO.getFlatElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(flatUsedElectricity)
+                // 计算该时段服务费单价
-                        .setScale(2, RoundingMode.DOWN);
+                BigDecimal servicePrice = billingTemplateVO.getFlatServicePrice();
                 // 计算该时段服务费
-                BigDecimal flatServiceAmount = billingTemplateVO.getFlatServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(flatUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(flatUsedElectricity)
-                        .setScale(2, RoundingMode.DOWN);
 
                 // 汇总
-                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(flatElectricityAmount);
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
-                afterDiscountServiceAmount = afterDiscountServiceAmount.add(flatServiceAmount);
+                afterDiscountServiceAmount = afterDiscountServiceAmount.add(serviceAmount);
             }
 
             // 谷时段用电量
             BigDecimal valleyUsedElectricity = orderDetail.getValleyUsedElectricity();
             if (valleyUsedElectricity != null) {
+                // 计算该时段电费单价
+                BigDecimal electricityPrice = billingTemplateVO.getValleyElectricityPrice();
                 // 计算该时段电费 = 电费单价 x 用电量
-                BigDecimal valleyElectricityAmount = billingTemplateVO.getValleyElectricityPrice()
+                BigDecimal electricityAmount = electricityPrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(valleyUsedElectricity)
+                // 计算该时段服务费单价
-                        .setScale(2, RoundingMode.DOWN);
+                BigDecimal servicePrice = billingTemplateVO.getValleyServicePrice();
                 // 计算该时段服务费
-                BigDecimal valleyServiceAmount = billingTemplateVO.getValleyServicePrice()
+                BigDecimal serviceAmount = servicePrice.multiply(valleyUsedElectricity).setScale(2, RoundingMode.DOWN);
-                        .multiply(valleyUsedElectricity)
-                        .setScale(2, RoundingMode.DOWN);
 
                 // 汇总
-                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(valleyElectricityAmount);
+                afterDiscountElectricityAmount = afterDiscountElectricityAmount.add(electricityAmount);
-                afterDiscountServiceAmount = afterDiscountServiceAmount.add(valleyServiceAmount);
+                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);
     }
 
     /**

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

@@ -454,8 +454,7 @@ public class DelayMerchantProgramLogic extends AbstractProgramLogic {
     /**
      * 订单结算/结算订单逻辑/订单结算逻辑
      */
-    @Override
+    public void settleOrderOld(TransactionRecordsData data, OrderBasicInfo orderBasicInfo) {
-    public void settleOrder(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())
+                .orderPayAmount(orderBasicInfo.getPayAmount()) // 支付金额
-                .orderConsumeAmount(orderBasicInfo.getOrderAmount())
+                .orderConsumeAmount(orderBasicInfo.getOrderAmount()) // 消费金额
-                .orderSettleAmount(orderBasicInfo.getSettleAmount())
+                .orderSettleAmount(orderBasicInfo.getSettleAmount()) // 结算金额
-                .orderElectricityAmount(orderDetail.getTotalElectricityAmount())
+                .orderElectricityAmount(orderDetail.getTotalElectricityAmount()) // 电费金额
-                .orderElectricityDiscountAmount(orderDetail.getDiscountElectricityAmount())
+                .orderElectricityDiscountAmount(orderDetail.getDiscountElectricityAmount()) // 电费折扣金额
-                .orderServiceAmount(orderDetail.getTotalServiceAmount())
+                .orderServiceAmount(orderDetail.getTotalServiceAmount()) // 服务费金额
-                .orderServiceDiscountAmount(orderDetail.getDiscountServiceAmount())
+                .orderServiceDiscountAmount(orderDetail.getDiscountServiceAmount()) // 服务费折扣金额
-                .orderRefundAmount(orderBasicInfo.getRefundAmount())
+                .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) {
         // 判断订单状态

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

@@ -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) {
 

jsowell-pile/src/main/resources/mapper/pile/PileMsgRecordMapper.xml

@@ -137,10 +137,10 @@
         <if test="frameType != null and frameType != ''">
             and frame_type = #{frameType,jdbcType=VARCHAR}
         </if>
-        <if test="startTime != null and startTime != ''">
+        <if test="startTime != null">
             and create_time &gt;= #{startTime,jdbcType=TIMESTAMP}
         </if>
-        <if test="endTime != null and endTime != ''">
+        <if test="endTime != null">
             and create_time &lt;= #{endTime,jdbcType=TIMESTAMP}
         </if>
         order by create_time desc

jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java

@@ -74,7 +74,7 @@ public class JsowellTask {
     public void setBarrier() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
     }
@@ -86,7 +86,7 @@ public class JsowellTask {
     public void close15MinutesOfUnpaidOrders() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // log.info("关闭15分钟未支付的订单");
@@ -100,7 +100,7 @@ public class JsowellTask {
     public void closeStartFailedOrder() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询出最近2天支付成功，并且订单状态为未启动的订单
@@ -115,7 +115,7 @@ public class JsowellTask {
     public void appointmentOrderStart() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询出 已支付 设置预约充电 未启动 的订单
@@ -164,7 +164,7 @@ public class JsowellTask {
     public void calculateTheSiteOrdersReport() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询出所有站点
@@ -193,7 +193,7 @@ public class JsowellTask {
     public void pushToAMap() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         Set<String> stationIds = redisCache.getCacheSet(CacheConstants.PUSH_STATION_CONNECTOR);
@@ -218,7 +218,7 @@ public class JsowellTask {
     public void pushStationRealTimePowerInfo() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询出要推送的站点（贵州、）
@@ -240,7 +240,7 @@ public class JsowellTask {
     public void processOrderSplitting() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询运营商列表
@@ -279,7 +279,7 @@ public class JsowellTask {
     public void generateMerchantBill() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询运营商列表
@@ -308,7 +308,7 @@ public class JsowellTask {
     public void automaticPayouts() {
         String env = SpringUtils.getActiveProfile();
         if (StringUtils.equalsIgnoreCase(env, "pre")) {
-            log.info("PRE环境不执行");
+            log.debug("PRE环境不执行");
             return;
         }
         // 查询开启自动提现运营商列表