art-trade-2/src/main/java/com/izouma/awesomeAdmin/service/CommissionService.java

package com.izouma.awesomeAdmin.service;

import com.izouma.awesomeAdmin.config.Constants;
import com.izouma.awesomeAdmin.domain.*;
import com.izouma.awesomeAdmin.dto.CommissionOrder;
import com.izouma.awesomeAdmin.dto.CommissionOverview;
import com.izouma.awesomeAdmin.dto.CommissionDetail;
import com.izouma.awesomeAdmin.dto.JuniorDTO;
import com.izouma.awesomeAdmin.enums.OrderStatus;
import com.izouma.awesomeAdmin.exception.BusinessException;
import com.izouma.awesomeAdmin.repo.*;
import com.izouma.awesomeAdmin.utils.Translator;
import lombok.AllArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import javax.persistence.criteria.Predicate;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
public class CommissionService {
    private CommissionRecordRepo   commissionRecordRepo;
    private UserRepo               userRepo;
    private OrderRepo              orderRepo;
    private ProductRepo            productRepo;
    private JuniorContributionRepo juniorContributionRepo;
    private SysConfigService       sysConfigService;
    private UserBalanceService     userBalanceService;
    private CommissionStatRepo     commissionStatRepo;

    public CommissionOverview overview(Long userId) {
        User user = userRepo.findById(userId).orElseThrow(new BusinessException(Translator.toLocale("user.not_found")));
        User superior = null;
        if (user.getSuperiorId() != null) {
            superior = userRepo.findById(user.getSuperiorId()).orElse(null);
        }
        List<CommissionRecord> commissionRecords = commissionRecordRepo.findByUserId(userId);
        List<User> juniors = userRepo.findBySuperiorId(userId);
        BigDecimal total = BigDecimal.ZERO;
        BigDecimal withdraw = BigDecimal.ZERO;
        BigDecimal available = BigDecimal.ZERO;
        for (CommissionRecord commissionRecord : commissionRecords) {
            total = total.add(commissionRecord.getAmount());
        }
        return CommissionOverview.builder()
                                 .total(total)
                                 .withdraw(withdraw)
                                 .available(available)
                                 .juniorCount(juniors.size())
                                 .orderCount(commissionRecordRepo.countByUserId(userId))
                                 .superior(Optional.ofNullable(superior).map(User::getNickname).orElse(null))
                                 .build();
    }

    public CommissionDetail detail(Long userId) {
        List<CommissionRecord> commissionRecords = commissionRecordRepo.findByUserId(userId);
        BigDecimal total = BigDecimal.ZERO;
        BigDecimal withdraw = BigDecimal.ZERO;
        BigDecimal available = BigDecimal.ZERO;
        BigDecimal notChecked = BigDecimal.ZERO;
        for (CommissionRecord commissionRecord : commissionRecords) {
            total = total.add(commissionRecord.getAmount());
        }
        return new CommissionDetail(total, withdraw, available, notChecked);
    }

    public Page<CommissionOrder> commissionOrders(Long userId, String status, Pageable pageable) {
        Page<CommissionRecord> page = commissionRecordRepo
                .findAll((Specification<CommissionRecord>) (root, criteriaQuery, criteriaBuilder) -> {
                    List<Predicate> predicates = new ArrayList<>();
                    predicates.add(criteriaBuilder.equal(root.get("userId"), userId));
                    if ("NOT_PAID".equals(status)) {
                        predicates.add(criteriaBuilder.equal(root.join("order").get("status"), OrderStatus.NOT_PAID));
                    } else if ("PAID".equals(status)) {
                        predicates.add(root.join("order").get("status")
                                           .in(OrderStatus.NOT_CONFIRMED,
                                                   OrderStatus.CONFIRMED,
                                                   OrderStatus.NOT_SHIPPED,
                                                   OrderStatus.SHIPPED,
                                                   OrderStatus.SELLING,
                                                   OrderStatus.SOLD_NOT_PAID,
                                                   OrderStatus.SOLD_NOT_CONFIRMED,
                                                   OrderStatus.SOLD,
                                                   OrderStatus.NOT_SHIPPED,
                                                   OrderStatus.SHIPPED,
                                                   OrderStatus.RECEIVED));
                    } else if ("FINISH".equals(status)) {
                        predicates.add(root.join("order").get("status")
                                           .in(OrderStatus.CONFIRMED, OrderStatus.SELLING, OrderStatus.SOLD,
                                                   OrderStatus.NOT_SHIPPED, OrderStatus.SHIPPED, OrderStatus.RECEIVED));
                    }
                    return criteriaQuery.where(predicates.toArray(new Predicate[0]))
                                        .orderBy(criteriaBuilder.desc(root.get("createdAt"))).getRestriction();
                }, pageable);
        List<CommissionOrder> commissionOrders = new ArrayList<>();
        for (CommissionRecord commissionRecord : page.getContent()) {
            Order order = orderRepo.findById(commissionRecord.getOrderId()).orElse(null);
            if (order != null) {
                Product product = productRepo.findById(order.getProductId()).orElse(null);
                if (product != null) {
                    CommissionOrder commissionOrder = CommissionOrder.builder()
                                                                     .orderId(commissionRecord.getOrderId())
                                                                     .createdAt(order.getCreatedAt())
                                                                     .juniorId(commissionRecord.getJuniorId())
                                                                     .commission(commissionRecord.getAmount())
                                                                     .pic(product.getPic().isEmpty()
                                                                             ? null : product.getPic().get(0))
                                                                     .name(product.getName())
                                                                     .price(order.getTotalPrice())
                                                                     .build();
                    commissionOrders.add(commissionOrder);
                }
            }
        }
        return new PageImpl<>(commissionOrders, pageable, page.getTotalElements());
    }

    public void doCommission(Long userId, Order sellerOrder, BigDecimal commissionRate) {
        User user = userRepo.findById(userId)
                            .orElseThrow(new BusinessException(Translator.toLocale("record.not_found")));
        if (user.getSuperiorId() != null) {
            User superior = userRepo.findById(user.getSuperiorId()).orElse(null);
            if (superior != null) {
                BigDecimal money = sellerOrder.getTotalPrice().multiply(commissionRate)
                                              .setScale(2, RoundingMode.HALF_UP);
                userBalanceService.modify(superior.getId(), null, money, Constants.BalanceRemark.COMMISSION,
                        null, null, null);
                commissionRecordRepo.save(CommissionRecord.builder()
                                                          .userId(superior.getId())
                                                          .juniorId(userId)
                                                          .orderId(sellerOrder.getId())
                                                          .amount(money)
                                                          .build());

                JuniorContribution juniorContribution = juniorContributionRepo.findByUserIdAndJuniorId(superior.getId(), userId)
                                                                              .orElse(new JuniorContribution(superior.getId(), userId));
                juniorContribution.setOrderNum(juniorContribution.getOrderNum() + 1);
                juniorContribution.setOrderSum(juniorContribution.getOrderSum().add(sellerOrder.getTotalPrice()));
                juniorContribution.setCommissionNum(juniorContribution.getCommissionNum() + 1);
                juniorContribution.setCommissionSum(juniorContribution.getCommissionSum().add(money));
                juniorContributionRepo.save(juniorContribution);

                CommissionStat commissionStat = commissionStatRepo.findByUserId(superior.getId())
                                                                  .orElse(new CommissionStat(superior.getId()));
                commissionStat.setCommissionNum(commissionStat.getCommissionNum() + 1);
                commissionStat.setCommissionSum(commissionStat.getCommissionSum().add(money));
                commissionStatRepo.save(commissionStat);

            }
        }
    }

    public void invite(Long superiorId, Long juniorId) {
        CommissionStat commissionStat = commissionStatRepo.findByUserId(superiorId)
                                                          .orElse(new CommissionStat(superiorId));
        commissionStat.setInviteNum((int) userRepo.countBySuperiorId(superiorId));
        commissionStatRepo.save(commissionStat);

        JuniorContribution juniorContribution = juniorContributionRepo.findByUserIdAndJuniorId(superiorId, juniorId)
                                                                      .orElse(new JuniorContribution(superiorId, juniorId));
        juniorContributionRepo.save(juniorContribution);
    }

    public CommissionStat userCommissionStat(Long userId) {
        return commissionStatRepo.findByUserId(userId).orElse(new CommissionStat(userId));
    }

    public Page<CommissionRecord> records(Long id, LocalDateTime start, LocalDateTime end, Pageable pageable) {
        Page<CommissionRecord> page;
        if (start != null && end != null) {
            page = commissionRecordRepo.findByUserIdAndCreatedAtBetweenOrderByCreatedAtDesc(id, start, end, pageable);
        } else {
            page = commissionRecordRepo.findByUserIdOrderByCreatedAtDesc(id, pageable);
        }
        List<Long> userIds = page.getContent().stream().map(CommissionRecord::getJuniorId).collect(Collectors.toList());
        if (!userIds.isEmpty()) {
            List<User> users = userRepo.findAllById(userIds);
            page.getContent().forEach(commissionRecord -> {
                users.stream().filter(user -> user.getId().equals(commissionRecord.getJuniorId()))
                     .findFirst().ifPresent(user -> {
                         JuniorDTO dto = new JuniorDTO(user);
                         commissionRecord.setJunior(dto);
                     });
            });
        }

        List<Long> orderIds = page.getContent().stream().map(CommissionRecord::getOrderId).collect(Collectors.toList());
        if (!orderIds.isEmpty()) {
            List<Order> orders = orderRepo.findAllById(orderIds);
            page.getContent().forEach(commissionRecord -> {
                orders.stream().filter(order -> order.getId().equals(commissionRecord.getOrderId()))
                      .findFirst().ifPresent(commissionRecord::setOrder);
            });
        }
        return page;
    }

    public Page<JuniorContribution> juniorContributions(Long userId, Pageable pageable) {
        Page<JuniorContribution> page = juniorContributionRepo.findByUserId(userId, pageable);
        List<Long> userIds = page.getContent().stream().map(JuniorContribution::getJuniorId)
                                 .collect(Collectors.toList());
        if (!userIds.isEmpty()) {
            List<User> users = userRepo.findAllById(userIds);
            page.getContent().forEach(juniorContribution -> {
                users.stream().filter(user -> user.getId().equals(juniorContribution.getJuniorId()))
                     .findFirst().ifPresent(user -> {
                         JuniorDTO dto = new JuniorDTO(user);
                         juniorContribution.setJunior(dto);
                     });
            });
        }
        return page;
    }
}