liebao-cloud/lb-app/src/main/java/com/ydd/app/service/impl/ApiPayServiceImpl.java

package com.ydd.app.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.binarywang.wxpay.exception.WxPayException;
import com.ijpay.core.enums.TradeType;
import com.ydd.api.DeliveryService;
import com.ydd.app.dto.OrderReq;
import com.ydd.app.dto.ValuationRes;
import com.ydd.app.listener.DeliveryOrderEvent;
import com.ydd.app.service.*;
import com.ydd.app.task.TipsTask;
import com.ydd.common.exception.CustomException;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.SnCodeUtils;
import com.ydd.module.domain.*;
import com.ydd.module.dto.CouponDto;
import com.ydd.module.dto.PayTradeQueryDto;
import com.ydd.module.enums.*;
import com.ydd.module.expection.CustomAppException;
import com.ydd.module.pay.alipay.AliPayService;
import com.ydd.module.pay.wechat.service.WechatPayService;
import com.ydd.module.service.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Project：lb-server
 * Class：PayServiceImpl
 * Description：TODO
 * Time：2021/2/24 15:57
 *
 * @author zoe
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ApiPayServiceImpl implements ApiPayService {

    private final IOrderService iOrderService;

    private final IMemberService iMemberService;

    private final IMemberBalanceLogService iMemberBalanceLogService;

    private final AliPayService aliPayService;

    private final IRechargeOptionService iRechargeOptionService;

    private final IRechargeService iRechargeService;

    private final ICouponService iCouponService;

    private final IMemberCouponService iMemberCouponService;

    private final WechatPayService wechatPayService;

    private final IPaymentService paymentService;

    private final IOrderLogService iOrderLogService;
    private final ApiCouponService apiCouponService;
    private final ApiProductService apiProductService;
    private final ApplicationContext applicationContext;

    private final IOrderTipService iOrderTipService;
    private final IDspDeliveryService iDspDeliveryService;
    private final IOrderDeliveryService iOrderDeliveryService;

    private final DeliveryService client;
    private final IShopDeliveryService iShopDeliveryService;
    private final ApiOrderNewService apiOrderNewService;
    private final ApiOrderService apiOrderService;
    private final IShopDeliveryBindService iShopDeliveryBindService;

    public static ScheduledExecutorService tipScheduledExecutorService = Executors.newScheduledThreadPool(10);

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void pay(Long loginId, Integer orderId, Integer paymentType) {
        Order order = iOrderService.getById(orderId);
        Member member = iMemberService.getById(loginId);
        if (order == null) {
            throw new CustomAppException("订单不存在！");
        }
        order.setPaymentType(paymentType);
        if (order.getStatus().equals(PayStatusEnum.NO_PAYED.status)) {
            //扣钱
            if (member.getAmount().compareTo(order.getPayAmount()) < 0) {
                throw new CustomAppException("余额不足！", 250);
            }
            iMemberService.updateAmount(loginId, order.getPayAmount().negate());
            //更新支付状态
            order.setStatus(PayStatusEnum.PAYED.status);
            order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status);
            //去三方平台发单
            //TODO

            //余额变动记录
            iMemberBalanceLogService.saveLog(loginId, LogTypeEnum.REDUCE.type, "余额支付", LogSourceEnum.CONSUMPTION.status, order.getPayAmount(), order.getMerchantId(),order.getId(), order.getPaymentType());
        }
        iOrderService.updateById(order);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object payWx(Long loginId, Integer id, BigDecimal money, Integer paymentType, Integer createType) {
        Recharge recharge = new Recharge();
        recharge.setAmount(money);
        recharge.setGiveAmount(BigDecimal.ZERO);
        if (id != null) {
            RechargeOption option = iRechargeOptionService.getById(id);
            if (option == null) {
                throw new CustomAppException("充值选项不存在！");
            }
            recharge.setGiveAmount(new BigDecimal(option.getGiveValue()));
            recharge.setAmount(new BigDecimal(option.getValue()));
            recharge.setCouponIds(option.getCouponIds());
        }
        String orderSn = "R" + SnCodeUtils.createSn();
        recharge.setMemberId(loginId);
        recharge.setRechargeSn(orderSn);
        recharge.setTransactionDesc("账户充值");
        recharge.setPaymentType(PaymentTypeEnum.WEI_XIN.type);
        recharge.setPayStatus(PayStatusEnum.NO_PAYED.status);
        iRechargeService.save(recharge);
        paymentService.savePayment(loginId, orderSn, money, PaymentTypeEnum.WEI_XIN.type, TradeTypeEnum.RECHARGE.type, "", orderSn);
        try {
            Object resp;
            if (createType != null && createType == 1) {
                // PC充值
                resp = apiOrderService.getPaymentQRCode(money, orderSn, PaymentTypeEnum.WEI_XIN.type);
            } else {
                // APP充值
                resp = wechatPayService.pay(recharge.getAmount(), recharge.getTransactionDesc(), recharge.getRechargeSn(), TradeType.APP);
            }
            return resp;
        } catch (WxPayException e) {
           // e.printStackTrace();
            throw new CustomException("支付失败, 请重试");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object payZfb(Long loginId, Integer id, BigDecimal money, Integer paymentType, Integer createType) {
        Recharge recharge = new Recharge();
        recharge.setAmount(money);
        recharge.setGiveAmount(BigDecimal.ZERO);
        if (id != null) {
            RechargeOption option = iRechargeOptionService.getById(id);
            if (option == null) {
                throw new CustomAppException("充值选项不存在！");
            }
            recharge.setGiveAmount(new BigDecimal(option.getGiveValue()));
            recharge.setAmount(new BigDecimal(option.getValue()));
            recharge.setCouponIds(option.getCouponIds());
        }
        String orderSn = "R" + SnCodeUtils.createSn();
        recharge.setMemberId(loginId);
        recharge.setRechargeSn(orderSn);
        recharge.setTransactionDesc("账户充值");
        recharge.setPaymentType(PaymentTypeEnum.ZHI_FU_BAO.type);
        recharge.setPayStatus(PayStatusEnum.NO_PAYED.status);
        iRechargeService.save(recharge);
        paymentService.savePayment(loginId, orderSn, money, PaymentTypeEnum.ZHI_FU_BAO.type, TradeTypeEnum.RECHARGE.type, "", orderSn);
        Object resp;
        if (createType != null && createType == 1) {
            // PC充值
            resp = apiOrderService.getPaymentQRCode(money, orderSn, PaymentTypeEnum.ZHI_FU_BAO.type);
        } else {
            // APP充值
            resp = aliPayService.pay(recharge.getRechargeSn(), recharge.getAmount().toString(), "账户充值");
        }
        return resp;
    }

    @Async
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void paySuccess(String orderSn, String tradeSn, Integer payMement) {
//        OrderTip orderTip =null;
//        if(orderSn.startsWith("T")){
//            orderTip = iOrderTipService.getOne(new QueryWrapper<OrderTip>().eq("child_order_no",orderSn));
//            orderSn = orderTip.getOrderNo();
//        }
        Payment payment = paymentService.getOne(new QueryWrapper<Payment>().eq("child_order_sn", orderSn).eq("payment_type", payMement));

        if (payment != null && TradeTypeEnum.RECHARGE.type.equals(payment.getTradeType())) {
            recharge(orderSn, tradeSn);
        } else if (payment != null && TradeTypeEnum.ORDER.type.equals(payment.getTradeType())) {
            Order order = iOrderService.getOne(new QueryWrapper<Order>().eq("order_sn", orderSn).eq("deleted", IsDeleteEnum.NORMAL.status));

            if (!PaymentTypeEnum.BALANCE.type.equals(payment.getPaymentType()) && PayStatusEnum.NO_PAYED.status.equals(order.getStatus())) {
                payment.setPayStatus(PayStatusEnum.PAYED.status);
                payment.setTransactionSn(tradeSn);
                payment.setPayTime(new Date());
                paymentService.updatePayment(payment);

                order.setStatus(PayStatusEnum.PAYED.status);
                order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status);
                iOrderService.updateById(order);

                iOrderLogService.addOrderLog(order.getId(), OrderStatusEnum.PAYED.status);
                iOrderLogService.addOrderLog(order.getId(), OrderStatusEnum.ORDERS_TO_BE_RECEIVED.status);
                CouponDto couponDto = null;
                if (order.getCouponId() != null && order.getCouponAmount().compareTo(BigDecimal.ZERO) > 0) {
                    couponDto = apiCouponService.findDetail(order.getCouponId().intValue());
                    couponDto.setStatus(MemberCouponStatusEnum.USED.getStatus());
                    apiCouponService.updateCoupon(couponDto);
                }
                iMemberBalanceLogService.saveLog(order.getMemberId(), LogTypeEnum.REDUCE.type, "下单支付", LogSourceEnum.CONSUMPTION.status, order.getPayAmount(), order.getMerchantId(),order.getId(), order.getPaymentType());

                List<ValuationRes> resList = JSONArray.parseArray(payment.getValuation(), ValuationRes.class);
                if (CollectionUtils.isNotEmpty(resList)) {
                    if (order.getWaimaiOrderId() != null) {
                        apiOrderNewService.getWaiMaiInfo(order, new OrderReq());
                    } else {
                        this.setOrderSource(order);
                    }
//                    else {
//                        Product product = apiProductService.findById(order.getProductId().intValue());
//                        order.setProduct(product);
//                    }

                    CouponDto finalCouponDto = couponDto;
                    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                        @Override
                        public void afterCommit() {
                            applicationContext.publishEvent(new DeliveryOrderEvent(order, resList, finalCouponDto));
                        }
                    });
                }
            }
        } else if (payment != null && TradeTypeEnum.ADDTIP.type.equals(payment.getTradeType())) {
            OrderTip orderTip = iOrderTipService.getOne(new QueryWrapper<OrderTip>().eq("child_order_no", orderSn));
            orderTip.setStatus(PayStatusEnum.PAYED.status);
            iOrderTipService.updateById(orderTip);

            iOrderDeliveryService.updateDelivery(orderTip.getAmount(), orderTip.getOrderNo());

            Order order = iOrderService.getOne(new QueryWrapper<Order>().eq("order_sn", orderTip.getOrderNo()).eq("deleted", IsDeleteEnum.NORMAL.status));
            Order updateOrder = new Order();
            updateOrder.setId(order.getId());
            if (order.getTipAmount() != null) {
                updateOrder.setTipAmount(order.getTipAmount().add(orderTip.getAmount()));
            } else {
                updateOrder.setTipAmount(orderTip.getAmount());
            }
//            order.setUseTip(StatusEnum.SHOW.status);
            updateOrder.setTotalAmount(order.getTotalAmount().add(orderTip.getAmount()));
            updateOrder.setPayAmount(order.getPayAmount().add(orderTip.getAmount()));
            iOrderService.updateById(updateOrder);

            payment.setPayStatus(PayStatusEnum.PAYED.status);
            payment.setTransactionSn(tradeSn);
            payment.setPayTime(new Date());
            paymentService.updatePayment(payment);
            iMemberBalanceLogService.saveLog(order.getMemberId(), LogTypeEnum.REDUCE.type, "加小费", LogSourceEnum.CONSUMPTION.status, orderTip.getAmount(), order.getMerchantId(),order.getId(), orderTip.getPayType());

            tipScheduledExecutorService.schedule(new TipsTask(order, null, iOrderService, iDspDeliveryService, client, orderTip.getAmount(), iOrderDeliveryService, iShopDeliveryService,iShopDeliveryBindService), 1, TimeUnit.SECONDS);

        }
    }

    private void setOrderSource(Order order) {
        Integer platformType = order.getPlatformType();
        if (platformType != null && platformType > 0) {
            order.setPoiSeq(order.getLbDaySeq());
            // 美团、美团闪购
            if (platformType == 1 || platformType == 5) {
                order.setOrderSource("101");
            } else if (platformType == 2) {
                // 饿了么
                order.setOrderSource("102");
            } else if (platformType == 3) {
                // 饿百零售
                order.setOrderSource("103");
            }
        }
    }

    private void recharge(String orderSn, String tradeSn) {
        Recharge recharge = iRechargeService.getOne(new QueryWrapper<Recharge>().eq("recharge_sn", orderSn));
        if (recharge.getPayStatus().equals(PayStatusEnum.NO_PAYED.status)) {
            recharge.setPayStatus(PayStatusEnum.PAYED.status);
            recharge.setTransactionSn(tradeSn);
            recharge.setPayTime(new Date());
            iRechargeService.updateById(recharge);
            Member member = iMemberService.getById(recharge.getMemberId());
            //加钱
            iMemberBalanceLogService.updateMemberBalanceLog(recharge.getMemberId(), recharge.getAmount(), LogSourceEnum.RECHARGE.status, LogTypeEnum.INCREASE.type, "余额充值", member.getMerchantId(), recharge.getPaymentType());
            if (recharge.getGiveAmount() != null && recharge.getGiveAmount().compareTo(BigDecimal.ZERO) > 0) {
                iMemberBalanceLogService.updateMemberBalanceLog(recharge.getMemberId(), recharge.getGiveAmount(), LogSourceEnum.SEND.status, LogTypeEnum.INCREASE.type, "充值赠送金额", member.getMerchantId(), null);
            }
            //处理优惠券
            if (StringUtils.isNotBlank(recharge.getCouponIds())) {
                String[] ids = recharge.getCouponIds().split(",");
                for (String id : ids) {
                    Coupon coupon = iCouponService.getById(id);
                    log.info("优惠券类型---" + JSONObject.toJSONString(coupon));
                    for (int i = 0; i < coupon.getMemberReciveNum(); i++) {
                        MemberCoupon memberCoupon = new MemberCoupon();
                        memberCoupon.setCouponId(Long.valueOf(id));
                        memberCoupon.setMemberId(recharge.getMemberId());
                        memberCoupon.setName(coupon.getCouponName());
                        memberCoupon.setType(coupon.getCouponType());
                        // 0->时间段  1->固定时间(天)
                        if (coupon.getTimeType().equals(0)) {
                            memberCoupon.setValidStartTime(coupon.getValidStartTime());
                            memberCoupon.setValidEndTime(coupon.getValidEndTime());
                        } else {
                            Integer days = coupon.getDays();
                            memberCoupon.setValidStartTime(new Date());
                            Date endTime = DateUtils.addDays(new Date(), days);
                            memberCoupon.setValidEndTime(DateUtils.getAutoTime(endTime, 23, 59, 59));
                        }
                        // 充值获取
                        memberCoupon.setScope(5);
                        iMemberCouponService.save(memberCoupon);
                    }
                    coupon.setReciveNum(coupon.getReciveNum() + coupon.getMemberReciveNum());
                    iCouponService.updateById(coupon);
                }
            }
        }
    }

    @Override
    public PayTradeQueryDto tradeQuery(String orderSn, Integer payType) {
        // payType (1-支付宝 2-微信)
        if (PaymentTypeEnum.ZHI_FU_BAO.type.equals(payType)) {
            return aliPayService.aliTradeQuery(orderSn);
        } else if (PaymentTypeEnum.WEI_XIN.type.equals(payType)) {
            return wechatPayService.wechatTradeQuery(orderSn);
        } else {
            log.warn("无效的付款类型! orderSn: {}, payType: {}", orderSn, payType);
            throw new CustomException("payType参数错误!");
        }
    }

}