admin
2020-03-23 e4ee46557cffc21be597d017a0d16f8e310f6077
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
package com.yeshi.fanli.service.impl.order;
 
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.yeshi.fanli.dao.mybatis.order.OrderTeamRewardMapper;
import com.yeshi.fanli.entity.order.InviteOrderSubsidy;
import com.yeshi.fanli.entity.order.OrderTeamReward;
import com.yeshi.fanli.exception.order.OrderTeamRewardException;
import com.yeshi.fanli.service.inter.order.OrderTeamRewardService;
import com.yeshi.fanli.util.StringUtil;
 
@Service
public class OrderTeamRewardServiceImpl implements OrderTeamRewardService {
 
    @Resource
    private OrderTeamRewardMapper orderTeamRewardMapper;
 
    @Override
    public OrderTeamReward getByOrderNoAndType(Long uid, String orderNo, Integer type) {
        return orderTeamRewardMapper.getByOrderNoAndType(uid, orderNo, type);
    }
 
    @Override
    public OrderTeamReward getByOrderNoAndTypeForUpdate(Long uid, String orderNo, Integer type) {
        return orderTeamRewardMapper.getByOrderNoAndTypeForUpdate(uid, orderNo, type);
    }
 
    @Transactional(rollbackFor = Exception.class)
    private void addOrderSubsidy(OrderTeamReward orderSubsidy) throws OrderTeamRewardException {
        if (orderSubsidy.getMoney() == null || StringUtil.isNullOrEmpty(orderSubsidy.getOrderNo())
                || orderSubsidy.getSourceType() == null || orderSubsidy.getUid() == null)
            throw new OrderTeamRewardException(1, "数据不完整");
        OrderTeamReward old = getByOrderNoAndType(orderSubsidy.getUid(), orderSubsidy.getOrderNo(),
                orderSubsidy.getSourceType());
        if (old != null) {// 修改
            if (old.getState() == OrderTeamReward.STATE_INVALID || old.getState() == OrderTeamReward.STATE_RECIEVED)
                return;
 
            // 修改状态
            OrderTeamReward update = new OrderTeamReward(old.getId());
            update.setMoney(orderSubsidy.getMoney());
            if (old.getState() == OrderTeamReward.STATE_UNKNOWN) {// 状态未确定之前才可以更改原始补贴资金
                update.setOriginalMoney(orderSubsidy.getOriginalMoney());
            }
            update.setState(orderSubsidy.getState());
            update.setUpdateTime(new Date());
            orderTeamRewardMapper.updateByPrimaryKeySelective(update);
        } else {// 添加
            if (orderSubsidy.getCreateTime() == null)
                orderSubsidy.setCreateTime(new Date());
            orderTeamRewardMapper.insertSelective(orderSubsidy);
        }
    }
 
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void addOrUpdate(InviteOrderSubsidy subsidy, BigDecimal money, Long uid, int level)
            throws OrderTeamRewardException {
        if (subsidy == null || subsidy.getId() == null)
            throw new OrderTeamRewardException(1, "补贴为空");
        if (money == null)
            throw new OrderTeamRewardException(2, "团队奖励资金为空");
        OrderTeamReward reward = orderTeamRewardMapper.selectBySubsidyIdAndUidForUpdate(subsidy.getId(), uid);
        if (reward != null) {// 原来已存在
            if (reward.getState() == OrderTeamReward.STATE_RECIEVED)
                return;
 
            if (reward.getState() == OrderTeamReward.STATE_INVALID)
                return;
 
            if (subsidy.getState().intValue() != reward.getState() || money.compareTo(reward.getMoney()) != 0) {
                // 状态或者资金改变,需要改变数据
                OrderTeamReward updateReward = new OrderTeamReward(reward.getId());
                updateReward.setState(subsidy.getState());
                updateReward.setMoney(money);
                updateReward.setUpdateTime(new Date());
                orderTeamRewardMapper.updateByPrimaryKeySelective(updateReward);
            }
        } else {// 原来不存在
            reward = new OrderTeamReward();
            reward.setCreateTime(new Date());
            reward.setMoney(money);
            reward.setOrderNo(subsidy.getOrderNo());
            reward.setOriginalMoney(money);
            reward.setSourceType(subsidy.getSourceType());
            reward.setState(subsidy.getState());
            reward.setSubsidy(subsidy);
            reward.setUid(uid);
            reward.setLevel(level);
            orderTeamRewardMapper.insertSelective(reward);
        }
 
    }
 
    @Override
    public long countByOrderIdAndSourceType(String orderId, int sourceType) {
        return orderTeamRewardMapper.countByOrderNoAndType(orderId, sourceType);
    }
 
    @Transactional
    @Override
    public void invalidByOrderIdAndSourceType(Long subsidyId) {
        List<OrderTeamReward> list = orderTeamRewardMapper.listBySubsidyId(subsidyId);
        if (list != null && list.size() > 0)
            for (OrderTeamReward subsidy : list) {
                if (subsidy.getState() == OrderTeamReward.STATE_UNKNOWN
                        || subsidy.getState() == OrderTeamReward.STATE_VALID) {
                    OrderTeamReward update = new OrderTeamReward(subsidy.getId());
                    update.setState(OrderTeamReward.STATE_INVALID);
                    update.setUpdateTime(new Date());
 
                    orderTeamRewardMapper.updateByPrimaryKeySelective(update);
                }
            }
    }
 
    @Transactional
    @Override
    public void validByOrderIdAndSourceType(Long subsidyId, Date preGetTime) {
        List<OrderTeamReward> list = orderTeamRewardMapper.listBySubsidyId(subsidyId);
        if (list != null && list.size() > 0)
            for (OrderTeamReward subsidy : list) {
                if (subsidy.getState() == OrderTeamReward.STATE_UNKNOWN) {
                    OrderTeamReward update = new OrderTeamReward(subsidy.getId());
                    update.setState(OrderTeamReward.STATE_VALID);
                    update.setUpdateTime(new Date());
                    update.setPreGetTime(preGetTime);
                    orderTeamRewardMapper.updateByPrimaryKeySelective(update);
                }
            }
    }
 
    @Override
    public void settleById(Long id, BigDecimal money) {
        OrderTeamReward orderSubsidy = new OrderTeamReward(id);
        orderSubsidy.setMoney(money);
        orderSubsidy.setState(OrderTeamReward.STATE_RECIEVED);
        orderSubsidy.setGetTime(new Date());
        orderSubsidy.setUpdateTime(new Date());
        orderTeamRewardMapper.updateByPrimaryKeySelective(orderSubsidy);
    }
 
    @Override
    public List<OrderTeamReward> listBySubsidyId(Long subsidyId) {
 
        return orderTeamRewardMapper.listBySubsidyId(subsidyId);
    }
 
    @Override
    public List<OrderTeamReward> listCanSettle(Long uid, int page, int pageSize) {
 
        return orderTeamRewardMapper.listCanSettleByUid(uid, (page - 1) * pageSize, pageSize);
    }
 
    @Override
    public long countCanSettle(Long uid) {
        return orderTeamRewardMapper.countCanSettle(uid);
    }
 
    @Override
    public List<Long> listCanSettleUid(Date time, int page, int count) {
        return orderTeamRewardMapper.listCanSettleUid(time, (page - 1) * count, count);
    }
 
    @Override
    public long countCanSettleUid(Date time) {
        return orderTeamRewardMapper.countCanSettleUid(time);
    }
}