luodangjia
2024-12-12 ff811ae8df41273d7ab0011b6b7f1f278f03bbd2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package com.ruoyi.order.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.account.api.feignClient.AppUserClient;
import com.ruoyi.account.api.model.AppUser;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.order.service.CommissionService;
import com.ruoyi.order.service.OrderGoodService;
import com.ruoyi.order.service.OrderService;
import com.ruoyi.other.api.domain.Shop;
import com.ruoyi.other.api.feignClient.ShopClient;
import com.ruoyi.order.model.Order;
import com.ruoyi.order.model.OrderGood;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
 
@Service
public class CommissionServiceImpl implements CommissionService {
    @Resource
    private OrderService orderService;
    @Resource
    private OrderGoodService orderGoodService;
    @Resource
    private AppUserClient appUserClient;
    @Resource
    private ShopClient shopClient;
    @Resource
    private RedisTemplate<String, String> redisTemplate;
 
    /**
     * 返佣延迟队列(redis有序集合)
     *
     * @param orderId           订单ID
     * @param afterSalesDeadline 售后截止日期(计算日期)
     */
    @Override
    public void addToCommissionDelayQueue(Long orderId, LocalDateTime afterSalesDeadline) {
        // 获取订单售后截止日期时间戳(秒)
        long deadlineTimestamp = afterSalesDeadline.atZone(ZoneId.systemDefault()).toEpochSecond();
        redisTemplate.opsForZSet().add("delay_queue:commission", orderId.toString(), deadlineTimestamp);
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void calculationCommission(Set<String> orderIds) {
        List<OrderGood> orderGoods = orderGoodService.list(new LambdaQueryWrapper<OrderGood>()
                .in(OrderGood::getOrderId, orderIds));
 
        Map<Long, List<OrderGood>> ogMap = orderGoods.stream().collect(Collectors.groupingBy(OrderGood::getOrderId));
 
        for (Map.Entry<Long, List<OrderGood>> entry : ogMap.entrySet()) {
            Long k = entry.getKey();
            List<OrderGood> v = entry.getValue();
            Order order = orderService.getById(k);
            if (order.getIsCommission() == 1) {
                continue;
            }
            order.setIsCommission(1);
            orderService.updateById(order);
            R<Shop> r = shopClient.getShopById(order.getShopId());
            if (!R.isSuccess(r)) {
                throw new RuntimeException("获取门店信息失败");
            }
            Shop shop = r.getData();
            if (shop == null) {
                throw new RuntimeException("获取门店信息失败");
            }
 
            Long appUserId = order.getAppUserId();
            AppUser appUser = appUserClient.getAppUserById(appUserId);
            if (appUser == null) {
                throw new RuntimeException("获取用户信息失败");
            }
            Long inviteUserId = appUser.getInviteUserId();
            // 直推上级用户
            AppUser inviteUser = appUserClient.getAppUserById(inviteUserId);
 
            // 获取直帮上级用户
            R<AppUser> superiorLeaderR = appUserClient.getSuperiorLeader(appUserId);
            if (!R.isSuccess(superiorLeaderR)) {
                throw new RuntimeException("获取直帮上级信息失败");
            }
            AppUser superiorLeader = superiorLeaderR.getData();
 
            for (OrderGood og : v) {// 累计分销金额
 
                // 直推上级分佣金额
                Integer superiorType = og.getSuperiorType();
                if (superiorType == 1 && inviteUser != null){
                    // 分佣金额
                    BigDecimal superiorSubcommission = og.getSuperiorSubcommission();
                    BigDecimal totalDistributionAmount = inviteUser.getTotalDistributionAmount();
                    totalDistributionAmount = totalDistributionAmount.add(superiorSubcommission);
                    inviteUser.setTotalDistributionAmount(totalDistributionAmount);
 
                    // 分佣积分
                    Integer sharePoint = inviteUser.getSharePoint();
                    Integer superiorRebatePoints = og.getSuperiorRebatePoints();
                    sharePoint = sharePoint + superiorRebatePoints;
                    inviteUser.setSharePoint(sharePoint);
 
                    appUserClient.editAppUserById(inviteUser);
                }else
                    // 直帮上级分佣金额
                    if (superiorType == 2 && superiorLeader != null){
                        // 分佣金额
                        BigDecimal superiorSubcommission = og.getSuperiorSubcommission();
                        BigDecimal totalDistributionAmount = superiorLeader.getTotalDistributionAmount();
                        totalDistributionAmount = totalDistributionAmount.add(superiorSubcommission);
                        superiorLeader.setTotalDistributionAmount(totalDistributionAmount);
 
                        // 分佣积分
                        Integer sharePoint = superiorLeader.getSharePoint();
                        Integer superiorRebatePoints = og.getSuperiorRebatePoints();
                        sharePoint = sharePoint + superiorRebatePoints;
                        superiorLeader.setSharePoint(sharePoint);
 
                        appUserClient.editAppUserById(superiorLeader);
                    }
            }
        }
 
 
    }
}