修改bug

Pu Zhibing

2024-10-12 7b477828acb81c542b34dc603511bf6bcbe88ca5

 ruoyi-service/ruoyi-order/src/main/java/com/ruoyi/order/service/impl/TChargingOrderServiceImpl.java

@@ -38,7 +38,7 @@
import com.ruoyi.order.api.query.SettlementListQuery;
import com.ruoyi.order.api.query.UploadRealTimeMonitoringDataQuery;
import com.ruoyi.order.api.vo.*;
import com.ruoyi.order.api.vo.SecurityDetection;
import com.ruoyi.order.api.vo.PlatformStopChargingReplyVO;
import com.ruoyi.order.dto.*;
import com.ruoyi.order.mapper.TChargingOrderMapper;
import com.ruoyi.order.mapper.TSettlementConfirmMapper;
@@ -47,6 +47,7 @@
import com.ruoyi.order.service.TChargingOrderService;
import com.ruoyi.order.service.TOrderEvaluateService;
import com.ruoyi.order.service.*;
import com.ruoyi.order.vo.EndOfChargePageInfo;
import com.ruoyi.other.api.domain.*;
import com.ruoyi.order.vo.ChargingOrderListInfoVO;
import com.ruoyi.other.api.feignClient.*;
@@ -56,7 +57,6 @@
import com.ruoyi.payment.api.model.RefundResp;
import com.ruoyi.payment.api.model.WxPaymentRefundModel;
import com.ruoyi.payment.api.vo.*;
import com.ruoyi.system.api.feignClient.SysUserClient;
import io.seata.spring.annotation.GlobalTransactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -73,6 +73,8 @@
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.format.TextStyle;
import java.time.temporal.WeekFields;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
@@ -97,8 +99,7 @@

   @Resource
   private SiteClient siteClient;


	
   @Resource
   private AppUserCarClient appUserCarClient;
   @Resource
@@ -139,8 +140,7 @@

   @Resource
   private TOrderEvaluateService orderEvaluateService;


	
   @Resource
   private AccountingStrategyDetailClient accountingStrategyDetailClient;

@@ -627,6 +627,9 @@
            }
         }
      }
		
      electrovalence = electrovalence.setScale(4, RoundingMode.HALF_EVEN);
      discountAmount = discountAmount.setScale(4, RoundingMode.HALF_EVEN);
      chargingOrder.setChargeAmount(electrovalence);
      chargingOrder.setVipDiscountAmount(discountAmount);
      this.updateById(chargingOrder);
@@ -641,10 +644,8 @@
      //使用订单id作为逻辑卡号
      platformStartCharging.setCard_number(chargingOrder.getId().toString());
      platformStartCharging.setAccount_balance(electrovalence);

      System.err.println("-------------------远程调起开始充电请求-------------------");
      System.err.println(platformStartCharging.toString());

		
      log.error(chargingOrder.getCode() + "：-------------------远程调起开始充电请求-------------------" + platformStartCharging.toString());
      sendMessageClient.platformStartCharging(platformStartCharging);
      //异步线程检测远程启动的应答结果。如果失败，则需要全额退款
      Long id = chargingOrder.getId();
@@ -676,17 +677,19 @@
      if(null != securityDetection){
         PreChargeCheck preChargeCheck1 =  redisService.getCacheObject("AQJC_" + chargingOrder.getChargingGunId());
         if(null != preChargeCheck1){
            preChargeCheck1.setElectronicLockLock(preChargeCheck1.getElectronicLockLock());
            preChargeCheck1.setElectronicLockLock(true);
            preChargeCheck1.setInsulationTesting(true);
            preChargeCheck1.setSecureConnectionDetection(preChargeCheck1.getSecureConnectionDetection());
            preChargeCheck1.setSecureConnectionDetection(securityDetection.getSecure_connection() == 1);
            preChargeCheck1.setStartupSuccess(1);
            redisService.setCacheObject("AQJC_" + chargingOrder.getChargingGunId(), preChargeCheck1, 24L, TimeUnit.HOURS);
         }
      }
      
      List<PlatformStartChargingReply> data = platformStartChargingReplyClient.getPlatformStartChargingReply(code).getData();
      System.err.println(code + "：-------------------开始检查调起充电结果-------------------");
      System.err.println(data.toString());
      if(null == data){
         return false;
      }
      log.error(code + "：-------------------开始检查调起充电结果-------------------" + data.toString());
      if(data.size() != 0){
         PlatformStartChargingReply platformStartChargingReply = data.get(1);
         Integer startup_result = platformStartChargingReply.getStartup_result();
@@ -725,9 +728,8 @@
         redisService.setCacheObject(key, preChargeCheck1, 24L, TimeUnit.HOURS);
         return true;
      }else{
         log.error(code + "：未上传开启充电结果........");
			
         Integer counter = boot_failed_map.get(code);
         log.error(code + "：-------------------未上传开启充电结果-------------------" + counter);
         PreChargeCheck preChargeCheck1 = redisService.getCacheObject(key);
         //5分钟内未启动成功，退回金额。
         if(null == counter || counter < 300){
@@ -762,27 +764,26 @@
    * @param securityDetection
    */
   @Override
   public void securityDetection(SecurityDetection securityDetection){
   public void securityDetection(SecurityDetectionVO securityDetection){
      GetChargingGunByCode code = new GetChargingGunByCode();
      code.setCharging_pile_code(securityDetection.getCharging_pile_code());
      code.setCharging_gun_code(securityDetection.getCharging_gun_code());
      TChargingGun chargingGun = chargingGunClient.getChargingGunByCode(code).getData();
      PreChargeCheck preChargeCheck1 =  redisService.getCacheObject("AQJC_" + chargingGun.getId());
      PreChargeCheck preChargeCheck1 = redisService.getCacheObject("AQJC_" + chargingGun.getId());
      if(null != preChargeCheck1){
         preChargeCheck1.setElectronicLockLock(preChargeCheck1.getElectronicLockLock());
         preChargeCheck1.setElectronicLockLock(true);
         preChargeCheck1.setInsulationTesting(true);
         preChargeCheck1.setSecureConnectionDetection(preChargeCheck1.getSecureConnectionDetection());
         preChargeCheck1.setStartupSuccess(1);
         preChargeCheck1.setSecureConnectionDetection(securityDetection.getSecure_connection() == 1);
         redisService.setCacheObject("AQJC_" + chargingGun.getId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      }
   }
   
   /**
    * 启动充电应发
    * 启动充电应答
    * @param message
    */
   @Override
   public void startChargeSuccessfully(PlatformStartChargingReplyMessage message) {
   public void startChargeSuccessfully(PlatformStartChargingReplyMessageVO message) {
      Integer startup_result = message.getStartup_result();
      Integer failure_cause = message.getFailure_cause();
      TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, message.getTransaction_serial_number()));
@@ -792,11 +793,9 @@
      String code = order.getCode();
      PreChargeCheck preChargeCheck1 =  redisService.getCacheObject("AQJC_" + order.getChargingGunId());
      if(null != preChargeCheck1){
         preChargeCheck1.setElectronicLockLock(preChargeCheck1.getElectronicLockLock());
         preChargeCheck1.setElectronicLockLock(true);
         preChargeCheck1.setInsulationTesting(true);
         preChargeCheck1.setSecureConnectionDetection(preChargeCheck1.getSecureConnectionDetection());
         preChargeCheck1.setStartupSuccess(1);
         redisService.setCacheObject("AQJC_" + order.getChargingGunId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      }
      if(0 == startup_result){
         //启动失败
@@ -812,6 +811,7 @@
         order.setStatus(3);
         order.setStartTime(LocalDateTime.now());
      }
      redisService.setCacheObject("AQJC_" + order.getChargingGunId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      this.updateById(order);
   }
   
@@ -820,6 +820,7 @@
    * @param code
    */
   public void refund(String code){
      log.error(code + "：-------------------充电启动失败，执行退款-------------------");
      TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, code));
      if(chargingOrder.getStatus() == 2){
         Integer rechargePaymentType = chargingOrder.getRechargePaymentType();
@@ -889,7 +890,7 @@
         TChargingOrderRefund one = chargingOrderRefundService.getOne(new LambdaQueryWrapper<TChargingOrderRefund>().eq(TChargingOrderRefund::getRefundCode, out_refund_no));
         one.setRefundSerialNumber(refund_id);
         one.setRefundStatus(2);
         one.setRefundTime(LocalDateTime.parse(success_time, DateTimeFormatter.ofPattern("yyyy-MM-DDTHH:mm:ss+TIMEZONE")));
         one.setRefundTime(LocalDateTime.now());
         chargingOrderRefundService.updateById(one);
      }
      return AjaxResult.success();
@@ -907,7 +908,7 @@
   public ChargingDetails getChargingDetails(Integer id) {
      Long userId = tokenService.getLoginUserApplet().getUserId();
      TChargingOrder one = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getAppUserId, userId).eq(TChargingOrder::getChargingGunId, id)
            .in(TChargingOrder::getStatus, Arrays.asList(1, 2, 3)).eq(TChargingOrder::getRechargePaymentStatus, 2).eq(TChargingOrder::getDelFlag, 0));
            .eq(TChargingOrder::getRechargePaymentStatus, 2).eq(TChargingOrder::getDelFlag, 0).orderByDesc(TChargingOrder::getEndTime).last(" limit 0, 1"));
      if(null == one){
         return null;
      }
@@ -954,13 +955,103 @@
   public AjaxResult stopCharging(String id) {
      TChargingOrder chargingOrder = this.getById(id);
      Integer status = chargingOrder.getStatus();
      if(status != 3){
         return AjaxResult.error("还未开始充电");
      }
      if(status == 4 || status == 5){
         return AjaxResult.error("不能重复操作");
      }
      chargingOrder.setEndTime(LocalDateTime.now());
      chargingOrder.setStatus(4);
      chargingOrder.setEndMode(1);
      this.updateById(chargingOrder);
      //计算用户标签
      editUserTag(chargingOrder);
      //用户推荐奖励
      referralReward(chargingOrder);
      //计算费用，处理退款
      endCharge(chargingOrder);
      TChargingGun chargingGun = chargingGunClient.getChargingGunById(chargingOrder.getChargingGunId()).getData();
      // 将枪状态重置为空闲
      chargingGun.setStatus(2);
      chargingGunClient.updateChargingGunById(chargingGun);
      
      String code1 = chargingOrder.getCode();
		
      //异步线程处理停机
      ExecutorService cachedThreadPool = Executors.newFixedThreadPool(1);
      cachedThreadPool.execute(()->{
         //调用硬件停止充电，停止成功后开始计算费用退款
         TChargingPile chargingPile = chargingPileClient.getChargingPileById(chargingOrder.getChargingPileId()).getData();
         PlatformStopCharging platformStopCharging = new PlatformStopCharging();
         platformStopCharging.setCharging_pile_code(chargingPile.getCode());
         platformStopCharging.setCharging_gun_code(chargingGun.getCode());
         sendMessageClient.platformStopCharging(platformStopCharging);
         log.error(code1 + "：-------------------远程停止充电请求-------------------");
         log.error(platformStopCharging.toString());
         //开始查询停机应答，成功后开始计费费用
         for (int i = 0; i < 60; i++) {
            TChargingOrder chargingOrder1 = this.getById(id);
            if(chargingOrder1.getStatus() != 3){
               break;
            }
            GetPlatformStopChargingReply query = new GetPlatformStopChargingReply();
            query.setCharging_gun_code(chargingGun.getCode());
            query.setCharging_pile_code(chargingPile.getCode());
            query.setEnd_time(chargingOrder.getEndTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            PlatformStopChargingReply reply = platformStopChargingReplyClient.getPlatformStopChargingReply(query).getData();
            log.error(code1 + "：-------------------查询远程停止充电应答-------------------");
            if(null == reply){
               log.error(code1 + "：-------------------远程停止充电应答无数据-------------------");
               try {
                  Thread.sleep(1000);
               } catch (InterruptedException e) {
                  throw new RuntimeException(e);
               }
               continue;
            }
            log.error(reply.toString());
				
            if(0 == reply.getStop_result()){
               String failure_cause = "";
               switch (reply.getFailure_cause()){
                  case 0:
                     failure_cause = "无";
                     break;
                  case 1:
                     failure_cause = "设备编号不匹配";
                     break;
                  case 2:
                     failure_cause = "枪未处于充电状态";
                     break;
                  case 3:
                     failure_cause = "其他";
                     break;
               }
               log.error(code1 + "：停机失败：订单号：{}，失败原因：{}", chargingOrder.getCode(), failure_cause);
               try {
                  Thread.sleep(1000);
               } catch (InterruptedException e) {
                  throw new RuntimeException(e);
               }
               continue;
            }
            log.error(code1 + "：-------------------远程停止充电请求成功-------------------");
            break;
         }
			
         chargingOrder.setStatus(5);
         this.updateById(chargingOrder);
      });
      return AjaxResult.success();
   }
	
	
   /**
    * 结束充电后处理用户标签数据
    * @param chargingOrder
    */
   public void editUserTag(TChargingOrder chargingOrder){
      //处理用户标签数据
      List<TUserTag> data = userTagClient.getAllUserTag().getData();
      //累计充电次数
@@ -1017,63 +1108,14 @@
            }
         }
      }
		
		
      //异步线程处理停机
      ExecutorService cachedThreadPool = Executors.newFixedThreadPool(1);
      cachedThreadPool.execute(()->{
         //调用硬件停止充电，停止成功后开始计算费用退款
         TChargingPile chargingPile = chargingPileClient.getChargingPileById(chargingOrder.getChargingPileId()).getData();
         TChargingGun chargingGun = chargingGunClient.getChargingGunById(chargingOrder.getChargingGunId()).getData();
         PlatformStopCharging platformStopCharging = new PlatformStopCharging();
         platformStopCharging.setCharging_pile_code(chargingPile.getCode());
         platformStopCharging.setCharging_gun_code(chargingGun.getCode());
         sendMessageClient.platformStopCharging(platformStopCharging);
         //开始查询停机应答，成功后开始计费费用
         for (int i = 0; i < 60; i++) {
            GetPlatformStopChargingReply query = new GetPlatformStopChargingReply();
            query.setCharging_gun_code(chargingGun.getCode());
            query.setCharging_pile_code(chargingPile.getCode());
            PlatformStopChargingReply reply = platformStopChargingReplyClient.getPlatformStopChargingReply(query).getData();
            if(null == reply){
               try {
                  Thread.sleep(1000);
               } catch (InterruptedException e) {
                  throw new RuntimeException(e);
               }
               continue;
            }

            if(0 == reply.getStop_result()){
               String failure_cause = "";
               switch (reply.getFailure_cause()){
                  case 0:
                     failure_cause = "无";
                     break;
                  case 1:
                     failure_cause = "设备编号不匹配";
                     break;
                  case 2:
                     failure_cause = "枪未处于充电状态";
                     break;
                  case 3:
                     failure_cause = "其他";
                     break;
               }
               log.error("停机失败：订单号：{}，失败原因：{}", chargingOrder.getCode(), failure_cause);
               throw new RuntimeException(failure_cause);
            }

            // 将枪状态重置为空闲
            chargingGun.setStatus(2);
            chargingGunClient.updateChargingGunById(chargingGun);
            //计算费用，处理退款
            endCharge(chargingOrder);
            break;
         }
      });


   }
	
	
   /**
    * 推荐奖励(被推荐首单奖励)
    * @param chargingOrder
    */
   public void referralReward(TChargingOrder chargingOrder){
      //处理推荐奖励(被推荐首单奖励)
      TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
      long count = this.count(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getAppUserId, chargingOrder.getAppUserId())
@@ -1117,16 +1159,71 @@
         appUserIntegralChange.setHistoricalIntegral(appUser1.getPoints());
         appUserIntegralChange.setCurrentIntegral(appUser1.getPoints() + num1);
         appUserIntegralChange.setCreateTime(LocalDateTime.now());
         appUserIntegralChange.setOrderCode(chargingOrder.getCode());
         appUserIntegralChangeClient.addAppUserIntegralChange(appUserIntegralChange);

			
         appUser1.setPoints(appUser1.getPoints() + num1);
         appUserClient.updateAppUser(appUser1);
      }

      return AjaxResult.success();
   }


	
	
	
   /**
    * 停止充电应答结果处理
    * @param platformStopChargingReply
    */
   @Override
   public void terminateSuccessfulResponse(PlatformStopChargingReplyVO platformStopChargingReply){
      GetChargingGunByCode code = new GetChargingGunByCode();
      code.setCharging_gun_code(platformStopChargingReply.getCharging_gun_code());
      code.setCharging_pile_code(platformStopChargingReply.getCharging_pile_code());
      TChargingGun chargingGun = chargingGunClient.getChargingGunByCode(code).getData();
      TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getChargingGunId, chargingGun.getId())
            .orderByDesc(TChargingOrder::getEndTime).eq(TChargingOrder::getRechargePaymentStatus, 2).last(" limit 0, 1"));
      if(null != order && order.getStatus() != 3){
         return;
      }
		
      order.setEndTime(LocalDateTime.now());
      order.setStatus(5);
      order.setEndMode(1);
      this.updateById(order);
      //计算用户标签
      editUserTag(order);
      //用户推荐奖励
      referralReward(order);
      //计算费用，处理退款
      endCharge(order);
      // 将枪状态重置为空闲
      chargingGun.setStatus(2);
      chargingGunClient.updateChargingGunById(chargingGun);
		
      String code1 = order.getCode();
      if(0 == platformStopChargingReply.getStop_result()){
         String failure_cause = "";
         switch (platformStopChargingReply.getFailure_cause()){
            case 0:
               failure_cause = "无";
               break;
            case 1:
               failure_cause = "设备编号不匹配";
               break;
            case 2:
               failure_cause = "枪未处于充电状态";
               break;
            case 3:
               failure_cause = "其他";
               break;
         }
         log.error(code1 + "：停机失败：订单号：{}，失败原因：{}", order.getCode(), failure_cause);
      }
   }
	
	
	
	
	
   /**
    * 手动结束后的费用计算和退款逻辑
    */
@@ -1183,6 +1280,7 @@
         appUser.setPoints(appUser.getPoints() + integral);
         appUserIntegralChange.setCurrentIntegral(appUser.getPoints());
         appUserIntegralChange.setCreateTime(LocalDateTime.now());
         appUserIntegralChange.setOrderCode(chargingOrder.getCode());
         appUserClient.updateAppUser(appUser);
         appUserIntegralChangeClient.addAppUserIntegralChange(appUserIntegralChange);
      }
@@ -1460,13 +1558,8 @@
   public List<Map<String, Object>> getYearData(List<Long> chargingOrderIds) {
      return this.baseMapper.getYearData(chargingOrderIds);
   }
   @Resource
   private SysUserClient sysUserClient;
   @Resource
   private UserSiteClient userSiteClient;

   @Resource
   private RoleSiteClient roleSiteClient;
	
   @Override
   public ChargingOrderTimeVO chargingList(ChargingListQuery dto) {
      String startTime1 = null;
@@ -1681,10 +1774,8 @@
      return chargingOrderTimeVO;
   }

//   @Override
//   public R payRefund(PayOrderRefundDto payOrderQueryDto) {
//      return null;
//   }

	

   @Override
   public ChargingOrderListInfoVO chargingInfo(String uid) {
@@ -1773,20 +1864,19 @@
    */
   @Override
   public void chargeMonitoring(UploadRealTimeMonitoringDataQuery query) {
      if(com.ruoyi.common.core.utils.StringUtils.isNotEmpty(query.getCharging_gun_code())){
      if(com.ruoyi.common.core.utils.StringUtils.isNotEmpty(query.getTransaction_serial_number())){
         //获取当前的计费策略
         TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, query.getCharging_gun_code()));
         TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, query.getTransaction_serial_number()));
         AccountingStrategyDetailOrder strategyDetail = accountingStrategyDetailOrderClient.getNowAccountingStrategyDetailOrder(chargingOrder.getId()).getData();
         TChargingOrderAccountingStrategy chargingOrderAccountingStrategy = chargingOrderAccountingStrategyService.getOne(new LambdaQueryWrapper<TChargingOrderAccountingStrategy>()
               .eq(TChargingOrderAccountingStrategy::getChargingOrderId, chargingOrder.getId()).orderByDesc(TChargingOrderAccountingStrategy::getCreateTime).last(" limit 0, 1"));
         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
         if(null == chargingOrderAccountingStrategy){
            chargingOrderAccountingStrategy = new TChargingOrderAccountingStrategy();
            chargingOrderAccountingStrategy.setChargingOrderId(chargingOrder.getId());
            chargingOrderAccountingStrategy.setAccountingStrategyDetailId(strategyDetail.getId());
            chargingOrderAccountingStrategy.setType(strategyDetail.getType());
            chargingOrderAccountingStrategy.setStartTime(sdf.format(chargingOrder.getStartTime()));
            chargingOrderAccountingStrategy.setEndTime(sdf.format(new Date()));
            chargingOrderAccountingStrategy.setStartTime(chargingOrder.getStartTime().format(DateTimeFormatter.ofPattern("HH:mm")));
            chargingOrderAccountingStrategy.setEndTime(LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm")));
            chargingOrderAccountingStrategy.setElectrovalence(strategyDetail.getElectrovalence());
            chargingOrderAccountingStrategy.setServiceCharge(strategyDetail.getServiceCharge());
            chargingOrderAccountingStrategy.setCostServiceCharge(strategyDetail.getCostServiceCharge());
@@ -1823,15 +1913,15 @@
               chargingOrderAccountingStrategy.setPeriodServicePrice(periodServicePrice);
               chargingOrderAccountingStrategy.setPeriodOriginalServicePrice(periodOriginalServicePrice);
               chargingOrderAccountingStrategy.setPeriodElectricPrice(periodElectricPrice);
               chargingOrderAccountingStrategy.setEndTime(sdf.format(new Date()));
               chargingOrderAccountingStrategy.setEndTime(LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm")));
               chargingOrderAccountingStrategyService.updateById(chargingOrderAccountingStrategy);
            }else{
               TChargingOrderAccountingStrategy chargingOrderAccountingStrategy1 = new TChargingOrderAccountingStrategy();
               chargingOrderAccountingStrategy1.setChargingOrderId(chargingOrder.getId());
               chargingOrderAccountingStrategy1.setAccountingStrategyDetailId(strategyDetail.getId());
               chargingOrderAccountingStrategy1.setType(strategyDetail.getType());
               chargingOrderAccountingStrategy1.setStartTime(sdf.format(chargingOrderAccountingStrategy.getEndTime()));
               chargingOrderAccountingStrategy1.setEndTime(sdf.format(new Date()));
               chargingOrderAccountingStrategy1.setStartTime(chargingOrderAccountingStrategy.getEndTime());
               chargingOrderAccountingStrategy1.setEndTime(LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm")));
               chargingOrderAccountingStrategy1.setElectrovalence(strategyDetail.getElectrovalence());
               chargingOrderAccountingStrategy1.setServiceCharge(strategyDetail.getServiceCharge());
               chargingOrderAccountingStrategy1.setCostServiceCharge(strategyDetail.getCostServiceCharge());
@@ -1881,60 +1971,19 @@
      }
      chargingOrder.setStatus(5);
      chargingOrder.setEndMode(endMode);
      chargingOrder.setEndTime(LocalDateTime.now());
      this.updateById(chargingOrder);

      // 将枪状态重置为空闲
      TChargingGun chargingGun = chargingGunClient.getChargingGunById(chargingOrder.getChargingGunId()).getData();
      chargingGun.setStatus(2);
      chargingGunClient.updateChargingGunById(chargingGun);
		
      //计算用户标签
      editUserTag(chargingOrder);
      //用户推荐奖励
      referralReward(chargingOrder);
      //计算费用，处理退款
      endCharge(chargingOrder);
		
      //处理推荐奖励(被推荐首单奖励)
      TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
      long count = this.count(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getAppUserId, chargingOrder.getAppUserId())
            .eq(TChargingOrder::getStatus, 5).isNull(TChargingOrder::getEndMode).eq(TChargingOrder::getDelFlag, 0));
      if(null != appUser.getInviteUserId() && 1 == count){
         TIntegralRule integralRule = integralRuleClient.getSet().getData();
         String inviteUsersToEarnPoints = integralRule.getInviteUsersToEarnPoints();
         JSONObject jsonObject = JSON.parseObject(inviteUsersToEarnPoints);
         Integer num1 = jsonObject.getInteger("num1");
			
         TAppUser appUser1 = appUserClient.getUserById(appUser.getInviteUserId()).getData();
         if(null != appUser1.getVipId()){
            TVip vip = vipClient.getInfo1(appUser1.getVipId()).getData();
            Integer doubleIntegration = vip.getDoubleIntegration();
            //双倍积分
            if(1 == doubleIntegration){
               num1 *= 2;
            }
         }
			
         GetInviteUser query = new GetInviteUser();
         query.setAppUserId(appUser1.getId());
         query.setBeInvitedAppUserId(chargingOrder.getAppUserId());
         TInviteUser inviteUser = inviteUserClient.getInviteUser(query).getData();
         if(null == inviteUser){
            inviteUser = new TInviteUser();
            inviteUser.setAppUserId(appUser1.getId());
            inviteUser.setBeInvitedAppUserId(chargingOrder.getAppUserId());
            inviteUser.setAward(num1);
            inviteUser.setCreateTime(LocalDateTime.now());
            inviteUserClient.saveInviteUser(inviteUser);
         }else{
            inviteUser.setAward(num1);
            inviteUserClient.updateInviteUser(inviteUser);
         }
         TAppUserIntegralChange appUserIntegralChange = new TAppUserIntegralChange();
         String code = Double.valueOf(Math.random() * 1000).intValue() + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS"));
         appUserIntegralChange.setCode(code);
         appUserIntegralChange.setAppUserId(appUser1.getId());
         appUserIntegralChange.setChangeType(5);
         appUserIntegralChange.setHistoricalIntegral(appUser1.getPoints());
         appUserIntegralChange.setCurrentIntegral(appUser1.getPoints() + num1);
         appUserIntegralChange.setCreateTime(LocalDateTime.now());
         appUserIntegralChangeClient.addAppUserIntegralChange(appUserIntegralChange);
			
         appUser1.setPoints(appUser1.getPoints() + num1);
         appUserClient.updateAppUser(appUser1);
      }
		
   }

   /**
@@ -2590,12 +2639,33 @@
   public List<Map<String, Object>> needElec1(List<Integer> siteIds, ChargingStatisticsQueryDto statisticsQueryDto) {
      return this.baseMapper.needElec1(siteIds,statisticsQueryDto);
   }

   public static void main(String[] args) {
//      String format = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss"));
//      String format1 = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss"));
//      System.err.println(format+"至"+format1);
//      LocalDateTime parse = LocalDateTime.parse("2024-01-12 00:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//      System.err.println(parse.format(DateTimeFormatter.ofPattern("yyyy-dd")));
	
   /**
    * 获取充电结束页面详情
    * @param id
    * @return
    */
   @Override
   public EndOfChargePageInfo getEndOfChargePageInfo(String id) {
      EndOfChargePageInfo info = new EndOfChargePageInfo();
      TChargingOrder chargingOrder = this.getById(id);
      info.setId(id);
      info.setCode(chargingOrder.getCode());
      info.setPaymentAmount(chargingOrder.getPaymentAmount());
      info.setCouponDiscountAmount(chargingOrder.getCouponDiscountAmount());
      TAppUserIntegralChange integralChange = appUserIntegralChangeClient.getTAppUserIntegralChangeByOrderCode(chargingOrder.getCode()).getData();
      info.setIntegral(null == integralChange ? 0 : integralChange.getCurrentIntegral() - integralChange.getHistoricalIntegral());
      info.setRechargeAmount(chargingOrder.getRechargeAmount());
      info.setRefundAmount(chargingOrder.getRefundAmount());
      LocalDateTime startTime = chargingOrder.getStartTime();
      LocalDateTime endTime = chargingOrder.getEndTime();
      info.setStartDay(startTime.format(DateTimeFormatter.ofPattern("MM月dd日")) + " 周" + startTime.getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.SIMPLIFIED_CHINESE));
      info.setStartHour(startTime.format(DateTimeFormatter.ofPattern("HH:mm")));
      info.setEndDay(endTime.format(DateTimeFormatter.ofPattern("MM月dd日")) + " 周" + endTime.getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.SIMPLIFIED_CHINESE));
      info.setEndHour(endTime.format(DateTimeFormatter.ofPattern("HH:mm")));
      int hour = endTime.getHour() - startTime.getHour();
      int second = endTime.getSecond() - startTime.getSecond();
      info.setDuration(0 == hour ? String.format("%s分钟", second) : String.format("%s小时%s分钟", hour, second));
      return info;
   }
}