申诉

xuhy

2024-08-29 e0207d7029b4e90ea1e4efeab5c3c5591f0e59c3

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

@@ -1,34 +1,63 @@
package com.ruoyi.order.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.account.api.feignClient.AppUserCarClient;
import com.ruoyi.account.api.feignClient.AppUserClient;
import com.ruoyi.account.api.feignClient.AppUserVipDetailClient;
import com.ruoyi.account.api.model.TAppUser;
import com.ruoyi.account.api.model.TAppUserCar;
import com.ruoyi.account.api.model.TAppUserVipDetail;
import com.ruoyi.account.api.vo.GetAppUserVipDetail;
import com.ruoyi.chargingPile.api.feignClient.ChargingGunClient;
import com.ruoyi.chargingPile.api.feignClient.ChargingPileClient;
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
import com.ruoyi.chargingPile.api.model.Site;
import com.ruoyi.chargingPile.api.model.TChargingGun;
import com.ruoyi.chargingPile.api.model.TChargingPile;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.BasePage;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.redis.service.RedisService;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.integration.api.feignClient.ChargingHandshakeClient;
import com.ruoyi.integration.api.feignClient.SendMessageClient;
import com.ruoyi.integration.api.feignClient.UploadRealTimeMonitoringDataClient;
import com.ruoyi.integration.api.model.ChargingHandshake;
import com.ruoyi.integration.api.model.PlatformStartCharging;
import com.ruoyi.integration.api.model.UploadRealTimeMonitoringData;
import com.ruoyi.order.api.model.TChargingOrder;
import com.ruoyi.order.api.model.TChargingOrderAccountingStrategy;
import com.ruoyi.order.dto.GetMyChargingOrderList;
import com.ruoyi.order.dto.GetNoInvoicedOrder;
import com.ruoyi.order.dto.MyChargingOrderInfo;
import com.ruoyi.order.dto.MyChargingOrderList;
import com.ruoyi.order.api.model.TChargingOrderRefund;
import com.ruoyi.order.api.model.TOrderEvaluate;
import com.ruoyi.order.api.query.ChargingOrderQuery;
import com.ruoyi.order.api.vo.ChargingOrderVO;
import com.ruoyi.order.api.vo.TCharingOrderVO;
import com.ruoyi.order.dto.*;
import com.ruoyi.order.mapper.TChargingOrderMapper;
import com.ruoyi.order.service.TChargingOrderAccountingStrategyService;
import com.ruoyi.order.service.TChargingOrderService;
import com.ruoyi.order.service.TOrderEvaluateService;
import com.ruoyi.payment.api.feignClient.AliPaymentClient;
import com.ruoyi.payment.api.feignClient.WxPaymentClient;
import com.ruoyi.payment.api.vo.*;
import io.seata.spring.annotation.GlobalTransactional;
import io.swagger.annotations.ApiModelProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
@@ -49,6 +78,8 @@
   
   @Resource
   private AppUserCarClient appUserCarClient;
   @Resource
   private AppUserClient appUserClient;
   
   @Resource
   private TChargingOrderAccountingStrategyService chargingOrderAccountingStrategyService;
@@ -56,9 +87,37 @@
   @Resource
   private TokenService tokenService;
   
   @Resource
   private WxPaymentClient wxPaymentClient;
	
   @Resource
   private AliPaymentClient aliPaymentClient;
	
   @Resource
   private ChargingPileClient chargingPileClient;
	

   @Resource
   private AppUserVipDetailClient appUserVipDetailClient;
	
   @Resource
   private RedisService redisService;
	
   @Resource
   private UploadRealTimeMonitoringDataClient uploadRealTimeMonitoringDataClient;
	
   @Resource
   private ChargingHandshakeClient chargingHandshakeClient;
	
   @Resource
   private SendMessageClient sendMessageClient;
	
   @Resource
   private TOrderEvaluateService orderEvaluateService;
   
   
   

   /**
    * 获取小程序充电记录列表数据
    * @param query
@@ -80,14 +139,20 @@
         myChargingOrderList.setTitle(site.getName());
         myChargingOrderList.setChargingDegree(tChargingOrder.getChargingCapacity());
         String name = chargingGunClient.getAllName(tChargingOrder.getChargingGunId()).getData();
         myChargingOrderList.setChargingGunId(tChargingOrder.getChargingGunId());
         myChargingOrderList.setName(name);
         myChargingOrderList.setEndMode(tChargingOrder.getEndMode());
         BigDecimal payMoney = tChargingOrder.getStatus() < 4 ? tChargingOrder.getRechargeAmount() : tChargingOrder.getPaymentAmount();
         myChargingOrderList.setPayMoney(payMoney);
         myChargingOrderList.setCreateTime(tChargingOrder.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
         long count = orderEvaluateService.count(new LambdaQueryWrapper<TOrderEvaluate>().eq(TOrderEvaluate::getOrderType, 1)
               .eq(TOrderEvaluate::getOrderId, tChargingOrder.getId()).eq(TOrderEvaluate::getDelFlag, 0));
         myChargingOrderList.setEvaluate(count + 1L);
         orderLists.add(myChargingOrderList);
      }
      list = this.baseMapper.getMyChargingOrderList(appUserId, query.getType(), null, null);
      map.put("list", orderLists);
      map.put("totle", list.size());
      return map;
   }
   
@@ -130,11 +195,39 @@
                  .orderByAsc(TChargingOrderAccountingStrategy::getStartTime)
      );
      myChargingOrderInfo.setStageCost(stageCost);
      // todo 待完善
      //再MongoDB中获取数据
      myChargingOrderInfo.setCurrentAndVoltage(null);
      //再MongoDB中获取数据
      myChargingOrderInfo.setPower(null);
      List<UploadRealTimeMonitoringData> dataList = uploadRealTimeMonitoringDataClient.getDataByOrderCode(chargingOrder.getCode()).getData();
      if(null != dataList){
         //在MongoDB中获取数据
         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
         List<String> time = dataList.stream().map(s -> sdf.format(s.getCreate_time())).collect(Collectors.toList());
         List<BigDecimal> outputVoltage = dataList.stream().map(UploadRealTimeMonitoringData::getOutput_voltage).collect(Collectors.toList());
         List<BigDecimal> outputCurrent = dataList.stream().map(UploadRealTimeMonitoringData::getOutput_current).collect(Collectors.toList());
         List<Map<String, Object>> currentAndVoltage = new ArrayList<>();
         for (int i = 0; i < time.size(); i++) {
            Map<String, Object> map = new HashMap<>();
            map.put("time", time.get(i));
            //电流
            map.put("electricity", outputCurrent.get(i));
            //电压
            map.put("voltage", outputVoltage.get(i));
            currentAndVoltage.add(map);
         }
         myChargingOrderInfo.setCurrentAndVoltage(currentAndVoltage);
         //在MongoDB中获取数据
         List<Integer> soc = dataList.stream().map(UploadRealTimeMonitoringData::getSoc).collect(Collectors.toList());
         List<BigDecimal> po = dataList.stream().map(s -> s.getOutput_current().multiply(s.getOutput_voltage()).divide(new BigDecimal(1000))).collect(Collectors.toList());
         List<Map<String, Object>> power = new ArrayList<>();
         for (int i = 0; i < time.size(); i++) {
            Map<String, Object> map = new HashMap<>();
            map.put("time", time.get(i));
            //soc
            map.put("soc", soc.get(i));
            //功率
            map.put("power", po.get(i));
            power.add(map);
         }
         myChargingOrderInfo.setPower(power);
      }
      myChargingOrderInfo.setActionable(myChargingOrderInfo.getEndTime() + 604800000L > System.currentTimeMillis() ? 0 : 1);
      return myChargingOrderInfo;
   }
@@ -163,8 +256,399 @@
         BigDecimal payMoney = tChargingOrder.getStatus() < 4 ? tChargingOrder.getRechargeAmount() : tChargingOrder.getPaymentAmount();
         myChargingOrderList.setPayMoney(payMoney);
         myChargingOrderList.setCreateTime(tChargingOrder.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
         myChargingOrderList.setElectricCharge(tChargingOrder.getElectrovalence());
         myChargingOrderList.setServiceCharge(tChargingOrder.getServiceCharge());
         list.add(myChargingOrderList);
      }
      return list;
   }
	
	
   /**
    * 充电支付
    * @param addChargingOrder
    * @return
    */
   @Override
   @GlobalTransactional(rollbackFor = Exception.class)
   public AjaxResult paymentChargingOrder(AddChargingOrder addChargingOrder) {
      Long userId = tokenService.getLoginUserApplet().getUserId();
      TAppUser appUser = appUserClient.getUserById(userId).getData();
      //查询待支付状态的订单，没有支付则删除订单
      List<TChargingOrder> list = this.list(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getAppUserId, userId)
            .eq(TChargingOrder::getRechargePaymentStatus, 1).eq(TChargingOrder::getDelFlag, 0));
      for (TChargingOrder tChargingOrder : list) {
         Integer rechargePaymentType = tChargingOrder.getRechargePaymentType();
         if(1 == rechargePaymentType){
            NotifyV3PayDecodeRespBody data = wxPaymentClient.queryOrderInfo(tChargingOrder.getCode()).getData();
            if(null != data){
               String trade_state = data.getTrade_state();
               //支付失败，删除无效的订单
               if(trade_state.equals("REFUND") || trade_state.equals("NOTPAY") || trade_state.equals("REVOKED") || trade_state.equals("PAYERROR")){
                  this.removeById(tChargingOrder.getId());
               }
            }
         }
         if(2 == rechargePaymentType){
            AliQueryOrder data = aliPaymentClient.query(tChargingOrder.getCode()).getData();
            if(null != data){
               //支付失败，删除无效的订单
               String tradeStatus = data.getTradeStatus();
               if(tradeStatus.equals("TRADE_CLOSED")){
                  this.removeById(tChargingOrder.getId());
               }
            }
         }
      }
		
      //检查当前枪是否是正在使用中
      TChargingOrder one = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getChargingGunId, addChargingOrder.getId())
            .in(TChargingOrder::getStatus, Arrays.asList(1, 2, 3)).eq(TChargingOrder::getDelFlag, 0));
      if(null != one){
         return AjaxResult.error("充电枪正在充电桩中，启动失败");
      }
      //查询当前充电枪是否有正在支付的订单
      one = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getChargingGunId, addChargingOrder.getId())
            .eq(TChargingOrder::getAppUserCarId, userId).eq(TChargingOrder::getRechargePaymentStatus, 1).eq(TChargingOrder::getDelFlag, 0));
      if(null != one){
         //查询三方支付数据，支付中直接结束三方订单
         if(1 == one.getRechargePaymentType()){
            NotifyV3PayDecodeRespBody data = wxPaymentClient.queryOrderInfo(one.getCode()).getData();
            if(null != data){
               String trade_state = data.getTrade_state();
               //支付失败，删除无效的订单
               if(trade_state.equals("REFUND") || trade_state.equals("NOTPAY") || trade_state.equals("REVOKED") || trade_state.equals("PAYERROR")){
                  this.removeById(one.getId());
               }else{
                  //结束第三方支付，删除订单
                  wxPaymentClient.close(one.getCode());
                  this.removeById(one.getId());
               }
            }
         }
         if(2 == one.getRechargePaymentType()){
            AliQueryOrder data = aliPaymentClient.query(one.getCode()).getData();
            if(null != data){
               String trade_state = data.getTradeStatus();
               //支付失败，删除无效的订单
               if(trade_state.equals("TRADE_CLOSED")){
                  this.removeById(one.getId());
               }
               if(trade_state.equals("WAIT_BUYER_PAY")){
                  //结束第三方支付，删除订单
                  aliPaymentClient.close(one.getCode());
                  this.removeById(one.getId());
               }
            }
         }
      }
		
		
      //构建新的待支付订单
      SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
      TChargingOrder chargingOrder = new TChargingOrder();
      String code = "CD" + Math.random() * 1000 + sdf.format(new Date());
      chargingOrder.setCode(code);
      chargingOrder.setOrderType(1);
      chargingOrder.setOrderClassification(1);
      chargingOrder.setAppUserId(userId);
      chargingOrder.setAppUserCarId(addChargingOrder.getAppUserCarId());
      TChargingGun tChargingGun = chargingGunClient.getChargingGunById(addChargingOrder.getId()).getData();
      chargingOrder.setSiteId(tChargingGun.getSiteId());
      chargingOrder.setChargingPileId(tChargingGun.getChargingPileId());
      chargingOrder.setChargingGunId(addChargingOrder.getId());
      chargingOrder.setRechargePaymentType(addChargingOrder.getPaymentType());
      chargingOrder.setRechargePaymentStatus(1);
      chargingOrder.setRechargeAmount(addChargingOrder.getPaymentAmount());
      chargingOrder.setAppCouponId(addChargingOrder.getAppUserCouponId());
      if(null != appUser.getVipId()){
         GetAppUserVipDetail getAppUserVipDetail = new GetAppUserVipDetail();
         getAppUserVipDetail.setAppUserId(appUser.getId());
         getAppUserVipDetail.setVipId(appUser.getVipId());
         TAppUserVipDetail vipDetail = appUserVipDetailClient.getAppUserVipDetail(getAppUserVipDetail).getData();
         if(null != vipDetail){
            Integer chargeNum = vipDetail.getChargeNum();
            if(0 > chargeNum){
               chargingOrder.setVipDiscount(vipDetail.getDiscount());
               BigDecimal discountAmount = addChargingOrder.getPaymentAmount().multiply((new BigDecimal(10)
                     .subtract(vipDetail.getDiscount())).divide(new BigDecimal(10))).setScale(4, BigDecimal.ROUND_HALF_EVEN);
               chargingOrder.setVipDiscountAmount(discountAmount);
            }
         }
			
      }
      this.save(chargingOrder);
      //会员优惠折扣将其计入增加充电时长（增加总充电金额）
      //如果充电总金额未使用完，则需要退回费用=(原金额/总金额)*(总金额-实际充电金额)
      if(1 == addChargingOrder.getPaymentType()){
         PaymentOrder paymentOrder = new PaymentOrder();
         paymentOrder.setCode(chargingOrder.getCode());
         paymentOrder.setAmount(addChargingOrder.getPaymentAmount());
         paymentOrder.setOpenId(appUser.getWxOpenid());
         paymentOrder.setDescription("充电充值");
         paymentOrder.setNotifyUrl("/order/t-charging-order/chargingOrderWXCallback");
         Map<String, Object> data = wxPaymentClient.orderPay(paymentOrder).getData();
         return AjaxResult.success(data);
      }
      if(2 == addChargingOrder.getPaymentType()){
         AliPaymentReq req = new AliPaymentReq();
         req.setOutTradeNo(chargingOrder.getCode());
         req.setTotalAmount(chargingOrder.getPaymentAmount().toString());
         req.setSubject("充电充值");
         req.setBuyerOpenId(appUser.getAliOpenid());
         req.setBody("充电充值");
         AliPaymentResp data = aliPaymentClient.payment(req).getData();
         if(null != data){
            data.setNotifyUrl(data.getNotifyUrl() + "/t-charging-order/chargingOrderALICallback");
            return AjaxResult.success(data);
         }
      }
      throw new RuntimeException("无效的支付方式");
   }
	
	
   /**
    * 支付成功后的回调处理逻辑
    * @param paymentType 支付方式：1=微信，2=支付宝
    * @param out_trade_no 业务流水号
    * @param transaction_id 三方支付流水号
    * @param attach 附加数据
    * @return
    */
   @Override
   public AjaxResult chargingOrderCallback(Integer paymentType, String out_trade_no, String transaction_id, String attach) {
      TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, out_trade_no));
      if(chargingOrder.getRechargePaymentStatus() == 2){
         return AjaxResult.success();
      }
      chargingOrder.setRechargePaymentStatus(2);
      chargingOrder.setRechargeSerialNumber(transaction_id);
      this.updateById(chargingOrder);
      //添加安全检测数据到缓存中，每步安全检测完成后需要更新缓存数据
      PreChargeCheck preChargeCheck = new PreChargeCheck();
      preChargeCheck.setElectronicLockLock(false);
      preChargeCheck.setInsulationTesting(false);
      preChargeCheck.setSecureConnectionDetection(false);
      String key = "AQJC_" + chargingOrder.getChargingGunId();
      redisService.setCacheObject(key, preChargeCheck);
		
      //根据当前充值的金额和计费模板算出充电的金额
      BigDecimal rechargeAmount = chargingOrder.getRechargeAmount();
      //计算充电金额，会员需要将折扣金额加入到充电总金额中
		
//      TAppUser appUser = appUserClient.getUserById(chargingOrder.getAppUserId()).getData();
//      if(){
//         appUser.getVipId()
//      }
//
//
//      //调用远程启动充电消息
//      PlatformStartCharging platformStartCharging = new PlatformStartCharging();
//      platformStartCharging.setTransaction_serial_number(chargingOrder.getCode());
//      platformStartCharging.setCharging_pile_code();
//      platformStartCharging.setCharging_gun_code();
//      platformStartCharging.setCard_number();
//      platformStartCharging.setAccount_balance()
//      sendMessageClient.platformStartCharging(platformStartCharging);
      return AjaxResult.success();
   }
	
	
   /**
    * 获取充电中的详情
    * @param id
    * @return
    */
   @Override
   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));
      if(null == one){
         return null;
      }
      ChargingDetails chargingDetails = new ChargingDetails();
      chargingDetails.setId(one.getId().toString());
      TChargingGun chargingGun = chargingGunClient.getChargingGunById(id).getData();
      TChargingPile chargingPile = chargingPileClient.getChargingPileById(chargingGun.getChargingPileId()).getData();
      Site site = siteClient.getSiteByIds(Arrays.asList(chargingPile.getSiteId())).getData().get(0);
      chargingDetails.setName(site.getName() + "-" + chargingPile.getName());
      chargingDetails.setCode(one.getCode());
      chargingDetails.setStatus(one.getStatus());
      UploadRealTimeMonitoringData data = uploadRealTimeMonitoringDataClient.chargingOrderInfo(one.getCode()).getData();
      if(null != data){
         chargingDetails.setChargeCurrent(data.getOutput_current());
         chargingDetails.setChargeVoltage(data.getOutput_voltage());
         BigDecimal power = data.getOutput_current().multiply(data.getOutput_voltage()).divide(new BigDecimal(1000));
         chargingDetails.setChargePower(power);
         chargingDetails.setCompletionRatio(data.getSoc());
         chargingDetails.setRemainingChargeTime(data.getTime_remaining());
         chargingDetails.setChargedDegrees(data.getCharging_degree());
         chargingDetails.setChargedTime(data.getCumulative_charging_time());
         chargingDetails.setChargingCost(data.getPaid_amount());
      }
      ChargingHandshake chargingHandshake = chargingHandshakeClient.getDataByOrderCode(one.getCode()).getData();
      if(null != chargingHandshake && null != data && null != one.getAppUserCarId()){
         BigDecimal bms_battery_capacity = chargingHandshake.getBms_battery_capacity();
         TAppUserCar appUserCar = appUserCarClient.getCarByIds(Arrays.asList(one.getAppUserCarId())).getData().get(0);
         //   续航 = 电池容量 / 续航里程 * soc
         BigDecimal divide = bms_battery_capacity.divide(new BigDecimal(appUserCar.getEndurance()));
         BigDecimal multiply = new BigDecimal(data.getSoc() / 100).multiply(divide);
         chargingDetails.setEndurance(multiply);
      }
      return chargingDetails;
   }
	
	
   /**
    * 停止充电操作
    * @param id 订单id
    * @return
    */
   @Override
   public AjaxResult stopCharging(String id) {
      TChargingOrder chargingOrder = this.getById(id);
      Integer status = chargingOrder.getStatus();
      if(status == 4 || status == 5){
         return AjaxResult.error("不能重复操作");
      }
      chargingOrder.setStatus(4);
      chargingOrder.setEndMode(1);
      this.updateById(chargingOrder);
      //调用硬件停止充电，停止成功后开始计算费用退款
		
		
		
      // todo 待完善
      return AjaxResult.success();
   }

	
	
   public void endCharge(){
	
   }
	
	
	

    @Override
    public TCharingOrderVO chargingOrder(ChargingOrderQuery dto) {
      TCharingOrderVO tCharingOrderVO = new TCharingOrderVO();


      String startTime1 = null;
      String startTime2 = null;
      String endTime1 = null;
      String endTime2 = null;

      if (StringUtils.hasLength(dto.getStartTime())){
         String[] split = dto.getStartTime().split(" - ");
         startTime1 = split[0];
         startTime2 = split[1];
      }
      if (StringUtils.hasLength(dto.getEndTime())){
         String[] split = dto.getEndTime().split(" - ");
         endTime1 = split[0];
         endTime2 = split[1];
      }
      PageInfo<ChargingOrderVO> pageInfo = new PageInfo<>(dto.getPageCurr(),dto.getPageSize());

      if (StringUtils.hasLength(dto.getPhone())){
         List<Long> data = appUserClient.getUserIdsByPhone(dto.getPhone()).getData();
         if (data.isEmpty()){
            tCharingOrderVO.setList(pageInfo);
            return tCharingOrderVO;
         }
         dto.setUserIds(data);
      }
      List<ChargingOrderVO> list = this.baseMapper.chargingOrder(pageInfo,dto,startTime1,startTime2,endTime1,endTime2);
       BigDecimal total = new BigDecimal("0");
       long time = 0L;
       BigDecimal income = new BigDecimal("0");
       BigDecimal electronicMoney = new BigDecimal("0");
       BigDecimal serviceMoney = new BigDecimal("0");
      for (ChargingOrderVO chargingOrderVO : list) {
         if (chargingOrderVO.getChargingCapacity()!=null){
            total = total.add(chargingOrderVO.getChargingCapacity());
         }
         // 充电订单 明细记录
         List<TChargingOrderAccountingStrategy> chargingOrderId = chargingOrderAccountingStrategyService.list(new QueryWrapper<TChargingOrderAccountingStrategy>()
               .eq("charging_order_id", chargingOrderVO.getId()));
         // 单个订单累计电费
         BigDecimal electronicMoney1 = new BigDecimal("0");
         // 单个订单累计服务费
         BigDecimal serviceMoney1 = new BigDecimal("0");
         LocalDateTime startTime = chargingOrderVO.getStartTime();
         LocalDateTime endTime = chargingOrderVO.getEndTime();
         // 计算时间差 秒 充电时长
         if (startTime!=null && endTime!=null){
            long between = ChronoUnit.SECONDS.between(startTime, endTime);
            chargingOrderVO.setChargingSecond(between);
            time += between;
         }
         // 总收入
         if (chargingOrderVO.getRefundStatus() !=null && chargingOrderVO.getRefundStatus() == 2){
            income = income.add(chargingOrderVO.getPaymentAmount().subtract(chargingOrderVO.getRefundAmount()));
         }else{
            if (chargingOrderVO.getPaymentAmount()!=null){
               income = income.add(chargingOrderVO.getPaymentAmount());
            }
         }
         for (TChargingOrderAccountingStrategy tChargingOrderAccountingStrategy : chargingOrderId) {
            // 累计电费
            electronicMoney1 = electronicMoney1.add(tChargingOrderAccountingStrategy.getElectrovalence()
                  .multiply(tChargingOrderAccountingStrategy.getChargingCapacity()));
            electronicMoney = electronicMoney.add(electronicMoney1);
            // 累计服务费
            serviceMoney1 = serviceMoney1.add(tChargingOrderAccountingStrategy.getServiceCharge());
            serviceMoney = serviceMoney.add(serviceMoney1);
         }
         chargingOrderVO.setServiceCharge(serviceMoney1);
         chargingOrderVO.setElectrovalence(electronicMoney1);
         // 充电时段数
         int size = chargingOrderId.size();
         chargingOrderVO.setCount(size);
         // 用户手机号
         TAppUser data = appUserClient.getUserById(chargingOrderVO.getAppUserId()).getData();
         if (data!=null){
            // 车牌号
            chargingOrderVO.setPhone(data.getPhone());
            List<Long> longs = new ArrayList<>();
            if (chargingOrderVO.getAppUserCarId()!=null){
               longs.add(chargingOrderVO.getAppUserCarId());
               List<TAppUserCar> data1 = appUserCarClient.getCarByIds(longs).getData();
               if (!data1.isEmpty()){
                  chargingOrderVO.setLicensePlate(data1.get(0).getLicensePlate());
               }
            }

         }
      }
      tCharingOrderVO.setTotal(total);
      tCharingOrderVO.setTime(time);
      tCharingOrderVO.setIncome(income);
      tCharingOrderVO.setElectronicMoney(electronicMoney);
      tCharingOrderVO.setServiceMoney(serviceMoney);
      pageInfo.setRecords(list);
      tCharingOrderVO.setList(pageInfo);
        return tCharingOrderVO;
    }

   @Override
   public R<PageInfo<PayOrderDto>> payOrderQuery(PayOrderQueryDto payOrderQueryDto) {
      PageInfo<PayOrderDto> pageInfo = new PageInfo<>(payOrderQueryDto.getPageCurr(),payOrderQueryDto.getPageSize());
      List<PayOrderDto> list = this.baseMapper.payOrderQuery(pageInfo,payOrderQueryDto);
      pageInfo.setRecords(list);
      return R.ok(pageInfo);
   }

   @Override
   public R<PageInfo<TChargingOrderRefund>> getRefundList(ChargingRefundDto chargingRefundDto) {
      PageInfo<TChargingOrderRefund> pageInfo = new PageInfo<>(chargingRefundDto.getPageCurr(),chargingRefundDto.getPageSize());
      List<TChargingOrderRefund> list = this.baseMapper.getRefundList(pageInfo,chargingRefundDto);
      pageInfo.setRecords(list);

      return R.ok(pageInfo);
   }
}