zyy
2025-07-21 f25b39e0d5fcae415a8824fc03d42fe681e96bf8
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
package com.nq.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.nq.common.ResponseCode;
import com.nq.common.ServerResponse;
import com.nq.dao.DkJGMapper;
import com.nq.dao.DkMapper;
import com.nq.dao.StockConfigMapper;
import com.nq.dao.UserMapper;
import com.nq.enums.EStockType;
import com.nq.enums.EUserAssets;
import com.nq.pojo.*;
import com.nq.service.IDkServices;
import com.nq.service.IUserAssetsServices;
import com.nq.service.IUserService;
import com.nq.utils.timeutil.DateTimeUtil;
import com.nq.vo.dk.DkModelVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
 
@Service
public class DkServices implements IDkServices {
 
    private static final Logger log = LoggerFactory.getLogger(DkServices.class);
    private final ConcurrentHashMap<Long, Object> locks = new ConcurrentHashMap<>();
 
    @Autowired
    DkMapper dkMapper;
    @Autowired
    DkJGMapper mapper;
    @Autowired
    UserMapper userMapper;
    @Autowired
    StockConfigMapper stockConfigMapper;
 
    @Autowired
    IUserService iUserService;
    @Autowired
    IUserAssetsServices iUserAssetsServices;
 
 
    /**
     * 申请贷款
     * @param dkMoney
     * @param phone
     * @param dkjgId
     * @param request
     * @return
     */
    @Override
    public ServerResponse addDk(BigDecimal dkMoney, String phone, String dkjgId, HttpServletRequest request) {
        try {
            User user = this.iUserService.getCurrentRefreshUser(request);
            if (user == null) {
                return ServerResponse.createByErrorCodeMsg(ResponseCode.NEED_LOGIN.getCode(),"请先登录", request);
            }
            if (user.getLoanLimit() == null || user.getLoanLimit().compareTo(BigDecimal.ZERO) <= 0) {
                System.out.println(user.getLoanLimit());
                return ServerResponse.createByErrorMsg("无贷款额度",request);
            }
            if (user.getLoanLimit().compareTo(dkMoney) < 0) {
                return ServerResponse.createByErrorMsg("最大贷款额度为:" + user.getLoanLimit() ,request);
            }
            String userId = String.valueOf(user.getId());
            //查询是否有未还款记录
            if (dkMapper.countByUserIdAndRStatus(userId, 0) > 0 ) {
                return ServerResponse.createByErrorMsg("已申请贷款,请勿重复申请!", request);
            }
            DkModel dkModel = new DkModel();
            dkModel.setDkUserId(userId);
            dkModel.setCreateTime(new Date());
            dkModel.setDkMoney(String.valueOf(dkMoney));
            dkModel.setDkState("0");
            dkModel.setDkRefundState(0);
            dkModel.setDkJgId(dkjgId);
            dkModel.setDkPhone(phone);
            dkMapper.insert(dkModel);
            return ServerResponse.createBySuccess("贷款申请成功", request);
        } catch (Exception e) {
            log.error("IDkServices addDk error", e);
        }
        return ServerResponse.createByError();
    }
 
    @Override
    public ServerResponse queryDk(int pageNum, int pageSize) {
        try {
            PageHelper.startPage(pageNum,pageSize);
            List<DkModelVo> dkModelVoList = dkMapper.queryDk();
            PageInfo<DkModelVo> pageInfo = new PageInfo<>(dkModelVoList);
            return ServerResponse.createBySuccess(pageInfo);
        } catch (Exception e) {
            log.error("IDkServices queryDk error", e);
        }
        return ServerResponse.createByError();
    }
 
    /**
     * 贷款审核
     * @param spMoney
     * @param message
     * @param state
     * @param dkId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ServerResponse dkSp(BigDecimal spMoney, String message, Integer state, Integer dkId) {
        try {
            DkModel dkModel = dkMapper.selectById(dkId);
            if (dkModel == null) {
                return ServerResponse.createByErrorMsg("无贷款记录");
            }
            String userId = String.valueOf(dkModel.getDkUserId());
            Object lock = locks.computeIfAbsent(Long.valueOf(userId), k -> new Object());
            synchronized (lock){
                User user = userMapper.selectById(Integer.valueOf(userId));
                if (user == null) {
                    return ServerResponse.createByErrorMsg("无用户信息");
                }
                if (state == 1) { //通过
                    if (user.getLoanLimit() == null || user.getLoanLimit().compareTo(BigDecimal.ZERO) <= 0) {
                        return ServerResponse.createByErrorMsg("无贷款额度");
                    }
                    if (user.getLoanLimit().compareTo(spMoney) < 0) {
                        return ServerResponse.createByErrorMsg("审核金额超出贷款额度:" + user.getLoanLimit());
                    }
                    dkModel.setSpMoney(String.valueOf(spMoney));
                    dkModel.setLoanTime(new Date());
                    //扣除用户贷款
                    user.setLoanLimit(user.getLoanLimit().subtract(spMoney));
                    //发放贷款金额 墨西哥账户
                    iUserAssetsServices.aiAvailableBalanceChange(EStockType.MX.getCode(), user.getId(), EUserAssets.DK, spMoney);
                    userMapper.updateById(user);
                } else if (state == 2) { //拒绝
                    dkModel.setDkMessage(message);
                }
                dkModel.setDkState(String.valueOf(state));
                dkMapper.updateById(dkModel);
                return ServerResponse.createBySuccess("贷款审核成功");
            }
        } catch (Exception e) {
            log.error("IDkServices dksp error", e);
        }
        return ServerResponse.createByError();
    }
 
    /**
     * 还款
     * @param id
     * @param request
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ServerResponse rtDk(Integer id, HttpServletRequest request) {
        try {
            DkModel dkModel = dkMapper.selectById(id);
            if (dkModel == null) {
                return ServerResponse.createByErrorMsg("无贷款记录", request);
            }
            if (!dkModel.getDkState().equals("1")) {
                return ServerResponse.createByErrorMsg("未审核通过记录不能还款", request);
            }
            String userId = String.valueOf(dkModel.getDkUserId());
            Object lock = locks.computeIfAbsent(Long.valueOf(userId), k -> new Object());
            synchronized (lock){
                User user = userMapper.selectById(Integer.valueOf(userId));
                if (user == null) {
                    return ServerResponse.createByErrorMsg("无用户信息", request);
                }
                UserAssets userAssets = iUserAssetsServices.assetsByTypeAndUserId(EStockType.MX.getCode(), user.getId());
                //应该还款金额
                BigDecimal amount = new BigDecimal(dkModel.getSpMoney());
                if(userAssets.getAvailableBalance().compareTo(amount) < 0){
                    return ServerResponse.createByErrorMsg("可用余额不足:" +  userAssets.getAvailableBalance(), request);
                }
                dkModel.setDkRefundState(1);
                //查看贷款利息
                StockConfig stockConfig = stockConfigMapper.selectOne(new QueryWrapper<StockConfig>().eq("c_key", "loan_interest"));
                if (stockConfig != null) {
                    long day = DateTimeUtil.getDaysRoundedUp(dkModel.getLoanTime());
                    //利息 利率*贷款金额*借款天数
                    BigDecimal intAmount = new BigDecimal(stockConfig.getCValue()).multiply(amount).multiply(BigDecimal.valueOf(day));
                    iUserAssetsServices.aiAvailableBalanceChange(EStockType.MX.getCode(), user.getId(), EUserAssets.RT_DK_INT, intAmount);
                }
                //还款
                iUserAssetsServices.aiAvailableBalanceChange(EStockType.MX.getCode(), user.getId(), EUserAssets.RT_DK, amount);
                dkMapper.updateById(dkModel);
                return ServerResponse.createBySuccess("贷款审核成功", request);
            }
        } catch (Exception e) {
            log.error("IDkServices rtDk error", e);
        }
        return ServerResponse.createByError();
    }
 
    @Override
    public List<DkJgBean> queryAll() {
        return mapper.queryAll();
    }
 
    /**
     * 贷款记录
     * @param pageNum
     * @param pageSize
     * @param httpServletRequest
     * @return
     */
    @Override
    public ServerResponse queryByShUserId(int pageNum, int pageSize, Integer state, HttpServletRequest httpServletRequest) {
        try {
            User user = this.iUserService.getCurrentRefreshUser(httpServletRequest);
            if (user == null) {
                return ServerResponse.createByErrorCodeMsg(ResponseCode.NEED_LOGIN.getCode(),"请先登录", httpServletRequest);
            }
            PageHelper.startPage(pageNum,pageSize);
            List<DkModel> dkModelList = dkMapper.selectList(new QueryWrapper<DkModel>()
                    .eq("dk_user_id", String.valueOf(user.getId()))
                    .eq(state != null,"dk_state", state)
                    .orderByDesc("create_time")
            );
            PageInfo<DkModel> pageInfo = new PageInfo<>(dkModelList);
            return ServerResponse.createBySuccess(pageInfo);
        } catch (Exception e) {
            log.error("IDkServices queryByShUserId error", e);
        }
        return ServerResponse.createByError();
    }
 
    @Override
    public int  inserDkJG(String dkjgName) {
        DkJgBean dkJgBean = new DkJgBean();
        dkJgBean.setDkJg(dkjgName);
        return mapper.insert(dkJgBean);
    }
 
 
 
    @Override
    public int update(DkJgBean dkJgBean) {
        return mapper.updateById(dkJgBean);
    }
 
    @Override
    public List<DkJgBean> queryDkJg() {
        return mapper.queryAll();
    }
 
    @Override
    public int deleteByDkjg(int id) {
       return mapper.deleteById(id);
    }
}