package project.loan.internal;
|
|
import java.sql.PreparedStatement;
|
import java.sql.SQLException;
|
import java.util.ArrayList;
|
import java.util.Calendar;
|
import java.util.Date;
|
import java.util.GregorianCalendar;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
|
import kernel.bo.RecordObjectMapper;
|
import kernel.exception.BusinessException;
|
import kernel.util.Arith;
|
import kernel.util.DateUtils;
|
import kernel.util.StringUtils;
|
import kernel.web.ApplicationUtil;
|
import kernel.web.Page;
|
import kernel.web.PagedQueryDao;
|
import project.Constants;
|
import project.data.DataService;
|
import project.data.model.Realtime;
|
import project.loan.LoanConstants;
|
import project.loan.LoanOrder;
|
import project.loan.LoanOrderService;
|
import project.loan.LoanRelationOrder;
|
import project.loan.LoanRelationOrderService;
|
import project.log.MoneyLog;
|
import project.log.MoneyLogService;
|
import project.syspara.SysparaService;
|
import project.wallet.Wallet;
|
import project.wallet.WalletExtend;
|
import project.wallet.WalletService;
|
import util.DateUtil;
|
import util.RandomUtil;
|
|
/**
|
* 质押借币service实现类
|
*/
|
public class LoanOrderServiceImpl implements LoanOrderService {
|
|
private DataService dataService;
|
|
private JdbcTemplate jdbcTemplate;
|
|
private PagedQueryDao pagedQueryDao;
|
|
private WalletService walletService;
|
|
private SysparaService sysparaService;
|
|
private MoneyLogService moneyLogService;
|
|
private LoanRelationOrderService loanRelationOrderService;
|
|
private Logger logger = LoggerFactory.getLogger(LoanOrderServiceImpl.class);
|
|
protected Map<String, LoanOrder> cache = new ConcurrentHashMap<String, LoanOrder>();
|
|
public void init() {
|
List<LoanOrder> list = queryOrdersByState();
|
for (LoanOrder order : list) {
|
cache.put(order.getId(), order);
|
}
|
}
|
|
/**
|
* 新增借币订单
|
*/
|
public void saveLoanOrder(LoanOrder order) {
|
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getPledgeCurrency());
|
if (walletExtend.getAmount() < order.getPledgeAmount()) {
|
throw new BusinessException(1, "Insufficient balance");
|
}
|
|
double amountBeforeExtend = walletExtend.getAmount();
|
double pledgeAmount = order.getPledgeAmount();
|
String partyId = walletExtend.getPartyId().toString();
|
// 修改拓展钱包 余额 及冻结余额
|
walletService.updateExtend(partyId, walletExtend.getWallettype(), Arith.sub(0, pledgeAmount), pledgeAmount);
|
|
String orderNo = DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8);
|
|
// 冻结资金日志
|
MoneyLog logExtend = new MoneyLog();
|
logExtend.setCategory(Constants.MONEYLOG_CATEGORY_LOAN);
|
logExtend.setAmount_before(amountBeforeExtend);
|
logExtend.setAmount(pledgeAmount);
|
logExtend.setAmount_after(Arith.add(amountBeforeExtend, Arith.sub(0, pledgeAmount)));
|
logExtend.setLog("质押借币，订单号[" + orderNo + "]，" + "冻结：" + pledgeAmount);
|
logExtend.setPartyId(partyId);
|
logExtend.setWallettype(order.getPledgeCurrency());
|
logExtend.setContent_type(Constants.MONEYLOG_CONTENT_LOAN_FROZEN);
|
logExtend.setCreateTime(new Date());
|
moneyLogService.save(logExtend);
|
|
Wallet wallet = walletService.saveWalletByPartyId(partyId);
|
double amountBefore = wallet.getMoney();
|
double loanAmount = order.getLoanAmount();
|
// 修改主钱包余额
|
walletService.update(partyId, loanAmount);
|
|
// 借款资金日志
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_LOAN);
|
moneylog.setAmount_before(amountBefore);
|
moneylog.setAmount(loanAmount);
|
moneylog.setAmount_after(Arith.add(amountBefore, loanAmount));
|
moneylog.setLog("质押借币，订单号[" + orderNo + "]，" + "借款：" + loanAmount);
|
moneylog.setPartyId(partyId);
|
moneylog.setWallettype(Constants.WALLET);
|
moneylog.setContent_type(Constants.MONEYLOG_CONTENT_LOAN_ADD);
|
moneylog.setCreateTime(new Date());
|
moneyLogService.save(moneylog);
|
|
// 质押借币记录
|
order.setOrderNo(orderNo);
|
order.setOrderType(LoanConstants.PLEDGE_ORDER_TYPE_LOAN);
|
order.setState(LoanConstants.PLEDGE_ORDER_STATE_CALCULATE);
|
order.setHourlyRate(Double.valueOf(getLoanConfig().get("hourlyRate").toString()));
|
order.setDebtAmount(loanAmount);
|
order.setPledgeType(LoanConstants.PLEDGE_TYPE);
|
order.setLoanCurrency("usdt");
|
order.setOverdueRate(Double.valueOf(getLoanConfig().get("overdueRate").toString()));
|
|
Date date = new Date();
|
Calendar calendar = new GregorianCalendar();
|
calendar.setTime(date);
|
calendar.add(Calendar.DATE, order.getLoanCycle());
|
Date expireTime = calendar.getTime();
|
order.setCreateTime(date);
|
order.setExpireTime(expireTime);
|
|
String insertSql = "INSERT INTO T_LOAN_ORDER(UUID,ORDER_NO,PARTY_ID,ORDER_TYPE,LOAN_AMOUNT,STATE,LOAN_CURRENCY,PLEDGE_CURRENCY,"
|
+ "PLEDGE_AMOUNT,PLEDGE_RATE,PLEDGE_TYPE,DEBT_AMOUNT,INTEREST_AMOUNT,OVERDUE_AMOUNT,OVERDUE_RATE,HOURLY_RATE,LOAN_CYCLE,"
|
+ "CREATE_TIME,EXPIRE_TIME) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
|
jdbcTemplate.update(insertSql,order.getId(),order.getOrderNo(),order.getPartyId(),order.getOrderType(),order.getLoanAmount(),
|
order.getState(),order.getLoanCurrency(),order.getPledgeCurrency(),order.getPledgeAmount(),order.getPledgeRate(),order.getPledgeType(),
|
order.getDebtAmount(),order.getInterestAmount(),order.getOverdueAmount(),order.getOverdueRate(),order.getHourlyRate(),
|
order.getLoanCycle(),order.getCreateTime(),order.getExpireTime());
|
// 放入缓存
|
cache.put(order.getId(), order);
|
}
|
|
/**
|
* 修改质押借币订单
|
*/
|
public void updateLoanOrder(LoanOrder order) {
|
String updateSql = "UPDATE T_LOAN_ORDER SET LOAN_AMOUNT=?,STATE=?,LOAN_CURRENCY=?,PLEDGE_CURRENCY=?,PLEDGE_AMOUNT=?,PLEDGE_RATE=?,"
|
+ "PLEDGE_TYPE=?,DEBT_AMOUNT=?,INTEREST_AMOUNT=?,OVERDUE_AMOUNT=?,OVERDUE_RATE=?,HOURLY_RATE=?,LOAN_CYCLE=?,EXPIRE_TIME=?"
|
+ " WHERE UUID=?";
|
jdbcTemplate.update(updateSql,order.getLoanAmount(),order.getState(),order.getLoanCurrency(),order.getPledgeCurrency(),
|
order.getPledgeAmount(),order.getPledgeRate(),order.getPledgeType(),order.getDebtAmount(),order.getInterestAmount(),order.getOverdueAmount(),
|
order.getOverdueRate(),order.getHourlyRate(),order.getLoanCycle(),order.getExpireTime(),order.getId());
|
}
|
|
/**
|
* 质押借币订单
|
*/
|
public List<Map<String, Object>> pagedQuery(int pageNo, int pageSize, String partyId) {
|
if (pageNo <= 0) pageNo = 1;
|
Page page = new Page(pageNo, pageSize, Integer.MAX_VALUE);
|
List<LoanOrder> orders = ApplicationUtil.executeSelect(LoanOrder.class,"WHERE PARTY_ID=? ORDER BY CREATE_TIME DESC LIMIT ?,?",new Object[] {partyId,page.getFirstElementNumber(),pageSize});
|
|
// 借款记录
|
List<Map<String, Object>> list = new ArrayList<>();
|
for (LoanOrder order : orders) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("id", order.getId());
|
map.put("orderType", order.getOrderType());
|
map.put("loanAmount", order.getLoanAmount());
|
map.put("state", order.getState());
|
map.put("loanCurrency", order.getLoanCurrency());
|
if (LoanConstants.PLEDGE_ORDER_STATE_CALCULATE == order.getState() || LoanConstants.PLEDGE_ORDER_STATE_OVERDUE == order.getState()) {
|
List<LoanRelationOrder> relations = loanRelationOrderService.queryOrders(order.getId(), LoanConstants.PLEDGE_ORDER_TYPE_REPLENISH);
|
double pledgeAmount = order.getPledgeAmount();
|
for (LoanRelationOrder relationOrder : relations) {
|
pledgeAmount = Arith.add(pledgeAmount, relationOrder.getPledgeAmount());
|
}
|
|
Map<String, Double> calculateMap = calculatePledgeRate(order.getPledgeCurrency(), order.getDebtAmount(), pledgeAmount);
|
map.put("pledgeRate", calculateMap.get("pledgeRate"));
|
}else {
|
map.put("pledgeRate", order.getPledgeRate());
|
}
|
map.put("debtAmount", order.getDebtAmount());
|
list.add(map);
|
}
|
return list;
|
}
|
|
/**
|
* 根据订单关联ID获取订单列表
|
*/
|
public List<LoanOrder> queryOrdersByState() {
|
List<LoanOrder> list = jdbcTemplate.query("SELECT * FROM T_LOAN_ORDER WHERE STATE = 1 OR STATE = 4",
|
RecordObjectMapper.newInstance(LoanOrder.class));
|
return list;
|
}
|
|
/**
|
* 根据订单关联ID获取订单列表
|
*/
|
public List<String> queryOrdersNoticeList(String partyId) {
|
List<LoanOrder> list = jdbcTemplate.query("SELECT * FROM T_LOAN_ORDER WHERE (STATE = 1 OR STATE = 4) AND PARTY_ID =?",
|
RecordObjectMapper.newInstance(LoanOrder.class), partyId);
|
List<String> noticeList = new ArrayList<>();
|
for (LoanOrder order : list) {
|
Map<String, Double> calculateMap = calculatePledgeRate(order.getPledgeCurrency(), order.getDebtAmount(), order.getPledgeAmount());
|
if (Double.valueOf(calculateMap.get("pledgeRate").toString()) >= LoanConstants.PLEDGE_RATE_NOTICE) {
|
noticeList.add(order.getId());
|
}
|
}
|
return noticeList;
|
}
|
|
/**
|
* 从缓存中获取订单
|
*/
|
public List<LoanOrder> cacheOrders() {
|
return new ArrayList<LoanOrder>(cache.values());
|
}
|
|
/**
|
* 存入缓存
|
*/
|
public void addCacheOrder(LoanOrder order) {
|
cache.put(order.getId(), order);
|
}
|
|
/**
|
* 从缓存中移除订单
|
*/
|
public void removeCacheOrder(String orderId) {
|
cache.remove(orderId);
|
}
|
|
/**
|
* 从缓存中移除订单
|
*/
|
public void cacheRemoveOrders(List<String> orderIds) {
|
for (String orderId : orderIds) {
|
cache.remove(orderId);
|
}
|
}
|
|
/**
|
* 订单详情
|
*/
|
public Map<String, Object> getLoanOrder(String id) {
|
LoanOrder order = getLoanOrderParam(id);
|
if (null == order) {
|
throw new BusinessException(1, "order is unknown");
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("id", order.getId());
|
map.put("state", order.getState());
|
map.put("debtAmount", order.getDebtAmount());
|
map.put("loanCurrency", order.getLoanCurrency());
|
map.put("pledgeCurrency", order.getPledgeCurrency());
|
map.put("loanAmount", order.getLoanAmount());
|
map.put("interestAmount", order.getInterestAmount());
|
map.put("hourlyRate", order.getHourlyRate());
|
map.put("orderNo", order.getOrderNo());
|
map.put("createTime", DateUtils.format(order.getCreateTime(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("expireTime", DateUtils.format(order.getExpireTime(), DateUtils.DF_yyyyMMddHHmmss));
|
|
// 计息中、已逾期
|
if (LoanConstants.PLEDGE_ORDER_STATE_CALCULATE == order.getState()
|
|| LoanConstants.PLEDGE_ORDER_STATE_OVERDUE == order.getState()) {
|
|
List<LoanRelationOrder> relations = loanRelationOrderService.queryOrders(order.getId(), LoanConstants.PLEDGE_ORDER_TYPE_REPLENISH);
|
double pledgeAmount = order.getPledgeAmount();
|
for (LoanRelationOrder relationOrder : relations) {
|
pledgeAmount = Arith.add(pledgeAmount, relationOrder.getPledgeAmount());
|
}
|
|
Map<String, Double> calculateMap = calculatePledgeRate(order.getPledgeCurrency(), order.getDebtAmount(), pledgeAmount);
|
map.put("pledgeRate", calculateMap.get("pledgeRate"));
|
map.put("closeOut", calculateMap.get("closeOut"));
|
map.put("overdueAmount", order.getOverdueAmount());
|
map.put("overdueRate", order.getOverdueRate());
|
}
|
return map;
|
}
|
|
/**
|
* 订单
|
*/
|
public LoanOrder getLoanOrderParam(String id) {
|
List<LoanOrder> list = jdbcTemplate.query("SELECT * FROM T_LOAN_ORDER WHERE UUID=?", RecordObjectMapper.newInstance(LoanOrder.class), id);
|
if (null != list && list.size() > 0) {
|
return list.get(0);
|
}
|
return null;
|
}
|
|
/**
|
* 获取配置
|
*/
|
public Map<String, Object> getLoanConfig() {
|
String config = sysparaService.find("exchange_loan").getValue();
|
Map<String, Object> map = new HashMap<>();
|
String[] configSplit = config.split("\\|");
|
map.put("hourlyRate", configSplit[0]);
|
map.put("loanCycle", configSplit[1].split(":"));
|
map.put("loanAmountMin", configSplit[3]);
|
map.put("overdueRate", configSplit[2]);
|
return map;
|
}
|
|
/**
|
* 分页查询 计息中、已逾期的订单
|
*/
|
public Page pagedQueryInterestOrder(int pageNo, int pageSize, Date date) {
|
if (pageNo <= 0) pageNo = 1;
|
Page page = new Page(pageNo, pageSize, Integer.MAX_VALUE);
|
List<LoanOrder> list=ApplicationUtil.executeSelect(LoanOrder.class,"WHERE STATE=1 OR STATE=4 AND CREATE_TIME<=? ORDER BY CREATE_TIME DESC LIMIT ?,?",new Object[] {date,page.getFirstElementNumber(),pageSize});
|
page.setElements(list);
|
return page;
|
}
|
|
/**
|
* 定时计算利息
|
*/
|
public void updateInterest(List<LoanOrder> orders) {
|
List<LoanOrder> updateOrders = new ArrayList<>();
|
Date date = new Date();
|
for (LoanOrder order : orders) {
|
// 还款记录
|
List<LoanRelationOrder> relationList = loanRelationOrderService.queryOrders(order.getId(), LoanConstants.PLEDGE_ORDER_TYPE_REPAY);
|
double repayAmount = 0;
|
for (LoanRelationOrder relation : relationList ) {
|
repayAmount += relation.getLoanAmount();
|
}
|
double loanAmountSum = Arith.sub(order.getLoanAmount(), repayAmount);
|
// 借款利息
|
double interestAmount = Arith.mul(loanAmountSum, order.getHourlyRate());
|
// 总利息
|
order.setInterestAmount(Arith.add(order.getInterestAmount(), interestAmount));
|
// 总负债
|
order.setDebtAmount(Arith.add(order.getDebtAmount(), interestAmount));
|
// 到期
|
if (LoanConstants.PLEDGE_ORDER_STATE_CALCULATE == order.getState() && date.after(order.getExpireTime())) {
|
order.setState(LoanConstants.PLEDGE_ORDER_STATE_OVERDUE);
|
}
|
// 已逾期
|
if (LoanConstants.PLEDGE_ORDER_STATE_OVERDUE == order.getState()) {
|
// 逾期扣款
|
double overdueAmount = Arith.mul(loanAmountSum, order.getOverdueRate());
|
// 总逾期
|
order.setOverdueAmount(Arith.add(order.getOverdueAmount(), overdueAmount));
|
// 总负债
|
order.setDebtAmount(Arith.add(order.getDebtAmount(), overdueAmount));
|
}
|
updateOrders.add(order);
|
}
|
|
// 批量更新
|
updateBatchOrder(updateOrders);
|
}
|
|
/**
|
* 批量新增收益记录
|
*/
|
protected void updateBatchOrder(final List<LoanOrder> orderList) {
|
String sql = "UPDATE T_LOAN_ORDER SET INTEREST_AMOUNT = ?, DEBT_AMOUNT = ?, STATE = ?, OVERDUE_AMOUNT = ? WHERE UUID=?";
|
int[] batchUpdate = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
|
@Override
|
public void setValues(PreparedStatement ps, int i) throws SQLException {
|
ps.setDouble(1, orderList.get(i).getInterestAmount());
|
ps.setDouble(2, orderList.get(i).getDebtAmount());
|
ps.setInt(3, orderList.get(i).getState());
|
ps.setDouble(4, orderList.get(i).getOverdueAmount());
|
ps.setString(5, orderList.get(i).getId());
|
}
|
@Override
|
public int getBatchSize() {
|
return orderList.size();
|
}
|
});
|
logger.info("end loan batch update attr:{}", batchUpdate);
|
}
|
|
|
/**
|
* 后台质押借币订单
|
*/
|
public Page pagedQueryAdmin(int pageNo, int pageSize, String userParam, String orderNo, String roleName, String state) {
|
Map<String, Object> parameters = new HashMap<>();
|
StringBuffer queryString = new StringBuffer(
|
" SELECT loan.UUID id, loan.ORDER_NO orderNo, loan.PARTY_ID partyId, "
|
+ "loan.ORDER_TYPE orderType, loan.LOAN_AMOUNT loanAmount, loan.STATE state, loan.LOAN_CURRENCY loanCurrency, "
|
+ "loan.PLEDGE_CURRENCY pledgeCurrency, loan.PLEDGE_AMOUNT pledgeAmount, loan.PLEDGE_TYPE pledgeType, loan.PLEDGE_RATE pledgeRate, "
|
+ "loan.DEBT_AMOUNT debtAmount, loan.INTEREST_AMOUNT interestAmount, loan.HOURLY_RATE hourlyRate, loan.LOAN_CYCLE loanCycle, "
|
+ "loan.CREATE_TIME createTime, loan.EXPIRE_TIME expireTime, ");
|
queryString.append(" party.USERNAME username,party.USERCODE usercode,party.ROLENAME rolename ");
|
queryString.append(" FROM T_LOAN_ORDER loan ");
|
queryString.append(" LEFT JOIN PAT_PARTY party ON loan.PARTY_ID = party.UUID ");
|
queryString.append(" WHERE 1 = 1 ");
|
|
if (!StringUtils.isNullOrEmpty(userParam)) {
|
queryString.append("AND (party.USERNAME like:userParam OR party.USERCODE like:userParam ) ");
|
parameters.put("userParam", "%" + userParam + "%");
|
}
|
|
if (!StringUtils.isNullOrEmpty(orderNo)) {
|
queryString.append(" and loan.ORDER_NO =:orderNo ");
|
parameters.put("orderNo", orderNo);
|
}
|
|
if (!StringUtils.isNullOrEmpty(state)) {
|
queryString.append(" and loan.STATE =:state ");
|
parameters.put("state", state);
|
}
|
|
if (!StringUtils.isNullOrEmpty(roleName)) {
|
queryString.append(" and party.ROLENAME =:rolename");
|
parameters.put("rolename", roleName);
|
}
|
|
queryString.append(" order by loan.CREATE_TIME desc ");
|
|
Page page = this.pagedQueryDao.pagedQuerySQL(pageNo, pageSize, queryString.toString(), parameters);
|
return page;
|
}
|
|
/**
|
* 根据订单总负债 计算质押率
|
*/
|
public Map<String, Double> calculatePledgeRate(String pledgeCurrency, double debtAmount, double pledgeAmount) {
|
List<Realtime> realtimes = dataService.realtime(pledgeCurrency);
|
// Map<String, Object> config = getLoanConfig();
|
// double hourlyRate = Double.valueOf(config.get("hourlyRate").toString());
|
// // 质押率 = (借款金额 + (借款金额 * 时利率 * 24 * 借款周期)) / 质押币的价格 / 质押数量
|
// // 质押率 = (借款金额 + (借款金额 * 时利率 * 24 * 借款周期)) / 质押币的价格 / 质押数量11
|
// double interestAmount = Arith.mul(loanAmount, hourlyRate * 24 * loanCycle);
|
// double debtAmount = Arith.add(loanAmount, interestAmount);
|
Map<String, Double> map = new HashMap<>();
|
map.put("pledgeRate", Arith.div(Arith.div(debtAmount, realtimes.get(0).getClose()), pledgeAmount, 2));
|
map.put("closeOut", Arith.div(Arith.div(debtAmount, LoanConstants.PLEDGE_RATE_CLOSEOUT), pledgeAmount, 2));
|
return map;
|
}
|
|
/**
|
* 系统强平
|
*/
|
public void updateCloseout(LoanOrder order, double pledgeRate) {
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getPledgeCurrency());
|
double pledgeAmount = order.getPledgeAmount();
|
List<LoanRelationOrder> relationOrderList = loanRelationOrderService.queryOrders(order.getId(), LoanConstants.PLEDGE_ORDER_TYPE_REPLENISH);
|
for (LoanRelationOrder relation : relationOrderList) {
|
// 补增质押
|
pledgeAmount = Arith.add(relation.getPledgeAmount(), pledgeAmount);
|
}
|
|
double amountBeforeExtend = walletExtend.getAmount();
|
String partyId = walletExtend.getPartyId().toString();
|
// 修改拓展钱包 冻结余额
|
walletService.updateExtend(partyId, walletExtend.getWallettype(), 0, Arith.sub(0, pledgeAmount));
|
|
// 强平资金日志
|
MoneyLog logExtend = new MoneyLog();
|
logExtend.setCategory(Constants.MONEYLOG_CATEGORY_LOAN);
|
logExtend.setAmount_before(amountBeforeExtend);
|
logExtend.setAmount(pledgeAmount);
|
logExtend.setAmount_after(Arith.add(amountBeforeExtend, Arith.sub(0, pledgeAmount)));
|
logExtend.setLog("质押借币，订单号[" + order.getOrderNo() + "]，" + "强平：" + pledgeAmount);
|
logExtend.setPartyId(partyId);
|
logExtend.setWallettype(order.getPledgeCurrency());
|
logExtend.setContent_type(Constants.MONEYLOG_CONTENT_LOAN_CLOSEOUT);
|
logExtend.setCreateTime(new Date());
|
moneyLogService.save(logExtend);
|
|
order.setPledgeRate(pledgeRate);
|
order.setState(LoanConstants.PLEDGE_ORDER_STATE_CLOSEOUT);
|
order.setOrderType(LoanConstants.PLEDGE_ORDER_TYPE_CLOSEOUT);
|
updateLoanOrder(order);
|
}
|
|
public void setPagedQueryDao(PagedQueryDao pagedQueryDao) {
|
this.pagedQueryDao = pagedQueryDao;
|
}
|
|
public void setWalletService(WalletService walletService) {
|
this.walletService = walletService;
|
}
|
|
public void setSysparaService(SysparaService sysparaService) {
|
this.sysparaService = sysparaService;
|
}
|
|
public void setMoneyLogService(MoneyLogService moneyLogService) {
|
this.moneyLogService = moneyLogService;
|
}
|
|
public void setDataService(DataService dataService) {
|
this.dataService = dataService;
|
}
|
|
public void setLoanRelationOrderService(LoanRelationOrderService loanRelationOrderService) {
|
this.loanRelationOrderService = loanRelationOrderService;
|
}
|
|
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
|
this.jdbcTemplate = jdbcTemplate;
|
}
|
|
}
|
