raex_back/src/main/java/com/izouma/nineth/service/TradeAuctionOrderService.java

package com.izouma.nineth.service;

import com.izouma.nineth.domain.*;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.*;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.CommissionRecordRepo;
import com.izouma.nineth.repo.TradeAuctionOrderRepo;
import com.izouma.nineth.repo.TradeAuctionRepo;
import com.izouma.nineth.repo.UserRepo;
import com.izouma.nineth.utils.JpaUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.List;

@Service
@AllArgsConstructor
@Slf4j
public class TradeAuctionOrderService {

    private TradeAuctionOrderRepo tradeAuctionOrderRepo;
    private TradeAuctionService   tradeAuctionService;
    private TradeAuctionRepo      tradeAuctionRepo;
    private UserRepo              userRepo;
    private UserBalanceService    userBalanceService;
    private SysConfigService      sysConfigService;
    private CommissionRecordRepo  commissionRecordRepo;

    private static int orderCancelInterval = 210;

    public Page<TradeAuctionOrder> all(PageQuery pageQuery) {
        return tradeAuctionOrderRepo.findAll(JpaUtils.toSpecification(pageQuery, TradeAuctionOrder.class), JpaUtils
                .toPageRequest(pageQuery));
    }

    public TradeAuctionOrder create(Long auctionId, Long userId, BigDecimal price, AuctionPaymentType auctionPaymentType) {
//        if (tradeAuctionService.getStock(auctionId) < 1) {
//            throw new BusinessException("库存不足");
//        }
        TradeAuction tradeAuction = tradeAuctionRepo.findById(auctionId).orElseThrow(new BusinessException("未找到易拍活动"));
        User user = userRepo.findById(userId).orElseThrow(new BusinessException("暂无用户"));
        if (tradeAuction.getStock() < 1) {
            throw new BusinessException("库存不足");
        }
        if (tradeAuction.getCurrentOwnerId() != null & tradeAuction.getStatus() != TradeAuctionStatus.PURCHASED) {
            if (tradeAuction.getCurrentOwnerId().equals(userId)) {
                throw new BusinessException("不可竞价持有的易拍产品");
            }
        }
        if (LocalDateTime.now().compareTo(tradeAuction.getCurrentStartTime()) < 0) {
            throw new BusinessException("未到竞价时间");
        }
        if (!tradeAuction.getStatus().equals(TradeAuctionStatus.ONGOING) & !tradeAuction.getStatus()
                .equals(TradeAuctionStatus.PURCHASED)) {
            throw new BusinessException("易拍产品未处在竞价状态");
        }
        if (auctionPaymentType.equals(AuctionPaymentType.DEPOSIT)) {
            if (price.compareTo(tradeAuction.getNextPrice()) != 0) {
                throw new BusinessException("购买资格已经没有");
            }
        }
        tradeAuctionService.decreaseStock(auctionId, 1);
        BigDecimal serviceCharge = (BigDecimal.valueOf(3).multiply(tradeAuction.getNextPrice())
                .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP))
                .add(tradeAuction.getCurrentPrice().subtract(tradeAuction.getPrice()));
        if (auctionPaymentType.equals(AuctionPaymentType.PURCHASE_PRICE)) {
            price = tradeAuction.getPrice().subtract(tradeAuction.getCommission());
        }
        TradeAuctionOrder tradeAuctionOrder = TradeAuctionOrder.builder()
                .tradeAuctionId(tradeAuction.getId())
                .earnedPrice(price.subtract(tradeAuction.getPrice()))
                .serviceCharge(serviceCharge)
                .name(tradeAuction.getName())
                .nickname(user.getNickname())
                .paymentType(auctionPaymentType)
                .userId(user.getId())
                .originPrice(tradeAuction.getPrice())
                .currentPrice(tradeAuction.getCurrentPrice())
                .price(price)
                .paybackStatus(PaybackStatus.NOPASSED)
                .pic(tradeAuction.getPic())
                .source(AuctionSource.OFFICIAL)
                .status(AuctionOrderStatus.NOT_PAID)
                .purchasedPrice(tradeAuction.getCurrentPrice())
                .build();

        if (user.getInviteType() != null) {
            if (user.getInviteType().equals(InviteType.AUCTION)) {
                tradeAuctionOrder.setInvitor(Long.valueOf(user.getInviteCode()));
            }
        }
        tradeAuctionOrder = tradeAuctionOrderRepo.save(tradeAuctionOrder);
        //下订单减库存
        return tradeAuctionOrder;
    }

    @Transactional
    public void notify(Long orderId, String transactionId, PayMethod payMethod) {
        TradeAuctionOrder tradeAuctionOrder = tradeAuctionOrderRepo.findById(orderId)
                .orElseThrow(new BusinessException("未找到订单"));
        if (!tradeAuctionOrder.getStatus().equals(AuctionOrderStatus.NOT_PAID)) {
            throw new BusinessException("订单已经处理");
        }
        tradeAuctionOrder.setPayTime(LocalDateTime.now());
        tradeAuctionOrder.setPayMethod(payMethod);
        tradeAuctionOrder.setTransactionId(transactionId);
        tradeAuctionOrder.setStatus(AuctionOrderStatus.FINISH);


        TradeAuction tradeAuction = tradeAuctionRepo.findById(tradeAuctionOrder.getTradeAuctionId())
                .orElseThrow(new BusinessException("未找到该易拍活动"));
        if (tradeAuction.getCurrentOrderId() != null & !tradeAuctionOrder.getPaymentType()
                .equals(AuctionPaymentType.PURCHASE_PRICE)) {
            //将上次订单设为待补偿状态
            TradeAuctionOrder lastOrder = tradeAuctionOrderRepo.findById(tradeAuction.getCurrentOrderId())
                    .orElseThrow(new BusinessException("暂无订单"));
            lastOrder.setPaybackStatus(PaybackStatus.PASSED);
            tradeAuctionOrderRepo.save(lastOrder);
        }
        tradeAuction.setCurrentOrderId(orderId);

        if (tradeAuctionOrder.getPaymentType().equals(AuctionPaymentType.FIXED_PRICE)) {
            tradeAuction.setCurrentPrice(tradeAuctionOrder.getCurrentPrice());
            tradeAuction.setCurrentOwner(tradeAuctionOrder.getNickname());
            tradeAuction.setCurrentOwnerId(tradeAuctionOrder.getUserId());
            tradeAuction.setStatus(TradeAuctionStatus.FIXED_PRICE_PURCHASED);

        } else if (tradeAuctionOrder.getPaymentType().equals(AuctionPaymentType.DEPOSIT)) {
            if (tradeAuction.getSale() == 29) {
                tradeAuction.setSale(30L);
                tradeAuction.setCurrentPrice(tradeAuctionOrder.getPrice());
                tradeAuction.setCurrentOwner(tradeAuctionOrder.getNickname());
                tradeAuction.setCurrentOwnerId(tradeAuctionOrder.getUserId());
                tradeAuctionService.purchase(tradeAuction);
                return;
            } else {
                BigDecimal result = tradeAuctionOrder.getPrice()
                        .multiply(BigDecimal.valueOf(tradeAuction.getIncreasePer()))
                        .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP);
                tradeAuction.setNextPrice(result.add(tradeAuctionOrder.getPrice()));
                tradeAuction.setEarning(tradeAuction.getNextPrice().subtract(tradeAuction.getPrice()));
                BigDecimal serviceCharge = (BigDecimal.valueOf(0.03).multiply(tradeAuction.getNextPrice()))
                        .add(tradeAuctionOrder.getPrice().subtract(tradeAuction.getPrice()));
                tradeAuction.setCommission(serviceCharge);
                tradeAuction.setCurrentPrice(tradeAuctionOrder.getPrice());
                tradeAuction.setCurrentOwner(tradeAuctionOrder.getNickname());
                tradeAuction.setCurrentOwnerId(tradeAuctionOrder.getUserId());
                tradeAuction.setCurrentStartTime(LocalDateTime.now().plusMinutes(1));
                tradeAuction
                        .setCurrentEndTime(tradeAuction.getCurrentStartTime().plusMinutes(tradeAuction.getMinutes())
                                .plusMinutes(10));
                tradeAuction.setFixedPrice(tradeAuctionOrder.getPrice().multiply(BigDecimal.valueOf(150))
                        .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP));
                tradeAuction.setStatus(TradeAuctionStatus.WAITING);
            }
        } else {
            tradeAuction.setCurrentPrice(tradeAuctionOrder.getCurrentPrice());
            tradeAuction.setCurrentOwner(tradeAuctionOrder.getNickname());
            tradeAuction.setCurrentOwnerId(tradeAuctionOrder.getUserId());
            tradeAuction.setStatus(TradeAuctionStatus.FINISH);
            finishLastOrder(tradeAuction.getCurrentOrderId());
            tradeAuctionOrder.setStatus(AuctionOrderStatus.AIR_DROP);
        }
        tradeAuctionOrder.setCurrentEndTime(LocalDateTime.now().plusMinutes(tradeAuction.getMinutes()).plusDays(1));
        tradeAuctionOrder.setCurrentPrice(tradeAuctionOrder.getPrice());
        tradeAuction.setStock(0L);
        tradeAuction.setSale(tradeAuction.getSale() + 1);
        tradeAuctionOrder.setTradeAuctionStatus(tradeAuction.getStatus());
        tradeAuctionOrderRepo.save(tradeAuctionOrder);
        tradeAuctionRepo.save(tradeAuction);
        tradeAuctionService.increaseSale(tradeAuction.getId(), 1);
    }


    public void finishLastOrder(Long lastOrderId) {
        TradeAuctionOrder tradeAuctionOrder = tradeAuctionOrderRepo.findById(lastOrderId)
                .orElseThrow(new BusinessException("暂无订单"));
        tradeAuctionOrder.setStatus(AuctionOrderStatus.PAID);
        tradeAuctionOrder.setPaybackStatus(PaybackStatus.PAYED);
        tradeAuctionOrderRepo.save(tradeAuctionOrder);
    }

    @Scheduled(fixedRate = 6000)
    public void batchCancelledAuctionOrder() {
        List<TradeAuctionOrder> orders = tradeAuctionOrderRepo
                .findByStatusAndCreatedAtBeforeAndDelFalse(AuctionOrderStatus.NOT_PAID,
                        LocalDateTime.now().minusSeconds(orderCancelInterval));
        orders.parallelStream().forEach(o -> {
            try {
                TradeAuctionOrder order = tradeAuctionOrderRepo.findById(o.getId())
                        .orElseThrow(new BusinessException("订单不存在"));
                if (order.getStatus() == AuctionOrderStatus.NOT_PAID) {
                    cancel(order);
                }
            } catch (Exception e) {
                log.error("取消易拍订单错误 " + o.getId(), e);
            }
        });
    }

    public void cancel(TradeAuctionOrder order) {
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("当前订单状态无法取消[" + order.getStatus().name() + "]");
        }
        order.setStatus(AuctionOrderStatus.CANCELLED);
        order.setCancelTime(LocalDateTime.now());
        tradeAuctionService.increaseStock(order.getTradeAuctionId(), 1);
        tradeAuctionOrderRepo.save(order);
    }

    @Scheduled(fixedRate = 30000)
    public void batchPayEarning() {
        List<TradeAuctionOrder> tradeAuctionOrders = tradeAuctionOrderRepo.findByPaybackStatus(PaybackStatus.PASSED);
        tradeAuctionOrders.parallelStream().forEach(o -> {
            try {
                TradeAuctionOrder order = tradeAuctionOrderRepo.findById(o.getId())
                        .orElseThrow(new BusinessException("订单不存在"));
                if (order.getPaybackStatus() == PaybackStatus.PASSED) {
                    payEarning(order);
                }
            } catch (Exception e) {
                log.error("取消易拍订单错误 " + o.getId(), e);
            }
        });
    }

    private void payEarning(TradeAuctionOrder order) {
        if (!order.getPaymentType().equals(AuctionPaymentType.PURCHASE_PRICE)) {
            userBalanceService.addBalance(order.getUserId(), order.getEarnedPrice(), order.getId(), BalanceType.BONUS);
            order.setPaybackStatus(PaybackStatus.PAYED);
            tradeAuctionOrderRepo.save(order);
        }
    }

    public void commission(TradeAuctionOrder order, BigDecimal price) {
        if (order.getInvitor() != null) {
            userRepo.findById(order.getInvitor()).ifPresent(user -> {
                BigDecimal shareRatio = sysConfigService.getBigDecimal("auction_commission_rate");
                if (StringUtils.isNotBlank(user.getSettleAccountId()) &&
                        shareRatio != null && shareRatio.compareTo(BigDecimal.ZERO) > 0) {
                    commissionRecordRepo.save(CommissionRecord.builder()
                            .orderId(order.getId())
                            .collectionId(order.getTradeAuctionId())
                            .name(order.getName())
                            .totalPrice(price)
                            .nickname(user.getNickname())
                            .userId(user.getId())
                            .shareRatio(user.getShareRatio())
                            .phone(user.getPhone())
                            .shareAmount(price.multiply(shareRatio)
                                    .divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP))
                            .type(InviteType.AUCTION)
                            .build());

                    userBalanceService.addBalance(user.getId(), price.multiply(shareRatio)
                            .divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP), order
                            .getId(), BalanceType.COMMISSION);
                }
            });
        }
    }
}