合并代码

Pu Zhibing

2024-10-16 c4664502dfdaffff555b532e65b51a57ac8b29c2

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

@@ -1,9 +1,7 @@
package com.ruoyi.order.service.impl;

import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -13,6 +11,7 @@
import com.ruoyi.account.api.vo.GetInviteUser;
import com.ruoyi.chargingPile.api.feignClient.*;
import com.ruoyi.chargingPile.api.model.*;
import com.ruoyi.chargingPile.api.vo.GetChargingGunByCode;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.dto.ChargingOrderGroup;
import com.ruoyi.common.core.dto.ChargingPercentProvinceDto;
@@ -34,12 +33,12 @@
import com.ruoyi.order.api.dto.SettlementConfirmAdd;
import com.ruoyi.order.api.feignClient.AccountingStrategyDetailOrderClient;
import com.ruoyi.order.api.feignClient.AccountingStrategyOrderClient;
import com.ruoyi.order.api.feignClient.ChargingOrderAccountingStrategyClient;
import com.ruoyi.order.api.model.*;
import com.ruoyi.order.api.query.ChargingOrderQuery;
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.PlatformStopChargingReplyVO;
import com.ruoyi.order.dto.*;
import com.ruoyi.order.mapper.TChargingOrderMapper;
import com.ruoyi.order.mapper.TSettlementConfirmMapper;
@@ -48,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.*;
@@ -57,19 +57,15 @@
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 com.sun.org.apache.bcel.internal.generic.NEW;
import io.seata.spring.annotation.GlobalTransactional;
import io.swagger.annotations.ApiModelProperty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
@@ -78,6 +74,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;
@@ -102,8 +100,7 @@

   @Resource
   private SiteClient siteClient;


	
   @Resource
   private AppUserCarClient appUserCarClient;
   @Resource
@@ -144,16 +141,12 @@

   @Resource
   private TOrderEvaluateService orderEvaluateService;


	
   @Resource
   private AccountingStrategyDetailClient accountingStrategyDetailClient;

   @Resource
   private AccountingStrategyDetailOrderClient accountingStrategyDetailOrderClient;
	
   @Resource
   private AccountingStrategyOrderClient accountingStrategyOrderClient;

   @Resource
   private AccountingStrategyClient accountingStrategyClient;
@@ -190,9 +183,15 @@
   
   @Resource
   private AppUserTagClient appUserTagClient;
	
   @Resource
   private SecurityDetectionClient securityDetectionClient;

   //计数器
   private Map<String, Integer> counter_map = new HashMap<>();
	
   //计数器
   private Map<String, Integer> boot_failed_map = new HashMap<>();



@@ -433,6 +432,7 @@
      chargingOrder.setAppUserId(userId);
      chargingOrder.setAppUserCarId(addChargingOrder.getAppUserCarId());
      TChargingGun tChargingGun = chargingGunClient.getChargingGunById(addChargingOrder.getId()).getData();
      TChargingPile chargingPile = chargingPileClient.getChargingPileById(tChargingGun.getChargingPileId()).getData();
      chargingOrder.setSiteId(tChargingGun.getSiteId());
      chargingOrder.setChargingPileId(tChargingGun.getChargingPileId());
      chargingOrder.setChargingGunId(addChargingOrder.getId());
@@ -442,6 +442,8 @@
      chargingOrder.setAppCouponId(addChargingOrder.getAppUserCouponId());
      chargingOrder.setVipDiscount(new BigDecimal(10));
      chargingOrder.setVipDiscountAmount(BigDecimal.ZERO);
      chargingOrder.setOrderSource(0);
      chargingOrder.setTitle("【充电桩充电】" + chargingPile.getNumber() + "号桩/" + tChargingGun.getCode() + "号枪");
      
      Site site = siteClient.getSiteByIds(Arrays.asList(tChargingGun.getSiteId())).getData().get(0);
      Integer accountingStrategyId = tChargingGun.getAccountingStrategyId();
@@ -453,7 +455,7 @@
      
      //直营站点才可以享受会员折扣
      if(null != appUser.getVipId() && 1 == site.getBusinessCategory()){
         TVip vip = vipClient.getInfo(appUser.getVipId()).getData();
         TVip vip = vipClient.getInfo1(appUser.getVipId()).getData();
         BigDecimal discount = null;
         if(1 == vip.getType()){
            //普通会员折扣使用积分策略上的折扣，且有最高优惠金额
@@ -498,7 +500,7 @@
         paymentOrder.setAmount(addChargingOrder.getPaymentAmount());
         paymentOrder.setOpenId(appUser.getWxOpenid());
         paymentOrder.setDescription("充电充值");
         paymentOrder.setNotifyUrl("/order/t-charging-order/chargingOrderWXCallback");
         paymentOrder.setNotifyUrl("/payment/wx/pay/notify");
         Map<String, Object> data = wxPaymentClient.orderPay(paymentOrder).getData();
         return AjaxResult.success(data);
      }
@@ -511,7 +513,7 @@
         req.setBody("充电充值");
         AliPaymentResp data = aliPaymentClient.payment(req).getData();
         if(null != data){
            data.setNotifyUrl(data.getNotifyUrl() + "/t-charging-order/chargingOrderALICallback");
            data.setNotifyUrl(data.getNotifyUrl() + "/order/t-charging-order/chargingOrderALICallback");
            return AjaxResult.success(data);
         }
      }
@@ -545,79 +547,94 @@
      preChargeCheck.setSecureConnectionDetection(false);
      preChargeCheck.setStartupSuccess(1);
      String key = "AQJC_" + chargingOrder.getChargingGunId();
      redisService.setCacheObject(key, preChargeCheck);
      redisService.setCacheObject(key, preChargeCheck, 24L, TimeUnit.HOURS);
      
      //根据当前充值的金额和计费模板算出充电的金额
      BigDecimal rechargeAmount = chargingOrder.getRechargeAmount();
      BigDecimal rechargeAmount1 = new BigDecimal(rechargeAmount.toString());
      Long now = System.currentTimeMillis();
      SimpleDateFormat sdf = new SimpleDateFormat("HHmm");
      Long now = Long.valueOf(sdf.format(new Date()));
      Long nowTimeMillis = System.currentTimeMillis();
      //根据支付金额，获取出使用的计费策略明细
      //计算电费金额和服务费
      BigDecimal serviceCharge = BigDecimal.ZERO;
      BigDecimal electrovalence = BigDecimal.ZERO;
      BigDecimal discountAmount = BigDecimal.ZERO;
      BigDecimal discount = chargingOrder.getVipDiscount();
      //先根据额定功率计算出每秒充电度数，然后计算出支付金额能充多少度电
      TChargingGun tChargingGun = chargingGunClient.getChargingGunById(chargingOrder.getChargingGunId()).getData();
      BigDecimal s_degrees = tChargingGun.getRatedPower().divide(new BigDecimal(3600));
		
      //1秒充电度数
      BigDecimal s_degrees = tChargingGun.getRatedPower().divide(new BigDecimal(3600), 6, RoundingMode.HALF_EVEN);
      
      TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
      List<AccountingStrategyDetailOrder> list = accountingStrategyDetailOrderClient.getAllAccountingStrategyDetailOrder(chargingOrder.getId()).getData();
      for (AccountingStrategyDetailOrder accountingStrategyDetailOrder : list) {
         AccountingStrategyOrder accountingStrategyOrder = accountingStrategyOrderClient.getAccountingStrategyOrderById(accountingStrategyDetailOrder.getAccountingStrategyOrderId()).getData();
         Integer start = Integer.valueOf(accountingStrategyDetailOrder.getStartTime().replaceAll(":", ""));
         String[] split = accountingStrategyDetailOrder.getEndTime().split(":");
         if(now >= start){
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
            calendar.set(Calendar.MINUTE, Integer.valueOf(split[1]));
            //到此策略结束的秒数
            long m = (calendar.getTimeInMillis() - now) / 1000;
            //每度电的单价
            BigDecimal total_unit = accountingStrategyDetailOrder.getElectrovalence().add(accountingStrategyDetailOrder.getServiceCharge());
            //每秒需要支付的金额
            BigDecimal multiply = s_degrees.multiply(total_unit);
            //计算充值金额能充多长时间的电
            long times = rechargeAmount1.divide(multiply, 0, RoundingMode.DOWN).longValue();
            if(times > m){
               //充电时间跨度两个计费策略，需要继续对下一个策略进行计算
               electrovalence = accountingStrategyDetailOrder.getElectrovalence().multiply(s_degrees).multiply(new BigDecimal(m));
               serviceCharge = accountingStrategyDetailOrder.getServiceCharge().multiply(s_degrees).multiply(new BigDecimal(m));
               discountAmount = discountAmount.add(serviceCharge.multiply((new BigDecimal(10).subtract(discount)).divide(new BigDecimal(10))));
               rechargeAmount1 = rechargeAmount1.subtract(multiply.multiply(new BigDecimal(m)));
            }else{
               electrovalence = accountingStrategyDetailOrder.getElectrovalence().multiply(s_degrees).multiply(new BigDecimal(times));
               serviceCharge = accountingStrategyDetailOrder.getServiceCharge().multiply(s_degrees).multiply(new BigDecimal(times));
               discountAmount = discountAmount.add(serviceCharge.multiply((new BigDecimal(10).subtract(discount)).divide(new BigDecimal(10))));
               break;
      //判断会员是否还有充电优惠次数，计算会员优惠的折扣金额
      if(null != appUser.getVipId()){
         GetAppUserVipDetail getAppUserVipDetail = new GetAppUserVipDetail();
         getAppUserVipDetail.setAppUserId(chargingOrder.getAppUserId());
         getAppUserVipDetail.setVipId(appUser.getVipId());
         TAppUserVipDetail data = appUserVipDetailClient.getAppUserVipDetail(getAppUserVipDetail).getData();
         if(null != data && data.getChargeNum() > 0){
            //计算折扣
            List<AccountingStrategyDetailOrder> list = accountingStrategyDetailOrderClient.getAllAccountingStrategyDetailOrder(chargingOrder.getId()).getData();
            //将数据叠加两份，处理跨天的情况
            list.addAll(list);
            boolean sta = false;
            for (AccountingStrategyDetailOrder accountingStrategyDetailOrder : list) {
               Integer start = Integer.valueOf(accountingStrategyDetailOrder.getStartTime().replaceAll(":", ""));
               Integer end = Integer.valueOf(accountingStrategyDetailOrder.getEndTime().replaceAll(":", ""));
               String[] split = accountingStrategyDetailOrder.getEndTime().split(":");
               if(sta || now >= start){
                  sta = true;
						
                  Calendar end_calendar = Calendar.getInstance();
                  end_calendar.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
                  end_calendar.set(Calendar.MINUTE, Integer.valueOf(split[1]));
                  //到此策略结束的秒数
                  if(null == nowTimeMillis){
                     String[] split1 = accountingStrategyDetailOrder.getStartTime().split(":");
                     Calendar start_calendar = Calendar.getInstance();
                     start_calendar.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split1[0]));
                     start_calendar.set(Calendar.MINUTE, Integer.valueOf(split1[1]));
                     nowTimeMillis = start_calendar.getTimeInMillis();
                  }
                  //间隔秒数
                  long m = (end_calendar.getTimeInMillis() - nowTimeMillis) / 1000;
                  //每秒需要支付的服务费金额
                  BigDecimal total_until = accountingStrategyDetailOrder.getElectrovalence().add(accountingStrategyDetailOrder.getServiceCharge());
                  BigDecimal s_total_amount = s_degrees.multiply(total_until);
                  //每秒需要支付的服务费金额
                  BigDecimal s_server_amount = s_degrees.multiply(accountingStrategyDetailOrder.getServiceCharge());
                  //计算剩余金额能充多长时间的电
                  long times = rechargeAmount1.divide(s_server_amount, 0, RoundingMode.DOWN).longValue();
                  if(times > m){
                     //充电时间跨度两个计费策略，需要继续对下一个策略进行计算
                     serviceCharge = s_server_amount.multiply(new BigDecimal(m));
                     discountAmount = discountAmount.add(serviceCharge.multiply((new BigDecimal(10).subtract(discount)).divide(new BigDecimal(10))));
                     rechargeAmount1 = rechargeAmount1.subtract(s_total_amount.multiply(new BigDecimal(m)));
                     nowTimeMillis = null;
                  }else{
                     serviceCharge = s_server_amount.multiply(new BigDecimal(times));
                     discountAmount = discountAmount.add(serviceCharge.multiply((new BigDecimal(10).subtract(discount)).divide(new BigDecimal(10))));
                     break;
                  }
               }
            }
            if(discountAmount.compareTo(BigDecimal.ZERO) >= 0){
               //计算会员最大优惠金额
               TVip vip = vipClient.getInfo1(appUser.getVipId()).getData();
               BigDecimal maximumDeduction = vip.getMaximumDeduction();
               //普通会员有最高优惠限制
               if(vip.getType() == 1 && discountAmount.compareTo(maximumDeduction) > 0){
                  discountAmount = maximumDeduction;
               }
            }
            discountAmount = discountAmount.setScale(4, RoundingMode.HALF_EVEN);
         }
      }
      if(discountAmount.compareTo(BigDecimal.ZERO) >= 0){
         //计算会员最大优惠金额
         if(null != appUser.getVipId()){
            TVip vip = vipClient.getInfo(appUser.getVipId()).getData();
            BigDecimal maximumDeduction = vip.getMaximumDeduction();
            //普通会员有最高优惠限制
            if(vip.getType() == 1 && discountAmount.compareTo(maximumDeduction) > 0){
               discountAmount = maximumDeduction;
            }
				
            //判断会员是否还有充电优惠次数
            GetAppUserVipDetail getAppUserVipDetail = new GetAppUserVipDetail();
            getAppUserVipDetail.setAppUserId(chargingOrder.getAppUserId());
            getAppUserVipDetail.setVipId(appUser.getVipId());
            TAppUserVipDetail data = appUserVipDetailClient.getAppUserVipDetail(getAppUserVipDetail).getData();
            if(data.getChargeNum() > 0){
               data.setChargeNum(data.getChargeNum() - 1);
               appUserVipDetailClient.updateAppUserVipDetail(data);
               //会员有充电优惠次数，直接将优惠金额加入到充电费用中增加充电时长
               electrovalence = electrovalence.add(discountAmount);
            }
         }
      }
      chargingOrder.setChargeAmount(electrovalence);
		
		
      //机子上显示的金额为用户充值的金额+会员折扣金额
      BigDecimal account_balance = chargingOrder.getRechargeAmount().add(discountAmount).setScale(4, RoundingMode.HALF_EVEN);
      chargingOrder.setChargeAmount(account_balance);
      chargingOrder.setVipDiscountAmount(discountAmount);
      this.updateById(chargingOrder);

@@ -630,63 +647,184 @@
      platformStartCharging.setCharging_gun_code(tChargingGun.getCode());
      //使用订单id作为逻辑卡号
      platformStartCharging.setCard_number(chargingOrder.getId().toString());
      platformStartCharging.setAccount_balance(electrovalence);
      platformStartCharging.setAccount_balance(account_balance);
		
      log.error(chargingOrder.getCode() + "：-------------------远程调起开始充电请求-------------------" + platformStartCharging.toString());
      sendMessageClient.platformStartCharging(platformStartCharging);
      //异步线程检测远程启动的应答结果。如果失败，则需要全额退款
      String code = chargingOrder.getCode();
      Long id = chargingOrder.getId();
      //执行5分钟的定时任务检测
      ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
      scheduler.scheduleAtFixedRate(()->{
         List<PlatformStartChargingReply> data = platformStartChargingReplyClient.getPlatformStartChargingReply(code).getData();
         if(data.size() != 0){
            PlatformStartChargingReply platformStartChargingReply = data.get(1);
            Integer startup_result = platformStartChargingReply.getStartup_result();
            Integer failure_cause = platformStartChargingReply.getFailure_cause();
            Integer counter = counter_map.get(code);
            PreChargeCheck preChargeCheck1 = redisService.getCacheObject(key);
            //状态为5的时候，硬件会间隔60秒后再次检测，依然未插枪，则不启动充电
            //因这里是间隔5秒执行检测，所以累计次数在30次以上
            if(failure_cause == 5 && (null == counter || counter < 35)){
               counter++;
               counter_map.put(code, counter);
               //启动失败
               preChargeCheck1.setStartupSuccess(3);
               preChargeCheck1.setFailureCause(failure_cause);
               redisService.setCacheObject(key, preChargeCheck1);
               return;
            }
            //清除计时器中的无效数据
            counter_map.remove(code);
            //开始处理退款
            TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, code));
            if(0 == startup_result){
               //启动失败
               preChargeCheck1.setStartupSuccess(3);
               preChargeCheck1.setFailureCause(failure_cause);
               //启动失败后取消订单，退款操作
               refund(code);
               order.setStatus(-1);
               order.setEndMode(0);
            }else{
               preChargeCheck1.setStartupSuccess(2);
               order.setStatus(3);
               order.setStartTime(LocalDateTime.now());
            }
            this.updateById(order);
            redisService.setCacheObject(key, preChargeCheck1);
            //提前结束定时任务
         if(timingDetection(id)){
            scheduler.shutdown();
         }
      }, 5, 300, TimeUnit.SECONDS);
      }, 5, 1, TimeUnit.SECONDS);
      return AjaxResult.success();
   }
   
	
   /**
    * 定时检测mongodb数据库数据
    * @param id
    * @return
    */
   public boolean timingDetection(Long id){
      TChargingOrder chargingOrder = this.getById(id);
      if(chargingOrder.getStatus() != 2){
         return true;
      }
      String code = chargingOrder.getCode();
      String key = "AQJC_" + chargingOrder.getChargingGunId();
      //获取安全校验
      com.ruoyi.integration.api.model.SecurityDetection securityDetection = securityDetectionClient.getSecurityDetection(chargingOrder.getCode()).getData();
      if(null != securityDetection){
         PreChargeCheck preChargeCheck1 =  redisService.getCacheObject("AQJC_" + chargingOrder.getChargingGunId());
         if(null != preChargeCheck1){
            preChargeCheck1.setElectronicLockLock(true);
            preChargeCheck1.setInsulationTesting(true);
            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();
      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();
         Integer failure_cause = platformStartChargingReply.getFailure_cause();
         Integer counter = counter_map.get(code);
         PreChargeCheck preChargeCheck1 = redisService.getCacheObject(key);
         //5分钟内还未插枪则取消充电，退回金额。
         if(failure_cause == 5 && (null == counter || counter < 300)){
            counter = (null == counter ? 0 : counter) + 1;
            counter_map.put(code, counter);
            //启动失败
            preChargeCheck1.setStartupSuccess(3);
            preChargeCheck1.setFailureCause(failure_cause);
            redisService.setCacheObject(key, preChargeCheck1, 24L, TimeUnit.HOURS);
            return false;
         }
			
         //清除计时器中的无效数据
         counter_map.remove(code);
         TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, code));
         if(0 == startup_result){
            //启动失败
            preChargeCheck1.setStartupSuccess(3);
            preChargeCheck1.setFailureCause(failure_cause);
            //启动失败后取消订单，退款操作
            refund(code);
            order.setStatus(-1);
            order.setEndMode(0);
         }else{
            //启动成功
            preChargeCheck1.setStartupSuccess(2);
            order.setStatus(3);
            order.setStartTime(LocalDateTime.now());
         }
         this.updateById(order);
         redisService.setCacheObject(key, preChargeCheck1, 24L, TimeUnit.HOURS);
         return true;
      }else{
         Integer counter = boot_failed_map.get(code);
         log.error(code + "：-------------------未上传开启充电结果-------------------" + counter);
         PreChargeCheck preChargeCheck1 = redisService.getCacheObject(key);
         //5分钟内未启动成功，退回金额。
         if(null == counter || counter < 300){
            counter = (null == counter ? 0 : counter) + 1;
            boot_failed_map.put(code, counter);
            //启动失败
            preChargeCheck1.setStartupSuccess(3);
            preChargeCheck1.setFailureCause(0);
            redisService.setCacheObject(key, preChargeCheck1, 24L, TimeUnit.HOURS);
            return false;
         }
			
         //清除计时器中的无效数据
         boot_failed_map.remove(code);
         TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, code));
         //启动失败
         preChargeCheck1.setStartupSuccess(3);
         preChargeCheck1.setFailureCause(0);
         //启动失败后取消订单，退款操作
         refund(code);
         order.setStatus(-1);
         order.setEndMode(0);
         this.updateById(order);
         redisService.setCacheObject(key, preChargeCheck1, 24L, TimeUnit.HOURS);
         return true;
      }
   }
	
	
   /**
    * 修改安全检测数据
    * @param securityDetection
    */
   @Override
   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());
      if(null != preChargeCheck1){
         preChargeCheck1.setElectronicLockLock(true);
         preChargeCheck1.setInsulationTesting(true);
         preChargeCheck1.setSecureConnectionDetection(securityDetection.getSecure_connection() == 1);
         redisService.setCacheObject("AQJC_" + chargingGun.getId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      }
   }
	
   /**
    * 启动充电应答
    * @param message
    */
   @Override
   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()));
      if(order.getStatus() != 2){
         return;
      }
      String code = order.getCode();
      PreChargeCheck preChargeCheck1 =  redisService.getCacheObject("AQJC_" + order.getChargingGunId());
      if(null != preChargeCheck1){
         preChargeCheck1.setElectronicLockLock(true);
         preChargeCheck1.setInsulationTesting(true);
         preChargeCheck1.setStartupSuccess(1);
      }
      if(0 == startup_result){
         //启动失败
         preChargeCheck1.setStartupSuccess(3);
         preChargeCheck1.setFailureCause(failure_cause);
         //启动失败后取消订单，退款操作
         refund(code);
         order.setStatus(-1);
         order.setEndMode(0);
      }else{
         //启动成功
         preChargeCheck1.setStartupSuccess(2);
         order.setStatus(3);
         order.setStartTime(LocalDateTime.now());
      }
      redisService.setCacheObject("AQJC_" + order.getChargingGunId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      this.updateById(order);
   }
   
   /**
    * 启动失败后的退款，取消订单
    * @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();
@@ -712,7 +850,7 @@
            model.setOut_trade_no(chargingOrder.getCode());
            model.setOut_refund_no(chargingOrderRefund.getRefundCode());
            model.setReason("充电失败，取消充电订单");
            model.setNotify_url("/order/t-charging-order/chargingOrderStartupFailureWxRefund");
            model.setNotify_url("/payment/wx/refund/notify");
            WxPaymentRefundModel.RefundAmount amount = new WxPaymentRefundModel.RefundAmount();
            amount.setRefund(rechargeAmount.multiply(new BigDecimal(100)).intValue());
            amount.setTotal(rechargeAmount.multiply(new BigDecimal(100)).intValue());
@@ -752,13 +890,11 @@
    * @return
    */
   public AjaxResult chargingOrderStartupFailureWxRefund(String out_refund_no, String refund_id, String tradeState, String success_time){
      if("SUCCESS".equals(tradeState)){
         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")));
         chargingOrderRefundService.updateById(one);
      }
      TChargingOrderRefund one = chargingOrderRefundService.getOne(new LambdaQueryWrapper<TChargingOrderRefund>().eq(TChargingOrderRefund::getRefundCode, out_refund_no));
      one.setRefundSerialNumber(refund_id);
      one.setRefundStatus(2);
      one.setRefundTime(LocalDateTime.now());
      chargingOrderRefundService.updateById(one);
      return AjaxResult.success();
   }

@@ -774,7 +910,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::getStartTime).last(" limit 0, 1"));
      if(null == one){
         return null;
      }
@@ -821,13 +957,98 @@
   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.setStatus(4);
      chargingOrder.setEndTime(LocalDateTime.now());
      chargingOrder.setEndMode(1);
      this.updateById(chargingOrder);
      
      String code1 = chargingOrder.getCode();
      TChargingGun chargingGun = chargingGunClient.getChargingGunById(chargingOrder.getChargingGunId()).getData();
      //异步线程处理停机
      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());
         //开始查询停机应答，成功后开始计费费用
         boolean stop_status = false;
         for (int i = 0; i < 60; i++) {
            TChargingOrder chargingOrder1 = this.getById(id);
            if(chargingOrder1.getStatus() != 3){
               stop_status = true;
               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);
               }
            }else{
               log.error(code1 + "：-------------------远程停止充电请求成功-------------------");
               stop_status = true;
               break;
            }
         }
         if(stop_status){
            chargingOrder.setEndMode(1);
            this.updateById(chargingOrder);
         }else{
            log.error(code1 + "：-------------------远程停止充电应答最终失败-------------------");
         }
      });
      return AjaxResult.success();
   }
	
	
   /**
    * 结束充电后处理用户标签数据
    * @param chargingOrder
    */
   public void editUserTag(TChargingOrder chargingOrder){
      //处理用户标签数据
      List<TUserTag> data = userTagClient.getAllUserTag().getData();
      //累计充电次数
@@ -884,60 +1105,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);
            }

            //计算费用，处理退款
            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())
@@ -950,7 +1125,7 @@
         
         TAppUser appUser1 = appUserClient.getUserById(appUser.getInviteUserId()).getData();
         if(null != appUser1.getVipId()){
            TVip vip = vipClient.getInfo(appUser1.getVipId()).getData();
            TVip vip = vipClient.getInfo1(appUser1.getVipId()).getData();
            Integer doubleIntegration = vip.getDoubleIntegration();
            //双倍积分
            if(1 == doubleIntegration){
@@ -981,172 +1156,60 @@
         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
    */
   @GlobalTransactional(rollbackFor = Exception.class)
   public void endCharge(TChargingOrder chargingOrder){
      //如果使用优惠券需要判断优惠券是否满足使用条件
      //根据实际的充电金额计算退款金额   退回费用=(原金额/总金额)*(总金额-实际充电金额)
      //退款金额=优惠券金额+剩余充电金额
      List<TChargingOrderAccountingStrategy> list = chargingOrderAccountingStrategyService.list(new LambdaQueryWrapper<TChargingOrderAccountingStrategy>().eq(TChargingOrderAccountingStrategy::getChargingOrderId, chargingOrder.getId()));
      BigDecimal total = BigDecimal.ZERO;
      for (TChargingOrderAccountingStrategy chargingOrderAccountingStrategy : list) {
         BigDecimal periodElectricPrice = chargingOrderAccountingStrategy.getPeriodElectricPrice();
         BigDecimal periodServicePrice = chargingOrderAccountingStrategy.getPeriodOriginalServicePrice();
         total = total.add(periodElectricPrice).add(periodServicePrice);
      }
      BigDecimal rechargeAmount = chargingOrder.getRechargeAmount();
      BigDecimal vipDiscountAmount = chargingOrder.getVipDiscountAmount();
      BigDecimal decimal = rechargeAmount.add(vipDiscountAmount);
      //退款金额（已经计算了折扣优惠部分）
      BigDecimal refundAmount = rechargeAmount.divide(decimal, new MathContext(4, RoundingMode.HALF_EVEN)).multiply(decimal.subtract(total));
      BigDecimal payAmount = BigDecimal.valueOf(total.doubleValue());
      BigDecimal orderAmount = BigDecimal.valueOf(total.doubleValue());
      if(null != chargingOrder.getVipDiscount()){
         orderAmount = orderAmount.divide(chargingOrder.getVipDiscount().divide(new BigDecimal(10)));
         chargingOrder.setOrderAmount(total);
      }

      if(chargingOrder.getEndMode() == 2){
         chargingOrder.setEndMode(refundAmount.compareTo(BigDecimal.ZERO) > 0 ? 2 : 3);
      }
      chargingOrder.setStatus(5);
      chargingOrder.setPaymentAmount(payAmount);
      this.updateById(chargingOrder);
		
      //添加积分
      TIntegralRule integralRule = integralRuleClient.getSet().getData();
      if(null != integralRule){
         TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
         Integer num1 = JSON.parseObject(integralRule.getChargeCredit()).getInteger("num1");
         Integer integral = payAmount.multiply(new BigDecimal(num1)).intValue();
         if(null != appUser.getVipId()){
            TVip vip = vipClient.getInfo(appUser.getVipId()).getData();
            Integer doubleIntegration = vip.getDoubleIntegration();
            //双倍积分
            if(1 == doubleIntegration){
               integral *= 2;
            }
         }
			
         TAppUserIntegralChange appUserIntegralChange = new TAppUserIntegralChange();
         appUserIntegralChange.setAppUserId(appUser.getId());
         appUserIntegralChange.setChangeType(2);
         appUserIntegralChange.setHistoricalIntegral(appUser.getPoints());
         appUser.setPoints(appUser.getPoints() + integral);
         appUserIntegralChange.setCurrentIntegral(appUser.getPoints());
         appUserIntegralChange.setCreateTime(LocalDateTime.now());
         appUserClient.updateAppUser(appUser);
         appUserIntegralChangeClient.addAppUserIntegralChange(appUserIntegralChange);
   @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;
      }
      
      //计算优惠券
      if(null != chargingOrder.getAppCouponId()){
         //判断实际充电金额是否满足优惠券使用条件，如果不满足则不适用优惠券。
         TAppCoupon appCoupon = appCouponClient.getAppCouponById(chargingOrder.getAppCouponId()).getData();
         String couponJson = appCoupon.getCouponJson();
         TCoupon tCoupon = JSON.parseObject(couponJson, TCoupon.class);
         Integer preferentialMode = tCoupon.getPreferentialMode();
         if(1 == preferentialMode){
            //满减
            if(total.compareTo(tCoupon.getMeetTheConditions()) >= 0){
               refundAmount = refundAmount.add(tCoupon.getDiscountAmount());
               chargingOrder.setCouponDiscountAmount(tCoupon.getDiscountAmount());
               payAmount = payAmount.subtract(tCoupon.getDiscountAmount());
            }else{
               chargingOrder.setAppCouponId(null);
               chargingOrder.setCouponDiscountAmount(BigDecimal.ZERO);
               appCouponClient.refund(chargingOrder.getAppCouponId().toString());
            }
      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;
         }
         if(2 == preferentialMode){
            //抵扣
            if(total.compareTo(tCoupon.getMeetTheConditions()) >= 0){
               //折扣金额
               BigDecimal divide = total.multiply(new BigDecimal(10).subtract(tCoupon.getDiscount())).divide(new BigDecimal(10));
               divide = divide.compareTo(tCoupon.getMaximumDiscountAmount()) > 0 ? tCoupon.getMaximumDiscountAmount() : divide;
               refundAmount = refundAmount.add(divide);
               chargingOrder.setCouponDiscountAmount(divide);
               payAmount = payAmount.subtract(divide);
            }else{
               chargingOrder.setAppCouponId(null);
               chargingOrder.setCouponDiscountAmount(BigDecimal.ZERO);
               appCouponClient.refund(chargingOrder.getAppCouponId().toString());
            }
         }
         log.error(code1 + "：停机失败：订单号：{}，失败原因：{}", order.getCode(), failure_cause);
      }else{
         TChargingOrder chargingOrder = new TChargingOrder();
         chargingOrder.setId(order.getId());
         chargingOrder.setAppUserId(order.getAppUserId());
         chargingOrder.setEndMode(1);
         this.updateById(chargingOrder);
      }

      if(null != chargingOrder.getVipDiscount()){
         BigDecimal subtract = orderAmount.subtract(total);
         chargingOrder.setVipDiscountAmount(subtract);
         payAmount = payAmount.subtract(subtract);
      }
      //开始构建退款费用
      if(refundAmount.compareTo(BigDecimal.ZERO) > 0){
         Integer rechargePaymentType = chargingOrder.getRechargePaymentType();
         //构建退款明细
         TChargingOrderRefund chargingOrderRefund = new TChargingOrderRefund();
         chargingOrderRefund.setChargingOrderId(chargingOrder.getId());
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
         chargingOrderRefund.setRefundCode("CDF" + sdf.format(new Date()) + (Double.valueOf(Math.random() * 1000).intValue()));
         chargingOrderRefund.setRefundAmount(refundAmount);
         chargingOrderRefund.setRefundStatus(1);
         chargingOrderRefund.setPayType(rechargePaymentType);
         chargingOrderRefund.setRefundStatus(1);
         chargingOrderRefund.setCode(chargingOrder.getCode());
         chargingOrderRefund.setRefundTitle("充电完成退款");
         chargingOrderRefund.setRefundContent("充电完成退款");
         chargingOrderRefund.setRefundReason("充电完成退款");
         chargingOrderRefund.setRefundRemark("充电完成退款");
         chargingOrderRefund.setRefundTotalAmount(refundAmount);
         chargingOrderRefund.setPayAmount(rechargeAmount);
         if(1 == rechargePaymentType){
            WxPaymentRefundModel model = new WxPaymentRefundModel();
            model.setOut_trade_no(chargingOrder.getCode());
            model.setOut_refund_no(chargingOrderRefund.getRefundCode());
            model.setReason("充电完成退款");
            model.setNotify_url("http://221.182.45.100:9000/order/t-charging-order/chargingOrderStartupFailureWxRefund");
            WxPaymentRefundModel.RefundAmount amount = new WxPaymentRefundModel.RefundAmount();
            amount.setRefund(refundAmount.multiply(new BigDecimal(100)).intValue());
            amount.setTotal(rechargeAmount.multiply(new BigDecimal(100)).intValue());
            amount.setCurrency("CNY");
            model.setAmount(amount);
            R<String> orderR = wxPaymentClient.refundOrderR(model);
            if(200 == orderR.getCode()){
               chargingOrderRefundService.save(chargingOrderRefund);
            }
         }
         if(2 == rechargePaymentType){
            RefundReq dto = new RefundReq();
            dto.setOutTradeNo(chargingOrder.getCode());
            dto.setOutRequestNo(chargingOrderRefund.getCode());
            dto.setRefundAmount(rechargeAmount.toString());
            dto.setRefundReason("充电完成退款");
            RefundResp resp = aliPaymentClient.refund(dto).getData();
            if(null != resp){
               SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-DDTHH:mm:ss+TIMEZONE");
               AjaxResult success = chargingOrderStartupFailureWxRefund(resp.getOutTradeNo(), resp.getTradeNo(), "SUCCESS", sdf1.format(new Date()));
               if(success.isSuccess()){
                  chargingOrderRefundService.save(chargingOrderRefund);
               }
            }
         }

      }

		
   }
	
	



@@ -1190,6 +1253,12 @@
      for (ChargingOrderVO chargingOrderVO : list) {
         TChargingGun data3 = chargingGunClient.getChargingGunById(chargingOrderVO.getChargingGunId()).getData();
         TChargingPile data2 = chargingPileClient.getChargingPileById(chargingOrderVO.getChargingPileId()).getData();
         if (chargingOrderVO.getSiteId()!=null){
            List<Integer> integers = new ArrayList<>();
            integers.add(chargingOrderVO.getSiteId());
            List<Site> data = siteClient.getSiteByIds(integers).getData();
            if (!data.isEmpty())chargingOrderVO.setSiteName(data.get(0).getName());
         }
         if (data2!=null && data3!=null){
            chargingOrderVO.setTerminalName(data2.getName()+"-"+data3.getName());

@@ -1205,7 +1274,9 @@
         // 单个订单累计服务费
         BigDecimal serviceMoney1 = new BigDecimal("0");
         UploadRealTimeMonitoringData data5 = uploadRealTimeMonitoringDataClient.chargingOrderInfo(chargingOrderVO.getCode()).getData();
         chargingOrderVO.setChargingSecond(data5.getTime_remaining()*60L);
         if (data5!=null){
            chargingOrderVO.setChargingSecond(data5.getTime_remaining()*60L);
         }
         // 总收入
         if (chargingOrderVO.getRefundStatus() !=null && chargingOrderVO.getRefundStatus() == 2){
            income = income.add(chargingOrderVO.getPaymentAmount().subtract(chargingOrderVO.getRefundAmount()));
@@ -1316,13 +1387,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;
@@ -1537,10 +1603,8 @@
      return chargingOrderTimeVO;
   }

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

	

   @Override
   public ChargingOrderListInfoVO chargingInfo(String uid) {
@@ -1629,23 +1693,23 @@
    */
   @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());
            //已充电总度数
            BigDecimal charging_degree = query.getCharging_degree();
            BigDecimal electrovalenc = strategyDetail.getElectrovalence().multiply(charging_degree);
            BigDecimal originalServicePrice = strategyDetail.getServiceCharge().multiply(charging_degree);
@@ -1662,35 +1726,40 @@
            chargingOrderAccountingStrategyService.save(chargingOrderAccountingStrategy);
         }else{
            if(chargingOrderAccountingStrategy.getAccountingStrategyDetailId().equals(strategyDetail.getId())){
               BigDecimal periodServicePrice = chargingOrderAccountingStrategy.getPeriodServicePrice();
               BigDecimal periodElectricPrice = chargingOrderAccountingStrategy.getPeriodElectricPrice();
               BigDecimal periodOriginalServicePrice = chargingOrderAccountingStrategy.getPeriodOriginalServicePrice();
               //已充电总度数
               BigDecimal charging_degree = query.getCharging_degree();
               BigDecimal electrovalenc = strategyDetail.getElectrovalence().multiply(charging_degree);
               BigDecimal originalServicePrice = strategyDetail.getServiceCharge().multiply(charging_degree);
               BigDecimal chargingCapacity = chargingOrderAccountingStrategy.getChargingCapacity();
               //计算本阶段充电度数
               BigDecimal subtract = charging_degree.subtract(chargingCapacity);
               //计算本阶段费用
               BigDecimal electrovalenc = strategyDetail.getElectrovalence().multiply(subtract);
               BigDecimal originalServicePrice = strategyDetail.getServiceCharge().multiply(subtract);
               BigDecimal serviceCharge = originalServicePrice;
               //计算优惠金额
               if(null != chargingOrder.getVipDiscount()){
                  serviceCharge = serviceCharge.multiply(chargingOrder.getVipDiscount().divide(new BigDecimal(10)));
               }
               periodServicePrice = periodServicePrice.add(serviceCharge);
               periodOriginalServicePrice = periodOriginalServicePrice.add(originalServicePrice);
               periodElectricPrice = periodElectricPrice.add(electrovalenc);
               chargingOrderAccountingStrategy.setPeriodServicePrice(periodServicePrice);
               chargingOrderAccountingStrategy.setPeriodOriginalServicePrice(periodOriginalServicePrice);
               chargingOrderAccountingStrategy.setPeriodElectricPrice(periodElectricPrice);
               chargingOrderAccountingStrategy.setEndTime(sdf.format(new Date()));
               //将本阶段的费用增加到总费用中
               electrovalenc = electrovalenc.add(chargingOrderAccountingStrategy.getPeriodElectricPrice());
               originalServicePrice = originalServicePrice.add(chargingOrderAccountingStrategy.getPeriodOriginalServicePrice());
               serviceCharge = serviceCharge.add(chargingOrderAccountingStrategy.getPeriodServicePrice());
               chargingOrderAccountingStrategy.setChargingCapacity(charging_degree);
               chargingOrderAccountingStrategy.setPeriodElectricPrice(electrovalenc);
               chargingOrderAccountingStrategy.setPeriodServicePrice(serviceCharge);
               chargingOrderAccountingStrategy.setPeriodOriginalServicePrice(originalServicePrice);
               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.setElectrovalence(strategyDetail.getElectrovalence());
               chargingOrderAccountingStrategy1.setServiceCharge(strategyDetail.getServiceCharge());
               chargingOrderAccountingStrategy1.setCostServiceCharge(strategyDetail.getCostServiceCharge());
               chargingOrderAccountingStrategy = new TChargingOrderAccountingStrategy();
               chargingOrderAccountingStrategy.setChargingOrderId(chargingOrder.getId());
               chargingOrderAccountingStrategy.setAccountingStrategyDetailId(strategyDetail.getId());
               chargingOrderAccountingStrategy.setType(strategyDetail.getType());
               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());
               //已充电总度数
               BigDecimal charging_degree = query.getCharging_degree();
               BigDecimal electrovalenc = strategyDetail.getElectrovalence().multiply(charging_degree);
               BigDecimal originalServicePrice = strategyDetail.getServiceCharge().multiply(charging_degree);
@@ -1699,25 +1768,34 @@
               if(null != chargingOrder.getVipDiscount()){
                  serviceCharge = serviceCharge.multiply(chargingOrder.getVipDiscount().divide(new BigDecimal(10)));
               }
               chargingOrderAccountingStrategy1.setChargingCapacity(charging_degree);
               chargingOrderAccountingStrategy1.setPeriodElectricPrice(electrovalenc);
               chargingOrderAccountingStrategy1.setPeriodOriginalServicePrice(originalServicePrice);
               chargingOrderAccountingStrategy1.setPeriodServicePrice(serviceCharge);
               chargingOrderAccountingStrategy1.setCreateTime(LocalDateTime.now());
               chargingOrderAccountingStrategyService.save(chargingOrderAccountingStrategy1);
               chargingOrderAccountingStrategy.setChargingCapacity(charging_degree);
               chargingOrderAccountingStrategy.setPeriodElectricPrice(electrovalenc);
               chargingOrderAccountingStrategy.setPeriodServicePrice(serviceCharge);
               chargingOrderAccountingStrategy.setPeriodOriginalServicePrice(originalServicePrice);
               chargingOrderAccountingStrategy.setCreateTime(LocalDateTime.now());
               chargingOrderAccountingStrategyService.save(chargingOrderAccountingStrategy);
            }
         }

         List<TChargingOrderAccountingStrategy> list = chargingOrderAccountingStrategyService.list(new LambdaQueryWrapper<TChargingOrderAccountingStrategy>()
               .eq(TChargingOrderAccountingStrategy::getChargingOrderId, chargingOrder.getId()));
         //总充电金额
         BigDecimal t = BigDecimal.ZERO;
         for (TChargingOrderAccountingStrategy coas : list) {
            t = t.add(coas.getPeriodServicePrice()).add(coas.getPeriodElectricPrice());
         }
         BigDecimal residualAmount = chargingOrder.getRechargeAmount().subtract(t).setScale(2, RoundingMode.HALF_EVEN);
         BigDecimal residualAmount = chargingOrder.getRechargeAmount().subtract(t).setScale(4, RoundingMode.HALF_EVEN);
         chargingOrder.setResidualAmount(residualAmount);
         BigDecimal divide = query.getOutput_current().multiply(query.getOutput_voltage()).divide(new BigDecimal(1000));
         chargingOrder.setChargingPower(divide);
         if(query.getOutput_current().compareTo(BigDecimal.ZERO) != 0){
            BigDecimal divide = query.getOutput_current().multiply(query.getOutput_voltage()).divide(new BigDecimal(1000));
            chargingOrder.setChargingPower(divide);
            chargingOrder.setCurrent(query.getOutput_current());
            chargingOrder.setVoltage(query.getOutput_voltage());
            chargingOrder.setPower(query.getOutput_current().multiply(query.getOutput_voltage()));
            chargingOrder.setNeedElec(query.getOutput_current());
         }
         chargingOrder.setElectricity(query.getCharging_degree());
         chargingOrder.setTotalElectricity(new BigDecimal(100 - query.getSoc()));
         this.updateById(chargingOrder);
      }
   }
@@ -1730,67 +1808,12 @@
   @Override
   @GlobalTransactional(rollbackFor = Exception.class)
   public void endCharge(String orderCode, Integer endMode) {
      TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, orderCode));
      Integer status = chargingOrder.getStatus();
      if(status == 4 || status == 5){
         return;
      }
      chargingOrder.setStatus(5);
      TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, orderCode));
      TChargingOrder chargingOrder = new TChargingOrder();
      chargingOrder.setId(order.getId());
      chargingOrder.setAppUserId(order.getAppUserId());
      chargingOrder.setEndMode(endMode);
      this.updateById(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.getInfo(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);
      }
		
   }

   /**
@@ -1801,7 +1824,273 @@
   public void excelEndCharge(String orderCode) {
      endCharge(orderCode, 0);
   }

	
	
   /**
    * 停止充电返回账单后计算费用
    * @param vo
    */
   @Override
   @GlobalTransactional(rollbackFor = Exception.class)
   public void endChargeBillingCharge(TransactionRecordMessageVO vo) {
      TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, vo.getTransaction_serial_number()));
      Integer status = chargingOrder.getStatus();
      if(status == 4 || status == 5){
         return;
      }
		
      //计算用户标签
      editUserTag(chargingOrder);
      //用户推荐奖励
      referralReward(chargingOrder);
		
      //如果使用优惠券需要判断优惠券是否满足使用条件
      //根据实际的充电金额计算退款金额   退回费用=(原金额/总金额)*(总金额-实际充电金额)
      //退款金额=优惠券金额+剩余充电金额
      BigDecimal periodElectricPrice_total = BigDecimal.ZERO;
      BigDecimal periodServicePrice_total = BigDecimal.ZERO;
      BigDecimal total = BigDecimal.ZERO;
		
      //获取订单的计费策略
      List<AccountingStrategyDetailOrder> accountingStrategyDetailOrderList = accountingStrategyDetailOrderClient.getAllAccountingStrategyDetailOrder(chargingOrder.getId()).getData();
      chargingOrderAccountingStrategyService.remove(new LambdaQueryWrapper<TChargingOrderAccountingStrategy>().eq(TChargingOrderAccountingStrategy::getChargingOrderId, chargingOrder.getId()));
      for (int i = 0; i < 12; i++) {
         Class<? extends TransactionRecordMessageVO> clazz = vo.getClass();
         try {
            String time = (String) clazz.getMethod("getTime" + (i + 1)).invoke(vo);
            if(StringUtils.hasLength(time)){
               //充电度数
               Object invoke = clazz.getMethod("getSharp_peak_charge" + (i + 1)).invoke(vo);
               BigDecimal Sharp_peak_charge = new BigDecimal(invoke.toString());
               //充电金额
               Object invoke1 = clazz.getMethod("getSharp_peak_amount" + (i + 1)).invoke(vo);
               BigDecimal sharp_peak_amount = new BigDecimal(invoke1.toString());
					
               String[] split = time.split("~");
               AccountingStrategyDetailOrder strategyDetail = accountingStrategyDetailOrderList.stream().filter(s -> s.getStartTime().equals(split[1]) && s.getEndTime().equals(split[2])).findFirst().get();
					
               TChargingOrderAccountingStrategy chargingOrderAccountingStrategy = new TChargingOrderAccountingStrategy();
               chargingOrderAccountingStrategy.setChargingOrderId(chargingOrder.getId());
               chargingOrderAccountingStrategy.setAccountingStrategyDetailId(strategyDetail.getId());
               chargingOrderAccountingStrategy.setType(strategyDetail.getType());
               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());
               //已充电总度数
               BigDecimal electrovalenc = strategyDetail.getElectrovalence().multiply(Sharp_peak_charge);
               BigDecimal originalServicePrice = strategyDetail.getServiceCharge().multiply(Sharp_peak_charge);
               BigDecimal serviceCharge = originalServicePrice;
               //计算优惠金额
               if(null != chargingOrder.getVipDiscount()){
                  serviceCharge = serviceCharge.multiply(chargingOrder.getVipDiscount().divide(new BigDecimal(10)));
               }
               chargingOrderAccountingStrategy.setChargingCapacity(Sharp_peak_charge);
               chargingOrderAccountingStrategy.setPeriodElectricPrice(electrovalenc);
               chargingOrderAccountingStrategy.setPeriodServicePrice(serviceCharge);
               chargingOrderAccountingStrategy.setPeriodOriginalServicePrice(originalServicePrice);
               chargingOrderAccountingStrategy.setCreateTime(LocalDateTime.now());
               chargingOrderAccountingStrategyService.save(chargingOrderAccountingStrategy);
					
               BigDecimal periodElectricPrice = chargingOrderAccountingStrategy.getPeriodElectricPrice();
               BigDecimal periodServicePrice = chargingOrderAccountingStrategy.getPeriodOriginalServicePrice();
               periodElectricPrice_total = periodElectricPrice_total.add(periodElectricPrice);
               periodServicePrice_total = periodServicePrice_total.add(periodServicePrice);
               total = total.add(periodElectricPrice).add(periodServicePrice);
            }
         } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
         } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
         } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
         }
      }
		
		
      //原金额
      BigDecimal rechargeAmount = chargingOrder.getRechargeAmount();
      BigDecimal vipDiscountAmount = chargingOrder.getVipDiscountAmount();
      //总金额（充值金额+会员折扣金额）
      BigDecimal decimal = rechargeAmount.add(vipDiscountAmount);
      //退款金额（已经计算了折扣优惠部分）
      BigDecimal refundAmount = rechargeAmount.divide(decimal, new MathContext(4, RoundingMode.HALF_EVEN)).multiply(decimal.subtract(total));
      BigDecimal orderAmount = BigDecimal.valueOf(total.doubleValue());
      BigDecimal payAmount = BigDecimal.valueOf(total.doubleValue());
      //折扣金额
      BigDecimal discountAmount = BigDecimal.ZERO;
      if(null != chargingOrder.getVipDiscount()){
         //服务费折扣
         discountAmount = periodServicePrice_total.multiply((new BigDecimal(10).subtract(chargingOrder.getVipDiscount())).divide(new BigDecimal(10)));
			
         TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
         if(null != appUser.getVipId()){
            //判断会员是否还有充电优惠次数
            GetAppUserVipDetail getAppUserVipDetail = new GetAppUserVipDetail();
            getAppUserVipDetail.setAppUserId(chargingOrder.getAppUserId());
            getAppUserVipDetail.setVipId(appUser.getVipId());
            TAppUserVipDetail data = appUserVipDetailClient.getAppUserVipDetail(getAppUserVipDetail).getData();
            if(null != data && data.getChargeNum() > 0){
               data.setChargeNum(data.getChargeNum() - 1);
               appUserVipDetailClient.updateAppUserVipDetail(data);
            }
				
            TVip vip = vipClient.getInfo1(appUser.getVipId()).getData();
            BigDecimal maximumDeduction = vip.getMaximumDeduction();
            //普通会员有最高优惠限制
            if(vip.getType() == 1 && discountAmount.compareTo(maximumDeduction) > 0){
               discountAmount = maximumDeduction;
            }
         }
         payAmount = payAmount.subtract(discountAmount);
      }
		
      TChargingOrder order = new TChargingOrder();
      order.setId(chargingOrder.getId());
      order.setAppUserId(chargingOrder.getAppUserId());
      if(null != chargingOrder.getEndMode() && chargingOrder.getEndMode() == 2){
         order.setEndMode(refundAmount.compareTo(BigDecimal.ZERO) > 0 ? 2 : 3);
      }
      if(null == chargingOrder.getEndMode()){
         order.setEndMode(1);
      }
      order.setResidualAmount(rechargeAmount.subtract(total));
      order.setEndTime(LocalDateTime.now());
      order.setStatus(5);
      order.setOrderAmount(orderAmount);
      order.setVipDiscountAmount(discountAmount);
      order.setServiceCharge(periodServicePrice_total);
      order.setElectrovalence(periodElectricPrice_total);
		
      //计算优惠券
      if(null != chargingOrder.getAppCouponId()){
         //判断实际充电金额是否满足优惠券使用条件，如果不满足则不适用优惠券。
         TAppCoupon appCoupon = appCouponClient.getAppCouponById(chargingOrder.getAppCouponId()).getData();
         String couponJson = appCoupon.getCouponJson();
         TCoupon tCoupon = JSON.parseObject(couponJson, TCoupon.class);
         Integer preferentialMode = tCoupon.getPreferentialMode();
         if(1 == preferentialMode){
            //满减
            if(payAmount.compareTo(tCoupon.getMeetTheConditions()) >= 0){
               refundAmount = refundAmount.add(tCoupon.getDiscountAmount());
               order.setCouponDiscountAmount(tCoupon.getDiscountAmount());
               payAmount = payAmount.subtract(tCoupon.getDiscountAmount());
            }else{
               order.setAppCouponId(null);
               order.setCouponDiscountAmount(BigDecimal.ZERO);
               appCouponClient.refund(chargingOrder.getAppCouponId().toString());
            }
         }
         if(2 == preferentialMode){
            //抵扣
            if(payAmount.compareTo(tCoupon.getMeetTheConditions()) >= 0){
               //折扣金额
               BigDecimal divide = payAmount.multiply(new BigDecimal(10).subtract(tCoupon.getDiscount())).divide(new BigDecimal(10));
               divide = divide.compareTo(tCoupon.getMaximumDiscountAmount()) > 0 ? tCoupon.getMaximumDiscountAmount() : divide;
               refundAmount = refundAmount.add(divide);
               order.setCouponDiscountAmount(divide);
               payAmount = payAmount.subtract(divide);
            }else{
               order.setAppCouponId(null);
               order.setCouponDiscountAmount(BigDecimal.ZERO);
               appCouponClient.refund(chargingOrder.getAppCouponId().toString());
            }
         }
      }
      order.setPaymentAmount(payAmount);
      order.setRefundAmount(refundAmount);
      order.setRefundStatus(1);
      this.updateById(order);
      chargingOrder = this.getById(order.getId());
		
      // 将枪状态重置为空闲
      TChargingGun chargingGun = chargingGunClient.getChargingGunById(chargingOrder.getChargingGunId()).getData();
      chargingGun.setStatus(2);
      chargingGunClient.updateChargingGunById(chargingGun);
		
      //添加积分
      TIntegralRule integralRule = integralRuleClient.getSet().getData();
      if(null != integralRule){
         TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
         Integer num1 = JSON.parseObject(integralRule.getChargeCredit()).getInteger("num1");
         Integer integral = payAmount.multiply(new BigDecimal(num1)).intValue();
         if(null != appUser.getVipId()){
            TVip vip = vipClient.getInfo1(appUser.getVipId()).getData();
            Integer doubleIntegration = vip.getDoubleIntegration();
            //双倍积分
            if(1 == doubleIntegration){
               integral *= 2;
            }
         }
			
         TAppUserIntegralChange appUserIntegralChange = new TAppUserIntegralChange();
         appUserIntegralChange.setAppUserId(appUser.getId());
         appUserIntegralChange.setChangeType(2);
         appUserIntegralChange.setHistoricalIntegral(appUser.getPoints());
         appUser.setPoints(appUser.getPoints() + integral);
         appUserIntegralChange.setCurrentIntegral(appUser.getPoints());
         appUserIntegralChange.setCreateTime(LocalDateTime.now());
         appUserIntegralChange.setOrderCode(chargingOrder.getCode());
         appUserClient.updateAppUser(appUser);
         appUserIntegralChangeClient.addAppUserIntegralChange(appUserIntegralChange);
      }
		
		
      //开始构建退款费用
      if(refundAmount.compareTo(BigDecimal.ZERO) > 0){
         Integer rechargePaymentType = chargingOrder.getRechargePaymentType();
         //构建退款明细
         TChargingOrderRefund chargingOrderRefund = new TChargingOrderRefund();
         chargingOrderRefund.setChargingOrderId(chargingOrder.getId());
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
         chargingOrderRefund.setRefundCode("CDF" + sdf.format(new Date()) + (Double.valueOf(Math.random() * 1000).intValue()));
         chargingOrderRefund.setRefundAmount(refundAmount);
         chargingOrderRefund.setRefundStatus(1);
         chargingOrderRefund.setPayType(rechargePaymentType);
         chargingOrderRefund.setRefundStatus(1);
         chargingOrderRefund.setCode(chargingOrder.getCode());
         chargingOrderRefund.setRefundTitle("充电完成退款");
         chargingOrderRefund.setRefundContent("充电完成退款");
         chargingOrderRefund.setRefundReason("充电完成退款");
         chargingOrderRefund.setRefundRemark("充电完成退款");
         chargingOrderRefund.setRefundTotalAmount(refundAmount);
         chargingOrderRefund.setPayAmount(rechargeAmount);
         if(1 == rechargePaymentType){
            WxPaymentRefundModel model = new WxPaymentRefundModel();
            model.setOut_trade_no(chargingOrder.getCode());
            model.setOut_refund_no(chargingOrderRefund.getRefundCode());
            model.setReason("充电完成退款");
            model.setNotify_url("/payment/wx/refund/notify");
            WxPaymentRefundModel.RefundAmount amount = new WxPaymentRefundModel.RefundAmount();
            amount.setRefund(refundAmount.multiply(new BigDecimal(100)).intValue());
            amount.setTotal(rechargeAmount.multiply(new BigDecimal(100)).intValue());
            amount.setCurrency("CNY");
            model.setAmount(amount);
            R<String> orderR = wxPaymentClient.refundOrderR(model);
            if(200 == orderR.getCode()){
               chargingOrderRefundService.save(chargingOrderRefund);
            }
         }
         if(2 == rechargePaymentType){
            RefundReq dto = new RefundReq();
            dto.setOutTradeNo(chargingOrder.getCode());
            dto.setOutRequestNo(chargingOrderRefund.getCode());
            dto.setRefundAmount(refundAmount.toString());
            dto.setRefundReason("充电完成退款");
            RefundResp resp = aliPaymentClient.refund(dto).getData();
            if(null != resp){
               SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-DDTHH:mm:ss+TIMEZONE");
               AjaxResult success = chargingOrderStartupFailureWxRefund(resp.getOutTradeNo(), resp.getTradeNo(), "SUCCESS", sdf1.format(new Date()));
               if(success.isSuccess()){
                  chargingOrderRefundService.save(chargingOrderRefund);
               }
            }
         }
			
      }
   }
	
   @Override
   public List<Map<String, Object>> getByDate(List<Long> chargingOrderIds) {
      return this.baseMapper.getByDate(chargingOrderIds);
@@ -1825,6 +2114,11 @@
   @Override
   public List<Map<String, Object>> usersDay() {
      return this.baseMapper.usersDay();
   }

   @Override
   public List<Map<String, Object>> usersDay1() {
      return this.baseMapper.usersDay1();
   }

   @Override
@@ -1875,6 +2169,8 @@

   @Resource
   private TShoppingOrderService shoppingOrderService;
   @Resource
   private TShoppingOrderRefundService shoppingOrderRefundService;
   @Override
   public R payRefund(PayOrderRefundDto payOrderQueryDto) {
         if (payOrderQueryDto.getType()==1){
@@ -1901,7 +2197,7 @@
               model.setOut_refund_no(chargingOrderRefund.getRefundCode());
               model.setTransaction_id(tChargingOrder.getRechargeSerialNumber());
               model.setReason("取消订单");
               model.setNotify_url("http://221.182.45.100:9000/order/t-shopping-order/cancelShoppingOrderWxRefund");
               model.setNotify_url("/order/t-shopping-order/cancelShoppingOrderWxRefund");
               WxPaymentRefundModel.RefundAmount amount = new WxPaymentRefundModel.RefundAmount();
               amount.setRefund(payOrderQueryDto.getRefundAmount().multiply(new BigDecimal(100)).intValue());
               amount.setTotal(tChargingOrder.getPaymentAmount().multiply(new BigDecimal(100)).intValue());
@@ -1909,6 +2205,9 @@
               model.setAmount(amount);
               R<String> orderR = wxPaymentClient.refundOrderR(model);
               if(200 == orderR.getCode()){
                  tChargingOrder.setRefundStatus(2);
                  tChargingOrder.setRefundAmount((tChargingOrder.getRefundAmount()==null? BigDecimal.valueOf(0) :tChargingOrder.getRefundAmount()).add(payOrderQueryDto.getRefundAmount()));
                  this.baseMapper.updateById(tChargingOrder);
                  chargingOrderRefundService.save(chargingOrderRefund);
               }
            }
@@ -1922,7 +2221,10 @@
               RefundResp resp = aliPaymentClient.refund(dto).getData();
               if(null != resp){
                  SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-DDTHH:mm:ss+TIMEZONE");
                     chargingOrderRefundService.save(chargingOrderRefund);
                  chargingOrderRefund.setRefundStatus(2);
                  chargingOrderRefund.setRefundAmount((tChargingOrder.getRefundAmount()==null? BigDecimal.valueOf(0) :tChargingOrder.getRefundAmount()).add(payOrderQueryDto.getRefundAmount()));
                  this.baseMapper.updateById(tChargingOrder);
                  chargingOrderRefundService.save(chargingOrderRefund);

               }
            }
@@ -1934,8 +2236,8 @@
         }
         if (payOrderQueryDto.getType()==2){
            TShoppingOrder tChargingOrder = shoppingOrderService.getById(payOrderQueryDto.getOrderId());
            TChargingOrderRefund chargingOrderRefund = new TChargingOrderRefund();
            chargingOrderRefund.setChargingOrderId(tChargingOrder.getId());
            TShoppingOrderRefund chargingOrderRefund = new TShoppingOrderRefund();
            chargingOrderRefund.setShoppingOrderId(tChargingOrder.getId());
            chargingOrderRefund.setRefundAmount(payOrderQueryDto.getRefundAmount());
            chargingOrderRefund.setRefundStatus(1);
            chargingOrderRefund.setPayType(tChargingOrder.getPaymentType());
@@ -1956,7 +2258,7 @@
               model.setOut_refund_no(chargingOrderRefund.getRefundCode());
               model.setTransaction_id(tChargingOrder.getSerialNumber());
               model.setReason("取消订单");
               model.setNotify_url("http://221.182.45.100:9000/order/t-shopping-order/cancelShoppingOrderWxRefund");
               model.setNotify_url("/order/t-shopping-order/cancelShoppingOrderWxRefund");
               WxPaymentRefundModel.RefundAmount amount = new WxPaymentRefundModel.RefundAmount();
               amount.setRefund(payOrderQueryDto.getRefundAmount().multiply(new BigDecimal(100)).intValue());
               amount.setTotal(tChargingOrder.getPaymentAmount().multiply(new BigDecimal(100)).intValue());
@@ -1964,7 +2266,10 @@
               model.setAmount(amount);
               R<String> orderR = wxPaymentClient.refundOrderR(model);
               if(200 == orderR.getCode()){
                  chargingOrderRefundService.save(chargingOrderRefund);
                  tChargingOrder.setRefundStatus(2);
                  tChargingOrder.setRefundAmount((tChargingOrder.getRefundAmount()==null? BigDecimal.valueOf(0) :tChargingOrder.getRefundAmount()).add(payOrderQueryDto.getRefundAmount()));
                  shoppingOrderService.updateById(tChargingOrder);
                  shoppingOrderRefundService.save(chargingOrderRefund);
               }
            }

@@ -1977,7 +2282,12 @@
               RefundResp resp = aliPaymentClient.refund(dto).getData();
               if(null != resp){
                  SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-DDTHH:mm:ss+TIMEZONE");
                  chargingOrderRefundService.save(chargingOrderRefund);

                  tChargingOrder.setRefundStatus(2);
                  tChargingOrder.setRefundAmount((tChargingOrder.getRefundAmount()==null? BigDecimal.valueOf(0) :tChargingOrder.getRefundAmount()).add(payOrderQueryDto.getRefundAmount()));
                  shoppingOrderService.updateById(tChargingOrder);

                  shoppingOrderRefundService.save(chargingOrderRefund);

               }
            }
@@ -2421,11 +2731,37 @@
      return this.baseMapper.countAllUserData();
   }

   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")));
   @Override
   public List<Map<String, Object>> needElec1(List<Integer> siteIds, ChargingStatisticsQueryDto statisticsQueryDto) {
      return this.baseMapper.needElec1(siteIds,statisticsQueryDto);
   }
	
   /**
    * 获取充电结束页面详情
    * @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;
   }
}