Merge remote-tracking branch 'origin/master'

xuhy

2024-10-11 95b274d2d563a07fa143fc66738ff5d731ee80e3

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

@@ -38,7 +38,7 @@
import com.ruoyi.order.api.query.SettlementListQuery;
import com.ruoyi.order.api.query.UploadRealTimeMonitoringDataQuery;
import com.ruoyi.order.api.vo.*;
import com.ruoyi.order.api.vo.SecurityDetection;
import com.ruoyi.order.api.vo.PlatformStopChargingReplyVO;
import com.ruoyi.order.dto.*;
import com.ruoyi.order.mapper.TChargingOrderMapper;
import com.ruoyi.order.mapper.TSettlementConfirmMapper;
@@ -56,7 +56,6 @@
import com.ruoyi.payment.api.model.RefundResp;
import com.ruoyi.payment.api.model.WxPaymentRefundModel;
import com.ruoyi.payment.api.vo.*;
import com.ruoyi.system.api.feignClient.SysUserClient;
import io.seata.spring.annotation.GlobalTransactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -97,8 +96,7 @@

   @Resource
   private SiteClient siteClient;


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

   @Resource
   private TOrderEvaluateService orderEvaluateService;


	
   @Resource
   private AccountingStrategyDetailClient accountingStrategyDetailClient;

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

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

		
      log.error(chargingOrder.getCode() + "：-------------------远程调起开始充电请求-------------------" + platformStartCharging.toString());
      sendMessageClient.platformStartCharging(platformStartCharging);
      //异步线程检测远程启动的应答结果。如果失败，则需要全额退款
      Long id = chargingOrder.getId();
@@ -685,8 +683,10 @@
      }
      
      List<PlatformStartChargingReply> data = platformStartChargingReplyClient.getPlatformStartChargingReply(code).getData();
      System.err.println(code + "：-------------------开始检查调起充电结果-------------------");
      System.err.println(data.toString());
      if(null == data){
         return false;
      }
      log.error(code + "：-------------------开始检查调起充电结果-------------------" + data.toString());
      if(data.size() != 0){
         PlatformStartChargingReply platformStartChargingReply = data.get(1);
         Integer startup_result = platformStartChargingReply.getStartup_result();
@@ -725,9 +725,8 @@
         redisService.setCacheObject(key, preChargeCheck1, 24L, TimeUnit.HOURS);
         return true;
      }else{
         log.error(code + "：未上传开启充电结果........");
			
         Integer counter = boot_failed_map.get(code);
         log.error(code + "：-------------------未上传开启充电结果-------------------" + counter);
         PreChargeCheck preChargeCheck1 = redisService.getCacheObject(key);
         //5分钟内未启动成功，退回金额。
         if(null == counter || counter < 300){
@@ -762,12 +761,12 @@
    * @param securityDetection
    */
   @Override
   public void securityDetection(SecurityDetection securityDetection){
   public void securityDetection(SecurityDetectionVO securityDetection){
      GetChargingGunByCode code = new GetChargingGunByCode();
      code.setCharging_pile_code(securityDetection.getCharging_pile_code());
      code.setCharging_gun_code(securityDetection.getCharging_gun_code());
      TChargingGun chargingGun = chargingGunClient.getChargingGunByCode(code).getData();
      PreChargeCheck preChargeCheck1 =  redisService.getCacheObject("AQJC_" + chargingGun.getId());
      PreChargeCheck preChargeCheck1 = redisService.getCacheObject("AQJC_" + chargingGun.getId());
      if(null != preChargeCheck1){
         preChargeCheck1.setElectronicLockLock(preChargeCheck1.getElectronicLockLock());
         preChargeCheck1.setInsulationTesting(true);
@@ -782,7 +781,7 @@
    * @param message
    */
   @Override
   public void startChargeSuccessfully(PlatformStartChargingReplyMessage message) {
   public void startChargeSuccessfully(PlatformStartChargingReplyMessageVO message) {
      Integer startup_result = message.getStartup_result();
      Integer failure_cause = message.getFailure_cause();
      TChargingOrder order = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, message.getTransaction_serial_number()));
@@ -796,7 +795,6 @@
         preChargeCheck1.setInsulationTesting(true);
         preChargeCheck1.setSecureConnectionDetection(preChargeCheck1.getSecureConnectionDetection());
         preChargeCheck1.setStartupSuccess(1);
         redisService.setCacheObject("AQJC_" + order.getChargingGunId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      }
      if(0 == startup_result){
         //启动失败
@@ -812,6 +810,7 @@
         order.setStatus(3);
         order.setStartTime(LocalDateTime.now());
      }
      redisService.setCacheObject("AQJC_" + order.getChargingGunId(), preChargeCheck1, 24L, TimeUnit.HOURS);
      this.updateById(order);
   }
   
@@ -820,6 +819,7 @@
    * @param code
    */
   public void refund(String code){
      log.error(code + "：-------------------充电启动失败，执行退款-------------------");
      TChargingOrder chargingOrder = this.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getCode, code));
      if(chargingOrder.getStatus() == 2){
         Integer rechargePaymentType = chargingOrder.getRechargePaymentType();
@@ -889,7 +889,7 @@
         TChargingOrderRefund one = chargingOrderRefundService.getOne(new LambdaQueryWrapper<TChargingOrderRefund>().eq(TChargingOrderRefund::getRefundCode, out_refund_no));
         one.setRefundSerialNumber(refund_id);
         one.setRefundStatus(2);
         one.setRefundTime(LocalDateTime.parse(success_time, DateTimeFormatter.ofPattern("yyyy-MM-DDTHH:mm:ss+TIMEZONE")));
         one.setRefundTime(LocalDateTime.now());
         chargingOrderRefundService.updateById(one);
      }
      return AjaxResult.success();
@@ -954,9 +954,13 @@
   public AjaxResult stopCharging(String id) {
      TChargingOrder chargingOrder = this.getById(id);
      Integer status = chargingOrder.getStatus();
      if(status != 3){
         return AjaxResult.error("还未开始充电");
      }
      if(status == 4 || status == 5){
         return AjaxResult.error("不能重复操作");
      }
      chargingOrder.setEndTime(LocalDateTime.now());
      chargingOrder.setStatus(4);
      chargingOrder.setEndMode(1);
      this.updateById(chargingOrder);
@@ -1017,7 +1021,7 @@
            }
         }
      }
		
      String code1 = chargingOrder.getCode();
      
      //异步线程处理停机
      ExecutorService cachedThreadPool = Executors.newFixedThreadPool(1);
@@ -1029,12 +1033,17 @@
         platformStopCharging.setCharging_pile_code(chargingPile.getCode());
         platformStopCharging.setCharging_gun_code(chargingGun.getCode());
         sendMessageClient.platformStopCharging(platformStopCharging);
         log.error(code1 + "：-------------------远程停止充电请求-------------------");
         log.error(platformStopCharging.toString());
         //开始查询停机应答，成功后开始计费费用
         for (int i = 0; i < 60; i++) {
            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 + "：-------------------查询远程停止充电应答-------------------");
            log.error(reply.toString());
            if(null == reply){
               try {
                  Thread.sleep(1000);
@@ -1043,7 +1052,12 @@
               }
               continue;
            }

				
            TChargingOrder chargingOrder1 = this.getById(id);
            if(chargingOrder1.getStatus() != 3){
               break;
            }
				
            if(0 == reply.getStop_result()){
               String failure_cause = "";
               switch (reply.getFailure_cause()){
@@ -1060,8 +1074,13 @@
                     failure_cause = "其他";
                     break;
               }
               log.error("停机失败：订单号：{}，失败原因：{}", chargingOrder.getCode(), failure_cause);
               throw new RuntimeException(failure_cause);
               log.error(code1 + "：停机失败：订单号：{}，失败原因：{}", chargingOrder.getCode(), failure_cause);
               try {
                  Thread.sleep(1000);
               } catch (InterruptedException e) {
                  throw new RuntimeException(e);
               }
               continue;
            }

            // 将枪状态重置为空闲
@@ -1069,6 +1088,7 @@
            chargingGunClient.updateChargingGunById(chargingGun);
            //计算费用，处理退款
            endCharge(chargingOrder);
            log.error(code1 + "：-------------------远程停止充电请求成功-------------------");
            break;
         }
      });
@@ -1125,8 +1145,56 @@

      return AjaxResult.success();
   }


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

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

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

	

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