Merge remote-tracking branch 'origin/feature_v1.1.2.20241212' into dev

fengliang
2 parents 6255eb92 e49f2ead
Showing 10 changed files with 580 additions and 413 deletions
etrade-order/src/main/java/com/diligrp/etrade/order/domain/OrderPayDto.java
etrade-order/src/main/java/com/diligrp/etrade/order/domain/OrderWeChatPayBatch.java
etrade-order/src/main/java/com/diligrp/etrade/order/model/OrderPayment.java
etrade-order/src/main/java/com/diligrp/etrade/order/service/OrderPaymentService.java
etrade-order/src/main/java/com/diligrp/etrade/order/service/impl/OrderPaymenServiceImpl.java
etrade-order/src/main/java/com/diligrp/etrade/order/service/impl/OrderServiceImpl.java
etrade-order/src/main/java/com/diligrp/etrade/order/type/OrderPaymentSubChannel.java
etrade-order/src/main/resources/com/diligrp/etrade/dao/mapper/order/OrderPaymentMapper.xml
scripts/etrade-order/etrade_order.sql
scripts/zr-upgrade/v1.1.2/etrade_order_v1.1.2_fengliang.sql
@@ -70,6 +70,11 @@ public class OrderPayDto {
     @Valid
     private OrderDeliveryDto delivery;
+    /**
+     * 园区卡支付子渠道分类
+     */
+    private Integer payChannelSub;
+
     public String getPaymentId() {
         return paymentId;
     }
@@ -245,7 +250,7 @@ public class OrderPayDto {
     public OrderPayDto(String str,Long marketId,Long payerCustomerId,Long payerStoreCustomerId,String payerCustomerName,String payerPhone,String payerCardNo
             ,Long payerAccountId,Long payerFundAccountId,String payerPassWord,Long operateId,String operateName,String holdName,String holdCertificateNumber,String holdContactsPhone
-            ,String customerAbbr,String paymentId){
+            ,String customerAbbr,String paymentId,Integer payChannelSub){
         this.code = str;
         this.marketId = marketId;
         this.payerCustomerId = payerCustomerId;
@@ -265,6 +270,7 @@ public class OrderPayDto {
         this.holdCertificateNumber = holdCertificateNumber;
         this.holdContactsPhone = holdContactsPhone;
         this.paymentId = paymentId;
+        this.payChannelSub = payChannelSub;
     }
     public OrderPayDto(){
@@ -286,4 +292,12 @@ public class OrderPayDto {
     public void setDelivery(OrderDeliveryDto delivery) {
         this.delivery = delivery;
     }
+
+    public Integer getPayChannelSub() {
+        return payChannelSub;
+    }
+
+    public void setPayChannelSub(Integer payChannelSub) {
+        this.payChannelSub = payChannelSub;
+    }
 }
@@ -61,6 +61,11 @@ public class OrderWeChatPayBatch {
     @Valid
     private OrderDeliveryDto delivery;
+    /**
+     * 园区卡支付子渠道分类
+     */
+    private Integer payChannelSub;
+
     public String getPayType() {
         return payType;
     }
@@ -204,4 +209,12 @@ public class OrderWeChatPayBatch {
     public void setDelivery(OrderDeliveryDto delivery) {
         this.delivery = delivery;
     }
+
+    public Integer getPayChannelSub() {
+        return payChannelSub;
+    }
+
+    public void setPayChannelSub(Integer payChannelSub) {
+        this.payChannelSub = payChannelSub;
+    }
 }
@@ -87,6 +87,11 @@ public class OrderPayment {
      */
     private Long relationId;
+    /**
+     * 园区卡支付子渠道分类
+     */
+    private Integer payChannelSub;
+
     public Long getTotleSellerFee() {
         return totleSellerFee;
     }
@@ -344,4 +349,12 @@ public class OrderPayment {
     public void setRelationId(Long relationId) {
         this.relationId = relationId;
     }
+
+    public Integer getPayChannelSub() {
+        return payChannelSub;
+    }
+
+    public void setPayChannelSub(Integer payChannelSub) {
+        this.payChannelSub = payChannelSub;
+    }
 }
 \ No newline at end of file
@@ -6,6 +6,7 @@ import com.diligrp.etrade.order.model.Order;
 import com.diligrp.etrade.order.model.OrderCoupon;
 import com.diligrp.etrade.order.model.OrderPayment;
 import com.diligrp.etrade.order.type.OrderPaymentAllChannel;
+import com.diligrp.etrade.order.type.OrderPaymentSubChannel;
 import com.diligrp.etrade.rpc.dto.WeChatPayFunctionBackDto;
 import com.diligrp.etrade.rpc.dto.WeChatPayFunctionDto;
 import com.diligrp.etrade.rpc.dto.WeChatPayTradeBackDto;
@@ -79,7 +80,7 @@ public interface OrderPaymentService {
      */
     OrderPayment payOrderBuyCreditCode(Order order, OrderPayDto orderPayDto, Integer identityType);
-    void checkPayChannel(OrderPaymentAllChannel orderPaymentChannel, Long marketId);
+    void checkPayChannel(OrderPaymentAllChannel orderPaymentChannel, Long marketId, OrderPaymentSubChannel subChannel);
     /**
      * 店员检测
@@ -103,53 +103,53 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public OrderPayment OrderPaymentByCard(Order order, OrderPayDto orderPayDto, Integer identityType) {
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_CARD, OrderPaymentAllChannel.CARD_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_CARD, OrderPaymentAllChannel.CARD_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
-        if(shop.getFundAccountId()==null){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"店铺未绑定收款园区卡，不能使用园区卡付款。");
+        if (shop.getFundAccountId() == null) {
+            throw new OrderException(OrderErrorCode.PARAM_ERROR, "店铺未绑定收款园区卡，不能使用园区卡付款。");
         }
-        LOGGER.info("开始生成结算单，{}",order.getCode());
+        LOGGER.info("开始生成结算单，{}", order.getCode());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.PAY.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.PAY.getCodeInteger()
                 , OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger());
         List<OrderCoupon> feeList = null;
-        if(orderPayment.getPayDiscount()>0){
-            LOGGER.info("优惠券调取，{}",order.getCode());
+        if (orderPayment.getPayDiscount() > 0) {
+            LOGGER.info("优惠券调取，{}", order.getCode());
             //获取优惠信息
-            feeList = orderCouponService.getCouponList(order.getId(),order.getMarketId(),OrderCouponState.COUPON_NORMAL.getCodeInteger());
+            feeList = orderCouponService.getCouponList(order.getId(), order.getMarketId(), OrderCouponState.COUPON_NORMAL.getCodeInteger());
 //            //优惠券使用记录
 //            orderCouponService.usedCoupon(feeList,order,shop);
         }
         //扣减库存T
-        orderGoodsService.deduct(order,orderPayment.getPayerCustomerId(),orderPayment.getPayerCustomerName());
-        LOGGER.info("准备调用支付，{}",order.getCode());
+        orderGoodsService.deduct(order, orderPayment.getPayerCustomerId(), orderPayment.getPayerCustomerName());
+        LOGGER.info("准备调用支付，{}", order.getCode());
         //调用支付服务
-        CreateSubmitTradeDto createSubmitTradeDto = createCreateSubmitTradeDto(order,orderPayment,feeList,orderPayDto.getPayerPassWord());
+        CreateSubmitTradeDto createSubmitTradeDto = createCreateSubmitTradeDto(order, orderPayment, feeList, orderPayDto.getPayerPassWord());
         Message<BalanceResponseDto> submitTrade = payRpcResolver.createSubmitTrade(createSubmitTradeDto);
-        if(!submitTrade.isSuccess()){
-            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR,"园区卡支付异常");
+        if (!submitTrade.isSuccess()) {
+            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR, "园区卡支付异常");
         }
-        LOGGER.info("调用支付完成，{}",order.getCode());
-        try{
+        LOGGER.info("调用支付完成，{}", order.getCode());
+        try {
             //修改订单与支付单状态
-            updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_CARD,submitTrade.getData().getTradeId(),shop);
+            updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_CARD, submitTrade.getData().getTradeId(), shop);
             //写入流水记录
-            sendSerialRecord(submitTrade.getData(),order,orderPayment,feeList,orderPayDto,null);
-        }catch (OrderException oe){
-            LOGGER.info("支付成功后，订单{}其他功能异常，{}",order.getCode(),oe.getMessage());
+            sendSerialRecord(submitTrade.getData(), order, orderPayment, feeList, orderPayDto, null);
+        } catch (OrderException oe) {
+            LOGGER.info("支付成功后，订单{}其他功能异常，{}", order.getCode(), oe.getMessage());
             CancelTradeDto cancelDto = new CancelTradeDto();
             cancelDto.setTradeId(submitTrade.getData().getTradeId());
             cancelDto.setMchId(orderPayment.getMarketId().toString());
             payRpcResolver.cancelTrade(cancelDto);
             throw oe;
-        }catch (Exception e){
-            LOGGER.error("订单支付系统异常",e);
+        } catch (Exception e) {
+            LOGGER.error("订单支付系统异常", e);
             CancelTradeDto cancelDto = new CancelTradeDto();
             cancelDto.setTradeId(submitTrade.getData().getTradeId());
             cancelDto.setMchId(orderPayment.getMarketId().toString());
             payRpcResolver.cancelTrade(cancelDto);
-            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR,"订单支付系统异常");
+            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR, "订单支付系统异常");
         }
         return orderPayment;
@@ -161,48 +161,48 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     public OrderPayVo OrderPaymentByCardOnly(Order order, OrderPayDto orderPayDto, Integer identityType) {
         OrderPayVo payVo = new OrderPayVo();
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_CARD, OrderPaymentAllChannel.CARD_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_CARD, OrderPaymentAllChannel.CARD_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
-        if(shop.getFundAccountId()==null){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"店铺未绑定收款园区卡，不能使用园区卡付款。");
+        if (shop.getFundAccountId() == null) {
+            throw new OrderException(OrderErrorCode.PARAM_ERROR, "店铺未绑定收款园区卡，不能使用园区卡付款。");
         }
-        LOGGER.info("开始生成结算单，{}",order.getCode());
+        LOGGER.info("开始生成结算单，{}", order.getCode());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.PAY.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.PAY.getCodeInteger()
                 , OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger());
         List<OrderCoupon> feeList = null;
-        if(orderPayment.getPayDiscount()>0){
-            LOGGER.info("优惠券调取，{}",order.getCode());
+        if (orderPayment.getPayDiscount() > 0) {
+            LOGGER.info("优惠券调取，{}", order.getCode());
             //获取优惠信息
-            feeList = orderCouponService.getCouponList(order.getId(),order.getMarketId(),OrderCouponState.COUPON_NORMAL.getCodeInteger());
+            feeList = orderCouponService.getCouponList(order.getId(), order.getMarketId(), OrderCouponState.COUPON_NORMAL.getCodeInteger());
 //            //优惠券使用记录
 //            orderCouponService.usedCoupon(feeList,order,shop);
         }
-        LOGGER.info("准备调用支付，{}",order.getCode());
+        LOGGER.info("准备调用支付，{}", order.getCode());
         //调用支付服务
-        CreateSubmitTradeDto createSubmitTradeDto = createCreateSubmitTradeDto(order,orderPayment,feeList,orderPayDto.getPayerPassWord());
+        CreateSubmitTradeDto createSubmitTradeDto = createCreateSubmitTradeDto(order, orderPayment, feeList, orderPayDto.getPayerPassWord());
         Message<BalanceResponseDto> submitTrade = payRpcResolver.createSubmitTrade(createSubmitTradeDto);
-        LOGGER.info("调用支付完成，{}",order.getCode());
-        try{
+        LOGGER.info("调用支付完成，{}", order.getCode());
+        try {
             //修改订单与支付单状态
-            updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_CARD,submitTrade.getData().getTradeId(),shop);
+            updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_CARD, submitTrade.getData().getTradeId(), shop);
             //获取流水记录
-            payVo.setSerialRecordDtos(getSerialRecord(submitTrade.getData(), order, orderPayment, feeList, orderPayDto,null));
-        }catch (OrderException oe){
-            LOGGER.info("支付成功后，订单{}其他功能异常，{}",order.getCode(),oe.getMessage());
+            payVo.setSerialRecordDtos(getSerialRecord(submitTrade.getData(), order, orderPayment, feeList, orderPayDto, null));
+        } catch (OrderException oe) {
+            LOGGER.info("支付成功后，订单{}其他功能异常，{}", order.getCode(), oe.getMessage());
             CancelTradeDto cancelDto = new CancelTradeDto();
             cancelDto.setTradeId(submitTrade.getData().getTradeId());
             cancelDto.setMchId(orderPayment.getMarketId().toString());
             payRpcResolver.cancelTrade(cancelDto);
             throw oe;
-        }catch (Exception e){
-            LOGGER.error("订单支付系统异常",e);
+        } catch (Exception e) {
+            LOGGER.error("订单支付系统异常", e);
             CancelTradeDto cancelDto = new CancelTradeDto();
             cancelDto.setTradeId(submitTrade.getData().getTradeId());
             cancelDto.setMchId(orderPayment.getMarketId().toString());
             payRpcResolver.cancelTrade(cancelDto);
-            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR,"订单支付系统异常");
+            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR, "订单支付系统异常");
         }
         payVo.setOrderPayment(orderPayment);
         return payVo;
@@ -211,114 +211,114 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public OrderPayment OrderPaymentByCash(Order order, OrderPayDto orderPayDto, Integer identityType) {
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_CASH, OrderPaymentAllChannel.CASH_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_CASH, OrderPaymentAllChannel.CASH_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.PAY.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.PAY.getCodeInteger()
                 , OrderPaymentAllChannel.CASH_CHANNEL.getCodeInteger());
         //扣减库存T
-        orderGoodsService.deduct(order,orderPayDto.getOperateId(),orderPayDto.getOperateName());
+        orderGoodsService.deduct(order, orderPayDto.getOperateId(), orderPayDto.getOperateName());
         //修改订单与支付单状态
-        updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_CASH,null,shop);
+        updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_CASH, null, shop);
         //写入流水记录
-        sendSerialRecord(null,order,orderPayment,null,orderPayDto,null);
+        sendSerialRecord(null, order, orderPayment, null, orderPayDto, null);
         return orderPayment;
     }
     @Override
     public OrderPayment OrderPaymentByWx(Order order, OrderPayDto orderPayDto, Integer identityType) {
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_WX, OrderPaymentAllChannel.WX_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_WX, OrderPaymentAllChannel.WX_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.PAY.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.PAY.getCodeInteger()
                 , OrderPaymentAllChannel.WX_CHANNEL.getCodeInteger());
         //扣减库存T
-        orderGoodsService.deduct(order,orderPayDto.getOperateId(),orderPayDto.getOperateName());
+        orderGoodsService.deduct(order, orderPayDto.getOperateId(), orderPayDto.getOperateName());
         //修改订单与支付单状态
-        updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_WX,null,shop);
+        updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_WX, null, shop);
         //写入流水记录
-        sendSerialRecord(null,order,orderPayment,null,orderPayDto,null);
+        sendSerialRecord(null, order, orderPayment, null, orderPayDto, null);
         return orderPayment;
     }
     @Override
     public OrderPayment OrderPaymentByZfb(Order order, OrderPayDto orderPayDto, Integer identityType) {
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_ZFB, OrderPaymentAllChannel.ZFB_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_ZFB, OrderPaymentAllChannel.ZFB_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.PAY.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.PAY.getCodeInteger()
                 , OrderPaymentAllChannel.ZFB_CHANNEL.getCodeInteger());
         //扣减库存T
-        orderGoodsService.deduct(order,orderPayDto.getOperateId(),orderPayDto.getOperateName());
+        orderGoodsService.deduct(order, orderPayDto.getOperateId(), orderPayDto.getOperateName());
         //修改订单与支付单状态
-        updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_ZFB,null,shop);
+        updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_ZFB, null, shop);
         //写入流水记录
-        sendSerialRecord(null,order,orderPayment,null,orderPayDto,null);
+        sendSerialRecord(null, order, orderPayment, null, orderPayDto, null);
         return orderPayment;
     }
     @Override
     public OrderPayment payOrderBuyCredit(Order order, OrderPayDto orderPayDto, Integer identityType) {
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_CREDIT, OrderPaymentAllChannel.CREDIT_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_CREDIT, OrderPaymentAllChannel.CREDIT_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.CREDIT.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.CREDIT.getCodeInteger()
                 , OrderPaymentAllChannel.CREDIT_CHANNEL.getCodeInteger());
         //扣减库存T
-        orderGoodsService.deduct(order,orderPayDto.getOperateId(),orderPayDto.getOperateName());
+        orderGoodsService.deduct(order, orderPayDto.getOperateId(), orderPayDto.getOperateName());
         //修改订单与支付单状态
-        updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_CREDIT,null,shop);
+        updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_CREDIT, null, shop);
         //生成赊销记账单
-        createLedgerDto(order,orderPayment,orderPayDto, shop);
+        createLedgerDto(order, orderPayment, orderPayDto, shop);
         //写入流水记录
-        sendSerialRecord(null,order,orderPayment,null,orderPayDto,null);
+        sendSerialRecord(null, order, orderPayment, null, orderPayDto, null);
         return orderPayment;
     }
     @Override
     public OrderPayment payOrderBuyCreditCode(Order order, OrderPayDto orderPayDto, Integer identityType) {
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_PAY_CREDITCODE, OrderPaymentAllChannel.CREDIT_CODE_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_PAY_CREDITCODE, OrderPaymentAllChannel.CREDIT_CODE_CHANNEL);
         //效验店铺
         ShopVo shop = orderGoodsService.checkShop(order.getShopId());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.CREDIT.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.CREDIT.getCodeInteger()
                 , OrderPaymentAllChannel.CREDIT_CODE_CHANNEL.getCodeInteger());
         //扣减库存
-        orderGoodsService.deduct(order,orderPayDto.getOperateId(),orderPayDto.getOperateName());
+        orderGoodsService.deduct(order, orderPayDto.getOperateId(), orderPayDto.getOperateName());
         //修改订单与支付单状态
-        updateOrderByPay(order,orderPayment,OrderOrderState.BUYER_PAY_CREDITCODE,null,shop);
+        updateOrderByPay(order, orderPayment, OrderOrderState.BUYER_PAY_CREDITCODE, null, shop);
         //生成赊销记账单
-        createLedgerDto(order,orderPayment,orderPayDto,shop);
+        createLedgerDto(order, orderPayment, orderPayDto, shop);
         //写入流水记录
-        sendSerialRecord(null,order,orderPayment,null,orderPayDto,null);
+        sendSerialRecord(null, order, orderPayment, null, orderPayDto, null);
         return orderPayment;
     }
-    private void updateOrderByPay(Order order, OrderPayment orderPayment,OrderOrderState operateState,String tradeId,ShopVo shop) {
+    private void updateOrderByPay(Order order, OrderPayment orderPayment, OrderOrderState operateState, String tradeId, ShopVo shop) {
         orderPayment.setState(OrderPaymentState.FINISH_PAY.getCodeInteger());
         orderPayment.setTradeId(tradeId);
         orderPayment.setPayTime(LocalDateTime.now());
-        if(orderPayment.getPayMode().equals(OrderPaymentPayMode.PAY.getCodeInteger())){
-            order.setTotlePaidAmount(order.getTotlePaidAmount()+orderPayment.getPayAmount());
-            if(order.getTotleAmount().equals(order.getTotlePaidAmount())){
+        if (orderPayment.getPayMode().equals(OrderPaymentPayMode.PAY.getCodeInteger())) {
+            order.setTotlePaidAmount(order.getTotlePaidAmount() + orderPayment.getPayAmount());
+            if (order.getTotleAmount().equals(order.getTotlePaidAmount())) {
                 order.setPayState(OrderPayState.PAY_FINISH.getCodeInteger());
                 order.setPayTime(orderPayment.getPayTime());
-            }else{
+            } else {
                 order.setPayState(OrderPayState.PART_PAY.getCodeInteger());
             }
-        }else if(orderPayment.getPayMode().equals(OrderPaymentPayMode.CREDIT.getCodeInteger())){
-            if(order.getTotleAmount().equals(order.getTotlePaidAmount()+orderPayment.getPayAmount())){
+        } else if (orderPayment.getPayMode().equals(OrderPaymentPayMode.CREDIT.getCodeInteger())) {
+            if (order.getTotleAmount().equals(order.getTotlePaidAmount() + orderPayment.getPayAmount())) {
                 order.setPayState(OrderPayState.PAY_FINISH.getCodeInteger());
                 order.setPayTime(orderPayment.getPayTime());
-            }else{
+            } else {
                 order.setPayState(OrderPayState.PART_PAY.getCodeInteger());
             }
         }
@@ -331,12 +331,12 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     private void updatepaymentOnly(OrderPayment orderPayment) {
         int u = orderPaymentMapper.updatepayment(orderPayment);
-        if(u==0){
-            throw new OrderException(OrderErrorCode.REPEATED_SUBMISSION,"请勿重复操作");
+        if (u == 0) {
+            throw new OrderException(OrderErrorCode.REPEATED_SUBMISSION, "请勿重复操作");
         }
     }
-    private CreateSubmitTradeDto createCreateSubmitTradeDto(Order order, OrderPayment orderPayment, List<OrderCoupon> feeList,String password) {
+    private CreateSubmitTradeDto createCreateSubmitTradeDto(Order order, OrderPayment orderPayment, List<OrderCoupon> feeList, String password) {
         CreateSubmitTradeDto tradeDto = new CreateSubmitTradeDto();
         tradeDto.setAmount(orderPayment.getPayAmount());
         tradeDto.setBusinessId(order.getId());
@@ -352,9 +352,9 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     }
     private List<DeductFeesDto> createDeductFeesDtos(List<OrderCoupon> feeList) {
-        if(feeList!=null&&feeList.size()>0){
+        if (feeList != null && feeList.size() > 0) {
             List<DeductFeesDto> deductFeesDtos = new ArrayList<>();
-            for(OrderCoupon coupon : feeList){
+            for (OrderCoupon coupon : feeList) {
                 DeductFeesDto deductFeesDto = new DeductFeesDto();
                 deductFeesDto.setAmount(coupon.getAmount());
                 deductFeesDto.setType(FundItem.TRADE_PAYMENT.getCode());
@@ -362,42 +362,51 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 deductFeesDtos.add(deductFeesDto);
             }
             return deductFeesDtos;
-        }else{
+        } else {
             return null;
         }
     }
-    private OrderPayment createOrderPayment(Order order, OrderPayDto orderPayDto,ShopVo shop, Integer identityType,Integer payMode,Integer payChannel) {
-        OrderPayment paydorderPayment = this.getOrderPaymentById(order.getId(),order.getMarketId(),OrderPaymentState.FINISH_PAY.getCodeInteger());
-        if(paydorderPayment!=null){
+    private OrderPayment createOrderPayment(Order order, OrderPayDto orderPayDto, ShopVo shop, Integer identityType, Integer payMode, Integer payChannel) {
+        OrderPayment paydorderPayment = this.getOrderPaymentById(order.getId(), order.getMarketId(), OrderPaymentState.FINISH_PAY.getCodeInteger());
+        if (paydorderPayment != null) {
             LOGGER.info("订单已支付，无需再次支付");
-            throw new OrderException(OrderErrorCode.PAYING,"订单已支付，无需再次支付");
+            throw new OrderException(OrderErrorCode.PAYING, "订单已支付，无需再次支付");
         }
         //获取未支付的结算单。将之改变
-        OrderPayment orderPayment = this.getOrderPaymentById(order.getId(),order.getMarketId(),OrderPaymentState.WAIT_PAY.getCodeInteger());
-        if(orderPayment!=null){
-            if(orderPayment.getPayChannel()!=null&& OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())&&StringUtils.isNotBlank(orderPayment.getTradeId())){
+        OrderPayment orderPayment = this.getOrderPaymentById(order.getId(), order.getMarketId(), OrderPaymentState.WAIT_PAY.getCodeInteger());
+        if (orderPayment != null) {
+            if (orderPayment.getPayChannel() != null && OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel()) && StringUtils.isNotBlank(orderPayment.getTradeId())) {
                 RLock lock = redissonClient.getLock(OrderConstant.OrderLock + orderPayment.getTradeId());
-                try{
+                try {
                     lock.lock();
-                    if(closePaymentOrder(orderPayment.getTradeId(),orderPayment.getMarketId())){
-                        finishPayUpdata(OrderPaymentState.CANCEL.getCodeInteger(),orderPayment.getTradeId(),null);
+                    if (closePaymentOrder(orderPayment.getTradeId(), orderPayment.getMarketId())) {
+                        finishPayUpdata(OrderPaymentState.CANCEL.getCodeInteger(), orderPayment.getTradeId(), null);
                     }
-                }catch(PlatformServiceException e){
-                    LOGGER.info("关闭订单失败：交易单号{}，异常编码{}，错误信息{}",orderPayment.getTradeId(),e.getCode(),e.getMessage());
-                    throw new OrderException(OrderErrorCode.REPEATED_SUBMISSION,"存在微信支付待付款信息，无法继续支付，请等待微信支付结果");
-                }finally {
+                } catch (PlatformServiceException e) {
+                    LOGGER.info("关闭订单失败：交易单号{}，异常编码{}，错误信息{}", orderPayment.getTradeId(), e.getCode(), e.getMessage());
+                    throw new OrderException(OrderErrorCode.REPEATED_SUBMISSION, "存在微信支付待付款信息，无法继续支付，请等待微信支付结果");
+                } finally {
                     lock.unlock();
                 }
                 orderPayment = new OrderPayment();
             }
-        }else{
+        } else {
             orderPayment = new OrderPayment();
         }
+
+        //卖方订单并且使用买方元气卡支付时，记录园区卡支付的具体方式
+        if (payChannel.equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger()) && OrderOrderType.SELLER_ORDER.getCodeInteger().equals(order.getOrderType())) {
+            if (orderPayDto.getPayChannelSub() == null) {
+                orderPayment.setPayChannelSub(OrderPaymentSubChannel.CARD_CHANNEL_BUYER.getCodeInteger());
+            } else {
+                orderPayment.setPayChannelSub(orderPayDto.getPayChannelSub());
+            }
+        }
         orderPayment.setMarketId(order.getMarketId());
         orderPayment.setOrderId(order.getId());
         orderPayment.setOrderCode(order.getCode());
-        orderPayment.setCode(order.getCode()+"P");
+        orderPayment.setCode(order.getCode() + "P");
         orderPayment.setPayAmount(order.getTotleAmount());
         orderPayment.setPayMode(payMode);
         orderPayment.setTradeId(orderPayDto.getPaymentId());
@@ -420,14 +429,15 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         orderPayment.setVersion(NumberTransform.DEFAULT_VERSION);
         orderPayment.setState(OrderPaymentState.WAIT_PAY.getCodeInteger());
         int l = orderPaymentMapper.save(orderPayment);
-        if(l == 0 ){
-            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR,"创建并保存结算单失败");
+        if (l == 0) {
+            throw new OrderException(OrderErrorCode.ORDER_SYSTEM_ERROR, "创建并保存结算单失败");
         }
         return orderPayment;
     }
     /**
      * 效验并补充支付参数
+     *
      * @param order
      * @param orderPayDto
      * @param identityType
@@ -435,68 +445,72 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
      * @param orderPaymentChannel
      */
     private void checkPaymentParameter(Order order, OrderPayDto orderPayDto, Integer identityType, OrderOrderState orderOrderState, OrderPaymentAllChannel orderPaymentChannel) {
-        if(!OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPaymentChannel.getCodeInteger())){
-            checkPayChannel(orderPaymentChannel,order.getMarketId());
+        if (!OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPaymentChannel.getCodeInteger())) {
+            if (orderPayDto.getPayChannelSub() != null) {
+                checkPayChannel(orderPaymentChannel, order.getMarketId(), OrderPaymentSubChannel.getByCode(orderPayDto.getPayChannelSub()));
+            } else {
+                checkPayChannel(orderPaymentChannel, order.getMarketId(), null);
+            }
         }
         //效验市场
-        if(!orderPayDto.getMarketId().equals(order.getMarketId())){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"与订单市场不一致");
+        if (!orderPayDto.getMarketId().equals(order.getMarketId())) {
+            throw new OrderException(OrderErrorCode.PARAM_ERROR, "与订单市场不一致");
         }
         //买方
-        if(order.getOrderType().equals(OrderOrderType.BUYER_ORDER.getCodeInteger())){
+        if (order.getOrderType().equals(OrderOrderType.BUYER_ORDER.getCodeInteger())) {
             //园区卡
-            if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CARD.getCodeInteger())){
-                if(!order.getBuyerId().equals(orderPayDto.getPayerCustomerId())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"非本人订单不允许支付");
+            if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CARD.getCodeInteger())) {
+                if (!order.getBuyerId().equals(orderPayDto.getPayerCustomerId())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "非本人订单不允许支付");
                 }
-                if(orderPayDto.getPayerCustomerId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户id不能为空");
+                if (orderPayDto.getPayerCustomerId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户id不能为空");
                 }
-                if(!orderPayDto.getOperateId().equals(order.getBuyerId())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"请勿操纵他人订单");
+                if (!orderPayDto.getOperateId().equals(order.getBuyerId())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "请勿操纵他人订单");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerCardNo())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户卡号不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerCardNo())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户卡号不能为空");
                 }
-                if(orderPayDto.getPayerAccountId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户卡账户不能为空");
+                if (orderPayDto.getPayerAccountId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户卡账户不能为空");
                 }
-                if(orderPayDto.getPayerFundAccountId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户资金账户不能为空");
+                if (orderPayDto.getPayerFundAccountId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户资金账户不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerCustomerName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerCustomerName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户名称不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerPassWord())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户卡密码不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerPassWord())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户卡密码不能为空");
                 }
-            }else if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDITCODE.getCodeInteger())){
-                if(!orderPayDto.getPayerCustomerId().equals(order.getBuyerId())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"请勿操纵他人订单");
+            } else if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDITCODE.getCodeInteger())) {
+                if (!orderPayDto.getPayerCustomerId().equals(order.getBuyerId())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "请勿操纵他人订单");
                 }
-                if(!orderPayDto.getOperateId().equals(order.getBuyerId())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"请勿操纵他人订单");
+                if (!orderPayDto.getOperateId().equals(order.getBuyerId())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "请勿操纵他人订单");
                 }
-                if(orderPayDto.getPayerCustomerId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"赊销客户id不能为空");
+                if (orderPayDto.getPayerCustomerId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "赊销客户id不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerCustomerName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"赊销客户名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerCustomerName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "赊销客户名称不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerPhone())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"赊销客户电话不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerPhone())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "赊销客户电话不能为空");
                 }
-                if(orderPayDto.getOperateId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人id不能为空");
+                if (orderPayDto.getOperateId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人id不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getOperateName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getOperateName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人名称不能为空");
                 }
-            }else if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CASH.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_WX.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_ZFB.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_WECHAT_PAY.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDIT.getCodeInteger())){
+            } else if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CASH.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_WX.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_ZFB.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_WECHAT_PAY.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDIT.getCodeInteger())) {
                 orderPayDto.setPayerCustomerId(order.getBuyerId());
                 orderPayDto.setPayerCustomerName(order.getBuyerName());
                 orderPayDto.setPayerAccountId(order.getBuyerAccountId());
@@ -507,9 +521,9 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
             Long payerStoreCustomerId = getCustomerStoreId(order.getShopCustomerId(), order.getBuyerId(), order.getMarketId());
             orderPayDto.setPayerStoreCustomerId(payerStoreCustomerId);
             order.setBuyerStoreCustomerId(payerStoreCustomerId);
-        }else if( order.getOrderType().equals(OrderOrderType.SELLER_ORDER.getCodeInteger())){
-            if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDIT.getCodeInteger())) {
-                if (orderPayDto.getPayerStoreCustomerId() == null && orderPayDto.getPayerCustomerId() ==null) {
+        } else if (order.getOrderType().equals(OrderOrderType.SELLER_ORDER.getCodeInteger())) {
+            if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDIT.getCodeInteger())) {
+                if (orderPayDto.getPayerStoreCustomerId() == null && orderPayDto.getPayerCustomerId() == null) {
                     throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款方常客id不能为空");
                 }
                 if (StrUtil.isEmpty(orderPayDto.getPayerCustomerName())) {
@@ -519,124 +533,132 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款方常客电话不能为空");
                 }
             }
-            if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CARD.getCodeInteger())){
-                if(orderPayDto.getPayerCustomerId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户id不能为空");
+            if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CARD.getCodeInteger())) {
+                if (orderPayDto.getPayerCustomerId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户id不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerCardNo())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户卡号不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerCardNo())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户卡号不能为空");
                 }
-                if(orderPayDto.getPayerAccountId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户卡账户不能为空");
+                if (orderPayDto.getPayerAccountId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户卡账户不能为空");
                 }
-                if(orderPayDto.getPayerFundAccountId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户资金账户不能为空");
+                if (orderPayDto.getPayerFundAccountId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户资金账户不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerCustomerName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerCustomerName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户名称不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerPassWord())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"付款客户卡密码不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerPassWord())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "付款客户卡密码不能为空");
                 }
                 order.setBuyerAccountId(orderPayDto.getPayerAccountId());
-                checkStoreEmployee(orderPayDto.getStoreEmployeeId(),order.getShopCustomerId(),order.getMarketId());
-            }else if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDITCODE.getCodeInteger())){
-                if(orderPayDto.getPayerCustomerId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"赊销客户id不能为空");
+                checkStoreEmployee(orderPayDto.getStoreEmployeeId(), order.getShopCustomerId(), order.getMarketId());
+            } else if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDITCODE.getCodeInteger())) {
+                if (orderPayDto.getPayerCustomerId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "赊销客户id不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerCustomerName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"赊销客户名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerCustomerName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "赊销客户名称不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getPayerPhone())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"赊销客户电话不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getPayerPhone())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "赊销客户电话不能为空");
                 }
-                if(orderPayDto.getOperateId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人id不能为空");
+                if (orderPayDto.getOperateId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人id不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getOperateName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getOperateName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人名称不能为空");
                 }
-                checkStoreEmployee(orderPayDto.getStoreEmployeeId(),order.getShopCustomerId(),order.getMarketId());
-            }else if(orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CASH.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_WX.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_ZFB.getCodeInteger())
-                    ||orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDIT.getCodeInteger())){
-                if(orderPayDto.getOperateId()==null){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人id不能为空");
+                checkStoreEmployee(orderPayDto.getStoreEmployeeId(), order.getShopCustomerId(), order.getMarketId());
+            } else if (orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CASH.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_WX.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_ZFB.getCodeInteger())
+                    || orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CREDIT.getCodeInteger())) {
+                if (orderPayDto.getOperateId() == null) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人id不能为空");
                 }
-                if(StrUtil.isEmpty(orderPayDto.getOperateName())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人名称不能为空");
+                if (StrUtil.isEmpty(orderPayDto.getOperateName())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人名称不能为空");
                 }
-                checkOperate(orderPayDto,order);
+                checkOperate(orderPayDto, order);
             }
             order.setBuyerId(orderPayDto.getPayerCustomerId());
             order.setBuyerPhone(orderPayDto.getPayerPhone());
             order.setBuyerName(orderPayDto.getPayerCustomerName());
             order.setBuyerStoreCustomerId(orderPayDto.getPayerStoreCustomerId());
-            if(orderPayDto.getPayerCustomerId()!=null){
+            if (orderPayDto.getPayerCustomerId() != null) {
                 Long payerStoreCustomerId = getCustomerStoreId(order.getShopCustomerId(), orderPayDto.getPayerCustomerId(), order.getMarketId());
-                if(payerStoreCustomerId!=null&&orderPayDto.getPayerStoreCustomerId()!=null&&!orderPayDto.getPayerStoreCustomerId().equals(payerStoreCustomerId)){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"常客数据异常，常客与客户不匹配");
+                if (payerStoreCustomerId != null && orderPayDto.getPayerStoreCustomerId() != null && !orderPayDto.getPayerStoreCustomerId().equals(payerStoreCustomerId)) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "常客数据异常，常客与客户不匹配");
                 }
                 orderPayDto.setPayerStoreCustomerId(payerStoreCustomerId);
                 order.setBuyerStoreCustomerId(payerStoreCustomerId);
             }
         }
-        if(!orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CARD.getCodeInteger())&&order.getTotleDiscount()>0){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"存在优惠，请使用园区卡支付");
+        if (!orderOrderState.getCodeInteger().equals(OrderOrderState.BUYER_PAY_CARD.getCodeInteger()) && order.getTotleDiscount() > 0) {
+            throw new OrderException(OrderErrorCode.PARAM_ERROR, "存在优惠，请使用园区卡支付");
         }
-        if(order.getShopCustomerId().equals(orderPayDto.getPayerCustomerId())){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"买方卖方不能为同一客户");
+        if (order.getShopCustomerId().equals(orderPayDto.getPayerCustomerId())) {
+            throw new OrderException(OrderErrorCode.PARAM_ERROR, "买方卖方不能为同一客户");
         }
     }
     /**
      * 效验卖方操作人
+     *
      * @param orderPayDto
      * @param order
      */
-    private void checkOperate(OrderPayDto orderPayDto,Order order) {
+    private void checkOperate(OrderPayDto orderPayDto, Order order) {
         Long employeeId = orderPayDto.getStoreEmployeeId();
         Long shopCustomerId = order.getShopCustomerId();
         Long operateId = orderPayDto.getOperateId();
         Long marketId = order.getMarketId();
         //效验店员操作人
-        if(employeeId==null){
-            if(!operateId.equals(shopCustomerId)){
-                throw new OrderException(OrderErrorCode.PARAM_ERROR,"操作人异常");
+        if (employeeId == null) {
+            if (!operateId.equals(shopCustomerId)) {
+                throw new OrderException(OrderErrorCode.PARAM_ERROR, "操作人异常");
             }
-        }else{
-            if(!operateId.equals(employeeId)){
-                throw new OrderException(OrderErrorCode.PARAM_ERROR,"店员信息异常");
+        } else {
+            if (!operateId.equals(employeeId)) {
+                throw new OrderException(OrderErrorCode.PARAM_ERROR, "店员信息异常");
             }
         }
-        checkStoreEmployee(operateId,shopCustomerId,marketId);
+        checkStoreEmployee(operateId, shopCustomerId, marketId);
     }
     private Long getCustomerStoreId(Long shopCustomerId, Long payerCustomerId, Long marketId) {
         StoreCustomerResponseDto storeCustomerByCustomerId = storeCustomerService.findStoreCustomerByCustomerId(shopCustomerId, payerCustomerId, marketId);
-        if(storeCustomerByCustomerId!=null){
+        if (storeCustomerByCustomerId != null) {
             return storeCustomerByCustomerId.getId();
-        }else {
+        } else {
             return null;
         }
     }
     @Override
-    public void checkPayChannel(OrderPaymentAllChannel orderPaymentChannel, Long marketId) {
-        if(!settingPaymentMethodService.isExist(marketId,orderPaymentChannel.getSettingChannel().longValue())){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"该市场不支持该支付渠道");
+    public void checkPayChannel(OrderPaymentAllChannel orderPaymentChannel, Long marketId, OrderPaymentSubChannel subChannel) {
+        if (subChannel != null) {
+            if (!settingPaymentMethodService.isExist(marketId, subChannel.getRealSettingChannel().longValue())) {
+                throw new OrderException(OrderErrorCode.PARAM_ERROR, "该市场不支持该支付渠道");
+            }
+        } else {
+            if (!settingPaymentMethodService.isExist(marketId, orderPaymentChannel.getSettingChannel().longValue())) {
+                throw new OrderException(OrderErrorCode.PARAM_ERROR, "该市场不支持该支付渠道");
+            }
         }
+
     }
-    private void createLedgerDto(Order order, OrderPayment orderPayment, OrderPayDto orderPayDto,ShopVo shop) {
+    private void createLedgerDto(Order order, OrderPayment orderPayment, OrderPayDto orderPayDto, ShopVo shop) {
         LedgerCreateDto ledgerDto = new LedgerCreateDto();
         ledgerDto.setCodeCreated(orderPayment.getPayTime());
-        ledgerDto.setAmount(orderPayment.getPayAmount()-orderPayment.getPayDiscount());
+        ledgerDto.setAmount(orderPayment.getPayAmount() - orderPayment.getPayDiscount());
         ledgerDto.setBusinessCode(orderPayment.getOrderCode());
         ledgerDto.setOrderType(order.getOrderType());
-        ledgerDto.setCustomerId(orderPayment.getPayerCustomerId()==null?order.getBuyerId():orderPayment.getPayerCustomerId());
-        ledgerDto.setCustomerName(StrUtil.isEmpty(orderPayment.getPayerCustomerName())?order.getBuyerName():orderPayment.getPayerCustomerName());
+        ledgerDto.setCustomerId(orderPayment.getPayerCustomerId() == null ? order.getBuyerId() : orderPayment.getPayerCustomerId());
+        ledgerDto.setCustomerName(StrUtil.isEmpty(orderPayment.getPayerCustomerName()) ? order.getBuyerName() : orderPayment.getPayerCustomerName());
         ledgerDto.setShopId(order.getShopId());
         ledgerDto.setMarketId(order.getMarketId());
         ledgerDto.setCustomerCellphone(order.getBuyerPhone());
@@ -645,26 +667,27 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     }
     @Override
-    public StoreEmployee checkStoreEmployee(Long employeeId, Long shopCustomerId, Long marketId){
+    public StoreEmployee checkStoreEmployee(Long employeeId, Long shopCustomerId, Long marketId) {
         //不是店铺负责人时统统使用雇员id
-        if(employeeId!=null&&!employeeId.equals(shopCustomerId)){
-            StoreEmployee storeEmployeeByParam = storeEmployeeService.findStoreEmployeeByParam(employeeId,shopCustomerId,marketId);
-            if(storeEmployeeByParam==null||storeEmployeeByParam.getId()==null){
-                throw new OrderException(OrderErrorCode.PARAM_ERROR,"请勿操作其他店铺订单");
+        if (employeeId != null && !employeeId.equals(shopCustomerId)) {
+            StoreEmployee storeEmployeeByParam = storeEmployeeService.findStoreEmployeeByParam(employeeId, shopCustomerId, marketId);
+            if (storeEmployeeByParam == null || storeEmployeeByParam.getId() == null) {
+                throw new OrderException(OrderErrorCode.PARAM_ERROR, "请勿操作其他店铺订单");
             }
             return storeEmployeeByParam;
         }
         return null;
     }
+
     @Override
-    public OrderPayVo createOrderPayment(Order order, OrderPayDto orderPayDto, Integer identityType,ShopVo shop) {
+    public OrderPayVo createOrderPayment(Order order, OrderPayDto orderPayDto, Integer identityType, ShopVo shop) {
         OrderPayVo payVo = new OrderPayVo();
         //根据状态检查入参
-        checkPaymentParameter(order,orderPayDto,identityType, OrderOrderState.BUYER_WECHAT_PAY, OrderPaymentAllChannel.BUYER_WX_CHANNEL);
+        checkPaymentParameter(order, orderPayDto, identityType, OrderOrderState.BUYER_WECHAT_PAY, OrderPaymentAllChannel.BUYER_WX_CHANNEL);
-        LOGGER.info("开始生成结算单，{}",order.getCode());
+        LOGGER.info("开始生成结算单，{}", order.getCode());
         //生成结算单
-        OrderPayment orderPayment = createOrderPayment(order,orderPayDto,shop,identityType,OrderPaymentPayMode.PAY.getCodeInteger()
+        OrderPayment orderPayment = createOrderPayment(order, orderPayDto, shop, identityType, OrderPaymentPayMode.PAY.getCodeInteger()
                 , OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger());
         payVo.setOrderPayment(orderPayment);
         return payVo;
@@ -678,7 +701,7 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public WeChatPayTradeBackDto WeChatPay(WeChatPayTradeDto weChatPayTradeDto) {
         Message<WeChatPayTradeBackDto> weChatPayTrade = weChatPayRpcResolver.createWeChatPayTrade(weChatPayTradeDto);
-        if(weChatPayTrade.getData()!=null){
+        if (weChatPayTrade.getData() != null) {
             return weChatPayTrade.getData();
         }
         return null;
@@ -686,7 +709,7 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public List<OrderPayment> getOrderPaymentList(String paymentId, Integer state) {
-        return orderPaymentMapper.getPaymentListByPaymentId(paymentId,state);
+        return orderPaymentMapper.getPaymentListByPaymentId(paymentId, state);
     }
     @Override
@@ -695,11 +718,11 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     }
     @Override
-    public void finishPayUpdata(Integer state, String paymentId,LocalDateTime payTime) {
-        if(!(Objects.equals(state, OrderPaymentState.CANCEL.getCodeInteger()) || Objects.equals(state, OrderPaymentState.FINISH_PAY.getCodeInteger()))){
-            throw new OrderException(OrderErrorCode.PARAM_ERROR,"参数范围异常");
+    public void finishPayUpdata(Integer state, String paymentId, LocalDateTime payTime) {
+        if (!(Objects.equals(state, OrderPaymentState.CANCEL.getCodeInteger()) || Objects.equals(state, OrderPaymentState.FINISH_PAY.getCodeInteger()))) {
+            throw new OrderException(OrderErrorCode.PARAM_ERROR, "参数范围异常");
         }
-        int a = orderPaymentMapper.finishPayUpdata(paymentId,state,payTime);
+        int a = orderPaymentMapper.finishPayUpdata(paymentId, state, payTime);
     }
     @Override
@@ -715,25 +738,25 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public UserAccountCardResponseDto getAccountInfo(Long payerAccountId) {
-        try{
-            UserAccountSingleQueryDto userAccountSingleQueryDto=new UserAccountSingleQueryDto();
+        try {
+            UserAccountSingleQueryDto userAccountSingleQueryDto = new UserAccountSingleQueryDto();
             userAccountSingleQueryDto.setAccountId(payerAccountId);
             Message<UserAccountCardResponseDto> message = accountRpc.findSingle(userAccountSingleQueryDto);
-            if(message.isSuccess()){
+            if (message.isSuccess()) {
                 return message.getData();
-            }else{
+            } else {
                 LOGGER.warn(message.getMessage());
                 return null;
             }
-        }catch (Exception e){
-            LOGGER.warn("账户调用异常",e);
+        } catch (Exception e) {
+            LOGGER.warn("账户调用异常", e);
             return null;
         }
     }
     @Override
     public List<String> checkNotPayPaymentOrder(List<String> codes) {
-        if(CollectionUtils.isEmpty(codes)){
+        if (CollectionUtils.isEmpty(codes)) {
             return null;
         }
         return orderPaymentMapper.getPaymentIdsByCodes(codes);
@@ -741,22 +764,22 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public Boolean closePaymentOrder(String paymentId, Long marketId) {
-        WeChatPayFunctionDto functionDto = new WeChatPayFunctionDto(paymentId,null, marketId);
+        WeChatPayFunctionDto functionDto = new WeChatPayFunctionDto(paymentId, null, marketId);
         Boolean closeFlag = false;
-        try{
+        try {
             closeFlag = weChatPayRpcResolver.closeWeChatPay(functionDto);
-        }catch(PlatformServiceException e){
+        } catch (PlatformServiceException e) {
             functionDto.setMode("online");
             Message<WeChatPayFunctionBackDto> weChatPayFunctionBackDtoMessage = weChatPayRpcResolver.checkWeChatPayState(functionDto);
-            if(weChatPayFunctionBackDtoMessage.isSuccess()){
-                if(weChatPayFunctionBackDtoMessage.getData().getState().equals(WeChatPayState.NOT_PAY.getCode())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"存在未支付的微信订单，关闭失败，请稍后再试");
-                }else if(weChatPayFunctionBackDtoMessage.getData().getState().equals(WeChatPayState.SUCCESS.getCode())){
-                    throw new OrderException(OrderErrorCode.PARAM_ERROR,"存在已缴费订单,请刷新后重新选择单据缴费!");
-                }else if(weChatPayFunctionBackDtoMessage.getData().getState().equals(WeChatPayState.PAY_FAIL.getCode())){
+            if (weChatPayFunctionBackDtoMessage.isSuccess()) {
+                if (weChatPayFunctionBackDtoMessage.getData().getState().equals(WeChatPayState.NOT_PAY.getCode())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "存在未支付的微信订单，关闭失败，请稍后再试");
+                } else if (weChatPayFunctionBackDtoMessage.getData().getState().equals(WeChatPayState.SUCCESS.getCode())) {
+                    throw new OrderException(OrderErrorCode.PARAM_ERROR, "存在已缴费订单,请刷新后重新选择单据缴费!");
+                } else if (weChatPayFunctionBackDtoMessage.getData().getState().equals(WeChatPayState.PAY_FAIL.getCode())) {
                     return true;
                 }
-            }else{
+            } else {
                 return false;
             }
         }
@@ -769,13 +792,13 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     }
     @Override
-    public OrderPaymentDto getPaymenDtoByOrderId(Long orderId, Long marketId,Integer paymentState) {
-        return orderPaymentMapper.getPaymenDtoByOrderId(orderId, marketId,paymentState);
+    public OrderPaymentDto getPaymenDtoByOrderId(Long orderId, Long marketId, Integer paymentState) {
+        return orderPaymentMapper.getPaymenDtoByOrderId(orderId, marketId, paymentState);
     }
     @Override
     public OrderPayment getOrderPaymentById(Long orderId, Long marketId, Integer paymentState) {
-        return orderPaymentMapper.getPaymenByOrderId(orderId, marketId,paymentState);
+        return orderPaymentMapper.getPaymenByOrderId(orderId, marketId, paymentState);
     }
     @Transactional
@@ -785,17 +808,17 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         cancelDto.setTradeId(orderPaymentDto.getTradeId());
         cancelDto.setMchId(orderPaymentDto.getMarketId().toString());
         Message<BalanceResponseDto> balanceResponseDtoMessage = payRpcResolver.cancelTradeOnly(cancelDto);
-        if(!balanceResponseDtoMessage.getCode().equals(200)){
-            if(balanceResponseDtoMessage.getCode().equals(503002)){
-                throw new OrderException(OrderErrorCode.ACCOUNT_ERROR,"卖方资金账户异常，无法付款，订单作废失败");
-            }else if(balanceResponseDtoMessage.getCode().equals(504002)){
-                throw new OrderException(OrderErrorCode.ACCOUNT_ERROR,"买方资金账户异常，无法收款，订单作废失败");
-            }else if(balanceResponseDtoMessage.getCode().equals(503004)){
-                throw new OrderException(OrderErrorCode.ACCOUNT_ERROR,"卖方账户资金不足，订单作废失败");
-            }else{
+        if (!balanceResponseDtoMessage.getCode().equals(200)) {
+            if (balanceResponseDtoMessage.getCode().equals(503002)) {
+                throw new OrderException(OrderErrorCode.ACCOUNT_ERROR, "卖方资金账户异常，无法付款，订单作废失败");
+            } else if (balanceResponseDtoMessage.getCode().equals(504002)) {
+                throw new OrderException(OrderErrorCode.ACCOUNT_ERROR, "买方资金账户异常，无法收款，订单作废失败");
+            } else if (balanceResponseDtoMessage.getCode().equals(503004)) {
+                throw new OrderException(OrderErrorCode.ACCOUNT_ERROR, "卖方账户资金不足，订单作废失败");
+            } else {
                 throw new PlatformServiceException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "作废交易信息失败：" + balanceResponseDtoMessage.getMessage());
             }
-        }else{
+        } else {
             return balanceResponseDtoMessage.getData();
         }
     }
@@ -803,7 +826,7 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     public OrderPayment saveInvalidOrderPayment(Order order, OrderPayment orderPaymentDto) {
         OrderPayment payment = new OrderPayment();
-        BeanUtils.copyProperties(orderPaymentDto,payment);
+        BeanUtils.copyProperties(orderPaymentDto, payment);
         payment.setCreatedTime(null);
         payment.setModifiedTime(null);
         payment.setVersion(1);
@@ -811,51 +834,51 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         payment.setOrderStatus(OrderStatus.INVALID.getCodeInteger());
         payment.setRelationId(orderPaymentDto.getId());
         payment.setPayTime(order.getPayTime());
-        payment.setTotleSellerFee(orderPaymentDto.getTotleSellerFee()==null?null:orderPaymentDto.getTotleSellerFee()*-1);
-        payment.setPayAmount(orderPaymentDto.getPayAmount()*-1);
-        payment.setPayDiscount(orderPaymentDto.getPayDiscount()==null?null:orderPaymentDto.getPayDiscount()*-1);
+        payment.setTotleSellerFee(orderPaymentDto.getTotleSellerFee() == null ? null : orderPaymentDto.getTotleSellerFee() * -1);
+        payment.setPayAmount(orderPaymentDto.getPayAmount() * -1);
+        payment.setPayDiscount(orderPaymentDto.getPayDiscount() == null ? null : orderPaymentDto.getPayDiscount() * -1);
         payment.setId(null);
         orderPaymentMapper.save(payment);
         return payment;
     }
-    private void sendSerialRecord(BalanceResponseDto balanceResponseDto,Order order ,OrderPayment orderPayment,List<OrderCoupon> coupons,OrderPayDto orderPayDto,OrderPaymentPayeeInfoDto payeeInfo) {
+    private void sendSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, List<OrderCoupon> coupons, OrderPayDto orderPayDto, OrderPaymentPayeeInfoDto payeeInfo) {
-        try{
+        try {
             //买方信息
-            if(order.getBuyerId()!=null && (StringUtils.isBlank(orderPayDto.getCustomerAbbr())||StringUtils.isBlank(order.getBuyerCode()))){
+            if (order.getBuyerId() != null && (StringUtils.isBlank(orderPayDto.getCustomerAbbr()) || StringUtils.isBlank(order.getBuyerCode()))) {
                 BaseOutput<CustomerBaseExtensionInfo> extenMessage = customerRpc.getCustomerAndBaseExtensionById(orderPayDto.getPayerCustomerId());
-                if(extenMessage.getCode().equals("200")){
+                if (extenMessage.getCode().equals("200")) {
                     orderPayDto.setCustomerAbbr(extenMessage.getData().getCustomerAbbr());
-                    if(StringUtils.isBlank(order.getBuyerCode())){
+                    if (StringUtils.isBlank(order.getBuyerCode())) {
                         order.setBuyerCode(extenMessage.getData().getCode());
                     }
-                }else{
-                    LOGGER.warn("客户服务调用失败：{}",extenMessage.getMessage());
+                } else {
+                    LOGGER.warn("客户服务调用失败：{}", extenMessage.getMessage());
                 }
             }
             //卖方信息
-            if(payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            if (payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payeeInfo = getPayeeInfo(order.getShopCustomerId());
-            }else if(payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            } else if (payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payeeInfo = getPayeeInfoByAccountId(orderPayment.getPayeeAccountId());
             }
-        }catch (Exception e){
-            LOGGER.warn("客户服务调用异常",e);
+        } catch (Exception e) {
+            LOGGER.warn("客户服务调用异常", e);
         }
         List<SerialRecordDto> list = new ArrayList<>();
         //买家付款
-        List<SerialRecordDto> mainSerialRecordDtoBuyer = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto,payeeInfo);
+        List<SerialRecordDto> mainSerialRecordDtoBuyer = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto, payeeInfo);
         list.addAll(mainSerialRecordDtoBuyer);
         //卖家收款
-        List<SerialRecordDto> mainSerialRecordDtoSeller = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto,payeeInfo);
+        List<SerialRecordDto> mainSerialRecordDtoSeller = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto, payeeInfo);
         list.addAll(mainSerialRecordDtoSeller);
-        if(coupons!=null&&coupons.size()>0){
+        if (coupons != null && coupons.size() > 0) {
             //买家优惠
-            List<SerialRecordDto> couponsSerialRecordDtoBuyer = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto,payeeInfo);
+            List<SerialRecordDto> couponsSerialRecordDtoBuyer = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto, payeeInfo);
             list.addAll(couponsSerialRecordDtoBuyer);
             //卖家优惠
-            List<SerialRecordDto> couponsSerialRecordDtoSeller = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto,payeeInfo);
+            List<SerialRecordDto> couponsSerialRecordDtoSeller = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto, payeeInfo);
             list.addAll(couponsSerialRecordDtoSeller);
         }
         //发送mq
@@ -864,81 +887,82 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     @Override
     @Transactional
-    public void sendSerialRecord(List<SerialRecordDto> list){
+    public void sendSerialRecord(List<SerialRecordDto> list) {
         rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_ACCOUNT_SERIAL, RabbitConfig.ROUTING_ACCOUNT_SERIAL, JsonUtils.toJsonString(list));
     }
     @Override
-    public List<SerialRecordDto> getSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, List<OrderCoupon> coupons, OrderPayDto orderPayDto,OrderPaymentPayeeInfoDto payeeInfo) {
-        try{
-            if(order.getBuyerId()!=null && (StringUtils.isBlank(orderPayDto.getCustomerAbbr())||StringUtils.isBlank(order.getBuyerCode()))){
+    public List<SerialRecordDto> getSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, List<OrderCoupon> coupons, OrderPayDto orderPayDto, OrderPaymentPayeeInfoDto payeeInfo) {
+        try {
+            if (order.getBuyerId() != null && (StringUtils.isBlank(orderPayDto.getCustomerAbbr()) || StringUtils.isBlank(order.getBuyerCode()))) {
                 BaseOutput<CustomerBaseExtensionInfo> extenMessage = customerRpc.getCustomerAndBaseExtensionById(orderPayDto.getPayerCustomerId());
-                if(extenMessage.getCode().equals("200")){
+                if (extenMessage.getCode().equals("200")) {
                     orderPayDto.setCustomerAbbr(extenMessage.getData().getCustomerAbbr());
-                    if(StringUtils.isBlank(order.getBuyerCode())){
+                    if (StringUtils.isBlank(order.getBuyerCode())) {
                         order.setBuyerCode(extenMessage.getData().getCode());
                     }
-                }else{
-                    LOGGER.warn("客户服务调用失败：{}",extenMessage.getMessage());
+                } else {
+                    LOGGER.warn("客户服务调用失败：{}", extenMessage.getMessage());
                 }
             }
             //流水所需卖方信息
-            if(payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            if (payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payeeInfo = getPayeeInfo(order.getShopCustomerId());
-            }else if(payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            } else if (payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payeeInfo = getPayeeInfoByAccountId(orderPayment.getPayeeAccountId());
             }
-        }catch (Exception e){
-            LOGGER.warn("客户服务调用异常",e);
+        } catch (Exception e) {
+            LOGGER.warn("客户服务调用异常", e);
         }
         List<SerialRecordDto> list = new ArrayList<>();
         //买家付款
-        List<SerialRecordDto> mainSerialRecordDtoBuyer = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto,payeeInfo);
+        List<SerialRecordDto> mainSerialRecordDtoBuyer = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto, payeeInfo);
         list.addAll(mainSerialRecordDtoBuyer);
         //卖家收款
-        List<SerialRecordDto> mainSerialRecordDtoSeller = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto,payeeInfo);
+        List<SerialRecordDto> mainSerialRecordDtoSeller = createMainSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto, payeeInfo);
         list.addAll(mainSerialRecordDtoSeller);
-        if(coupons!=null&&coupons.size()>0){
+        if (coupons != null && coupons.size() > 0) {
             //买家优惠
-            List<SerialRecordDto> couponsSerialRecordDtoBuyer = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto,payeeInfo);
+            List<SerialRecordDto> couponsSerialRecordDtoBuyer = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, orderPayDto, payeeInfo);
             list.addAll(couponsSerialRecordDtoBuyer);
             //卖家优惠
-            List<SerialRecordDto> couponsSerialRecordDtoSeller = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto,payeeInfo);
+            List<SerialRecordDto> couponsSerialRecordDtoSeller = createCouponsSerialRecordDto(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, orderPayDto, payeeInfo);
             list.addAll(couponsSerialRecordDtoSeller);
         }
         return list;
     }
     private OrderPaymentPayeeInfoDto getPayeeInfo(Long shopCustomerId) {
-        try{
-            if(shopCustomerId!=null){
+        try {
+            if (shopCustomerId != null) {
                 BaseOutput<CustomerBaseExtensionInfo> extenMessage = customerRpc.getCustomerAndBaseExtensionById(shopCustomerId);
-                if(extenMessage.getCode().equals("200")&&extenMessage.getData()!=null){
+                if (extenMessage.getCode().equals("200") && extenMessage.getData() != null) {
                     OrderPaymentPayeeInfoDto payeeInfoDto = new OrderPaymentPayeeInfoDto();
                     payeeInfoDto.setCustomerAbbr(extenMessage.getData().getCustomerAbbr());
                     payeeInfoDto.setCustomerId(extenMessage.getData().getCustomerId());
                     payeeInfoDto.setCustomerNo(extenMessage.getData().getCode());
                     payeeInfoDto.setCustomerName(extenMessage.getData().getName());
                     return payeeInfoDto;
-                }else{
-                    LOGGER.warn("客户服务调用失败：{}",extenMessage.getMessage());
+                } else {
+                    LOGGER.warn("客户服务调用失败：{}", extenMessage.getMessage());
                 }
             }
-        }catch (Exception e){
-            LOGGER.warn("客户服务调用异常",e);
+        } catch (Exception e) {
+            LOGGER.warn("客户服务调用异常", e);
         }
         return null;
     }
     /**
      * 创建买方货款流水
+     *
      * @param order
      * @param orderPayment
-     * @param actionEnum 买家角度
+     * @param actionEnum   买家角度
      * @return
      */
-    private List<SerialRecordDto> createMainSerialRecordDto(BalanceResponseDto balanceResponseDto,Order order ,OrderPayment orderPayment,ActionEnum actionEnum
-            ,List<OrderCoupon> coupons,OrderPayDto orderPayDto,OrderPaymentPayeeInfoDto payeeInfo){
+    private List<SerialRecordDto> createMainSerialRecordDto(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, ActionEnum actionEnum
+            , List<OrderCoupon> coupons, OrderPayDto orderPayDto, OrderPaymentPayeeInfoDto payeeInfo) {
         List<SerialRecordDto> serialRecordDtos = new ArrayList<>();
         //买方货款
@@ -946,10 +970,10 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         serialRecord.setSettleDayNo(DateUtils.formatDate(orderPayment.getPayTime().toLocalDate(), "yyyy-MM-dd"));
         serialRecord.setType(BizNumberTypeEnum.ETRADE_TRADE.getCode());
         serialRecord.setTypeName(BizNumberTypeEnum.ETRADE_TRADE.getName());
-        if(actionEnum.getCode()==ActionEnum.EXPENSE.getCode()){
+        if (actionEnum.getCode() == ActionEnum.EXPENSE.getCode()) {
             //买方
             serialRecord.setAction(ActionEnum.EXPENSE.getCode());
-            if(balanceResponseDto == null){
+            if (balanceResponseDto == null) {
                 serialRecord.setAccountId(null);
                 serialRecord.setStartBalance(null);
                 serialRecord.setEndBalance(null);
@@ -961,10 +985,10 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 //持卡人联系电话(客户联系电话)
                 serialRecord.setHoldContactsPhone(null);
-            }else{
+            } else {
                 serialRecord.setAccountId(balanceResponseDto.getAccountId());
                 serialRecord.setStartBalance(balanceResponseDto.getBalance());
-                serialRecord.setEndBalance(balanceResponseDto.getBalance()-orderPayment.getPayAmount()+orderPayment.getPayDiscount());
+                serialRecord.setEndBalance(balanceResponseDto.getBalance() - orderPayment.getPayAmount() + orderPayment.getPayDiscount());
                 serialRecord.setTradeNo(balanceResponseDto.getTradeId());
                 //持卡人姓名（客户姓名）
                 serialRecord.setHoldName(orderPayDto.getHoldName());
@@ -975,57 +999,57 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 //客户简称
                 serialRecord.setCustomerAbbr(orderPayDto.getCustomerAbbr());
             }
-            if(orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            if (orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 serialRecord.setCardNo(orderPayment.getPayerCardNo());
             }
-            serialRecord.setCustomerId(orderPayment.getPayerCustomerId()==null?0L:orderPayment.getPayerCustomerId());
+            serialRecord.setCustomerId(orderPayment.getPayerCustomerId() == null ? 0L : orderPayment.getPayerCustomerId());
             serialRecord.setCustomerNo(order.getBuyerCode());
             serialRecord.setCustomerAbbr(orderPayDto.getCustomerAbbr());
-            serialRecord.setCustomerName(StrUtil.isBlank(orderPayment.getPayerCustomerName())?"默认用户":orderPayment.getPayerCustomerName());
-            serialRecord.setAmount(orderPayment.getPayAmount()-orderPayment.getPayDiscount());
+            serialRecord.setCustomerName(StrUtil.isBlank(orderPayment.getPayerCustomerName()) ? "默认用户" : orderPayment.getPayerCustomerName());
+            serialRecord.setAmount(orderPayment.getPayAmount() - orderPayment.getPayDiscount());
             serialRecord.setNotes(String.format("买方，订单号 %s", order.getCode()));
-        }else if(actionEnum.getCode()==ActionEnum.INCOME.getCode()){
+        } else if (actionEnum.getCode() == ActionEnum.INCOME.getCode()) {
             //卖方
             serialRecord.setAction(ActionEnum.INCOME.getCode());
-            if(balanceResponseDto != null){
+            if (balanceResponseDto != null) {
                 serialRecord.setAccountId(balanceResponseDto.getRelation().getAccountId());
                 serialRecord.setStartBalance(balanceResponseDto.getRelation().getBalance());
-                serialRecord.setEndBalance(balanceResponseDto.getRelation().getBalance()+orderPayment.getPayAmount()-orderPayment.getPayDiscount());
+                serialRecord.setEndBalance(balanceResponseDto.getRelation().getBalance() + orderPayment.getPayAmount() - orderPayment.getPayDiscount());
                 serialRecord.setTradeNo(balanceResponseDto.getTradeId());
-                if(payeeInfo!=null){
+                if (payeeInfo != null) {
                     serialRecord.setHoldName(payeeInfo.getHoldName());
                     serialRecord.setHoldCertificateNumber(payeeInfo.getHoldCertificateNumber());
                     serialRecord.setHoldContactsPhone(payeeInfo.getHoldContactsPhone());
                 }
             }
-            if(payeeInfo!=null){
+            if (payeeInfo != null) {
                 serialRecord.setCustomerAbbr(payeeInfo.getCustomerAbbr());
                 serialRecord.setCustomerNo(payeeInfo.getCustomerNo());
             }
             serialRecord.setCustomerId(order.getShopCustomerId());
             serialRecord.setCustomerName(order.getShopCustomerName());
-            if(orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            if (orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 serialRecord.setCardNo(order.getShopCardNo());
             }
-            serialRecord.setAmount(orderPayment.getPayAmount()-orderPayment.getPayDiscount());
+            serialRecord.setAmount(orderPayment.getPayAmount() - orderPayment.getPayDiscount());
             serialRecord.setNotes(String.format("卖方，订单号 %s", order.getCode()));
         }
         //serialRecord.setCustomerType(); //买家身份类型暂无
         //serialRecord.setTradeType();//
-        if(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        if (OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.BALANCE.getCode());
-        }else if(OrderPaymentAllChannel.WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.WECHAT.getCode());
-        }else if(OrderPaymentAllChannel.ZFB_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.ZFB_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.ALI.getCode());
-        }else if(OrderPaymentAllChannel.CASH_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.CASH_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.CASH.getCode());
-        }else if(OrderPaymentAllChannel.CREDIT_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.CREDIT_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.CASH.getCode());
-        }else if(OrderPaymentAllChannel.CREDIT_CODE_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.CREDIT_CODE_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.CASH.getCode());
-        }else if(OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.WECHAT.getCode());
         }
         serialRecord.setFundItem(FundItem.TRADE_PAYMENT.getIntegerCode().longValue());
@@ -1041,9 +1065,9 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         return serialRecordDtos;
     }
-    private void setSerialRecordCustomerInfo(Long marketId, Long shopCustomerId,SerialRecordDto serialRecordDto) {
+    private void setSerialRecordCustomerInfo(Long marketId, Long shopCustomerId, SerialRecordDto serialRecordDto) {
         BaseOutput<CustomerBaseExtensionInfo> extenMessage = customerRpc.getCustomerAndBaseExtensionById(shopCustomerId);
-        if(extenMessage.getData()!=null){
+        if (extenMessage.getData() != null) {
             CustomerBaseExtensionInfo customerBaseExtensionInfo = extenMessage.getData();
             serialRecordDto.setCustomerId(customerBaseExtensionInfo.getCustomerId());
             serialRecordDto.setCustomerNo(customerBaseExtensionInfo.getCode());
@@ -1054,6 +1078,7 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     /**
      * 买方优惠券流水
+     *
      * @param balanceResponseDto
      * @param order
      * @param orderPayment
@@ -1062,15 +1087,15 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
      * @param orderPayDto
      * @return
      */
-    private List<SerialRecordDto> createCouponsSerialRecordDto(BalanceResponseDto balanceResponseDto,Order order ,OrderPayment orderPayment,ActionEnum actionEnum
-            ,List<OrderCoupon> coupons,OrderPayDto orderPayDto,OrderPaymentPayeeInfoDto payeeInfoDto){
+    private List<SerialRecordDto> createCouponsSerialRecordDto(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, ActionEnum actionEnum
+            , List<OrderCoupon> coupons, OrderPayDto orderPayDto, OrderPaymentPayeeInfoDto payeeInfoDto) {
         Long startBalance = 0L;
-        if(balanceResponseDto != null){
-            startBalance = balanceResponseDto.getRelation().getBalance()+orderPayment.getPayAmount()-orderPayment.getPayDiscount();
+        if (balanceResponseDto != null) {
+            startBalance = balanceResponseDto.getRelation().getBalance() + orderPayment.getPayAmount() - orderPayment.getPayDiscount();
         }
         List<SerialRecordDto> serialRecordDtos = new ArrayList<>();
-        for(OrderCoupon coupon : coupons) {
+        for (OrderCoupon coupon : coupons) {
             //买方货款
             SerialRecordDto serialRecord = new SerialRecordDto();
             serialRecord.setSettleDayNo(DateUtils.formatDate(orderPayment.getPayTime().toLocalDate(), "yyyy-MM-dd"));
@@ -1099,11 +1124,11 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 serialRecord.setCustomerAbbr(orderPayDto.getCustomerAbbr());
                 serialRecord.setCustomerName(StrUtil.isBlank(orderPayment.getPayerCustomerName()) ? "默认用户" : orderPayment.getPayerCustomerName());
                 serialRecord.setAmount(coupon.getAmount());
-                serialRecord.setNotes(String.format("买方，订单号： %s，优惠券码：%s", order.getCode(),coupon.getCouponCode()));
-            }else if(actionEnum.getCode()==ActionEnum.INCOME.getCode()){
+                serialRecord.setNotes(String.format("买方，订单号： %s，优惠券码：%s", order.getCode(), coupon.getCouponCode()));
+            } else if (actionEnum.getCode() == ActionEnum.INCOME.getCode()) {
                 //卖方
                 serialRecord.setAction(ActionEnum.INCOME.getCode());
-                if(balanceResponseDto == null){
+                if (balanceResponseDto == null) {
                     serialRecord.setAccountId(null);
                     serialRecord.setStartBalance(null);
                     serialRecord.setEndBalance(null);
@@ -1115,12 +1140,12 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     //持卡人联系电话(客户联系电话)
                     serialRecord.setHoldContactsPhone(null);
-                }else{
+                } else {
                     serialRecord.setAccountId(balanceResponseDto.getRelation().getAccountId());
                     serialRecord.setStartBalance(startBalance);
-                    serialRecord.setEndBalance(startBalance+coupon.getAmount());
+                    serialRecord.setEndBalance(startBalance + coupon.getAmount());
                     serialRecord.setTradeNo(balanceResponseDto.getTradeId());
-                    if(payeeInfoDto!=null){
+                    if (payeeInfoDto != null) {
                         //持卡人姓名（客户姓名）
                         serialRecord.setHoldName(payeeInfoDto.getHoldName());
                         //持卡人证件号（客户证件号）
@@ -1130,17 +1155,17 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     }
                     startBalance += coupon.getAmount();
                 }
-                if(payeeInfoDto!=null){
+                if (payeeInfoDto != null) {
                     serialRecord.setCustomerAbbr(payeeInfoDto.getCustomerAbbr());
                     serialRecord.setCustomerNo(payeeInfoDto.getCustomerNo());
                 }
-                if(orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+                if (orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                     serialRecord.setCardNo(order.getShopCardNo());
                 }
                 serialRecord.setCustomerId(order.getShopCustomerId());
                 serialRecord.setCustomerName(order.getShopCustomerName());
                 serialRecord.setAmount(coupon.getAmount());
-                serialRecord.setNotes(String.format("卖方，订单号： %s，优惠券码：%s", order.getCode(),coupon.getCouponCode()));
+                serialRecord.setNotes(String.format("卖方，订单号： %s，优惠券码：%s", order.getCode(), coupon.getCouponCode()));
             }
             //serialRecord.setCustomerType(); //买家身份类型暂无
             //serialRecord.setTradeType();//
@@ -1160,47 +1185,48 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     /**
      * 作废流水
+     *
      * @param balanceResponseDto
      * @param order
      * @param orderPayment
      * @param coupons
-     * @param payeeInfo 买方信息
+     * @param payeeInfo          买方信息
      */
     @Override
-    public void sendInvalidSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, List<OrderCoupon> coupons,OrderPaymentPayeeInfoDto payeeInfo) {
+    public void sendInvalidSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, List<OrderCoupon> coupons, OrderPaymentPayeeInfoDto payeeInfo) {
         OrderPaymentPayeeInfoDto payerInfo = null;
-        try{
+        try {
             //买方信息
-            if(payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
-                if(order.getBuyerId()!=null){
+            if (payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
+                if (order.getBuyerId() != null) {
                     payerInfo = getPayeeInfo(order.getBuyerId());
                 }
-            }else if(payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            } else if (payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payerInfo = getPayeeInfoByAccountId(orderPayment.getPayerAccountId());
             }
             //卖方信息
-            if(payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            if (payeeInfo == null && !orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payeeInfo = getPayeeInfo(order.getShopCustomerId());
-            }else if(payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            } else if (payeeInfo == null && orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 payeeInfo = getPayeeInfoByAccountId(orderPayment.getPayeeAccountId());
             }
-        }catch (Exception e){
-            LOGGER.warn("客户服务调用异常",e);
+        } catch (Exception e) {
+            LOGGER.warn("客户服务调用异常", e);
         }
         List<SerialRecordDto> list = new ArrayList<>();
         //买家收款
-        List<SerialRecordDto> mainSerialRecordDtoBuyer = createInvalidSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons,payerInfo,payeeInfo);
+        List<SerialRecordDto> mainSerialRecordDtoBuyer = createInvalidSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, payerInfo, payeeInfo);
         list.addAll(mainSerialRecordDtoBuyer);
         //卖家付款
-        List<SerialRecordDto> mainSerialRecordDtoSeller = createInvalidSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons,payerInfo,payeeInfo);
+        List<SerialRecordDto> mainSerialRecordDtoSeller = createInvalidSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, payerInfo, payeeInfo);
         list.addAll(mainSerialRecordDtoSeller);
-        if(coupons!=null&&coupons.size()>0){
+        if (coupons != null && coupons.size() > 0) {
             //买家优惠作废
-            List<SerialRecordDto> couponsSerialRecordDtoBuyer = createInvalidCouponsSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons,payerInfo,payeeInfo);
+            List<SerialRecordDto> couponsSerialRecordDtoBuyer = createInvalidCouponsSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.INCOME, coupons, payerInfo, payeeInfo);
             list.addAll(couponsSerialRecordDtoBuyer);
             //卖家优惠作废
-            List<SerialRecordDto> couponsSerialRecordDtoSeller = createInvalidCouponsSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons,payerInfo,payeeInfo);
+            List<SerialRecordDto> couponsSerialRecordDtoSeller = createInvalidCouponsSerialRecord(balanceResponseDto, order, orderPayment, ActionEnum.EXPENSE, coupons, payerInfo, payeeInfo);
             list.addAll(couponsSerialRecordDtoSeller);
         }
         //发送mq
@@ -1209,13 +1235,14 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     /**
      * 创建买方货款流水
+     *
      * @param order
      * @param orderPayment
-     * @param actionEnum 买家角度
+     * @param actionEnum   买家角度
      * @return
      */
-    private List<SerialRecordDto> createInvalidSerialRecord(BalanceResponseDto balanceResponseDto,Order order ,OrderPayment orderPayment,ActionEnum actionEnum
-            ,List<OrderCoupon> coupons,OrderPaymentPayeeInfoDto payerInfo ,OrderPaymentPayeeInfoDto payeeInfo){
+    private List<SerialRecordDto> createInvalidSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, ActionEnum actionEnum
+            , List<OrderCoupon> coupons, OrderPaymentPayeeInfoDto payerInfo, OrderPaymentPayeeInfoDto payeeInfo) {
         List<SerialRecordDto> serialRecordDtos = new ArrayList<>();
         //买方货款
@@ -1223,10 +1250,10 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         serialRecord.setSettleDayNo(DateUtils.formatDate(orderPayment.getPayTime().toLocalDate(), "yyyy-MM-dd"));
         serialRecord.setType(BizNumberTypeEnum.ETRADE_TRADE.getCode());
         serialRecord.setTypeName(BizNumberTypeEnum.ETRADE_TRADE.getName());
-        if(actionEnum.getCode()==ActionEnum.INCOME.getCode()){
+        if (actionEnum.getCode() == ActionEnum.INCOME.getCode()) {
             //买方
             serialRecord.setAction(ActionEnum.INCOME.getCode());
-            if(balanceResponseDto == null){
+            if (balanceResponseDto == null) {
                 serialRecord.setAccountId(null);
                 serialRecord.setStartBalance(null);
                 serialRecord.setEndBalance(null);
@@ -1238,18 +1265,18 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 //持卡人联系电话(客户联系电话)
                 serialRecord.setHoldContactsPhone(null);
-            }else{
-                if(balanceResponseDto.getRelation()!=null){
+            } else {
+                if (balanceResponseDto.getRelation() != null) {
                     serialRecord.setAccountId(balanceResponseDto.getRelation().getAccountId());
                     serialRecord.setStartBalance(balanceResponseDto.getRelation().getBalance());
-                    serialRecord.setEndBalance(balanceResponseDto.getRelation().getBalance()-orderPayment.getPayAmount()+orderPayment.getPayDiscount());
-                }else{
+                    serialRecord.setEndBalance(balanceResponseDto.getRelation().getBalance() - orderPayment.getPayAmount() + orderPayment.getPayDiscount());
+                } else {
                     serialRecord.setAccountId(null);
                     serialRecord.setStartBalance(null);
                     serialRecord.setEndBalance(null);
                 }
                 serialRecord.setTradeNo(balanceResponseDto.getTradeId());
-                if(payerInfo!=null){
+                if (payerInfo != null) {
                     //持卡人姓名（客户姓名）
                     serialRecord.setHoldName(payerInfo.getHoldName());
                     //持卡人证件号（客户证件号）
@@ -1258,22 +1285,22 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     serialRecord.setHoldContactsPhone(payerInfo.getHoldContactsPhone());
                 }
             }
-            if(payerInfo!=null){
+            if (payerInfo != null) {
                 serialRecord.setCustomerNo(payerInfo.getCustomerNo());
                 serialRecord.setCustomerAbbr(payerInfo.getCustomerAbbr());
             }
-            if(orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())){
+            if (orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 serialRecord.setCardNo(orderPayment.getPayerCardNo());
             }
-            serialRecord.setCustomerId(orderPayment.getPayerCustomerId()==null?0L:orderPayment.getPayerCustomerId());
+            serialRecord.setCustomerId(orderPayment.getPayerCustomerId() == null ? 0L : orderPayment.getPayerCustomerId());
             serialRecord.setCustomerNo(order.getBuyerCode());
-            serialRecord.setCustomerName(StrUtil.isBlank(orderPayment.getPayerCustomerName())?"默认用户":orderPayment.getPayerCustomerName());
-            serialRecord.setAmount(Math.abs(orderPayment.getPayAmount())-Math.abs(orderPayment.getPayDiscount()));
+            serialRecord.setCustomerName(StrUtil.isBlank(orderPayment.getPayerCustomerName()) ? "默认用户" : orderPayment.getPayerCustomerName());
+            serialRecord.setAmount(Math.abs(orderPayment.getPayAmount()) - Math.abs(orderPayment.getPayDiscount()));
             serialRecord.setNotes(String.format("作废买方，订单号 %s", order.getCode()));
-        }else if(actionEnum.getCode()==ActionEnum.EXPENSE.getCode()){
+        } else if (actionEnum.getCode() == ActionEnum.EXPENSE.getCode()) {
             //卖方
             serialRecord.setAction(ActionEnum.EXPENSE.getCode());
-            if(balanceResponseDto == null){
+            if (balanceResponseDto == null) {
                 serialRecord.setAccountId(null);
                 serialRecord.setStartBalance(null);
                 serialRecord.setEndBalance(null);
@@ -1284,12 +1311,12 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 serialRecord.setHoldCertificateNumber(null);
                 //持卡人联系电话(客户联系电话)
                 serialRecord.setHoldContactsPhone(null);
-            }else{
+            } else {
                 serialRecord.setAccountId(balanceResponseDto.getAccountId());
                 serialRecord.setStartBalance(balanceResponseDto.getBalance());
-                serialRecord.setEndBalance(balanceResponseDto.getBalance()+orderPayment.getPayAmount()-orderPayment.getPayDiscount());
+                serialRecord.setEndBalance(balanceResponseDto.getBalance() + orderPayment.getPayAmount() - orderPayment.getPayDiscount());
                 serialRecord.setTradeNo(balanceResponseDto.getTradeId());
-                if(payeeInfo!=null){
+                if (payeeInfo != null) {
                     //持卡人姓名（客户姓名）
                     serialRecord.setHoldName(payeeInfo.getHoldName());
                     //持卡人证件号（客户证件号）
@@ -1298,33 +1325,33 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     serialRecord.setHoldContactsPhone(payeeInfo.getHoldContactsPhone());
                 }
             }
-            if(orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
+            if (orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                 serialRecord.setCardNo(order.getShopCardNo());
             }
             serialRecord.setCustomerId(order.getShopCustomerId());
             serialRecord.setCustomerName(order.getShopCustomerName());
-            if(payeeInfo!=null){
+            if (payeeInfo != null) {
                 serialRecord.setCustomerNo(payeeInfo.getCustomerNo());
                 serialRecord.setCustomerAbbr(payeeInfo.getCustomerAbbr());
             }
-            serialRecord.setAmount(Math.abs(orderPayment.getPayAmount())-Math.abs(orderPayment.getPayDiscount()));
+            serialRecord.setAmount(Math.abs(orderPayment.getPayAmount()) - Math.abs(orderPayment.getPayDiscount()));
             serialRecord.setNotes(String.format("作废卖方，订单号 %s", order.getCode()));
         }
         //serialRecord.setCustomerType(); //买家身份类型暂无
         //serialRecord.setTradeType();//
-        if(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        if (OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.BALANCE.getCode());
-        }else if(OrderPaymentAllChannel.WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.WECHAT.getCode());
-        }else if(OrderPaymentAllChannel.ZFB_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.ZFB_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.ALI.getCode());
-        }else if(OrderPaymentAllChannel.CASH_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.CASH_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.CASH.getCode());
-        }else if(OrderPaymentAllChannel.CREDIT_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.CREDIT_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.CASH.getCode());
-        }else if(OrderPaymentAllChannel.CREDIT_CODE_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.CREDIT_CODE_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.CASH.getCode());
-        }else if(OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())){
+        } else if (OrderPaymentAllChannel.BUYER_WX_CHANNEL.getCodeInteger().equals(orderPayment.getPayChannel())) {
             serialRecord.setTradeChannel(TradeChannelEnum.WECHAT.getCode());
         }
         serialRecord.setFundItem(FundItem.TRADE_PAYMENT.getIntegerCode().longValue());
@@ -1342,24 +1369,25 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
     /**
      * 买方优惠券流水
+     *
      * @param balanceResponseDto
      * @param order
      * @param orderPayment
      * @param actionEnum
      * @param coupons
-     * @param payerInfo 买方信息
-     * @param payeeInfoDto 卖方信息
+     * @param payerInfo          买方信息
+     * @param payeeInfoDto       卖方信息
      * @return
      */
-    private List<SerialRecordDto> createInvalidCouponsSerialRecord(BalanceResponseDto balanceResponseDto,Order order ,OrderPayment orderPayment,ActionEnum actionEnum
-            ,List<OrderCoupon> coupons,OrderPaymentPayeeInfoDto payerInfo,OrderPaymentPayeeInfoDto payeeInfoDto){
+    private List<SerialRecordDto> createInvalidCouponsSerialRecord(BalanceResponseDto balanceResponseDto, Order order, OrderPayment orderPayment, ActionEnum actionEnum
+            , List<OrderCoupon> coupons, OrderPaymentPayeeInfoDto payerInfo, OrderPaymentPayeeInfoDto payeeInfoDto) {
         Long startBalance = 0L;
-        if(balanceResponseDto != null){
-            startBalance = balanceResponseDto.getBalance()+orderPayment.getPayAmount()-orderPayment.getPayDiscount();
+        if (balanceResponseDto != null) {
+            startBalance = balanceResponseDto.getBalance() + orderPayment.getPayAmount() - orderPayment.getPayDiscount();
         }
         List<SerialRecordDto> serialRecordDtos = new ArrayList<>();
-        for(OrderCoupon coupon : coupons) {
+        for (OrderCoupon coupon : coupons) {
             //买方货款
             SerialRecordDto serialRecord = new SerialRecordDto();
             serialRecord.setSettleDayNo(DateUtils.formatDate(orderPayment.getPayTime().toLocalDate(), "yyyy-MM-dd"));
@@ -1379,7 +1407,7 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 if (balanceResponseDto != null) {
                     serialRecord.setTradeNo(balanceResponseDto.getTradeId());
                 }
-                if(payerInfo!=null){
+                if (payerInfo != null) {
                     serialRecord.setCustomerAbbr(payerInfo.getCustomerAbbr());
                 }
                 serialRecord.setOperateTime(orderPayment.getPayTime());
@@ -1387,11 +1415,11 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                 serialRecord.setCustomerNo(order.getBuyerCode());
                 serialRecord.setCustomerName(StrUtil.isBlank(orderPayment.getPayerCustomerName()) ? "默认用户" : orderPayment.getPayerCustomerName());
                 serialRecord.setAmount(Math.abs(coupon.getAmount()));
-                serialRecord.setNotes(String.format("作废买方，订单号： %s，优惠券码：%s", order.getCode(),coupon.getCouponCode()));
-            }else if(actionEnum.getCode()==ActionEnum.EXPENSE.getCode()){
+                serialRecord.setNotes(String.format("作废买方，订单号： %s，优惠券码：%s", order.getCode(), coupon.getCouponCode()));
+            } else if (actionEnum.getCode() == ActionEnum.EXPENSE.getCode()) {
                 //卖方
                 serialRecord.setAction(ActionEnum.EXPENSE.getCode());
-                if(balanceResponseDto == null){
+                if (balanceResponseDto == null) {
                     serialRecord.setAccountId(null);
                     serialRecord.setStartBalance(null);
                     serialRecord.setEndBalance(null);
@@ -1402,12 +1430,12 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     serialRecord.setHoldCertificateNumber(null);
                     //持卡人联系电话(客户联系电话)
                     serialRecord.setHoldContactsPhone(null);
-                }else{
+                } else {
                     serialRecord.setAccountId(balanceResponseDto.getAccountId());
                     serialRecord.setStartBalance(startBalance);
-                    serialRecord.setEndBalance(startBalance+coupon.getAmount());
+                    serialRecord.setEndBalance(startBalance + coupon.getAmount());
                     serialRecord.setTradeNo(balanceResponseDto.getTradeId());
-                    if(payeeInfoDto!=null){
+                    if (payeeInfoDto != null) {
                         serialRecord.setHoldContactsPhone(payeeInfoDto.getHoldContactsPhone());
                         serialRecord.setHoldName(payeeInfoDto.getHoldName());
                         serialRecord.setHoldCertificateNumber(payeeInfoDto.getHoldCertificateNumber());
@@ -1415,17 +1443,17 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
                     }
                     startBalance += coupon.getAmount();
                 }
-                if(payeeInfoDto!=null){
+                if (payeeInfoDto != null) {
                     serialRecord.setCustomerNo(payeeInfoDto.getCustomerNo());
                     serialRecord.setCustomerAbbr(payeeInfoDto.getCustomerAbbr());
                 }
-                if(orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
+                if (orderPayment.getPayChannel().equals(OrderPaymentAllChannel.CARD_CHANNEL.getCodeInteger())) {
                     serialRecord.setCardNo(order.getShopCardNo());
                 }
                 serialRecord.setCustomerId(order.getShopCustomerId());
                 serialRecord.setCustomerName(order.getShopCustomerName());
                 serialRecord.setAmount(Math.abs(coupon.getAmount()));
-                serialRecord.setNotes(String.format("作废卖方，订单号： %s，优惠券码：%s", order.getCode(),coupon.getCouponCode()));
+                serialRecord.setNotes(String.format("作废卖方，订单号： %s，优惠券码：%s", order.getCode(), coupon.getCouponCode()));
             }
             //serialRecord.setCustomerType(); //买家身份类型暂无
             //serialRecord.setTradeType();//
@@ -1443,14 +1471,14 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         return serialRecordDtos;
     }
-    private SerialRecordDto setSerialRecordAccountInfo(SerialRecordDto recordDto,Long AccountId){
-        if(recordDto!=null&&AccountId!=null){
-            UserAccountSingleQueryDto userAccountSingleQueryDto=new UserAccountSingleQueryDto();
+    private SerialRecordDto setSerialRecordAccountInfo(SerialRecordDto recordDto, Long AccountId) {
+        if (recordDto != null && AccountId != null) {
+            UserAccountSingleQueryDto userAccountSingleQueryDto = new UserAccountSingleQueryDto();
             userAccountSingleQueryDto.setAccountId(AccountId);
             Message<UserAccountCardResponseDto> message = accountRpc.findSingle(userAccountSingleQueryDto);
             //
             UserAccountCardResponseDto userAccountCardResponseDto = message.getData();
-            AssertUtils.notNull(userAccountCardResponseDto,"未获取到买方持卡人信息");
+            AssertUtils.notNull(userAccountCardResponseDto, "未获取到买方持卡人信息");
             recordDto.setCustomerId(userAccountCardResponseDto.getCustomerId());
             recordDto.setCustomerNo(userAccountCardResponseDto.getCustomerCode());
             recordDto.setCustomerName(userAccountCardResponseDto.getCustomerName());
@@ -1465,15 +1493,15 @@ public class OrderPaymenServiceImpl implements OrderPaymentService {
         return recordDto;
     }
-    private OrderPaymentPayeeInfoDto getPayeeInfoByAccountId(Long AccountId){
-        if(AccountId!=null){
+    private OrderPaymentPayeeInfoDto getPayeeInfoByAccountId(Long AccountId) {
+        if (AccountId != null) {
             OrderPaymentPayeeInfoDto payeeInfoDto = new OrderPaymentPayeeInfoDto();
-            UserAccountSingleQueryDto userAccountSingleQueryDto=new UserAccountSingleQueryDto();
+            UserAccountSingleQueryDto userAccountSingleQueryDto = new UserAccountSingleQueryDto();
             userAccountSingleQueryDto.setAccountId(AccountId);
             Message<UserAccountCardResponseDto> message = accountRpc.findSingle(userAccountSingleQueryDto);
             //
             UserAccountCardResponseDto userAccountCardResponseDto = message.getData();
-            AssertUtils.notNull(userAccountCardResponseDto,"未获取到买方持卡人信息");
+            AssertUtils.notNull(userAccountCardResponseDto, "未获取到买方持卡人信息");
             payeeInfoDto.setCustomerId(userAccountCardResponseDto.getCustomerId());
             payeeInfoDto.setCustomerNo(userAccountCardResponseDto.getCustomerCode());
             payeeInfoDto.setCustomerName(userAccountCardResponseDto.getCustomerName());
@@ -814,7 +814,7 @@ public class OrderServiceImpl implements OrderService {
                 OrderPayDto orderPayDto = new OrderPayDto(order.getCode(), orderWeChatPayBatch.getMarketId(),orderWeChatPayBatch.getPayerCustomerId()
                         ,orderWeChatPayBatch.getPayerStoreCustomerId(),orderWeChatPayBatch.getPayerCustomerName(),orderWeChatPayBatch.getPayerPhone()
                         ,null,null,null,null,orderWeChatPayBatch.getOperateId(),orderWeChatPayBatch.getOperateName()
-                        ,null,null,null,orderWeChatPayBatch.getCustomerAbbr(),weChatPayTradeBackDto.getPaymentId());
+                        ,null,null,null,orderWeChatPayBatch.getCustomerAbbr(),weChatPayTradeBackDto.getPaymentId(),orderWeChatPayBatch.getPayChannelSub());
                 orderPaymentService.createOrderPayment(order, orderPayDto, identityType,shop);
             }catch (PlatformServiceException pe){
                 LOGGER.info("微信支付异常，支付订单号：{}，异常信息{}",orderWeChatPayBatch.getCodes(),pe.getMessage());
@@ -917,7 +917,7 @@ public class OrderServiceImpl implements OrderService {
                 orderPayDto = new OrderPayDto(order.getCode(), order.getMarketId(),payment.getPayerCustomerId()
                         ,payment.getPayerStoreCustomerId(),payment.getPayerCustomerName(),order.getBuyerPhone()
                         ,null,null,null,null, order.getBuyerId(), order.getBuyerName()
-                        ,null,null,null,payerInfo.getCustomerAbbr(),payment.getTradeId());
+                        ,null,null,null,payerInfo.getCustomerAbbr(),payment.getTradeId(),null);
                 if(StringUtils.isBlank(order.getBuyerCode())){
                     order.setBuyerCode(payerInfo.getCustomerNo());
                 }
@@ -925,7 +925,7 @@ public class OrderServiceImpl implements OrderService {
                 orderPayDto = new OrderPayDto(order.getCode(), order.getMarketId(),payment.getPayerCustomerId()
                         ,payment.getPayerStoreCustomerId(),payment.getPayerCustomerName(),order.getBuyerPhone()
                         ,null,null,null,null, order.getBuyerId(), order.getBuyerName()
-                        ,null,null,null,null,payment.getTradeId());
+                        ,null,null,null,null,payment.getTradeId(),null);
             }
             if(payeeInfo==null){
                 payeeInfo = getPayeeInfo(order.getShopCustomerId());
+package com.diligrp.etrade.order.type;
+
+import com.diligrp.etrade.core.type.EnumArrayValuableEnums;
+import com.diligrp.etrade.core.type.IEnumType;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * 操作类型
+ */
+public enum OrderPaymentSubChannel implements IEnumType, EnumArrayValuableEnums {
+    //1现金，2支付宝，3微信，4园区卡
+    CARD_CHANNEL_BUYER("买方扫码", 1, 4, 4),
+    CARD_CHANNEL_SELLER("卖方扫码", 2, 4, 8),
+    CARD_CHANNEL_NFC("NFC", 3, 4, 8);
+
+    private String name;
+    private Integer code;
+
+    private Integer settingChannel;
+
+    private Integer realSettingChannel;
+
+    private OrderPaymentSubChannel(String name, Integer code, Integer channel, Integer realSettingChannel) {
+        this.name = name;
+        this.code = code;
+        this.settingChannel = channel;
+        this.realSettingChannel = realSettingChannel;
+    }
+
+    public static OrderPaymentSubChannel getByCode(Integer code) {
+        for (OrderPaymentSubChannel temp : OrderPaymentSubChannel.values()) {
+            if (temp.getCodeInteger().equals(code)) {
+                return temp;
+            }
+        }
+        return null;
+    }
+
+    public static String getNameByCode(Integer code) {
+        for (OrderPaymentSubChannel temp : OrderPaymentSubChannel.values()) {
+            if (temp.getCodeInteger().equals(code)) {
+                return temp.getName();
+            }
+        }
+        return null;
+    }
+
+    public Integer getSettingChannel() {
+        return this.settingChannel;
+    }
+
+    public Integer getCodeInteger() {
+        return this.code;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public int getCode() {
+        return this.code;
+    }
+
+    public String toString() {
+        return this.name;
+    }
+
+    public Integer getRealSettingChannel() {
+        return realSettingChannel;
+    }
+
+    /**
+     * 自定义序列化
+     *
+     * @return {@link Map}<{@link String}, {@link String}>
+     */
+    @Override
+    public Map<String, String> keyValue() {
+        return Stream.of(OrderPaymentSubChannel.values())
+                .collect(Collectors.toMap(OrderPaymentSubChannel::getCode, OrderPaymentSubChannel::getName)).entrySet().stream()
+                .collect(Collectors.toMap(vo -> vo.getKey().toString(), Map.Entry::getValue));
+    }
+}
 \ No newline at end of file
@@ -34,13 +34,14 @@
     <result column="seller_fee_state" jdbcType="VARCHAR" property="sellerFeeState" />
     <result column="order_status" jdbcType="TINYINT" property="orderStatus" />
     <result column="relation_id" jdbcType="BIGINT" property="relationId" />
+    <result column="pay_channel_sub" jdbcType="TINYINT" property="payChannelSub"/>
   </resultMap>
     <sql id="Base_Column_List">
         id, `code`, order_id, order_code,market_id, pay_amount, pay_discount, payer_customer_id, payer_store_customer_id,
         payer_customer_name, payer_card_no, payer_account_id, payer_fund_account_id, payee_shop_id,
         payee_shop_name, payee_card_no, payee_account_id, payee_fund_account_id, payee_seller_id,
         payee_seller_name, pay_time, pay_mode, pay_channel, version, created_time, modified_time,
-        `state`, trade_id,totle_seller_fee,seller_fee_state,order_status,relation_id
+        `state`, trade_id,totle_seller_fee,seller_fee_state,order_status,relation_id,pay_channel_sub
     </sql>
     <sql id="VO_Column_List">
         id, `code`, order_id, order_code, convert(pay_amount, decimal(20,2))/100 as pay_amount, convert(pay_discount, decimal(20,2))/100 as pay_discount, payer_customer_id, payer_store_customer_id,
@@ -58,7 +59,8 @@
                                payee_account_id, payee_fund_account_id, payee_seller_id,
                                payee_seller_name, pay_time, pay_mode,
                                pay_channel, version,  state, trade_id,
-                               totle_seller_fee,seller_fee_state,order_status,relation_id
+                               totle_seller_fee,seller_fee_state,order_status,relation_id,
+                               pay_channel_sub
     )
     values (#{id,jdbcType=BIGINT}, #{code,jdbcType=VARCHAR}, #{orderId,jdbcType=INTEGER},#{marketId,jdbcType=BIGINT},
             #{orderCode,jdbcType=VARCHAR}, #{payAmount,jdbcType=BIGINT}, #{payDiscount,jdbcType=BIGINT},
@@ -68,7 +70,8 @@
             #{payeeAccountId,jdbcType=BIGINT}, #{payeeFundAccountId,jdbcType=BIGINT}, #{payeeSellerId,jdbcType=BIGINT},
             #{payeeSellerName,jdbcType=VARCHAR}, #{payTime,jdbcType=TIMESTAMP}, #{payMode,jdbcType=INTEGER},
             #{payChannel,jdbcType=INTEGER}, #{version,jdbcType=INTEGER}, #{state,jdbcType=TINYINT}, #{tradeId,jdbcType=VARCHAR},
-            #{totleSellerFee,jdbcType=BIGINT}, #{sellerFeeState,jdbcType=TINYINT},#{orderStatus,jdbcType=TINYINT}, #{relationId,jdbcType=BIGINT})
+            #{totleSellerFee,jdbcType=BIGINT}, #{sellerFeeState,jdbcType=TINYINT},#{orderStatus,jdbcType=TINYINT}, #{relationId,jdbcType=BIGINT},
+            #{payChannelSub,jdbcType=INTEGER})
   </insert>
     <insert id="saveBatch" useGeneratedKeys="true" keyProperty="id">
         insert into order_payment (id, code, order_id,market_id,
@@ -79,7 +82,8 @@
                                    payee_account_id, payee_fund_account_id, payee_seller_id,
                                    payee_seller_name, pay_time, pay_mode,
                                    pay_channel, version,  state, trade_id,
-                                   totle_seller_fee,seller_fee_state,order_status,relation_id
+                                   totle_seller_fee,seller_fee_state,order_status,relation_id,
+                                   pay_channel_sub
         )
         values
         <foreach collection="list" item="payment" separator=",">
@@ -91,7 +95,8 @@
                 #{payment.payeeAccountId,jdbcType=BIGINT}, #{payment.payeeFundAccountId,jdbcType=BIGINT}, #{payment.payeeSellerId,jdbcType=BIGINT},
                 #{payment.payeeSellerName,jdbcType=VARCHAR}, #{payment.payTime,jdbcType=TIMESTAMP}, #{payment.payMode,jdbcType=INTEGER},
                 #{payment.payChannel,jdbcType=INTEGER}, #{payment.version,jdbcType=INTEGER}, #{payment.state,jdbcType=TINYINT}, #{payment.tradeId,jdbcType=VARCHAR},
-                #{payment.totleSellerFee,jdbcType=BIGINT}, #{payment.sellerFeeState,jdbcType=TINYINT},#{payment.orderStatus,jdbcType=TINYINT}, #{payment.relationId,jdbcType=BIGINT})
+                #{payment.totleSellerFee,jdbcType=BIGINT}, #{payment.sellerFeeState,jdbcType=TINYINT},#{payment.orderStatus,jdbcType=TINYINT}, #{payment.relationId,jdbcType=BIGINT},
+                #{payChannelSub,jdbcType=INTEGER})
         </foreach>
     </insert>
     <update id="updatepayment" parameterType="com.diligrp.etrade.order.model.OrderPayment">
@@ -213,6 +213,7 @@ CREATE TABLE `order_payment`  (
       `seller_fee_state` tinyint DEFAULT NULL COMMENT '卖方手续费缴费状态',
       `order_status` tinyint DEFAULT NULL COMMENT '单据类型',
       `relation_id` bigint DEFAULT NULL COMMENT '关联id',
+      `pay_channel_sub` tinyint DEFAULT NULL COMMENT '园区卡支付子分类',
       PRIMARY KEY (`id`) USING BTREE,
       KEY `orderId` (`order_id`,`market_id`) USING BTREE,
       KEY `shop` (`payee_shop_id`,`pay_channel`) USING BTREE,
+ALTER TABLE `zr_etrade`.`order_payment`
+    ADD COLUMN `pay_channel_sub` tinyint NULL COMMENT '园区卡支付子分类';
+
+UPDATE zr_etrade.`order_payment` payment LEFT JOIN zr_etrade.`order` ord ON payment.order_id = ord.id
+SET payment.pay_channel_sub = 1
+WHERE ord.order_type = 2
 \ No newline at end of file