package com.yami.trading.service.miner.service.impl;
|
|
import java.math.BigDecimal;
|
import java.sql.PreparedStatement;
|
import java.sql.SQLException;
|
import java.sql.Timestamp;
|
import java.util.*;
|
import java.util.Map.Entry;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import com.alibaba.fastjson2.JSON;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.yami.trading.service.miner.job.MinerOrderMessage;
|
import com.yami.trading.service.miner.service.MinerOrderProfitService;
|
import com.yami.trading.bean.data.domain.Realtime;
|
import com.yami.trading.bean.miner.Miner;
|
import com.yami.trading.bean.miner.MinerOrder;
|
import com.yami.trading.bean.model.*;
|
import com.yami.trading.common.constants.Constants;
|
import com.yami.trading.common.util.Arith;
|
import com.yami.trading.common.util.DateUtils;
|
import com.yami.trading.common.util.StringUtils;
|
import com.yami.trading.common.util.ThreadUtils;
|
import com.yami.trading.dao.miner.MinerOrderMapper;
|
import com.yami.trading.service.MoneyLogService;
|
import com.yami.trading.service.WalletService;
|
import com.yami.trading.service.data.DataService;
|
import com.yami.trading.service.miner.service.MinerRedisKeys;
|
import com.yami.trading.service.miner.service.MinerService;
|
import com.yami.trading.service.syspara.SysparaService;
|
import com.yami.trading.service.user.UserDataService;
|
import com.yami.trading.service.user.UserRecomService;
|
import com.yami.trading.service.user.UserService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
|
import com.yami.trading.service.miner.service.MinerOrderService;
|
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
@Service
|
@Transactional
|
@Slf4j
|
public class MinerOrderProfitServiceImpl extends ServiceImpl<MinerOrderMapper, MinerOrder> implements MinerOrderProfitService {
|
@Autowired
|
protected MinerService minerService;
|
@Autowired
|
protected UserService partyService;
|
@Autowired
|
protected UserRecomService userRecomService;
|
@Autowired
|
private RedisTemplate redisTemplate;
|
@Autowired
|
protected UserDataService userDataService;
|
@Autowired
|
protected MoneyLogService moneyLogService;
|
@Autowired
|
protected MinerOrderService minerOrderService;
|
@Autowired
|
protected WalletService walletService;
|
@Autowired
|
protected JdbcTemplate jdbcTemplate;
|
@Autowired
|
protected SysparaService sysparaService;
|
@Autowired
|
protected DataService dataService;
|
@Autowired
|
protected NamedParameterJdbcOperations namedParameterJdbcTemplate;
|
|
/**
|
* 计算推荐人收益
|
*/
|
protected Map<String, Double> cacheRecomProfit = new ConcurrentHashMap<>();
|
|
/**
|
* 分页获取计息中的矿机订单
|
*
|
* @param pageNo
|
* @param pageSize
|
* @return
|
*/
|
@Override
|
public Page pagedQueryComputeOrder(int pageNo, int pageSize) {
|
Page page = new Page(pageNo,pageSize);
|
this.baseMapper.pagedQueryComputeOrder(page);
|
return page;
|
}
|
|
/**
|
* 计算订单收益
|
*
|
* @param orders 订单列表
|
* @param miner_profit_symbol 指定币种
|
* @param realtime 币种行情
|
* @param miner_bonus_parameters 推荐人收益参数
|
*/
|
@Override
|
public void saveComputeOrderProfit(List orders, String miner_profit_symbol, Realtime realtime,
|
String miner_bonus_parameters, Date systemTime) {
|
log.info("start compute order size:{}", orders.size());
|
List<MinerOrderMessage> saveMinerOrders = new ArrayList<>();
|
Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
|
for (Object order1 : orders) {
|
MinerOrder order = JSON.parseObject(JSON.toJSONString(order1),MinerOrder.class);
|
/**
|
* 截止时间要大于现在这个时间则计算收益
|
*/
|
Miner miner = minerService.cacheById(order.getMiner_id());
|
if (null == miner) {
|
log.error("该矿机不存在，停止计息，minerId:" + order.getMiner_id());
|
continue;
|
}
|
// 非体验矿机，今天<起息时间 不计息，表示满24小时才开始计息
|
if (miner.getTest().equals("N") && systemTime.before(order.getEarn_time())) {
|
continue;
|
}
|
// 体验矿机，今天<起息日 不计息
|
if (miner.getTest().equals("Y") && systemTime.before(DateUtils.getDayStart(order.getEarn_time()))) {
|
continue;
|
}
|
|
if (order.getStop_time() != null && systemTime.after(order.getStop_time())) {// 当前时间>截止时间
|
order.setState("0");// 正常赎回，停止计息，退还本金
|
order.setCompute_day(systemTime);
|
minerOrderService.saveClose(order);// 截止日=今天时就已经返还完毕
|
} else {
|
// 当天计算过，则不再计算，例如 1号4点计算， 则2号0点以前进入都判定计算过
|
if (order.getCompute_day() != null
|
&& systemTime.before(DateUtils.getDayStart(DateUtils.addDate(order.getCompute_day(), 1)))) {
|
double day_profit = 0;
|
if (miner.getTest().equals("Y")) {
|
day_profit = miner_test_profit;
|
} else {
|
day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
|
}
|
handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);// 已经计息过的直接进入缓存
|
continue;
|
}
|
/**
|
* 当日获取的收益
|
*/
|
double day_profit = 0;
|
if (miner.getTest().equals("Y")) {
|
day_profit = miner_test_profit;
|
} else {
|
day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
|
}
|
order.setCompute_day(systemTime);// 记息日期
|
order.setProfit(Arith.add(order.getProfit(), day_profit));// 累计收益
|
/**
|
* 给钱包增加收益
|
*/
|
/**
|
* 矿机产出是否需要转化成某个币种,若为空则不转化，若写入的symbol代码不存在则也不转化
|
*/
|
updateProfitToWallet(miner_profit_symbol, day_profit, realtime, order, systemTime);
|
|
saveMinerOrders
|
.add(new MinerOrderMessage(order.getOrder_no(), order.getProfit(), order.getCompute_day()));
|
// 更新矿机订单
|
redisTemplate.opsForValue().set(MinerRedisKeys.MINER_ORDER_ORDERNO + order.getOrder_no(), order);
|
|
userDataService.saveMinerProfit(order.getPartyId().toString(), day_profit);
|
|
handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);
|
//每单处理完后等待100ms，避免循环提交事务导致问题
|
ThreadUtils.sleep(200);
|
}
|
}
|
log.info("start miner batch update size:{}", saveMinerOrders.size());
|
updateBatchMinerOrdersProfit(saveMinerOrders);
|
}
|
|
/**
|
* 计算订单收益
|
*
|
* @param orders 订单列表
|
* @param miner_profit_symbol 指定币种
|
* @param realtime 币种行情
|
* @param miner_bonus_parameters 推荐人收益参数
|
*/
|
@Override
|
public void saveComputeOrderProfit(List orders, String miner_profit_symbol, Realtime realtime,
|
String miner_bonus_parameters) {
|
log.info("start compute order size:{}", orders.size());
|
List<MinerOrderMessage> saveMinerOrders = new ArrayList<MinerOrderMessage>();
|
Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
|
for (Object obj : orders) {
|
MinerOrder order = JSON.parseObject(JSON.toJSONString(obj),MinerOrder.class);
|
/**
|
* 截止时间要大于现在这个时间则计算收益
|
*/
|
Miner miner = minerService.cacheById(order.getMiner_id());
|
if (null == miner) {
|
log.error("该矿机不存在，停止计息，minerId:" + order.getMiner_id());
|
continue;
|
}
|
// 非体验矿机，今天<起息时间 不计息，表示满24小时才开始计息
|
if (miner.getTest().equals("N") && new Date().before(order.getEarn_time())) {
|
continue;
|
}
|
// 体验矿机，今天<起息日 不计息
|
if (miner.getTest().equals("Y") && new Date().before(DateUtils.getDayStart(order.getEarn_time()))) {
|
continue;
|
}
|
|
if (order.getStop_time() != null && new Date().after(order.getStop_time())) {// 当前时间>截止时间
|
order.setState("0");// 正常赎回，停止计息，退还本金
|
order.setCompute_day(new Date());
|
minerOrderService.saveClose(order);// 截止日=今天时就已经返还完毕
|
} else {
|
// 当天计算过，则不再计算，例如 1号4点计算， 则2号0点以前进入都判定计算过
|
if (order.getCompute_day() != null
|
&& new Date().before(DateUtils.getDayStart(DateUtils.addDate(order.getCompute_day(), 1)))) {
|
double day_profit = 0;
|
if (miner.getTest().equals("Y")) {
|
day_profit = miner_test_profit;
|
} else {
|
day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
|
}
|
handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);// 已经计息过的直接进入缓存
|
continue;
|
}
|
/**
|
* 当日获取的收益
|
*/
|
double day_profit = 0;
|
if (miner.getTest().equals("Y")) {
|
day_profit = miner_test_profit;
|
} else {
|
day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
|
}
|
order.setCompute_day(new Date());// 记息日期
|
order.setProfit(Arith.add(order.getProfit(), day_profit));// 累计收益
|
/**
|
* 给钱包增加收益
|
*/
|
/**
|
* 矿机产出是否需要转化成某个币种,若为空则不转化，若写入的symbol代码不存在则也不转化
|
*/
|
updateProfitToWallet(miner_profit_symbol, day_profit, realtime, order);
|
|
saveMinerOrders
|
.add(new MinerOrderMessage(order.getOrder_no(), order.getProfit(), order.getCompute_day()));
|
// 更新矿机订单
|
redisTemplate.opsForValue().set(MinerRedisKeys.MINER_ORDER_ORDERNO + order.getOrder_no(), order);
|
|
userDataService.saveMinerProfit(order.getPartyId(), day_profit);
|
|
handleRecomProfit(order.getPartyId(), day_profit, miner, miner_bonus_parameters);
|
//每单处理完后等待100ms，避免循环提交事务导致问题
|
ThreadUtils.sleep(200);
|
}
|
}
|
log.info("start miner batch update size:{}", saveMinerOrders.size());
|
updateBatchMinerOrdersProfit(saveMinerOrders);
|
}
|
|
/**
|
* 更新收益到钱包
|
*
|
* @param miner_profit_symbol 指定币种
|
* @param day_profit 当日收益
|
* @param realtime 币种行情
|
* @param order 矿机订单
|
*/
|
protected void updateProfitToWallet(String miner_profit_symbol, double day_profit, Realtime realtime, MinerOrder order) {
|
// 矿机购买时使用的币种，则产生对应的币种，转换成u
|
String miner_buy_symbol = sysparaService.find("miner_buy_symbol").getSvalue();
|
if (StringUtils.isNotEmpty(miner_buy_symbol)) {
|
if (miner_buy_symbol.equals(miner_profit_symbol)) {
|
day_profit = Arith.mul(day_profit, realtime.getClose());
|
} else {
|
List<Realtime> realtime_list = this.dataService.realtime(miner_buy_symbol);
|
Realtime realtimeBuySymbol = null;
|
if (realtime_list.size() > 0) {
|
realtimeBuySymbol = realtime_list.get(0);
|
}
|
day_profit = Arith.mul(day_profit, realtimeBuySymbol.getClose());
|
}
|
}
|
// 非USDT币种收益
|
if (StringUtils.isNotEmpty(miner_profit_symbol)) {
|
double getSymbolVolume = Arith.div(day_profit, realtime.getClose());
|
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), miner_profit_symbol);
|
double amountBefore = walletExtend.getAmount();
|
this.walletService.updateExtend(order.getPartyId(), miner_profit_symbol, getSymbolVolume);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmountBefore(BigDecimal.valueOf(amountBefore));
|
moneylog.setAmount(BigDecimal.valueOf(getSymbolVolume));
|
moneylog.setAmountAfter(BigDecimal.valueOf(Arith.add(amountBefore, getSymbolVolume)));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(realtime.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(new Date());
|
moneyLogService.save(moneylog);
|
}
|
// 此为收益为USDT
|
else {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amountBefore = wallet.getMoney().doubleValue();
|
this.walletService.update(wallet.getUserId(), day_profit);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmountBefore(BigDecimal.valueOf(amountBefore));
|
moneylog.setAmount(BigDecimal.valueOf(day_profit));
|
moneylog.setAmountAfter(BigDecimal.valueOf(Arith.add(amountBefore, day_profit)));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(Constants.WALLET);
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(new Date());
|
moneyLogService.save(moneylog);
|
}
|
}
|
|
/**
|
* 更新收益到钱包
|
*
|
* @param miner_profit_symbol 指定币种
|
* @param day_profit 当日收益
|
* @param realtime 币种行情
|
* @param order 矿机订单
|
*/
|
protected void updateProfitToWallet(String miner_profit_symbol, double day_profit, Realtime realtime, MinerOrder order, Date systemTime) {
|
// 矿机购买时使用的币种，则产生对应的币种，转换成u
|
String miner_buy_symbol = sysparaService.find("miner_buy_symbol").getSvalue();
|
if (StringUtils.isNotEmpty(miner_buy_symbol)) {
|
if (miner_buy_symbol.equals(miner_profit_symbol)) {
|
day_profit = Arith.mul(day_profit, realtime.getClose());
|
} else {
|
List<Realtime> realtime_list = this.dataService.realtime(miner_buy_symbol);
|
Realtime realtimeBuySymbol = null;
|
if (realtime_list.size() > 0) {
|
realtimeBuySymbol = realtime_list.get(0);
|
}
|
day_profit = Arith.mul(day_profit, realtimeBuySymbol.getClose());
|
}
|
}
|
// 非Usdt币种收益
|
if (StringUtils.isNotEmpty(miner_profit_symbol)) {
|
double get_symbol_volume = Arith.div(day_profit, realtime.getClose());
|
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), miner_profit_symbol);
|
double amountBefore = walletExtend.getAmount();
|
this.walletService.updateExtend(order.getPartyId(), miner_profit_symbol, get_symbol_volume);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmountBefore(BigDecimal.valueOf(amountBefore));
|
moneylog.setAmount(BigDecimal.valueOf(get_symbol_volume));
|
moneylog.setAmountAfter(BigDecimal.valueOf(Arith.add(amountBefore, get_symbol_volume)));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(realtime.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(systemTime);
|
moneyLogService.save(moneylog);
|
}
|
// 此为收益为usdt
|
else {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amountBefore = wallet.getMoney().doubleValue();
|
this.walletService.update(wallet.getUserId(), day_profit);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmountBefore(BigDecimal.valueOf(amountBefore));
|
moneylog.setAmount(BigDecimal.valueOf(day_profit));
|
moneylog.setAmountAfter(BigDecimal.valueOf(Arith.add(amountBefore, day_profit)));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(Constants.WALLET);
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(systemTime);
|
moneyLogService.save(moneylog);
|
}
|
}
|
|
/**
|
* 批量更新订单收益
|
*
|
* @param orderList
|
*/
|
protected void updateBatchMinerOrdersProfit(final List<MinerOrderMessage> orderList) {
|
String sql = "UPDATE T_MINER_ORDER SET PROFIT=?,COMPUTE_DAY=? WHERE ORDER_NO=?";
|
int[] batchUpdate = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
|
@Override
|
public void setValues(PreparedStatement ps, int i) throws SQLException {
|
ps.setDouble(1, orderList.get(i).getProfit());
|
ps.setTimestamp(2, new Timestamp(orderList.get(i).getComputeDay().getTime()));
|
ps.setString(3, orderList.get(i).getOrderNo());
|
}
|
@Override
|
public int getBatchSize() {
|
return orderList.size();
|
}
|
});
|
log.info("end miner batch update attr:{}", batchUpdate);
|
}
|
|
public void handleRecomProfit(String partyId, double profit, Miner miner, String miner_bonus_parameters) {
|
if (miner.getTest().equals("Y")) {
|
return;
|
}
|
List<UserRecom> list_parents = this.userRecomService.getParents(partyId);
|
if (list_parents.size() == 0) {
|
return;
|
}
|
String[] miner_bonus_array = miner_bonus_parameters.split(",");
|
int loop = 0;
|
int loopMax = miner_bonus_array.length;
|
for (int i = 0; i < list_parents.size(); i++) {
|
if (loop >= loopMax) {
|
break;
|
}
|
User party_parent = this.partyService.cacheUserBy(list_parents.get(i).getRecomUserId());
|
if (!Constants.SECURITY_ROLE_MEMBER.equals(party_parent.getRoleName())) {
|
continue;
|
}
|
loop++;
|
Map<String, MinerOrder> map_party = (Map<String, MinerOrder>) redisTemplate.opsForValue()
|
.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + party_parent.getUserId().toString());
|
if (map_party == null || map_party.size() == 0) {
|
continue;
|
}
|
/*
|
* 判断是否
|
*/
|
int cycle = 0;
|
Iterator<Entry<String, MinerOrder>> it = map_party.entrySet().iterator();
|
while (it.hasNext()) {
|
Entry<String, MinerOrder> entry = it.next();
|
MinerOrder minerOrder = entry.getValue();
|
if (!"1".equals(minerOrder.getState())) {
|
continue;
|
}
|
Miner miner_party = this.minerService.cacheById(minerOrder.getMiner_id());
|
if (cycle < miner_party.getCycle()) {
|
cycle = miner_party.getCycle();
|
}
|
|
}
|
|
if (cycle >= miner.getCycle()) {
|
/**
|
* 增加收益
|
*/
|
double pip_amount = Double.valueOf(miner_bonus_array[loop - 1]);
|
double get_money = Arith.mul(profit, pip_amount);
|
|
Double recom_profit = cacheRecomProfit.get(party_parent.getUserId().toString());
|
cacheRecomProfit.put(party_parent.getUserId().toString(),
|
Arith.add(recom_profit == null ? 0D : recom_profit, get_money));
|
}
|
}
|
}
|
|
/**
|
* 最终收益持久化数据库
|
*/
|
@Override
|
public void saveRecomProfit() {
|
if (cacheRecomProfit.isEmpty()) {
|
return;
|
}
|
|
// 开始增加推荐人收益
|
log.info("start ------recom user miner profit,date:{},count:{}",
|
new Object[] { new Date(), cacheRecomProfit.size() });
|
for (Entry<String, Double> entry : cacheRecomProfit.entrySet()) {
|
Wallet wallet = walletService.saveWalletByPartyId(entry.getKey());
|
double amountBefore = wallet.getMoney().doubleValue();
|
walletService.update(wallet.getUserId(), entry.getValue());
|
|
MoneyLog moneyLog = new MoneyLog();
|
moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneyLog.setAmountBefore(BigDecimal.valueOf(amountBefore));
|
moneyLog.setAmount(BigDecimal.valueOf(entry.getValue()));
|
moneyLog.setAmountAfter(BigDecimal.valueOf(Arith.add(amountBefore, entry.getValue())));
|
moneyLog.setLog("矿机推荐奖励金");
|
moneyLog.setUserId(entry.getKey());
|
moneyLog.setWalletType(Constants.WALLET);
|
moneyLog.setContentType(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
|
moneyLogService.save(moneyLog);
|
userDataService.saveMinerProfit(entry.getKey(), entry.getValue());
|
}
|
// 推荐人矿机收益计算完成，纪录日志
|
log.info("finish ------recom user miner profit,date:{},count:{}",
|
new Object[] { new Date(), cacheRecomProfit.size() });
|
// 处理完后收益清空
|
|
}
|
|
/**
|
* 最终收益持久化数据库
|
*/
|
@Override
|
public void saveRecomProfit(Date systemTime) {
|
if (cacheRecomProfit.isEmpty()) {
|
return;
|
}
|
|
// 开始增加推荐人收益
|
log.info("start ------recom user miner profit,date:{},count:{}",
|
new Object[] { new Date(), cacheRecomProfit.size() });
|
for (Entry<String, Double> entry : cacheRecomProfit.entrySet()) {
|
Wallet wallet = walletService.saveWalletByPartyId(entry.getKey());
|
double amountBefore = wallet.getMoney().doubleValue();
|
walletService.update(wallet.getUserId(), entry.getValue());
|
|
MoneyLog moneyLog = new MoneyLog();
|
moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneyLog.setAmountBefore(BigDecimal.valueOf(amountBefore));
|
moneyLog.setAmount(BigDecimal.valueOf(entry.getValue()));
|
moneyLog.setAmountAfter(BigDecimal.valueOf(Arith.add(amountBefore, entry.getValue())));
|
moneyLog.setLog("矿机推荐奖励金");
|
moneyLog.setUserId(entry.getKey());
|
moneyLog.setWalletType(Constants.WALLET);
|
moneyLog.setContentType(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
|
moneyLog.setCreateTime(systemTime);
|
moneyLogService.save(moneyLog);
|
userDataService.saveMinerProfit(entry.getKey(), entry.getValue());
|
}
|
// 推荐人矿机收益计算完成，纪录日志
|
log.info("finish ------recom user miner profit,date:{},count:{}",
|
new Object[] { new Date(), cacheRecomProfit.size() });
|
// 处理完后收益清空
|
|
}
|
|
@Override
|
public void cacheRecomProfitClear() {
|
cacheRecomProfit.clear();
|
}
|
|
}
|
