package project.miner.job;
|
|
import java.sql.PreparedStatement;
|
import java.sql.SQLException;
|
import java.sql.Timestamp;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
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.exception.BusinessException;
|
import kernel.util.Arith;
|
import kernel.util.DateUtils;
|
import kernel.util.ThreadUtils;
|
import kernel.web.ApplicationUtil;
|
import kernel.web.Page;
|
import project.Constants;
|
import project.data.DataService;
|
import project.data.model.Realtime;
|
import project.log.MoneyLog;
|
import project.log.MoneyLogService;
|
import project.miner.MinerOrderService;
|
import project.miner.MinerRedisKeys;
|
import project.miner.MinerService;
|
import project.miner.model.Miner;
|
import project.miner.model.MinerOrder;
|
import project.party.PartyService;
|
import project.party.model.Party;
|
import project.party.model.UserRecom;
|
import project.party.recom.UserRecomService;
|
import project.redis.RedisHandler;
|
import project.syspara.SysparaService;
|
import project.user.UserDataService;
|
import project.wallet.Wallet;
|
import project.wallet.WalletExtend;
|
import project.wallet.WalletService;
|
|
public class MinerOrderProfitServiceImpl implements MinerOrderProfitService {
|
|
protected DataService dataService;
|
|
protected MinerService minerService;
|
|
protected PartyService partyService;
|
|
protected RedisHandler redisHandler;
|
|
protected WalletService walletService;
|
|
protected SysparaService sysparaService;
|
|
protected UserDataService userDataService;
|
|
protected MoneyLogService moneyLogService;
|
|
protected UserRecomService userRecomService;
|
|
protected MinerOrderService minerOrderService;
|
|
private static final Logger logger = LoggerFactory.getLogger(MinerOrderProfitServiceImpl.class);
|
|
/**
|
* 计算推荐人收益
|
*/
|
protected Map<String, Double> cacheRecomProfit = new ConcurrentHashMap<String, Double>();
|
|
/**
|
* 分页获取计息中的矿机订单
|
*/
|
public Page pagedQueryComputeOrder(int pageNo, int pageSize) {
|
if (pageNo <= 0) pageNo = 1;
|
Page page = new Page(pageNo, pageSize, Integer.MAX_VALUE);
|
List<MinerOrder> list=ApplicationUtil.executeSelect(MinerOrder.class,"WHERE STATE=1 LIMIT ?,?",new Object[] {page.getFirstElementNumber(),pageSize});
|
page.setElements(list);
|
return page;
|
}
|
|
/**
|
* 计算订单收益
|
*
|
* @param orders 订单列表
|
* @param miner_profit_symbol 指定币种
|
* @param realtime 币种行情
|
* @param miner_bonus_parameters 推荐人收益参数
|
*/
|
public void saveComputeOrderProfit(List<MinerOrder> orders, String miner_bonus_parameters, Date systemTime) {
|
logger.info("start compute order size:{}", orders.size());
|
List<MinerOrderMessage> saveMinerOrders = new ArrayList<MinerOrderMessage>();
|
for (MinerOrder order : orders) {
|
Miner miner = minerService.cacheById(order.getMinerId());
|
if (null == miner) {
|
logger.error("该矿机不存在，停止计息，minerId:" + order.getMinerId());
|
continue;
|
}
|
if (!miner.getTest() && systemTime.before(order.getEarn_time())) {
|
// 非体验矿机，今天<起息时间 不计息，表示满24小时才开始计息
|
continue;
|
}
|
|
// if (miner.getTest() && systemTime.before(DateUtils.getDayStart(order.getEarn_time()))) {
|
if (miner.getTest() && systemTime.before(order.getEarn_time())) {
|
// 体验矿机，今天<起息日 不计息
|
continue;
|
}
|
|
// 当前时间 > 截止时间
|
if (order.getStop_time() != null && systemTime.after(order.getStop_time())) {
|
// 正常赎回，停止计息，退还本金
|
order.setState("0");
|
order.setCompute_day(systemTime);
|
// 截止日 = 今天时就已经返还完毕
|
minerOrderService.saveClose(order, miner);
|
} else {
|
Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
|
double day_profit = 0;
|
if (miner.getTest()) {
|
day_profit = miner_test_profit;
|
} else {
|
day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
|
}
|
|
// 当天计算过，则不再计算，例如 1号4点计算， 则2号0点以前进入都判定计算过
|
if (order.getCompute_day() != null
|
&& systemTime.before(DateUtils.getDayStart(DateUtils.addDate(order.getCompute_day(), 1)))) {
|
// 已经计息过的直接进入缓存
|
handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);
|
continue;
|
}
|
order.setCompute_day(systemTime);// 记息日期
|
order.setProfit(Arith.add(order.getProfit(), day_profit));// 累计收益
|
|
updateProfitToWallet(day_profit, order, miner, systemTime);
|
|
saveMinerOrders.add(new MinerOrderMessage(order.getOrder_no(), order.getProfit(), order.getCompute_day()));
|
// 更新矿机订单
|
redisHandler.setSync(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);
|
}
|
}
|
logger.info("start miner batch update size:{}", saveMinerOrders.size());
|
updateBatchMinerOrdersProfit(saveMinerOrders);
|
}
|
|
/**
|
* 计算订单收益
|
*
|
* @param orders 订单列表
|
* @param miner_profit_symbol 指定币种
|
* @param realtime 币种行情
|
* @param miner_bonus_parameters 推荐人收益参数
|
*/
|
public void saveComputeOrderProfit(List<MinerOrder> orders, String miner_bonus_parameters) {
|
logger.info("start compute order size:{}", orders.size());
|
List<MinerOrderMessage> saveMinerOrders = new ArrayList<MinerOrderMessage>();
|
for (MinerOrder order : orders) {
|
Miner miner = minerService.cacheById(order.getMinerId());
|
if (null == miner) {
|
logger.error("该矿机不存在，停止计息，minerId:" + order.getMinerId());
|
continue;
|
}
|
if (!miner.getTest() && new Date().before(order.getEarn_time())) {
|
// 非体验矿机，今天<起息时间 不计息，表示满24小时才开始计息
|
continue;
|
}
|
|
if (miner.getTest() && new Date().before(order.getEarn_time())) {
|
// if (miner.getTest() && 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, miner);
|
} else {
|
Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
|
// 当日获取的收益
|
double day_profit = 0;
|
if (miner.getTest()) {
|
day_profit = miner_test_profit;
|
} else {
|
day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
|
}
|
|
// 当天计算过，则不再计算，例如 1号4点计算， 则2号0点以前进入都判定计算过
|
if (order.getCompute_day() != null
|
&& new Date().before(DateUtils.getDayStart(DateUtils.addDate(order.getCompute_day(), 1)))) {
|
|
// 已经计息过的直接进入缓存
|
handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);
|
continue;
|
}
|
// 记息日期
|
order.setCompute_day(new Date());
|
// 累计收益
|
order.setProfit(Arith.add(order.getProfit(), day_profit));
|
/**
|
* 矿机产出是否需要转化成某个币种,若为空则不转化，若写入的symbol代码不存在则也不转化
|
*/
|
updateProfitToWallet(day_profit, order, miner);
|
|
saveMinerOrders
|
.add(new MinerOrderMessage(order.getOrder_no(), order.getProfit(), order.getCompute_day()));
|
// 更新矿机订单
|
redisHandler.setSync(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);
|
}
|
}
|
logger.info("start miner batch update size:{}", saveMinerOrders.size());
|
updateBatchMinerOrdersProfit(saveMinerOrders);
|
}
|
|
/**
|
* 更新收益到钱包
|
*
|
* @param miner_profit_symbol 指定币种
|
* @param day_profit 当日收益
|
* @param realtime 币种行情
|
* @param order 矿机订单
|
*/
|
protected void updateProfitToWallet(double dayProfit, MinerOrder order, Miner miner) {
|
// 矿机购买时使用的币种，则产生对应的币种，转换成u
|
String buyCurrency = miner.getBuyCurrency();
|
String outputCurrency = miner.getOutputCurrency();
|
|
// // U购买 产出U
|
// if ("usdt".equals(buyCurrency) && "usdt".equals(outputCurrency)) {
|
// symbolProfit = symbolProfit;
|
// }
|
|
// U购买 产出第三方币
|
if ("usdt".equals(buyCurrency) && !"usdt".equals(outputCurrency)) {
|
List<Realtime> realtimes = this.dataService.realtime(outputCurrency);
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.div(dayProfit, realtimes.get(0).getClose());
|
}
|
|
// 第三方币购买 产出U
|
if (!"usdt".equals(buyCurrency) && "usdt".equals(outputCurrency)) {
|
List<Realtime> realtimes = this.dataService.realtime(buyCurrency);
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.mul(dayProfit, realtimes.get(0).getClose());
|
}
|
|
// 第三方币购买 产出第三方币
|
if (!"usdt".equals(buyCurrency) && !"usdt".equals(outputCurrency)) {
|
// A购买 产出B
|
if (!buyCurrency.equals(outputCurrency)) {
|
List<Realtime> realtimes = this.dataService.realtime(buyCurrency);
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.mul(dayProfit, realtimes.get(0).getClose());
|
|
List<Realtime> realtimeList = this.dataService.realtime(outputCurrency);
|
if (null == realtimeList || realtimeList.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.div(dayProfit, realtimeList.get(0).getClose());
|
}
|
}
|
|
// 收益为USDT
|
if ("usdt".equals(outputCurrency)) {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amount_before = wallet.getMoney();
|
this.walletService.update(wallet.getPartyId().toString(), dayProfit);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmount_before(amount_before);
|
moneylog.setAmount(dayProfit);
|
moneylog.setAmount_after(Arith.add(wallet.getMoney(), dayProfit));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setPartyId(order.getPartyId());
|
moneylog.setWallettype(Constants.WALLET);
|
moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(new Date());
|
moneyLogService.save(moneylog);
|
}
|
// 非USDT币种收益
|
else {
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), outputCurrency);
|
double amount_before = walletExtend.getAmount();
|
this.walletService.updateExtend(order.getPartyId().toString(), outputCurrency, dayProfit);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmount_before(amount_before);
|
moneylog.setAmount(dayProfit);
|
moneylog.setAmount_after(Arith.add(walletExtend.getAmount(), dayProfit));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setPartyId(order.getPartyId());
|
moneylog.setWallettype(outputCurrency);
|
moneylog.setContent_type(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(double dayProfit, MinerOrder order, Miner miner, Date systemTime) {
|
// 矿机购买时使用的币种，则产生对应的币种，转换成u
|
String buyCurrency = miner.getBuyCurrency();
|
String outputCurrency = miner.getOutputCurrency();
|
|
// // U购买 产出U
|
// if ("usdt".equals(buyCurrency) && "usdt".equals(outputCurrency)) {
|
// symbolProfit = symbolProfit;
|
// }
|
|
// U购买 产出第三方币
|
if ("usdt".equals(buyCurrency) && !"usdt".equals(outputCurrency)) {
|
List<Realtime> realtimes = this.dataService.realtime(outputCurrency);
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.div(dayProfit, realtimes.get(0).getClose());
|
}
|
|
// 第三方币购买 产出U
|
if (!"usdt".equals(buyCurrency) && "usdt".equals(outputCurrency)) {
|
List<Realtime> realtimes = this.dataService.realtime(buyCurrency);
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.mul(dayProfit, realtimes.get(0).getClose());
|
}
|
|
// 第三方币购买 产出第三方币
|
if (!"usdt".equals(buyCurrency) && !"usdt".equals(outputCurrency)) {
|
// // A购买 产出A
|
// if (buyCurrency.equals(outputCurrency)) {
|
// symbolProfit = symbolProfit;
|
// }
|
// A购买 产出B
|
if (!buyCurrency.equals(outputCurrency)) {
|
List<Realtime> realtimes = this.dataService.realtime(buyCurrency);
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.mul(dayProfit, realtimes.get(0).getClose());
|
|
List<Realtime> realtimeList = this.dataService.realtime(outputCurrency);
|
if (null == realtimeList || realtimeList.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
dayProfit = Arith.div(dayProfit, realtimeList.get(0).getClose());
|
}
|
}
|
|
// 收益为USDT
|
if ("usdt".equals(outputCurrency)) {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amount_before = wallet.getMoney();
|
this.walletService.update(wallet.getPartyId().toString(), dayProfit);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmount_before(amount_before);
|
moneylog.setAmount(dayProfit);
|
moneylog.setAmount_after(Arith.add(wallet.getMoney(), dayProfit));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setPartyId(order.getPartyId());
|
moneylog.setWallettype(Constants.WALLET);
|
moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(systemTime);
|
moneyLogService.save(moneylog);
|
}
|
// 非USDT币种收益
|
else {
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), outputCurrency);
|
double amount_before = walletExtend.getAmount();
|
this.walletService.updateExtend(order.getPartyId().toString(), outputCurrency, dayProfit);
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneylog.setAmount_before(amount_before);
|
moneylog.setAmount(dayProfit);
|
moneylog.setAmount_after(Arith.add(walletExtend.getAmount(), dayProfit));
|
moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
moneylog.setPartyId(order.getPartyId());
|
moneylog.setWallettype(outputCurrency);
|
moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
moneylog.setCreateTime(systemTime);
|
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) {
|
// // 矿机购买时使用的币种，则产生对应的币种，转换成u
|
// String miner_buy_symbol = sysparaService.find("miner_buy_symbol").getValue();
|
// if (StringUtils.isNotEmpty(miner_buy_symbol)) {
|
// if (miner_buy_symbol.equals(miner_profit_symbol)) {// 两个相同，则行情直接可用，转化为U
|
// 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());
|
// }
|
// }
|
// if (StringUtils.isNotEmpty(miner_profit_symbol)) {
|
// /**
|
// * 非Usdt币种收益
|
// */
|
//
|
// double get_symbol_volume = Arith.div(day_profit, realtime.getClose());
|
//
|
// WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), miner_profit_symbol);
|
// double amount_before = walletExtend.getAmount();
|
//// walletExtend.setAmount(Arith.add(walletExtend.getAmount(), get_symbol_volume));
|
// this.walletService.updateExtend(order.getPartyId().toString(), miner_profit_symbol, get_symbol_volume);
|
// /*
|
// * 保存资金日志
|
// */
|
// MoneyLog moneylog = new MoneyLog();
|
// moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
// moneylog.setAmount_before(amount_before);
|
// moneylog.setAmount(get_symbol_volume);
|
// moneylog.setAmount_after(Arith.add(walletExtend.getAmount(), get_symbol_volume));
|
// moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
// moneylog.setPartyId(order.getPartyId());
|
// moneylog.setWallettype(realtime.getSymbol());
|
// moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
// moneylog.setCreateTime(new Date());
|
// moneyLogService.save(moneylog);
|
// } else {
|
// /**
|
// * 此为收益为usdt
|
// */
|
// Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
// double amount_before = wallet.getMoney();
|
//// wallet.setMoney(Arith.add(wallet.getMoney(), day_profit));
|
// this.walletService.update(wallet.getPartyId().toString(), day_profit);
|
// /**
|
// * 保存资金日志
|
// */
|
// MoneyLog moneylog = new MoneyLog();
|
// moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
// moneylog.setAmount_before(amount_before);
|
// moneylog.setAmount(day_profit);
|
// moneylog.setAmount_after(Arith.add(wallet.getMoney(), day_profit));
|
// moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
// moneylog.setPartyId(order.getPartyId());
|
// moneylog.setWallettype(Constants.WALLET);
|
// moneylog.setContent_type(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").getValue();
|
// if (StringUtils.isNotEmpty(miner_buy_symbol)) {
|
// if (miner_buy_symbol.equals(miner_profit_symbol)) {// 两个相同，则行情直接可用，转化为U
|
// 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());
|
// }
|
// }
|
// if (StringUtils.isNotEmpty(miner_profit_symbol)) {
|
// /**
|
// * 非Usdt币种收益
|
// */
|
// double get_symbol_volume = Arith.div(day_profit, realtime.getClose());
|
//
|
// WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), miner_profit_symbol);
|
// double amount_before = walletExtend.getAmount();
|
//// walletExtend.setAmount(Arith.add(walletExtend.getAmount(), get_symbol_volume));
|
// this.walletService.updateExtend(order.getPartyId().toString(), miner_profit_symbol, get_symbol_volume);
|
// /*
|
// * 保存资金日志
|
// */
|
// MoneyLog moneylog = new MoneyLog();
|
// moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
// moneylog.setAmount_before(amount_before);
|
// moneylog.setAmount(get_symbol_volume);
|
// moneylog.setAmount_after(Arith.add(walletExtend.getAmount(), get_symbol_volume));
|
// moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
// moneylog.setPartyId(order.getPartyId());
|
// moneylog.setWallettype(realtime.getSymbol());
|
// moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
|
// moneylog.setCreateTime(systemTime);
|
// moneyLogService.save(moneylog);
|
// } else {
|
// /**
|
// * 此为收益为usdt
|
// */
|
// Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
// double amount_before = wallet.getMoney();
|
//// wallet.setMoney(Arith.add(wallet.getMoney(), day_profit));
|
// this.walletService.update(wallet.getPartyId().toString(), day_profit);
|
// /**
|
// * 保存资金日志
|
// */
|
// MoneyLog moneylog = new MoneyLog();
|
// moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
// moneylog.setAmount_before(amount_before);
|
// moneylog.setAmount(day_profit);
|
// moneylog.setAmount_after(Arith.add(wallet.getMoney(), day_profit));
|
// moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
|
// moneylog.setPartyId(order.getPartyId());
|
// moneylog.setWallettype(Constants.WALLET);
|
// moneylog.setContent_type(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 = ApplicationUtil.getBean(JdbcTemplate.class).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();
|
}
|
});
|
|
logger.info("end miner batch update attr:{}", batchUpdate);
|
}
|
|
public void handleRecomProfit(String partyId, double profit, Miner miner, String miner_bonus_parameters) {
|
if (miner.getTest()) {
|
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;
|
}
|
Party party_parent = this.partyService.cachePartyBy(list_parents.get(i).getReco_id(), true);
|
if (!Constants.SECURITY_ROLE_MEMBER.equals(party_parent.getRolename())) {
|
continue;
|
}
|
loop++;
|
Map<String, MinerOrder> map_party = (Map<String, MinerOrder>) redisHandler.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + party_parent.getId().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.getMinerId());
|
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.getId().toString());
|
cacheRecomProfit.put(party_parent.getId().toString(),
|
Arith.add(recom_profit == null ? 0D : recom_profit, get_money));
|
|
}
|
|
}
|
|
}
|
|
/**
|
* 最终收益持久化数据库
|
*/
|
public void saveRecomProfit() {
|
if (cacheRecomProfit.isEmpty())
|
return;
|
|
// 开始增加推荐人收益
|
logger.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 amount_before = wallet.getMoney();
|
// wallet.setMoney(Arith.add(wallet.getMoney(), entry.getValue()));
|
walletService.update(wallet.getPartyId().toString(), entry.getValue());
|
|
/**
|
* 保存资金日志
|
*/
|
MoneyLog moneyLog = new MoneyLog();
|
moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneyLog.setAmount_before(amount_before);
|
moneyLog.setAmount(entry.getValue());
|
moneyLog.setAmount_after(Arith.add(wallet.getMoney(), entry.getValue()));
|
moneyLog.setLog("矿机推荐奖励金");
|
moneyLog.setPartyId(entry.getKey());
|
moneyLog.setWallettype(Constants.WALLET);
|
moneyLog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
|
moneyLogService.save(moneyLog);
|
userDataService.saveMinerProfit(entry.getKey(), entry.getValue());
|
}
|
// 推荐人矿机收益计算完成，纪录日志
|
logger.info("finish ------recom user miner profit,date:{},count:{}",
|
new Object[] { new Date(), cacheRecomProfit.size() });
|
// 处理完后收益清空
|
|
}
|
|
/**
|
* 最终收益持久化数据库
|
*/
|
public void saveRecomProfit(Date systemTime) {
|
if (cacheRecomProfit.isEmpty())
|
return;
|
|
// 开始增加推荐人收益
|
logger.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 amount_before = wallet.getMoney();
|
// wallet.setMoney(Arith.add(wallet.getMoney(), entry.getValue()));
|
walletService.update(wallet.getPartyId().toString(), entry.getValue());
|
|
/**
|
* 保存资金日志
|
*/
|
MoneyLog moneyLog = new MoneyLog();
|
moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
|
moneyLog.setAmount_before(amount_before);
|
moneyLog.setAmount(entry.getValue());
|
moneyLog.setAmount_after(Arith.add(wallet.getMoney(), entry.getValue()));
|
moneyLog.setLog("矿机推荐奖励金");
|
moneyLog.setPartyId(entry.getKey());
|
moneyLog.setWallettype(Constants.WALLET);
|
moneyLog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
|
moneyLog.setCreateTime(systemTime);
|
moneyLogService.save(moneyLog);
|
userDataService.saveMinerProfit(entry.getKey(), entry.getValue());
|
}
|
// 推荐人矿机收益计算完成，纪录日志
|
logger.info("finish ------recom user miner profit,date:{},count:{}",
|
new Object[] { new Date(), cacheRecomProfit.size() });
|
// 处理完后收益清空
|
|
}
|
|
public void cacheRecomProfitClear() {
|
cacheRecomProfit.clear();
|
}
|
|
public void setMinerService(MinerService minerService) {
|
this.minerService = minerService;
|
}
|
|
public void setPartyService(PartyService partyService) {
|
this.partyService = partyService;
|
}
|
|
public void setUserRecomService(UserRecomService userRecomService) {
|
this.userRecomService = userRecomService;
|
}
|
|
public void setRedisHandler(RedisHandler redisHandler) {
|
this.redisHandler = redisHandler;
|
}
|
|
public void setUserDataService(UserDataService userDataService) {
|
this.userDataService = userDataService;
|
}
|
|
public void setMoneyLogService(MoneyLogService moneyLogService) {
|
this.moneyLogService = moneyLogService;
|
}
|
|
public void setMinerOrderService(MinerOrderService minerOrderService) {
|
this.minerOrderService = minerOrderService;
|
}
|
|
public void setWalletService(WalletService walletService) {
|
this.walletService = walletService;
|
}
|
|
public void setSysparaService(SysparaService sysparaService) {
|
this.sysparaService = sysparaService;
|
}
|
|
public void setDataService(DataService dataService) {
|
this.dataService = dataService;
|
}
|
}
|
