BJ_ZTEITS-Developers / parking-cloud

package com.zteits.ipay.biz;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.clouds.common.cache.sys.SysCodeValueCacheUtil;
import com.clouds.common.constants.*;
import com.clouds.common.redis.RedisCacheUtil;
import com.clouds.common.utils.BeanValidatorsUtils;
import com.clouds.common.utils.DateUtil;
import com.clouds.common.utils.ResultUtils;
import com.clouds.common.utils.SequenceUtil;
import com.zteits.clouds.api.apibase.bean.BizResult;
import com.zteits.clouds.api.apibase.constants.*;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.bill.vipcard.param.UseTimeVipCardReq;
import com.zteits.clouds.api.dto.business.dto.TdCBusinessAcctDTO;
import com.zteits.clouds.api.dto.business.param.TdCBusinessAcctPayoutRequest;
import com.zteits.clouds.api.dto.business.param.TdCBusinessAcctRequest;
import com.zteits.clouds.api.dto.datacollect.param.df.DfGroundLockOpenByPayPushRequest;
import com.zteits.clouds.api.dto.order.param.OrderAppointmentRequest;
import com.zteits.clouds.api.dto.order.payorder.dto.PayOrderDTO;
import com.zteits.clouds.api.dto.order.payorder.param.*;
import com.zteits.clouds.api.dto.order.vipcardorder.param.OrderVipcardQueryByOrderIdReq;
import com.zteits.clouds.api.dto.park.dto.BerthsDTO;
import com.zteits.clouds.api.dto.park.dto.ParkingLotDTO;
import com.zteits.clouds.api.dto.park.param.QueryParkLotInfoByPkNoRequest;
import com.zteits.clouds.api.dto.pay.*;
import com.zteits.clouds.api.dto.pay.param.*;
import com.zteits.clouds.api.dto.pda.msgpush.PDAMsgTypeEnum;
import com.zteits.clouds.api.dto.pda.param.ArrearageRecordInfo;
import com.zteits.clouds.api.dto.pda.param.PayedFeeByCashRequest;
import com.zteits.clouds.api.dto.pda.param.QueryBerthByPlNoAndBerthNoRequest;
import com.zteits.clouds.api.dto.sys.SysCodeValueDTO;
import com.zteits.clouds.api.service.bill.viptime.TVipTimeCardCustInfoService;
import com.zteits.clouds.api.service.business.TdCBusinessAcctPayoutService;
import com.zteits.clouds.api.service.business.TdCBusinessAcctService;
import com.zteits.clouds.api.service.datacollect.DfGroundLockMsgPushService;
import com.zteits.clouds.api.service.order.parkorder.oper.PDAParkOrderOperService;
import com.zteits.clouds.api.service.order.pay.AliWxPayService;
import com.zteits.clouds.api.service.park.ParkingLotQueryService;
import com.zteits.clouds.api.service.park.berths.query.TpPBerthsQueryService;
import com.zteits.clouds.api.service.pay.AppOrgService;
import com.zteits.clouds.api.service.pay.JPushService;
import com.zteits.clouds.api.service.pay.TdCAcctPersonService;
import com.zteits.clouds.api.service.pay.TdCCustPersonService;
import com.zteits.clouds.api.service.pay.oper.TdCRechargeCardOperService;
import com.zteits.ipay.service.apppubpay.aliwxinpay.base.AliWxinPayInnerRouteService;
import com.zteits.ipay.service.apppubpay.busigroup.base.CommonBusiPayInnerService;
import com.zteits.ipay.service.apppubpay.busigroup.base.PubBusiInnerRouteService;
import com.zteits.ipay.service.apppubpay.busigroup.impl.park.notify.ParkPayNotifyThirdService;
import com.zteits.ipay.service.apppubpay.busigroup.impl.park.notify.base.ParkPayNotifyThirdServiceRoute;
import com.zteits.ipay.service.transfers.TransfersInnerService;
import com.zteits.order.dao.OrderAppointmentDao;
import com.zteits.order.dao.parkorder.OrderParkAppOutTimeUpdateRecordDao;
import com.zteits.order.dao.parkorder.OrderParkDao;
import com.zteits.order.dao.payorder.PayOrderDao;
import com.zteits.order.dao.vipcardorder.OrderVipcardDao;
import com.zteits.order.domain.*;
import com.zteits.order.service.payorder.oper.PubPayOrderOperInnerService;
import com.zteits.order.service.payorder.query.PayOrderQueryInnerService;
import org.apache.commons.lang3.math.NumberUtils;
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.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;

@Service("com.zteits.ipay.biz.AliWxPayServiceImpl")
public class AliWxPayServiceImpl implements AliWxPayService{
	private static final Logger logger = LoggerFactory.getLogger(AliWxPayServiceImpl.class);
	@Autowired
	private PubBusiInnerRouteService busiInnerRouteService;
	@Autowired
	private AliWxinPayInnerRouteService aliWxinPayInnerRouteService;
	@Autowired
	private TransfersInnerService transfersInnerService;
	@Autowired
	private CommonBusiPayInnerService commonBusiPayInnerService;
	@Autowired
	private TdCAcctPersonService tdCAcctPersonService;
	@Autowired
	private JPushService jPushService;
	@Autowired
	private PushPaySuccessMsgService pushPaySuccessMsgService;
	@Autowired
	private OrderParkDao orderParkDao;
	@Autowired
	private OrderVipcardDao orderVipcardDao;
	@Autowired
	private TdCCustPersonService tdCCustPersonService;
	@Autowired
	private PayOrderQueryInnerService payOrderQueryInnerService;
	@Autowired
	private AppOrgService appOrgService;
	@Autowired
	private Map<String,ParkPayNotifyThirdService> parkPayNotifyThirdServiceMap;
	@Autowired
	private PubPayOrderOperInnerService pubPayOrderOperInnerService;

	@Autowired
	private OrderParkAppOutTimeUpdateRecordDao orderParkAppOutTimeUpdateRecordDao;

	@Autowired
	private PDAParkOrderOperService pDAParkOrderOperService;
	@Autowired
	private DfGroundLockMsgPushService dfGroundLockMsgPushService;

	@Autowired
	private TdCRechargeCardOperService tdCRechargeCardOperService;
	@Autowired
	private TpPBerthsQueryService tpPBerthsQueryService;
	@Autowired
	private ParkingLotQueryService parkingLotQueryService;
	@Autowired
	private RedisCacheUtil redisCacheUtil;
	@Autowired
	private TVipTimeCardCustInfoService tVipTimeCardCustInfoService;

	@Autowired
	private OrderAppointmentDao orderAppointmentDao;

    @Autowired
    private PayOrderDao payOrderDao;
    @Autowired
    private TdCBusinessAcctService tdCBusinessAcctService;

    @Resource
    private TdCBusinessAcctPayoutService tdCBusinessAcctPayoutService;


	@Override
	@Transactional
	public BizResult<String> appPay(AliWeixinPayOrderCreateRequest request) throws Exception {
		/**创建支付单*/
		PayOrder payOrder = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).createOrUpPayOrder(request);

		/**获取支付宝/微信支付标题和回调参数*/
		PayNutifyEnum payNutifyEnum = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).getPayNotifyParams(payOrder.getPayOrderType());

		/**根据支付方式拼接字符串*/
		String orderInfo = aliWxinPayInnerRouteService.getRealService(Integer.valueOf(request.getPayType())).getAppPayString(payOrder.getOrgId(),payOrder.getCarNumber(),payOrder.getPayType(),payNutifyEnum,
				payOrder.getAppId(),payOrder.getPayOrderId(),payOrder.getOrderActFee(),request.getOpenId(),request.getSpbillCreateIp(),request.getTerminalSource());

		return new BizResult<String>(orderInfo);

	}
	@Override
	@Transactional
	public BizResult<Boolean> payNotify(AliPayNotifyRequest request) throws Exception {

		/**验证参数，获取相关支付信息*/
		AliWxinPayNotifyDTO aliWxinPayNotifyDTO = aliWxinPayInnerRouteService.getRealService(Integer.valueOf(request.getPayType())).getPayInfoByPayNotify(request);

		if(aliWxinPayNotifyDTO.getIsRepetData()!=null && aliWxinPayNotifyDTO.getIsRepetData()){
			/**重复数据，已经处理成功了*/
			return new BizResult<Boolean>(true);
		}
		this.getPassBackParams(aliWxinPayNotifyDTO);
		// 支付方式赋值
		aliWxinPayNotifyDTO.setPayType(request.getPayType());
		logger.info("回调==支付方式:"+aliWxinPayNotifyDTO.getPayType());
		/**支付成功，处理相关的业务逻辑*/
		PayOrderDTO payOrder = busiInnerRouteService.getRealServiceByPassBackParams(aliWxinPayNotifyDTO.getPassback_params()).payNotifyDeal(aliWxinPayNotifyDTO);
		if(payOrder.getCouponType() == APPdisEnum.CASH_COUPON_DIS.value()) {
			/**如果是代金券抵扣,需要抵扣代金券金额*/
			AccountPayFeeForAccountRequest accountPayFeeForAccountRequest = new AccountPayFeeForAccountRequest();
			accountPayFeeForAccountRequest.setOrderId(payOrder.getRltOrderId());
			accountPayFeeForAccountRequest.setOrderType(payOrder.getOrderBigType());
			accountPayFeeForAccountRequest.setCustId(payOrder.getCustId());
			accountPayFeeForAccountRequest.setPayOrderType(Integer.valueOf(payOrder.getPayOrderType()));
			accountPayFeeForAccountRequest.setPayOrderId(payOrder.getPayOrderId());
			accountPayFeeForAccountRequest.setPayFee(new BigDecimal(payOrder.getOrderDicountFee()));
			accountPayFeeForAccountRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
			accountPayFeeForAccountRequest.setOrgId(payOrder.getOrgId());
			accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_CASH_COUPON.value());
			tdCAcctPersonService.accountPayFeeForAccount(accountPayFeeForAccountRequest);
		}
		/**个人卡券修改*/
		commonBusiPayInnerService.updateCouponPerson(payOrder.getCouponPersonId(), payOrder.getRltOrderId(), payOrder.getPayOrderId());
		/**更改停车券状态*/
		commonBusiPayInnerService.updateCouponRuleUseState(payOrder);
		/**更改第三方优惠*/
		commonBusiPayInnerService.updateThirdCouponRule(payOrder);
		/**更改农行充值优惠*/
		logger.info("更改农行充值优惠payOrder.getThirdDiscFee():"+payOrder.getThirdDiscFee());
		commonBusiPayInnerService.updateABCBankCouponRule(payOrder);
		/**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
		pushPaySuccessMsgService.sendPaySuccessMsg(Arrays.asList(payOrder));

		return new BizResult<Boolean>(true);
	}

	/**
	 * 获取业务路由
	 * @param
	 * @return
	 * @Author: xiejianpeng
	 * @Date: 2021/2/23 14:35
	 *
	 */
	private void getPassBackParams(AliWxinPayNotifyDTO aliWxinPayNotifyDTO ){
		/**查询支付单信息*/
		PayOrder payOrder = payOrderDao.queryPayOrderByPayOrderId(aliWxinPayNotifyDTO.getOutTradeNo());
		if(StringUtils.isNotEmpty(aliWxinPayNotifyDTO.getPassback_params())){
			return;
		}
		String passback_params = "";
		PayOrderTypeEnum payOrderTypeEnum = PayOrderTypeEnum.getValue(payOrder.getPayOrderType());

		switch (payOrderTypeEnum){
			case PARK_PAY:
				passback_params = PayNutifyEnum.APP_ALI_ORDER_PARK_NUTIFY.getCode();
				break;
			case PARKPRE_PAY:
				passback_params = PayNutifyEnum.APP_ALI_ORDER_PRE_PARK_NUTIFY.getCode();
				break;
			case PARKBACK_PAY:
				passback_params = PayNutifyEnum.APP_ALI_ARREARAGE_BACK_NUTIFY.getCode();
				break;
			case BALANCE_PAY:
				passback_params = PayNutifyEnum.BALANCE_PAY_NUTIFY.getCode();
				break;
			case DEPOSIT_PAY:
				passback_params = PayNutifyEnum.DEPOSIT_PAY_NUTIFY.getCode();
				break;
			case BATTERY_CHARGE_PAY:
				passback_params = PayNutifyEnum.BATTERY_CHARGE_PAY_NUTIFY.getCode();
				break;
			case VIP_CARD_ADDED:
				passback_params = PayNutifyEnum.APP_ALI_VIP_CARD_ADD_NUTIFY.getCode();
				break;
			case VIP_CARD_RENEW:
				passback_params = PayNutifyEnum.APP_ALI_VIP_CARD_EDIT_NUTIFY.getCode();
				break;
			case AREA_VIP_CARD_ADDED:
				passback_params = PayNutifyEnum.APP_ALI_AREA_CARD_ADD_NUTIFY.getCode();
				break;
			case AREA_VIP_CARD_CHANGE_CARNUM:
				passback_params = PayNutifyEnum.APP_ALI_AREA_CARD_EDIT_NUTIFY.getCode();
				break;
			case TIME_VIP_CARD_ADDED:
				passback_params = PayNutifyEnum.APP_ALI_TIME_CARD_ADD_NUTIFY.getCode();
				break;
			case TIME_VIP_CARD_CHANGE_CARNUM:
				passback_params = PayNutifyEnum.APP_ALI_TIME_CARD_EDIT_NUTIFY.getCode();
				break;
			case BERTH_APPOINTMENT:
				passback_params = PayNutifyEnum.BERTH_APPOINTMENT_NUTIFY.getCode();
				break;
			case CHARGE_PRE_PAY:
				passback_params = PayNutifyEnum.APP_PRDER_CHARGE_PAY_NUTIFY.getCode();
				break;
			default:
                passback_params = "";
                break;
		}
        aliWxinPayNotifyDTO.setPassback_params(passback_params);

	}

	@Override
	@Transactional
	public BizResult<String> transfers(AliWeixinTransfersRequest request) {
		/**保存提现记录*/
		OrderTransfer orderTransfer = transfersInnerService.saveOrderTransfe(request);
		if(orderTransfer==null){
			throw new BizException(ErrorType.APP_ERROR,"保存提现记录异常");
		}
		/**调用真正的提现（转账）服务*/
		TransfersResultDTO response = aliWxinPayInnerRouteService.getRealService(Integer.valueOf(request.getPayType())).transfers(request,orderTransfer);

		if (response.getIsSuccess()){
			orderTransfer.setTransferFinishTime(response.getTransferFinishTime());
			orderTransfer.setTransactionId(response.getTransactionId());
			orderTransfer.setActFee(request.getTotalFee());
			orderTransfer.setOrderState(OrderStateEnum.REFUND_SUCCESS.value());
			transfersInnerService.updateOrderTransfer(orderTransfer);
			transfersInnerService.updateTransferAcctPerson(request, orderTransfer);
		}else {
			orderTransfer.setOrderState(OrderStateEnum.ALL_REFUND_FAIL.value());
			orderTransfer.setErrorCode(response.getErrorCode());
			orderTransfer.setErrorMsg(response.getErrorMsg());
			transfersInnerService.updateOrderTransfer(orderTransfer);
		}
		return new BizResult<>(orderTransfer.getOrderId());
	}

	@Override
	@Transactional
	public BizResult<Integer> accountPay(AccountPayRequest request) {
		logger.info("begin个人账户支付ServiceImpl,入参={}",JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);
		/**获取orgID*/
		Long orgId = this.getOrgIdByOrderId(request);
//		SysCodeValueDTO sysCodeValueDTO = SysCodeValueCacheUtil.queryCodeValueDTO(CodeValKindEnum.SPECIAL_ORG_CONFIG);
//		logger.info("begin个人账户充值--sysCodeValueDTO"+JSONObject.toJSON(sysCodeValueDTO));

		request.setOrgId(orgId);
//		Long otherOrgId = orgId;
//		//订单属于赤峰市医院组织，使用赤峰中智账户余额支付，不影响用户体验
//		if(sysCodeValueDTO != null){
//			String codeValue = sysCodeValueDTO.getCodeValue();
//			String codeValueDesc = sysCodeValueDTO.getCodeValueDesc();
//			if(codeValue.equals(request.getOrgId().toString())){
//				 otherOrgId  = Long.valueOf(codeValueDesc);
//			}
//		}

		/**判断个人账户余额是否充足*/
		validateBalanceEnough(request.getCustId(),request.getPayFee(),orgId);
		/**扣除个人账户金额*/
		List<AcctPayoutDTO> dtoList = this.queryPayFeeByAcctPerson(request,orgId);
		/**调用业务处理*/
		List<PayOrderDTO> payOrders = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).accountPay(request,dtoList);
		/**个人卡券修改*/
		commonBusiPayInnerService.updateCouponPerson(payOrders.get(0).getCouponPersonId(),
				payOrders.get(0).getRltOrderId(), payOrders.get(0).getPayOrderId());
		/**更改停车券状态*/
		commonBusiPayInnerService.updateCouponRuleUseState(payOrders.get(0));
		/**支付单支付完成,修改order表支出金额对应的订单**/
		for(PayOrderDTO dto : payOrders){
			AccountPayFeeForAccountRequest accountPayFeeForAccountRequest = new AccountPayFeeForAccountRequest();
			accountPayFeeForAccountRequest.setOrderId(dto.getRltOrderId());
			accountPayFeeForAccountRequest.setOrderType(dto.getOrderBigType());
			accountPayFeeForAccountRequest.setCustId(request.getCustId());
			accountPayFeeForAccountRequest.setPayOrderType(Integer.valueOf(request.getPaySrcType()));
			accountPayFeeForAccountRequest.setPayOrderId(dto.getPayOrderId());
			accountPayFeeForAccountRequest.setPayFee(new BigDecimal(dto.getOrderActFee()));
			accountPayFeeForAccountRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
			accountPayFeeForAccountRequest.setOrgId(dto.getOrgId());
			if(dto.getPayType() == PayTypeEnum.ZH.getValue()){
				accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_RECHARGE.value());
			}else if(dto.getPayType() == PayTypeEnum.SHAREZH.getValue()){
				accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_SHARE_BERTH.value());
			}else{
				accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_SEND_RECHARGE.value());
			}
			BizResult<Boolean> bizResult = tdCAcctPersonService.accountPayFeeForAccount(accountPayFeeForAccountRequest);
			if(!bizResult.isSuccess() || !bizResult.getErrCode().getCode().equals(ErrorType.BIZ_SUCCESS.getCode())){
				throw new BizException(bizResult.getErrCode(),bizResult.getErrMsg(),false);
			}
			if(dto.getCouponType() != null){
				/**如果是代金券抵扣,需要抵扣代金券金额*/
				if(dto.getCouponType() == APPdisEnum.CASH_COUPON_DIS.value() && dto.getOrderDicountFee() != 0L){
					accountPayFeeForAccountRequest.setOrderId(dto.getRltOrderId());
					accountPayFeeForAccountRequest.setOrderType(dto.getOrderBigType());
					accountPayFeeForAccountRequest.setCustId(request.getCustId());
					accountPayFeeForAccountRequest.setPayOrderType(Integer.valueOf(request.getPaySrcType()));
					accountPayFeeForAccountRequest.setPayOrderId(dto.getPayOrderId());
					accountPayFeeForAccountRequest.setPayFee(new BigDecimal(dto.getOrderDicountFee()));
					accountPayFeeForAccountRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
					accountPayFeeForAccountRequest.setOrgId(dto.getOrgId());
					accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_CASH_COUPON.value());
					BizResult<Boolean> bizResult1 = tdCAcctPersonService.accountPayFeeForAccount(accountPayFeeForAccountRequest);
					if(!bizResult1.isSuccess() || !bizResult1.getErrCode().getCode().equals(ErrorType.BIZ_SUCCESS.getCode())){
						throw new BizException(bizResult1.getErrCode(),bizResult1.getErrMsg(),false);
					}
				}
			}
		}

		/**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
		// 由于消息接收那边会去查询本事务内新增的数据，所以这里要保证事务结束以后，再发送数据
		TransactionSynchronizationManager.registerSynchronization(
				new TransactionSynchronizationAdapter() {
					@Override
					public void afterCommit() {
						logger.warn("个人账户支付事务结束后，发送消息");
						pushPaySuccessMsgService.sendPaySuccessMsg(payOrders);
					}
				}
		);

		return new BizResult<Integer>(CollectionUtils.isNotEmpty(payOrders)?1:0);
	}
	/**
	 * 商户账户余额支付
	 */
	@Override
	public BizResult<Integer> busAccountPay(BusAccountPayRequest request) {
		logger.info("begin商户账户支付 busAccountPay--,入参={}", JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);
		// 判断账户余额是否充足
		List<TdCBusinessAcctDTO> dtoList = validateBusAccountBalanceEnough(request.getCustId(), request.getPayFee());

		/**调用业务处理*/
		List<PayOrderDTO> payOrders = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).busAccountPay(request, dtoList);

		// 购买优惠券的就不推送了
		if (PayOrderTypeEnum.BUS_COUPON_BUY.value() != NumberUtils.toInt(request.getPaySrcType())) {
			pushPaySuccessMsgService.sendPaySuccessMsg(payOrders);
		}

		/**增加商户代缴支付成功后，后续的业务逻辑处理 1、更新账户余额  2、保存商户账户支出明细*/
		if (PayOrderTypeEnum.PARK_PAY.value() == NumberUtils.toInt(request.getPaySrcType())) {

			TdCBusinessAcctDTO businessAcctDTO = dtoList.get(0);
			// 商户扣除余额金额
			this.updateBusAcctBalance(businessAcctDTO, request);

			// 商户增加余额支出信息
			this.addBusAcctPayout(businessAcctDTO, request, payOrders.get(0));
		}

		return new BizResult<>(1);
	}

	// 商户扣除余额金额
	private void updateBusAcctBalance(TdCBusinessAcctDTO businessAcctDTO, BusAccountPayRequest request) {
		Long payFee = request.getPayFee();

		TdCBusinessAcctRequest updateRequest = new TdCBusinessAcctRequest();
		updateRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
		updateRequest.setId(businessAcctDTO.getId());
		// 修改余额
		updateRequest.setAcctBalance(businessAcctDTO.getAcctBalance() != null ? businessAcctDTO.getAcctBalance()
				.subtract(BigDecimal.valueOf(payFee)) : businessAcctDTO.getAcctBalance());
		updateRequest.setModifyDate(new Date());
		// 更新余额
		BizResult<Boolean> booleanBizResult = tdCBusinessAcctService.updateByPrimaryKeySelective(updateRequest);

		businessAcctDTO.setAcctBalance(updateRequest.getAcctBalance());
	}

	// 商户增加余额支出信息
	private void addBusAcctPayout(TdCBusinessAcctDTO businessAcctDTO, BusAccountPayRequest request,
								  PayOrderDTO payOrderDTO) {
		String payoutBillId = SequenceUtil.getNextId(SequenceTypeEnum.ACCOUNT_BULL_ID_C_SQE);
		TdCBusinessAcctPayoutRequest addRequest = new TdCBusinessAcctPayoutRequest();
		addRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
		addRequest.setPayoutBillId(payoutBillId);
		addRequest.setAcctId(businessAcctDTO.getAcctId());
		addRequest.setBusinessId(businessAcctDTO.getBusinessId());
		addRequest.setBusinessName(businessAcctDTO.getBusinessName());
		addRequest.setUserPhone(businessAcctDTO.getUserPhone());
		addRequest.setAcctType(businessAcctDTO.getAcctType());
		addRequest.setTradeType(request.getTradeType());
		addRequest.setTradeDetialType(NumberUtils.toInt(request.getPaySrcType()));
		addRequest.setTradeFee(BigDecimal.valueOf(request.getPayFee()));
		addRequest.setTradeBalance(businessAcctDTO.getAcctBalance());


		addRequest.setTraderId(request.getUserCode());
		addRequest.setTraderName(request.getUserName());
		addRequest.setTradeTime(new Date());
		addRequest.setRltPayorderId(payOrderDTO.getPayOrderId());
		addRequest.setRltOrderId(payOrderDTO.getRltOrderId());
		addRequest.setRltOrderType(payOrderDTO.getOrderBigType() + "");
		addRequest.setCarNumber(payOrderDTO.getCarNumber());
		//20221209增加保存车场编码
		addRequest.setPlNo(request.getPlNo());
		logger.info("商户保存支出明细:{}", addRequest);
		tdCBusinessAcctPayoutService.saveTdCBusinessAcctPayout(addRequest);

	}

	private List<TdCBusinessAcctDTO> validateBusAccountBalanceEnough(String custId, Long payFee) {
		TdCBusinessAcctRequest request = new TdCBusinessAcctRequest();
		request.setSysCode(BasicEnum.SYS_CODE.getValue());
		request.setBusinessId(custId);
		request.setAcctType(AccountTypeEnum.ACCT_RECHARGE.value());
		request.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
		BizResult<List<TdCBusinessAcctDTO>> listBizResult = tdCBusinessAcctService.queryTdCBusinessAcct(request);
		TdCBusinessAcctDTO acctDTO = null;
		if (listBizResult.isSuccess() && CollectionUtils.isNotEmpty(listBizResult.getData())) {
			acctDTO = listBizResult.getData().get(0);
			if (acctDTO.getAcctBalance().compareTo(new BigDecimal(payFee)) < 0) {
				throw new BizException(ErrorType.ACCOUNT_NO_MONEY, "账户余额不足,请充值");
			}

			return listBizResult.getData();
		}

		throw new BizException(ErrorType.ACCOUNT_NO_MONEY, "找不到有效的充值账户!");


	}

	@Override
	public BizResult<String> aliH5Pay(AliWeixinPayOrderCreateRequest request) throws Exception {
		/**创建支付单*/
		PayOrder payOrder = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).createOrUpPayOrder(request);

		/**获取支付宝/微信支付标题和回调参数*/
		PayNutifyEnum payNutifyEnum = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).getPayNotifyParams(payOrder.getPayOrderType());

		/**根据支付方式拼接字符串*/
		String orderInfo = aliWxinPayInnerRouteService.getRealService(Integer.valueOf(request.getPayType())).getAppPayString(payOrder.getOrgId(),payOrder.getCarNumber(),payOrder.getPayType(),payNutifyEnum,
				payOrder.getAppId(),payOrder.getPayOrderId(),payOrder.getOrderActFee(),request.getOpenId(),request.getSpbillCreateIp(),request.getTerminalSource());

		return new BizResult<String>(orderInfo);
	}

	@Override
	@Transactional
	public BizResult<Boolean> accountRechargeByParkCard(AliWeixinPayOrderCreateRequest request) {

		logger.info("begin个人账户充值--充值卡ServiceImpl,入参={}",JSONObject.toJSON(request));
		/**创建完成支付单-和账户充值*/
		PayOrder payOrder = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).createRechargePayOrder(request);


		/**修改充值卡的状态*/
		TdCRechargeCardRequest req = new TdCRechargeCardRequest();
		req.setCardNo(request.getCouponPersonId());
		req.setRemark("用户:"+request.getAccountRechargeRequest().getsOpName()+"用于充值缴费");
		req.setIsUsed(RechargeCardEnum.UsedEnum.USED.getCode());
		req.setUsedDate(new Date());
		req.setRltOrderId(payOrder.getRltOrderId());
		req.setRltPayOrderId(payOrder.getPayOrderId());
		req.setUsedCustId(request.getCustId());
		req.setUsedPhone(request.getAccountRechargeRequest().getsOpName());
		req.setSysCode(BasicEnum.SYS_CODE.getValue());
		tdCRechargeCardOperService.updateRechargeCardStatusByCardNo(req);

		return new BizResult<>(true);
	}
	/**
	 * 补缴使用优惠券后变成 "0" 元支付的处理过程
	 */
	public BizResult<Boolean> zeroPayOfArrearageInCoupon(ZeroPayRequest request) {

		logger.info("begin支付欠费-使用优惠券后0元支付处理,入参={}", JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);
		if (!request.getPayOrderType().equals(PayOrderTypeEnum.PARKBACK_PAY.value() + "")) {
			logger.error("该订单orderId:" + request.getOrderId() + "不是欠费订单");
			throw new BizException(ErrorType.PARAM_NOT_VALID, "不是欠费订单", false, false);
		}

		/**根据停车订单ID 查询停车订单信息***/
		OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(request.getOrderId());
		if (orderPark != null
				&& orderPark.getParkState().equals(ParkStateEnum.OUT.getValue())
				&& !orderPark.getOrderState().equals(OrderStateEnum.ARREARAGE.value())) {
			throw new BizException(ErrorType.PARK_SEND_FAIL, "订单已支付", false, false);
		}

		/**创建支付单*/
		AliWeixinPayOrderCreateRequest payOrderRequest = new AliWeixinPayOrderCreateRequest();

		payOrderRequest.setOrderId(request.getOrderId());
		if ((TerminalSourceEnum.WECHAT_APPLET.value() + "").equals(payOrderRequest.getTerminalSource())) {
			payOrderRequest.setPayType(PayOrderEnum.PAY_TYPE_APPLETS.getValue());
		} else {
			payOrderRequest.setPayType(PayOrderEnum.PAY_TYPE_WXGZH.getValue());
		}
		// 补缴单103
		payOrderRequest.setPaySrcType(PayOrderTypeEnum.PARKBACK_PAY.value() + "");
		if (null != request.getTerminalSource()) {
			payOrderRequest.setTerminalSource(request.getTerminalSource() + "");
		} else {
			payOrderRequest.setTerminalSource(TerminalSourceEnum.WECHAT_APPLET.value() + "");
		}
		payOrderRequest.setPayFee(new BigDecimal("0"));
		if (orderPark != null) {
			payOrderRequest.setCustId(orderPark.getCustId());
		}
		payOrderRequest.setCouponPersonId(request.getCouponPersonId());
		payOrderRequest.setAppId("");
		payOrderRequest.setAccountRechargeRequest(null);
		payOrderRequest.setCarNumber(orderPark.getCarNumber());

		List<ArrearageRecordInfo> recordInfos = new ArrayList<>();
		ArrearageRecordInfo arrearageRecordInfo = new ArrearageRecordInfo();
		arrearageRecordInfo.setOrderId(request.getOrderId());
		arrearageRecordInfo.setParkId(orderPark.getPlNo());
		arrearageRecordInfo.setOrderNotPayFee(Long.valueOf(0));
		recordInfos.add(arrearageRecordInfo);
		String strArrearageRecordInfo = JSON.toJSONString(recordInfos);
		logger.info("封装欠费记录信息数组转字符串：{}", strArrearageRecordInfo);
		payOrderRequest.setRecordArreaInfos(strArrearageRecordInfo);

		payOrderRequest.setBackTotalFee(orderPark.getArrearageFee());
		payOrderRequest.setOpenId("");
		payOrderRequest.setSourceType(null);
		payOrderRequest.setSpbillCreateIp("");

		Long orgId = Long.valueOf(SysCodeValueCacheUtil.queryCodeValue(CodeValKindEnum.SYS_ORG_ID_RECHARGR));
		payOrderRequest.setOrgId(orgId);

		payOrderRequest.setBackDeveloperCode("");
		payOrderRequest.setBackDeveloperName("");

		payOrderRequest.setBusCouponNo("");
		payOrderRequest.setBusDiscValue(null);
		logger.info("开始处理使用优惠券补缴欠费：{}", JSON.toJSONString(payOrderRequest));

		payOrderRequest.setsOpName("");
		payOrderRequest.setsOpId(null);
		payOrderRequest.setBackType(1);

		// 生成欠费订单和欠费订单明细
		PayOrder payOrder = busiInnerRouteService.getRealService(Integer.valueOf(payOrderRequest.getPaySrcType())).createOrUpPayOrder(payOrderRequest);

		AliWxinPayNotifyDTO aliWxinPayNotifyDTO = new AliWxinPayNotifyDTO();
		aliWxinPayNotifyDTO.setNotifyTime(DateUtil.getDateString(DateUtil.YYYYMMDDHHMMSS));
		aliWxinPayNotifyDTO.setTradeNo("");
		aliWxinPayNotifyDTO.setOutTradeNo(payOrder.getPayOrderId());
		aliWxinPayNotifyDTO.setBuyerLogonId("");
		aliWxinPayNotifyDTO.setSellerEmail("");
		aliWxinPayNotifyDTO.setPassback_params(PayNutifyEnum.APP_ALI_ARREARAGE_BACK_NUTIFY.getCode());
		aliWxinPayNotifyDTO.setReceiptAmount("0");

		/** 支付成功，处理相关的业务逻辑 **/
		PayOrderDTO payOrderDTO = busiInnerRouteService.getRealServiceByPassBackParams(aliWxinPayNotifyDTO.getPassback_params()).payNotifyDeal(aliWxinPayNotifyDTO);
		/**个人卡券修改*/
		commonBusiPayInnerService.updateCouponPerson(request.getCouponPersonId()
				, payOrderDTO.getRltOrderId()
				, payOrderDTO.getPayOrderId()
				, payOrderDTO.getOrderDicountFee()
				, payOrderDTO.getPayFinishTime());
		/**发送支付成功消息*/
		pushPaySuccessMsgService.sendPaySuccessMsg(Arrays.asList(payOrderDTO));
		return new BizResult<>(true);
	}

	@Override
	@Transactional
	public BizResult<Boolean> zeroPay(ZeroPayRequest request) {
		logger.info("begin零元支付,入参={}",JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);
		if(!request.getPayOrderType().equals(PayOrderTypeEnum.PARK_PAY.value()+"")){
			logger.error("该订单orderId:"+request.getOrderId()+"暂时不支持0元支付");
			throw new BizException(ErrorType.PARAM_NOT_VALID,"该功能暂不支持0元支付",false,false);
		}
		/**根据停车订单ID 查询停车订单信息***/
		OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(request.getOrderId());
		if(orderPark!=null && orderPark.getParkState().equals(ParkStateEnum.OUT.getValue())&&
				!SourceTypeEnum.SHARED_BERTHS.getValue().equals(orderPark.getSourceType())){
			throw new BizException(ErrorType.PARK_SEND_FAIL,"订单已支付",false,false);
		}
		/**更新支付单状态-支付完成**/
		PayOrder payOrder = payOrderQueryInnerService.queryWaitPayOrder(request.getOrderId(), request.getTerminalSource());
		if (payOrder == null) {
			logger.error("payOrder == null 0元不创建支付单");
			if(orderPark.getOrderState() == OrderStateEnum.PAYED.value()) {
				//判断sourceType，如果是德飞地锁，则降下车锁
				if((SourceTypeEnum.DEFEI.getValue()).equals(orderPark.getSourceType())){
					try {
						this.openTheDfLockForPaid(orderPark);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "您已经支付，请及时离场", false, false);
			}else{
				throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "停车费为0元，请申请离场", false, false);
			}
		}
		if(payOrder.getOrderTotalFee()==0){
			logger.error("order"+request.getOrderId()+"payOrderId:"+payOrder.getPayOrderId()+"，停车费为0元，不允许支付");
			if(orderPark.getOrderState() == OrderStateEnum.PAYED.value()) {
				//判断sourceType，如果是德飞地锁，则降下车锁
				if((SourceTypeEnum.DEFEI.getValue()).equals(orderPark.getSourceType())){
					try {
						this.openTheDfLockForPaid(orderPark);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "您已经支付，请及时离场", false, false);
			}else{
				throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "停车费为0元，请申请离场", false, false);
			}
		}
		if(payOrder.getOrderActFee()>0){
			logger.error("order"+request.getOrderId()+"payOrderId:"+payOrder.getPayOrderId()+"，应支付金额不为0，无法0元支付出场");
			throw new BizException(ErrorType.PAY_ORDER_FEE_NOT_ZERO, "该订单费用不为0，请先支付再申请出场", false,false);

//			throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "应支付金额不为0，无法0元支付出场", false,false);
		}
		/**更新支付单信息*/
		PayOrder updatePayOrderInfoDO = new PayOrder();
		updatePayOrderInfoDO.setPayType(PayTypeEnum.ZH.getValue());
		updatePayOrderInfoDO.setCouponPersonId(request.getCouponPersonId());
		//增加支付中状态
		updatePayOrderInfoDO.setPayOrderState(OrderStateEnum.PAYED.value());
		updatePayOrderInfoDO.setPayFinishTime(new Date());
		updatePayOrderInfoDO.setAppId("no_app_id");
		updatePayOrderInfoDO.setChargerCode(orderPark.getParkInSourceCode());
		updatePayOrderInfoDO.setChargerName(orderPark.getParkInSourceName());
		pubPayOrderOperInnerService.updatePayOrderState(updatePayOrderInfoDO,payOrder.getPayOrderId());
		//回填变化的值
		payOrder.setPayType(updatePayOrderInfoDO.getPayType());
		payOrder.setCouponPersonId(updatePayOrderInfoDO.getCouponPersonId());
		payOrder.setAppId(updatePayOrderInfoDO.getAppId());
		payOrder.setPayFinishTime(updatePayOrderInfoDO.getPayFinishTime());
		payOrder.setPayOrderState(updatePayOrderInfoDO.getPayOrderState());
		payOrder.setChargerCode(updatePayOrderInfoDO.getChargerCode());
		payOrder.setChargerName(updatePayOrderInfoDO.getChargerName());
		redisCacheUtil.put(payOrder.getPayOrderId(),JSONObject.toJSONString(orderPark),3600L);

		/**根据数据来源路由具体的通知服务*/
		ParkPayNotifyThirdService notifyThirdService = ParkPayNotifyThirdServiceRoute.selectorParkPayNotifyThirdService(SourceTypeEnum.getEnumByValue(orderPark.getSourceType()), parkPayNotifyThirdServiceMap);
		/**根据数据来源类型，通知第三方，例如青岛，艾润*/
		notifyThirdService.payResultNotify(payOrder, orderPark,new CommonPayRequest());
		/**个人卡券修改*/
		commonBusiPayInnerService.updateCouponPerson(payOrder.getCouponPersonId(),
				payOrder.getRltOrderId(), payOrder.getPayOrderId());
		/**更改停车券状态*/
		PayOrderDTO dto = new PayOrderDTO();
		BeanUtils.copyProperties(payOrder,dto);
		commonBusiPayInnerService.updateCouponRuleUseState(dto);
		/**如果是代金券抵扣,需要抵扣代金券金额*/
		if(payOrder.getCouponType() != null && payOrder.getCouponType() == APPdisEnum.CASH_COUPON_DIS.value() && payOrder.getOrderDicountFee() != 0L){
			AccountPayFeeForAccountRequest accountPayFeeForAccountRequest = new AccountPayFeeForAccountRequest();
			accountPayFeeForAccountRequest.setOrderId(dto.getRltOrderId());
			accountPayFeeForAccountRequest.setOrderType(dto.getOrderBigType());
			accountPayFeeForAccountRequest.setCustId(payOrder.getCreateEmpId());
			accountPayFeeForAccountRequest.setPayOrderType(Integer.valueOf(request.getPayOrderType()));
			accountPayFeeForAccountRequest.setPayOrderId(dto.getPayOrderId());
			accountPayFeeForAccountRequest.setPayFee(new BigDecimal(dto.getOrderDicountFee()));
			accountPayFeeForAccountRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
			accountPayFeeForAccountRequest.setOrgId(dto.getOrgId());
			accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_CASH_COUPON.value());
			BizResult<Boolean> bizResult1 = tdCAcctPersonService.accountPayFeeForAccount(accountPayFeeForAccountRequest);
			if(!bizResult1.isSuccess() || !bizResult1.getErrCode().getCode().equals(ErrorType.BIZ_SUCCESS.getCode())){
				throw new BizException(bizResult1.getErrCode(),bizResult1.getErrMsg(),false);
			}
		}
		/**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
		pushPaySuccessMsgService.sendPaySuccessMsg(Arrays.asList(dto));
		logger.info("零元支付成功，orderId:"+request.getOrderId()+"payOrderId:"+payOrder.getPayOrderId());
		return new BizResult<>(true);
	}

	@Override
	@Transactional
	public BizResult<Boolean> zeroPayForTimeCard(ZeroPayForTimeCardRequest request) {
		logger.info("时域卡-begin零元支付,入参={}",JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);

		/**根据停车订单ID 查询停车订单信息***/
		OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(request.getOrderId());
		logger.info("时域卡-begin零元支付,订单{}",JSONObject.toJSON(orderPark));
		if(orderPark!=null && orderPark.getParkState().equals(ParkStateEnum.OUT.getValue())&&
				!SourceTypeEnum.SHARED_BERTHS.getValue().equals(orderPark.getSourceType())){
			throw new BizException(ErrorType.PARK_SEND_FAIL,"订单已支付",false,false);
		}

		/**更新支付单状态-支付完成**/
		PayOrder payOrder = payOrderQueryInnerService.queryWaitPayOrder(request.getOrderId(), request.getTerminalSource());
		if (payOrder == null) {
			logger.error("payOrder == null 0元不创建支付单");
			if(orderPark.getOrderState() == OrderStateEnum.PAYED.value()) {
				//判断sourceType，如果是德飞地锁，则降下车锁
				if((SourceTypeEnum.DEFEI.getValue()).equals(orderPark.getSourceType())){
					try {
						this.openTheDfLockForPaid(orderPark);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "您已经支付，请及时离场", false, false);
			}else{
				throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "停车费为0元，请申请离场", false, false);
			}
		}

		/**
		 * 使用时域卡进行抵扣
		 * 2020年5月28日18:09:37
		 */
		UseTimeVipCardReq timeCardReq = new UseTimeVipCardReq();
		timeCardReq.setSysCode(BasicEnum.SYS_CODE.getValue());
		timeCardReq.setParkingDuration(request.getParkFeeDuration());
		timeCardReq.setPlNo(orderPark.getPlNo());
		timeCardReq.setCustId(orderPark.getCustId());
		timeCardReq.setCarNumber(orderPark.getCarNumber());
		timeCardReq.setOrderId(orderPark.getOrderId());
		logger.info("时域卡使用抵扣{}",JSONObject.toJSON(timeCardReq));
		BizResult<Boolean> cardResult = tVipTimeCardCustInfoService.useVipTimeCardByCarNumber(timeCardReq);
		logger.info("时域卡使用抵扣{}",JSONObject.toJSON(cardResult));
		if(!cardResult.getData()){
			throw new BizException(ErrorType.BIZ_ERROR,cardResult.getErrMsg());
		}

		/**更新支付单信息*/
		PayOrder updatePayOrderInfoDO = new PayOrder();
		updatePayOrderInfoDO.setPayType(PayTypeEnum.TIME_CARD_PAY.getValue());//时域卡支付
		updatePayOrderInfoDO.setCouponPersonId(request.getCouponPersonId());
		//增加支付中状态
		updatePayOrderInfoDO.setPayOrderState(OrderStateEnum.PAYED.value());
		updatePayOrderInfoDO.setPayFinishTime(new Date());
		updatePayOrderInfoDO.setAppId("no_app_id");
		updatePayOrderInfoDO.setChargerCode(orderPark.getParkInSourceCode());
		updatePayOrderInfoDO.setChargerName(orderPark.getParkInSourceName());
		updatePayOrderInfoDO.setOrderTotalFee(payOrder.getOrderTotalFee());//应收从支付单取
		updatePayOrderInfoDO.setOrderDicountFee(updatePayOrderInfoDO.getOrderTotalFee());//应收全部放入折扣
		updatePayOrderInfoDO.setOrderActFee(0L);//时域卡抵扣，费用为0
		updatePayOrderInfoDO.setRemark("时域卡抵扣，费用为0");
		pubPayOrderOperInnerService.updatePayOrderState(updatePayOrderInfoDO,payOrder.getPayOrderId());
		//回填变化的值
		payOrder.setPayType(updatePayOrderInfoDO.getPayType());
		payOrder.setCouponPersonId(updatePayOrderInfoDO.getCouponPersonId());
		payOrder.setAppId(updatePayOrderInfoDO.getAppId());
		payOrder.setPayFinishTime(updatePayOrderInfoDO.getPayFinishTime());
		payOrder.setPayOrderState(updatePayOrderInfoDO.getPayOrderState());
		payOrder.setChargerCode(updatePayOrderInfoDO.getChargerCode());
		payOrder.setChargerName(updatePayOrderInfoDO.getChargerName());
		payOrder.setOrderTotalFee(updatePayOrderInfoDO.getOrderTotalFee());//应收从支付单单取
		payOrder.setOrderDicountFee(updatePayOrderInfoDO.getOrderTotalFee());//应收全部放入折扣
		payOrder.setOrderActFee(0L);//时域卡抵扣，费用为0
		redisCacheUtil.put(payOrder.getPayOrderId(),JSONObject.toJSONString(orderPark),3600L);

		/**根据数据来源路由具体的通知服务*/
		ParkPayNotifyThirdService notifyThirdService = ParkPayNotifyThirdServiceRoute.selectorParkPayNotifyThirdService(SourceTypeEnum.getEnumByValue(orderPark.getSourceType()), parkPayNotifyThirdServiceMap);
		/**根据数据来源类型，通知第三方，例如青岛，艾润*/
		CommonPayRequest commonPayRequest = new CommonPayRequest();
		commonPayRequest.setTimeCardPayed(true);
		notifyThirdService.payResultNotify(payOrder, orderPark,commonPayRequest);
		/**个人卡券修改*/
//		commonBusiPayInnerService.updateCouponPerson(payOrder.getCouponPersonId(),
//				payOrder.getRltOrderId(), payOrder.getPayOrderId());
		/**更改停车券状态*/
		PayOrderDTO dto = new PayOrderDTO();
		BeanUtils.copyProperties(payOrder,dto);
//		commonBusiPayInnerService.updateCouponRuleUseState(dto);
//		/**如果是代金券抵扣,需要抵扣代金券金额*/
//		if(payOrder.getCouponType() != null && payOrder.getCouponType() == APPdisEnum.CASH_COUPON_DIS.value() && payOrder.getOrderDicountFee() != 0L){
//			AccountPayFeeForAccountRequest accountPayFeeForAccountRequest = new AccountPayFeeForAccountRequest();
//			accountPayFeeForAccountRequest.setOrderId(dto.getRltOrderId());
//			accountPayFeeForAccountRequest.setOrderType(dto.getOrderBigType());
//			accountPayFeeForAccountRequest.setCustId(payOrder.getCreateEmpId());
//			accountPayFeeForAccountRequest.setPayOrderType(Integer.valueOf(request.getPayOrderType()));
//			accountPayFeeForAccountRequest.setPayOrderId(dto.getPayOrderId());
//			accountPayFeeForAccountRequest.setPayFee(new BigDecimal(dto.getOrderDicountFee()));
//			accountPayFeeForAccountRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
//			accountPayFeeForAccountRequest.setOrgId(dto.getOrgId());
//			accountPayFeeForAccountRequest.setAcctType(AccountTypeEnum.ACCT_CASH_COUPON.value());
//			BizResult<Boolean> bizResult1 = tdCAcctPersonService.accountPayFeeForAccount(accountPayFeeForAccountRequest);
//			if(!bizResult1.isSuccess() || !bizResult1.getErrCode().getCode().equals(ErrorType.BIZ_SUCCESS.getCode())){
//				throw new BizException(bizResult1.getErrCode(),bizResult1.getErrMsg(),false);
//			}
//		}
		/**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
		pushPaySuccessMsgService.sendPaySuccessMsg(Arrays.asList(dto));
		logger.info("时域卡-零元支付成功，orderId:"+request.getOrderId()+"payOrderId:"+payOrder.getPayOrderId());
		return new BizResult<>(true);
	}

	/**
	 * 德飞地锁开锁请求
	 * @param orderPark
	 * 2019年8月28日 wangfei
	 * @throws InterruptedException
	 */
	private void openTheDfLockForPaid(OrderPark orderPark) throws InterruptedException {
		DfGroundLockOpenByPayPushRequest request = new DfGroundLockOpenByPayPushRequest();
		request.setSysCode(BasicEnum.SYS_CODE.getValue());
		request.setEqpNo(orderPark.getCarNumber());
		request.setPlNo(orderPark.getPlNo());
		BizResult<Boolean> result = dfGroundLockMsgPushService.pushGroundLockOpenByPay(request);
		logger.info("0元支付德飞开锁请求返回：{}",JSONObject.toJSON(result));

	}
	@Override
	public BizResult<Boolean> appApplyParkOut(ZeroPayRequest request) {
		logger.info("beginAPP申请离场,入参={}",JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);
		if(!request.getPayOrderType().equals(PayOrderTypeEnum.PARK_PAY.value()+"")){
			logger.error("该订单orderId:"+request.getOrderId()+"暂时不支持APP申请离场");
			throw new BizException(ErrorType.PARAM_NOT_VALID,"该功能暂不支持APP申请离场",false,false);
		}
		/**根据停车订单ID 查询停车订单信息***/
		OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(request.getOrderId());
		if(orderPark!=null && orderPark.getParkState().equals(ParkStateEnum.OUT.getValue())&&
				!SourceTypeEnum.SHARED_BERTHS.getValue().equals(orderPark.getSourceType())){
			throw new BizException(ErrorType.PARK_SEND_FAIL,"订单已支付",false,false);
		}
		/**更新支付单状态-支付完成**/
		PayOrder payOrder = payOrderQueryInnerService.queryWaitPayOrder(request.getOrderId(), request.getTerminalSource());
		if (payOrder == null) {
			logger.error("payOrder == null 0元不创建支付单");
			redisCacheUtil.put(RedisKeyEnum.PARK_ZERO_PAY_ORDER_ID.key() + request.getOrderId(), "1", TimeConstants.SECOND_1_WEEK);
			this.pushOutParkMsgForCharger(orderPark,request);
		}
		if(payOrder.getOrderTotalFee()==0){
			redisCacheUtil.put(RedisKeyEnum.PARK_ZERO_PAY_ORDER_ID.key() + request.getOrderId(), "1", TimeConstants.SECOND_1_WEEK);
			logger.error("order"+request.getOrderId()+"payOrderId:"+payOrder.getPayOrderId()+"，停车费为0元，APP申请离场");
			this.pushOutParkMsgForCharger(orderPark,request);
		}
		if(payOrder.getOrderActFee()>0){
			logger.error("order"+request.getOrderId()+"payOrderId:"+payOrder.getPayOrderId()+"，应支付金额不为0，无法0元支付出场");
			throw new BizException(ErrorType.PAY_ORDER_FEE_NOT_ZERO, "该订单费用不为0，请先支付再申请出场", false,false);
		}
		return new BizResult<>(true);
	}

	/**
	 * 微信JSAPI扫码支付
	 * @param request
	 * @Author: wangfs
	 * @return
	 */
	@Override
	@Transactional
	public BizResult<String> wxJSAPIPay( AliWeixinPayOrderCreateRequest request) throws Exception {
		/**创建支付单*/
		PayOrder payOrder = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).createOrUpPayOrder(request);
		/**获取支付宝/微信支付标题和回调参数*/
		PayNutifyEnum payNutifyEnum = busiInnerRouteService.getRealService(Integer.valueOf(request.getPaySrcType())).getPayNotifyParams(payOrder.getPayOrderType());

		/**根据支付方式拼接字符串*/
		String orderInfo = aliWxinPayInnerRouteService.getRealService(Integer.valueOf(request.getPayType())).getAppPayStringForNATIVE(payOrder.getOrgId(),payOrder.getCarNumber(),payOrder.getPayType(),payNutifyEnum,
				payOrder.getAppId(),payOrder.getPayOrderId(),payOrder.getOrderActFee(),request.getOpenId(),request.getSpbillCreateIp(),request.getTerminalSource());

		return new BizResult<String>(orderInfo);
	}

	/**
	 * 给收费员车主将要离场推送
	 * @param
	 * @return
	 * @Author: xiejianpeng
	 * @Date: 2019/6/19 16:20
	 *
	 */
	private void pushOutParkMsgForCharger(OrderPark orderPark,ZeroPayRequest requestZero) {
		if(orderPark.getSourceType() == SourceTypeEnum.ROAD_SIDE.getValue() || orderPark.getSourceType() == SourceTypeEnum.SELF_PARK.getValue()) {// 加上自助停车
			try {
				/**1.修改订单的APP操作出场时间**/
				OrderPark orderParkUpdate = new OrderPark();
				orderParkUpdate.setOrderId(orderPark.getOrderId());
				orderParkUpdate.setAppOptOutTime(new Date());
				orderParkDao.updateOrderParkByOrderId(orderParkUpdate);
				/**保存操作记录*/
				OrderParkAppOutTimeUpdateRecord appOutTimeUpdateRecord = new OrderParkAppOutTimeUpdateRecord();
				BeanUtils.copyProperties(orderPark,appOutTimeUpdateRecord);
				appOutTimeUpdateRecord.setTerminalSource(requestZero.getTerminalSource());
				appOutTimeUpdateRecord.setInOutType(OrderInOutTypeEnum.OUT_CUST_APPLY_TYPE.value());// 车主申请出场
				appOutTimeUpdateRecord.setOptDate(new Date());
				appOutTimeUpdateRecord.setCreateEmpId(orderPark.getCreateEmpId());
				appOutTimeUpdateRecord.setCreateEmpName(orderPark.getCreateEmpName());
				orderParkAppOutTimeUpdateRecordDao.saveOrderParkAppOutTimeUpdateRecord(appOutTimeUpdateRecord);

				/**2.先查询泊位的地磁上报的出场信息**/
				Date endFeeDate = null;
				//获取计费截至时间-出场取地磁上报的出场时间，判断依据：地磁上报的出场时间大于pda录入的进场时间，则取地磁上报的出场时间，否在取当前时间 add zwg 20180710
				QueryBerthByPlNoAndBerthNoRequest queryberthInfoByPlNoAndBerthNoRequest = new QueryBerthByPlNoAndBerthNoRequest();
				queryberthInfoByPlNoAndBerthNoRequest.setPlNo(orderPark.getPlNo());
				queryberthInfoByPlNoAndBerthNoRequest.setBerthNo(orderPark.getBerthNo());
				queryberthInfoByPlNoAndBerthNoRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
				BizResult<BerthsDTO> bizResult12 = tpPBerthsQueryService.queryBerthInfoByPlNoAndBerthNo(queryberthInfoByPlNoAndBerthNoRequest);
				BerthsDTO berthsDTO = ResultUtils.getBizResultData(bizResult12);
				if(berthsDTO!=null && berthsDTO.getEqpOutTime()!=null && berthsDTO.getEqpOutTime().after(orderPark.getParkInTime())){
					endFeeDate = (berthsDTO.getEqpOutTime());
				}
				/**处理特殊车场逻辑**/
				Integer isSpecial = 0;
				QueryParkLotInfoByPkNoRequest parkLotInfoByPkNoRequest = new QueryParkLotInfoByPkNoRequest();
				parkLotInfoByPkNoRequest.setPklNo(orderPark.getPlNo());
				parkLotInfoByPkNoRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
				BizResult<ParkingLotDTO> parkingLotDTO = parkingLotQueryService.QueryParkingLotByPkNo(parkLotInfoByPkNoRequest);
				if(parkingLotDTO.isSuccess() && parkingLotDTO.getData().getPlNo() != null ){
					isSpecial = parkingLotDTO.getData().getIsSpecial();
				}
				if(isSpecial == 1 && endFeeDate != null) {
					/**调用出场服务*/
					logger.info("车主申请离场进行自动出场-开始,custId={}", orderPark.getCustId());
					PayedFeeByCashRequest payedFeeByCashRequest = new PayedFeeByCashRequest();
					payedFeeByCashRequest.setChargerCode(orderPark.getCustId());
					payedFeeByCashRequest.setChargerName(orderPark.getCreateEmpName());
					payedFeeByCashRequest.setParkTotalFee(0L);
					payedFeeByCashRequest.setOrderTotalFee(0L);
					payedFeeByCashRequest.setOrderActFee(0L);
					payedFeeByCashRequest.setOrderDicountFee(0L);
					payedFeeByCashRequest.setOrderRefundFee(0L);
					payedFeeByCashRequest.setOrderId(orderPark.getOrderId());
					payedFeeByCashRequest.setIsBatchOutPark(false);
					payedFeeByCashRequest.setIsAutomaticOutPark(1);
					payedFeeByCashRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
					BizResult<String> bizResult1 = pDAParkOrderOperService.outParkPayedByCash(payedFeeByCashRequest);
					logger.info("地磁自动出场-结束:" + JSONObject.toJSONString(bizResult1));
				}else {
					/**3.车主进行离场操作，推送给收费员**/
					JPushMsgForPDARequest request = new JPushMsgForPDARequest();
					request.setBerthNo(orderPark.getBerthNo());
					Set<String> chargerCodes = new HashSet<>();
					chargerCodes.add(orderPark.getParkInSourceCode());
					request.setChargerCodes(chargerCodes);
					request.setParkState(orderPark.getParkState());
					request.setOrderId(orderPark.getOrderId());
					request.setCarNumber(orderPark.getCarNumber());
					request.setPdaMsgTypeEnum(PDAMsgTypeEnum.OUT_PARK_ALERT);
					request.setSysCode("ORDER");
					jPushService.sendPushPDAMsg(request);
				}
			} catch (Exception e) {
				logger.info("orderId :+" + orderPark.getOrderId() + "车主支付，给收费员推送消息失败", e);
			}
			throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "您已成功申请离场!", false,false);
		}else{
			throw new BizException(ErrorType.NOT_FOUND_PAY_ORDER, "停车费用0元,您可以直接离场!", false,false);
		}

	}

	/**
	 * 更新个人账户余额
	 * @param request
	 * 2018年4月26日 zhaowg
	 */
	private List<AcctPayoutDTO> queryPayFeeByAcctPerson(AccountPayRequest request,Long otherOrgId){
		//更新个人账户余额
		List<AcctPayoutDTO> dtoList = new ArrayList<>();
		AccountPayFeeForAccountRequest accountPayFeeForAccountRequest = new AccountPayFeeForAccountRequest();
		accountPayFeeForAccountRequest.setOrderId("-1");
		accountPayFeeForAccountRequest.setOrderType(-1);
		accountPayFeeForAccountRequest.setCustId(request.getCustId());
		accountPayFeeForAccountRequest.setPayOrderType(Integer.valueOf(request.getPaySrcType()));
		accountPayFeeForAccountRequest.setPayOrderId("-1");
		accountPayFeeForAccountRequest.setPayFee(new BigDecimal(request.getPayFee()));
		accountPayFeeForAccountRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
		accountPayFeeForAccountRequest.setOrgId(otherOrgId);
		BizResult<List<AcctPayoutDTO>> bizResult= tdCAcctPersonService.queryAccountPayFeeForAccount(accountPayFeeForAccountRequest);
		if(bizResult.isSuccess()){
			dtoList = bizResult.getData();
		}
		return dtoList;
	}
	/**通过订单查询orgID*/
	private Long getOrgIdByOrderId(AccountPayRequest request){
		Long orgId = null;
		PayOrderTypeEnum payOrderTypeEnum = PayOrderTypeEnum.getValue(Integer.valueOf(request.getPaySrcType()));
		if(payOrderTypeEnum == PayOrderTypeEnum.PARK_PAY
				|| payOrderTypeEnum == PayOrderTypeEnum.PARKPRE_PAY){
			AccountPayForParkRequest accountPayForParkRequest = (AccountPayForParkRequest)request;
			//停车业务请求对象
			OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(accountPayForParkRequest.getOrderId());
			orgId = orderPark.getOrgId();
		}else if(payOrderTypeEnum == PayOrderTypeEnum.VIP_CARD_ADDED
				|| payOrderTypeEnum == PayOrderTypeEnum.VIP_CARD_RENEW
				|| payOrderTypeEnum == PayOrderTypeEnum.AREA_VIP_CARD_ADDED
				|| payOrderTypeEnum == PayOrderTypeEnum.AREA_VIP_CARD_CHANGE_CARNUM
				|| payOrderTypeEnum == PayOrderTypeEnum.TIME_VIP_CARD_ADDED
				|| payOrderTypeEnum == PayOrderTypeEnum.TIME_VIP_CARD_CHANGE_CARNUM){
			//会员卡业务请求对象
			AccountPayForVipCardRequest accountPayForVipCardRequest = (AccountPayForVipCardRequest)request;
			OrderVipcardQueryByOrderIdReq requesVipCard = new OrderVipcardQueryByOrderIdReq();
			requesVipCard.setOrderId(accountPayForVipCardRequest.getOrderId());
			OrderVipcard orderVipcardQ = orderVipcardDao.queryOrderVipcardByOrderIdOrId(requesVipCard);
			orgId = orderVipcardQ.getOrgId();
		}else if(payOrderTypeEnum == PayOrderTypeEnum.PARKBACK_PAY){
			//停车欠费补缴业务请求对象
			AccountPayForBackArrearageRequest arrearageRequest = (AccountPayForBackArrearageRequest)request;
			logger.info("RNT-欠费补缴-现金支付请求参数："+JSONObject.toJSON(arrearageRequest));
			String orderId = arrearageRequest.getRecordInfos().get(0).getOrderId();
			OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(orderId);
			orgId = orderPark.getOrgId();
		}else if(payOrderTypeEnum == PayOrderTypeEnum.BERTH_APPOINTMENT){
			//车位预约业务请求对象
			AccountPayForAppointmentRequest accountPayForAppointmentRequest = (AccountPayForAppointmentRequest) request;
			OrderAppointmentRequest orderRequest = new OrderAppointmentRequest();
			orderRequest.setOrderId(accountPayForAppointmentRequest.getOrderId());
			orderRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
			OrderAppointment orderAppointment = orderAppointmentDao.queryOrderAppointmentByOrderId(orderRequest);
			orgId = orderAppointment.getOrgId();
		}
		return orgId;
	}
	/**
	 * 判断账户余额是否充足
	 * @param custId
	 * @param payFee
	 * 2018年3月8日 zhaowg
	 */
	private void validateBalanceEnough(String custId,Long payFee,Long orgId  ) {
		/**判断账户状态**/
		TdCCustPersonByCustIdRequest custIdRequest = new TdCCustPersonByCustIdRequest();
		custIdRequest.setCustId(custId);
		custIdRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
		BizResult<TdCCustPersonDTO> reDto = tdCCustPersonService.queryPersonByCustId( custIdRequest);
		TdCCustPersonDTO tdCCustPersonDTO = ResultUtils.getBizResultData(reDto);
		if(tdCCustPersonDTO.getFreezeState() != null && tdCCustPersonDTO.getFreezeState() == 1){
			throw new BizException(ErrorType.ACCOUNT_FREEZED,"您的账户已经被冻结，请您联系客服处理!");
		}

		AcctPersonRequest accountBalanceRequest = new AcctPersonRequest();
		accountBalanceRequest.setCustId(custId);
		accountBalanceRequest.setAcctType(AccountTypeEnum.ACCT_RECHARGE.value());
		accountBalanceRequest.setOrgId(orgId);
		accountBalanceRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
		BizResult<AcctPersonDTO> result = tdCAcctPersonService.getAcctPerson(accountBalanceRequest);
		logger.info("custId:"+custId+"的账户余额为："+result.getData().getAcctBalance()+",本次应付金额为："+payFee);
		AcctPersonDTO accountBalanceDTO = ResultUtils.getBizResultData(result);
		if(accountBalanceDTO.getAcctBalance().compareTo(new BigDecimal(payFee))<0){
			AppOrgRequest appOrgRequest = new AppOrgRequest();
			appOrgRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
			appOrgRequest.setOrgId(orgId+"");
			BizResult<AppOrgDTO> bizResult1= appOrgService.queryAppOrgByOrgId(appOrgRequest);
			String orgName = "";
			if(bizResult1.isSuccess()){
				orgName = bizResult1.getData().getOrgName();
			}
			if(orgId==10228L){
				throw new BizException(ErrorType.ACCOUNT_NO_MONEY,"本车场暂未开通任你停app余额支付,无法使用任你停app扫码余额支付及任你停app无感支付，敬请谅解");
			}else {
				throw new BizException(ErrorType.ACCOUNT_NO_MONEY,"账户余额不足,请选择"+orgName+"账户充值");
			}
		}
	}



}