package com.yami.trading.service.exchange.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.yami.trading.bean.data.domain.Kline;
|
import com.yami.trading.bean.data.domain.Realtime;
|
import com.yami.trading.bean.exchange.ExchangeApplyOrder;
|
import com.yami.trading.bean.exchange.dto.ExchangeApplyOrderDto;
|
import com.yami.trading.bean.exchange.dto.ExchangeSymbolDto;
|
import com.yami.trading.bean.exchange.dto.TodayTransactionDto;
|
import com.yami.trading.bean.item.domain.Item;
|
import com.yami.trading.bean.model.MoneyLog;
|
import com.yami.trading.bean.model.Wallet;
|
import com.yami.trading.bean.model.WalletExtend;
|
import com.yami.trading.bean.purchasing.dto.ExchangeRecord;
|
import com.yami.trading.common.constants.Constants;
|
import com.yami.trading.common.exception.YamiShopBindException;
|
import com.yami.trading.common.util.Arith;
|
import com.yami.trading.common.util.DateTimeTools;
|
import com.yami.trading.common.util.DateUtil;
|
import com.yami.trading.common.util.RandomUtil;
|
import com.yami.trading.common.util.StringUtils;
|
import com.yami.trading.common.util.UTCDateUtils;
|
import com.yami.trading.dao.exchange.ExchangeApplyOrderMapper;
|
import com.yami.trading.service.MarketOpenChecker;
|
import com.yami.trading.service.MoneyLogService;
|
import com.yami.trading.service.WalletService;
|
import com.yami.trading.service.data.DataService;
|
import com.yami.trading.service.exchange.ExchangeApplyOrderService;
|
import com.yami.trading.service.item.ItemService;
|
import com.yami.trading.service.rate.ExchangeRateService;
|
import com.yami.trading.service.syspara.SysparaService;
|
import com.yami.trading.service.user.UserDataService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.ZoneId;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
@Service
|
@Slf4j
|
public class ExchangeApplyOrderServiceImpl extends ServiceImpl<ExchangeApplyOrderMapper, ExchangeApplyOrder> implements ExchangeApplyOrderService {
|
@Autowired
|
SysparaService sysparaService;
|
@Autowired
|
ItemService itemService;
|
@Autowired
|
DataService dataService;
|
@Autowired
|
WalletService walletService;
|
@Autowired
|
MoneyLogService moneyLogService;
|
@Autowired
|
UserDataService userDataService;
|
@Resource
|
ExchangeApplyOrderMapper exchangeApplyOrderMapper;
|
@Autowired
|
private ExchangeRateService exchangeRateService;
|
|
@Override
|
public List<ExchangeApplyOrder> findSubmitted() {
|
return list(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_SUBMITTED));
|
}
|
|
@Override
|
@Transactional
|
public void saveSpotTradOpenCreated(ExchangeApplyOrder order, Double orderPrice) {
|
// 针对限价部分成交做特殊处理
|
double realValue = order.getSymbolValue();
|
if (order.getSuccessVolume() != 0) {
|
realValue = order.getSuccessVolume();
|
// 退回部分下单金额
|
double returnValue = order.getSymbolValue() - order.getSuccessVolume();
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amountBefore = wallet.getMoney().doubleValue();
|
BigDecimal returnAmount = BigDecimal.valueOf(returnValue).multiply(BigDecimal.valueOf(order.getPrice()))
|
.setScale(2, RoundingMode.HALF_DOWN);
|
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
returnAmount = exchangeRateService.getUsdtByType(returnAmount, type);
|
walletService.update(wallet.getUserId(), returnAmount.doubleValue());
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amountBefore));
|
log.setAmount(returnAmount);
|
log.setAmountAfter(BigDecimal.valueOf(amountBefore).add(returnAmount));
|
log.setLog(name + type2 + "买入订单限价成交，回退金额。订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setSymbol(order.getSymbol());
|
log.setWalletType(order.getSymbol());
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_CANCEL);
|
moneyLogService.save(log);
|
}
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amountBeforeExtend = walletExtend.getAmount();
|
this.walletService.updateExtend(walletExtend.getPartyId(), walletExtend.getWallettype(), realValue);
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amountBeforeExtend));
|
log.setAmount(BigDecimal.valueOf(realValue));
|
log.setAmountAfter(BigDecimal.valueOf(amountBeforeExtend + realValue));
|
log.setLog(name + type2 + "现货交易买入委托单成交，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setSymbol(order.getSymbol());
|
log.setWalletType(order.getSymbol());
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_OPEN);
|
// 记录账变日志
|
moneyLogService.save(log);
|
order.setCloseTime(new Date());
|
// 竞价单的要求按照前端给的价格成交
|
order.setClosePrice(order.getOrderNo().length() == 21 ? order.getPrice() : orderPrice);
|
order.setState(ExchangeApplyOrder.STATE_CREATED);
|
order.setAmount(order.getVolume());
|
order.setWalletFee(order.getFee());
|
// 更新订单信息
|
updateById(order);
|
}
|
|
@Override
|
@Transactional
|
public void saveSpotTradCloseCreated(ExchangeApplyOrder order, Double orderPrice) {
|
// 针对限价部分成交做特殊处理
|
double realValue = order.getVolume();
|
if (order.getSuccessVolume() != 0) {
|
realValue = order.getSuccessVolume();
|
// 退回部分下单金额
|
double returnValue = order.getSymbolValue() - order.getSuccessVolume();
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amountBeforeExtend = walletExtend.getAmount();
|
walletService.updateExtend(walletExtend.getPartyId(), walletExtend.getWallettype(), returnValue);
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amountBeforeExtend));
|
log.setAmount(BigDecimal.valueOf(returnValue));
|
log.setAmountAfter(BigDecimal.valueOf(amountBeforeExtend + returnValue));
|
log.setLog(name + type2 + "卖出订单限价成交，回退数量。订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setSymbol(order.getSymbol());
|
log.setWalletType(order.getSymbol());
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_CANCEL);
|
moneyLogService.save(log);
|
}
|
double sub = Arith.sub(realValue, order.getFee());
|
double amount = Arith.mul(sub, orderPrice);
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amountBefore = wallet.getMoney().doubleValue();
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
amount = exchangeRateService.getUsdtByType(BigDecimal.valueOf(amount), type).doubleValue();
|
this.walletService.update(wallet.getUserId(), amount);
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amountBefore));
|
log.setAmount(new BigDecimal(amount));
|
log.setAmountAfter(wallet.getMoney().add(BigDecimal.valueOf(amount)));
|
log.setLog(name + type2 + "现货交易卖出委托单成交，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setWalletType(Constants.WALLET);
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_CLOSE);
|
log.setSymbol(order.getSymbol());
|
moneyLogService.save(log);
|
order.setCloseTime(new Date());
|
order.setClosePrice(orderPrice);
|
order.setWalletFee(Arith.mul(order.getFee(), orderPrice));
|
order.setState(ExchangeApplyOrder.STATE_CREATED);
|
updateById(order);
|
}
|
|
@Override
|
public ExchangeApplyOrder findByOrderNo(String orderNo) {
|
return getOne(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getOrderNo, orderNo));
|
}
|
|
@Override
|
public List<ExchangeSymbolDto> querySpotTradPositionList(String userId, String type) {
|
List<String> symbols = itemService.findByType(type).stream().map(Item::getSymbol).collect(Collectors.toList());
|
symbols.add("-1");
|
LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
|
lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, symbols);
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
|
lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
|
List<ExchangeApplyOrder> list = list(lambdaQueryWrapper);
|
return getDataList(list);
|
}
|
|
@Override
|
public List<ExchangeSymbolDto> querySpotTradPositionList(String userId) {
|
LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
|
lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
|
List<ExchangeApplyOrder> list = list(lambdaQueryWrapper);
|
return getSettleList(list);
|
}
|
|
@Override
|
public List<ExchangeSymbolDto> querySpotTradPosition(String userId, String symbol) {
|
LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getSymbol, symbol);
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
|
lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
|
List<ExchangeApplyOrder> list = list(lambdaQueryWrapper);
|
return getDataList(list);
|
}
|
|
public List<ExchangeSymbolDto> getSettleList(List<ExchangeApplyOrder> dbList) {
|
List<ExchangeSymbolDto> result = new ArrayList<>();
|
Map<String, List<ExchangeSymbolDto>> map = new HashMap<>();
|
for (ExchangeApplyOrder order : dbList) {
|
List<ExchangeSymbolDto> exchangeSymbolDtos = map.get(order.getSymbol());
|
if (exchangeSymbolDtos == null) {
|
exchangeSymbolDtos = new ArrayList<>();
|
}
|
// List<Realtime> symbolList = dataService.realtime(order.getSymbol());
|
// if (!CollectionUtil.isEmpty(symbolList)) {
|
// Realtime realtime = symbolList.get(0);
|
ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
exchangeSymbolDto.setVolume(order.getSuccessVolume() != 0 ? order.getSuccessVolume() : order.getSymbolValue());
|
// exchangeSymbolDto.setName(realtime.getName());
|
exchangeSymbolDto.setOpenPrice(order.getPrice());
|
// exchangeSymbolDto.setCurrentPrice(realtime.getClose());
|
exchangeSymbolDto.setPrice(order.getClosePrice());
|
exchangeSymbolDto.setOffset(order.getOffset());
|
exchangeSymbolDto.setState(order.getState());
|
exchangeSymbolDto.setCloseTimeTs(order.getCreateTimeTs());
|
exchangeSymbolDtos.add(exchangeSymbolDto);
|
map.put(order.getSymbol(), exchangeSymbolDtos);
|
// }
|
}
|
for (String key : map.keySet()) {
|
List<ExchangeSymbolDto> list = map.get(key);
|
Item item = itemService.findBySymbol(key);
|
double volume = 0; //可用
|
double costValue = 0.0;//总价值
|
double marketValue = 0; //市值
|
double currentPrice = 0; //当前价格
|
double profitLoss = 0; //浮盈
|
double toDayProfitLoss = 0; //今日盈亏(浮动)
|
double todayProfit = 0; //今日盈亏(结算)
|
double profitTotal = 0; //累计盈亏
|
double openPrice = 0;//开仓价格
|
String name = "";
|
BigDecimal price = BigDecimal.ZERO;//成本价
|
List<ExchangeSymbolDto> sort = list.stream().sorted(Comparator.comparing(ExchangeSymbolDto::getCloseTimeTs)).collect(Collectors.toList());
|
for (ExchangeSymbolDto dto : sort) {
|
name = dto.getName();
|
currentPrice = dto.getCurrentPrice();
|
openPrice = dto.getPrice();
|
//成本价值
|
double cost = dto.getVolume() * dto.getPrice();
|
|
if (dto.getOffset().equals(ExchangeApplyOrder.OFFSET_CLOSE)) {
|
volume -= dto.getVolume();
|
|
if (ExchangeApplyOrder.STATE_CREATED.equalsIgnoreCase(dto.getState())) {
|
profitTotal += dto.getVolume() * (dto.getPrice() - price.doubleValue());
|
if (dto.getCloseTimeTs() != null && UTCDateUtils.isTimestampFromToday(dto.getCloseTimeTs(), ZoneId.systemDefault())) {
|
todayProfit += dto.getVolume() * (dto.getPrice() - price.doubleValue());
|
}
|
costValue -= (dto.getVolume() * dto.getPrice());
|
marketValue -= (dto.getCurrentPrice() * dto.getVolume());
|
}
|
if (volume == 0) {
|
price = BigDecimal.ZERO;
|
}
|
} else {
|
volume += dto.getVolume();
|
if (volume != 0) {
|
price = price.multiply(BigDecimal.valueOf(volume - dto.getVolume()));
|
price = price.add(BigDecimal.valueOf(cost));
|
price = price.divide(BigDecimal.valueOf(volume), item.getDecimals(), RoundingMode.FLOOR);
|
} else {
|
price = BigDecimal.ZERO;
|
}
|
costValue += (dto.getVolume() * dto.getPrice());
|
marketValue += (dto.getCurrentPrice() * dto.getVolume());
|
//当日浮动盈亏
|
List<Kline> kline = dataService.kline(key, Kline.PERIOD_1DAY);
|
kline = kline.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
|
double diff = 0.0;
|
if (CollectionUtil.isNotEmpty(kline)) {
|
Kline day = kline.get(0);
|
Long ts = day.getTs() / 1000;
|
Long timeTs = dto.getCloseTimeTs();
|
if (timeTs > ts) {
|
diff = currentPrice - openPrice;
|
} else {
|
diff = currentPrice - day.getClose();
|
}
|
}
|
toDayProfitLoss += diff * dto.getVolume();
|
}
|
}
|
//总浮动盈亏
|
profitLoss = marketValue - costValue;
|
ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
exchangeSymbolDto.setVolume(new BigDecimal(volume).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setPositionVolume(new BigDecimal(volume).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setPrice(price.setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setName(name);
|
exchangeSymbolDto.setSymbol(key);
|
exchangeSymbolDto.setToDayProfitLoss(new BigDecimal(toDayProfitLoss).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setToDayProfitLossPercentage(calculateProfitPercentage(openPrice, currentPrice));
|
exchangeSymbolDto.setCurrentPrice(new BigDecimal(currentPrice).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setOpenPrice(new BigDecimal(openPrice).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setMarketValue(new BigDecimal(marketValue).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setProfitLoss(new BigDecimal(profitLoss).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setProfitLossPercentage(calculateProfitPercentage(price.doubleValue(), currentPrice));
|
exchangeSymbolDto.setProfitTotal(new BigDecimal(profitTotal).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setTodayProfit(todayProfit);
|
result.add(exchangeSymbolDto);
|
}
|
return result;
|
}
|
|
public List<ExchangeSymbolDto> getDataList(List<ExchangeApplyOrder> dbList) {
|
List<ExchangeSymbolDto> result = new ArrayList<>();
|
Map<String, List<ExchangeSymbolDto>> map = new HashMap<>();
|
for (ExchangeApplyOrder order : dbList) {
|
List<ExchangeSymbolDto> exchangeSymbolDtos = map.get(order.getSymbol());
|
if (exchangeSymbolDtos == null) {
|
exchangeSymbolDtos = new ArrayList<>();
|
}
|
List<Realtime> symbolList = dataService.realtime(order.getSymbol());
|
if (!CollectionUtil.isEmpty(symbolList)) {
|
Realtime realtime = symbolList.get(0);
|
ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
exchangeSymbolDto.setVolume(order.getSuccessVolume() != 0 ? order.getSuccessVolume() : order.getSymbolValue());
|
exchangeSymbolDto.setName(realtime.getName());
|
exchangeSymbolDto.setOpenPrice(order.getPrice());
|
exchangeSymbolDto.setCurrentPrice(realtime.getClose());
|
exchangeSymbolDto.setPrice(order.getClosePrice());
|
exchangeSymbolDto.setOffset(order.getOffset());
|
exchangeSymbolDto.setState(order.getState());
|
exchangeSymbolDto.setCloseTimeTs(order.getCreateTimeTs());
|
exchangeSymbolDtos.add(exchangeSymbolDto);
|
map.put(order.getSymbol(), exchangeSymbolDtos);
|
}
|
}
|
for (String key : map.keySet()) {
|
List<ExchangeSymbolDto> list = map.get(key);
|
Item item = itemService.findBySymbol(key);
|
double volume = 0; //可用
|
double costValue = 0.0;//总价值
|
double marketValue = 0; //市值
|
double currentPrice = 0; //当前价格
|
double profitLoss = 0; //浮盈
|
double toDayProfitLoss = 0; //今日盈亏(浮动)
|
double todayProfit = 0; //今日盈亏(结算)
|
double profitTotal = 0; //累计盈亏
|
double openPrice = 0;//开仓价格
|
String name = "";
|
BigDecimal price = BigDecimal.ZERO;//成本价
|
List<ExchangeSymbolDto> sort = list.stream().sorted(Comparator.comparing(ExchangeSymbolDto::getCloseTimeTs)).collect(Collectors.toList());
|
for (ExchangeSymbolDto dto : sort) {
|
name = dto.getName();
|
currentPrice = dto.getCurrentPrice();
|
openPrice = dto.getPrice();
|
//成本价值
|
double cost = dto.getVolume() * dto.getPrice();
|
|
if (dto.getOffset().equals(ExchangeApplyOrder.OFFSET_CLOSE)) {
|
volume -= dto.getVolume();
|
|
if (ExchangeApplyOrder.STATE_CREATED.equalsIgnoreCase(dto.getState())) {
|
profitTotal += dto.getVolume() * (dto.getPrice() - price.doubleValue());
|
if (dto.getCloseTimeTs() != null && UTCDateUtils.isTimestampFromToday(dto.getCloseTimeTs(), ZoneId.systemDefault())) {
|
todayProfit += dto.getVolume() * (dto.getPrice() - price.doubleValue());
|
}
|
costValue -= (dto.getVolume() * dto.getPrice());
|
marketValue -= (dto.getCurrentPrice() * dto.getVolume());
|
}
|
if (volume == 0) {
|
price = BigDecimal.ZERO;
|
}
|
} else {
|
volume += dto.getVolume();
|
if (volume != 0) {
|
price = price.multiply(BigDecimal.valueOf(volume - dto.getVolume()));
|
price = price.add(BigDecimal.valueOf(cost));
|
price = price.divide(BigDecimal.valueOf(volume), item.getDecimals(), RoundingMode.FLOOR);
|
} else {
|
price = BigDecimal.ZERO;
|
}
|
costValue += (dto.getVolume() * dto.getPrice());
|
marketValue += (dto.getCurrentPrice() * dto.getVolume());
|
//当日浮动盈亏
|
List<Kline> kline = dataService.kline(key, Kline.PERIOD_1DAY);
|
kline = kline.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
|
double diff = 0.0;
|
if (CollectionUtil.isNotEmpty(kline)) {
|
Kline day = kline.get(0);
|
Long ts = day.getTs() / 1000;
|
Long timeTs = dto.getCloseTimeTs();
|
if (timeTs > ts) {
|
diff = currentPrice - openPrice;
|
} else {
|
diff = currentPrice - day.getClose();
|
}
|
}
|
toDayProfitLoss += diff * dto.getVolume();
|
}
|
}
|
if (volume > 0) {
|
//总浮动盈亏
|
profitLoss = marketValue - costValue;
|
ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
exchangeSymbolDto.setVolume(new BigDecimal(volume).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setPositionVolume(new BigDecimal(volume).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setPrice(price.setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setName(name);
|
exchangeSymbolDto.setSymbol(key);
|
exchangeSymbolDto.setToDayProfitLoss(new BigDecimal(toDayProfitLoss).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setToDayProfitLossPercentage(calculateProfitPercentage(openPrice, currentPrice));
|
exchangeSymbolDto.setCurrentPrice(new BigDecimal(currentPrice).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setOpenPrice(new BigDecimal(openPrice).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setMarketValue(new BigDecimal(marketValue).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setProfitLoss(new BigDecimal(profitLoss).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setProfitLossPercentage(calculateProfitPercentage(price.doubleValue(), currentPrice));
|
exchangeSymbolDto.setProfitTotal(new BigDecimal(profitTotal).setScale(4, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setTodayProfit(todayProfit);
|
result.add(exchangeSymbolDto);
|
}
|
}
|
return result;
|
}
|
|
public static double calculateProfitPercentage(double buyPrice, double currentPrice) {
|
if (buyPrice == 0D) {
|
log.error("计算收益率数据异常{}", buyPrice);
|
return 0D;
|
}
|
double profit = currentPrice - buyPrice;
|
double profitPercentage = (profit / buyPrice) * 100;
|
return new BigDecimal(profitPercentage).setScale(2, RoundingMode.HALF_UP).doubleValue();
|
}
|
|
@Override
|
public void saveCancel(String partyId, String orderNo) {
|
ExchangeApplyOrder order = findByOrderNo(orderNo);
|
if (order == null || !"submitted".equals(order.getState()) || !partyId.equals(order.getPartyId())) {
|
return;
|
}
|
String symbol = order.getSymbol();
|
Item item = itemService.findBySymbol(symbol);
|
String itemType = item.getType();
|
if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amountBefore = wallet.getMoney().doubleValue();
|
double realAmount = order.getVolume() + order.getFee();
|
realAmount = exchangeRateService.getUsdtByType(BigDecimal.valueOf(realAmount), itemType).doubleValue();
|
walletService.update(wallet.getUserId(), realAmount);
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
moneylog.setAmountBefore(new BigDecimal(amountBefore));
|
moneylog.setAmount(BigDecimal.valueOf(realAmount));
|
moneylog.setAmountAfter(wallet.getMoney());
|
moneylog.setLog(name + type2 + "现货交易买入撤单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(Constants.WALLET);
|
moneylog.setContentType(type2 + Constants.MONEYLOG_CONTENT_CANCEL);
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setCreateTime(new Date());
|
moneylog.setUpdateTime(new Date());
|
moneyLogService.save(moneylog);
|
} else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amountBefore = walletExtend.getAmount();
|
walletService.updateExtend(walletExtend.getPartyId(), walletExtend.getWallettype(), order.getVolume());
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
moneylog.setAmountBefore(new BigDecimal(amountBefore));
|
moneylog.setAmount(BigDecimal.valueOf(order.getVolume()));
|
moneylog.setAmountAfter(BigDecimal.valueOf(Arith.add(walletExtend.getAmount(), order.getVolume())));
|
moneylog.setLog(name + type2 + "现货交易卖出撤单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(order.getSymbol());
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(type2 + Constants.MONEYLOG_CONTENT_CANCEL);
|
moneylog.setCreateTime(new Date());
|
moneylog.setUpdateTime(new Date());
|
moneyLogService.save(moneylog);
|
}
|
order.setState(ExchangeApplyOrder.STATE_CANCELED);
|
updateById(order);
|
}
|
|
@Override
|
public Page<ExchangeApplyOrderDto> listPage(Page page, String rolename, String userName, String orderNo, String state,
|
String offset, String symbolType, String userCode, String symbol, String usernameParent, List<String> userIds) {
|
return baseMapper.listPage(page, rolename, userName, orderNo, state, offset, symbolType, userCode, symbol, usernameParent, userIds);
|
}
|
|
@Override
|
public ExchangeApplyOrder findByOrderNoAndPartyId(String order_no, String userId) {
|
return getOne(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getOrderNo, order_no).eq(ExchangeApplyOrder::getPartyId, userId));
|
}
|
|
@Override
|
public List<TodayTransactionDto> getTodayTransaction(String symbol, String userId, Date startDate,
|
Date endDate) {
|
Date startTime = DateUtil.minDate(startDate);
|
Date endTime = DateUtil.maxDate(endDate);
|
List<String> symbols = new ArrayList<>();
|
// if (StringUtils.isNotEmpty(symbolType)) {
|
// symbols.add("-1");
|
// }
|
symbols.add(symbol);
|
return baseMapper.getTodayTransaction(userId, ExchangeApplyOrder.STATE_CREATED, startTime, endTime, symbols);
|
}
|
|
@Override
|
public List<Map<String, Object>> getPaged(int pageNo, int size, String userId, String symbol, String type, String isAll, String startTime, String endTime, String symbolType,
|
String orderPriceType) {
|
LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
|
if (!StringUtils.isNullOrEmpty(symbol)) {
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getSymbol, symbol);
|
}
|
if (StringUtils.isNotEmpty(orderPriceType)) {
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getOrderPriceType, orderPriceType);
|
}
|
if (null != isAll) {
|
List<String> items = itemService.getAllSymbol();
|
lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, items);
|
}
|
if ("orders".equals(type)) {
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_SUBMITTED);
|
} else if ("hisorders".equals(type)) {
|
lambdaQueryWrapper.in(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED, ExchangeApplyOrder.STATE_CANCELED);
|
} else if ("opponent".equals(type)) {
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
|
} else if ("canceled".equals(type)) {
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CANCELED);
|
}
|
if (!StringUtils.isNullOrEmpty(startTime)) {
|
lambdaQueryWrapper.ge(ExchangeApplyOrder::getCreateTime, DateUtil.minDate(DateUtil.stringToDate(startTime, "yyyy-MM-dd")));
|
}
|
if (!StringUtils.isNullOrEmpty(endTime)) {
|
lambdaQueryWrapper.le(ExchangeApplyOrder::getCreateTime, DateUtil.maxDate(DateUtil.stringToDate(endTime, "yyyy-MM-dd")));
|
}
|
List<String> symbols = itemService.findByType(symbolType).stream().map(Item::getSymbol).collect(Collectors.toList());
|
symbols.add("-1");
|
if (StringUtils.isNotEmpty(symbolType)) {
|
lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, symbols);
|
}
|
lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
|
Page page = new Page(pageNo, size);
|
page(page, lambdaQueryWrapper);
|
return this.entrustBulidData(page.getRecords());
|
}
|
|
private List<Map<String, Object>> entrustBulidData(List<ExchangeApplyOrder> list) {
|
List<Map<String, Object>> data = new ArrayList();
|
for (int i = 0; i < list.size(); i++) {
|
ExchangeApplyOrder order = list.get(i);
|
Map<String, Object> map = new HashMap<String, Object>();
|
String symbol = itemService.findBySymbol(order.getSymbol()).getName();
|
map.put("profitLoss", 0);
|
List<Realtime> symbolList = dataService.realtime(symbol);
|
if (!CollectionUtil.isEmpty(symbolList)) {
|
Realtime realtime = symbolList.get(0);
|
double oldPrie = order.getClosePrice().doubleValue() * order.getVolume().doubleValue();
|
double newPrie = realtime.getClose() * order.getVolume().doubleValue();
|
map.put("profitLoss", oldPrie - newPrie); //盈亏
|
}
|
map.put("order_no", order.getOrderNo());
|
map.put("name", symbol);
|
map.put("symbol", order.getSymbol());
|
Item bySymbol = itemService.findBySymbol(symbol);
|
if (bySymbol != null) {
|
map.put("symbol_data", bySymbol.getSymbolData());
|
}
|
map.put("create_time", order.getCreateTime());
|
// 买的时候total 为volume，卖的时候total = volume*closeTime
|
if (ExchangeApplyOrder.OFFSET_OPEN.equalsIgnoreCase(order.getOffset())) {
|
double realVolume = order.getSuccessVolume() != 0 ? order.getSuccessVolume() : order.getSymbolValue();
|
map.put("total", BigDecimal.valueOf(realVolume * order.getClosePrice()).setScale(2, RoundingMode.HALF_UP));
|
map.put("volume", realVolume);
|
} else {
|
double realVolume = order.getSuccessVolume() != 0 ? order.getSuccessVolume() : order.getVolume();
|
map.put("total", BigDecimal.valueOf(realVolume * order.getClosePrice()).setScale(2, RoundingMode.HALF_UP));
|
map.put("volume", realVolume);
|
}
|
map.put("offset", order.getOffset());
|
map.put("price", order.getPrice());
|
map.put("order_price_type", order.getOrderPriceType());
|
map.put("state", order.getState());
|
map.put("closePrice", order.getClosePrice());
|
map.put("fee", order.getFee());
|
long showCreateTimeTs = DateTimeTools.transferShowTimeToClientTime(order.getCreateTimeTs());
|
map.put("create_time_ts", showCreateTimeTs);
|
long showUpdateTimeTs = DateTimeTools.transferShowTimeToClientTime(order.getUpdateTimeTs());
|
map.put("update_time_ts", showUpdateTimeTs);
|
data.add(map);
|
}
|
return data;
|
}
|
|
/**
|
* 现货交易买入
|
*/
|
@Override
|
public void saveSpotTradOpen(ExchangeApplyOrder order) {
|
order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
|
double fee = Arith.mul(order.getVolume(), sysparaService.find("exchange_apply_order_buy_fee").getDouble());
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
String symbol = order.getSymbol();
|
Item item = itemService.findBySymbol(symbol);
|
double amountBefore = wallet.getMoney().doubleValue();
|
double realAmount = order.getVolume() + fee;
|
String type = item.getType();
|
realAmount = exchangeRateService.getUsdtByType(BigDecimal.valueOf(realAmount), type).doubleValue();
|
if (wallet.getMoney().doubleValue() < realAmount) {
|
log.error("现货交易买入余额不足，钱包余额：{},订单额度：{},手续费{}", wallet.getMoney(), order.getVolume(), fee);
|
throw new YamiShopBindException("余额不足");
|
}
|
// 休市期间，下市价订单, 叫 "竞价单",竞价单订单号长度为21,其他订单号长度为20位
|
if (ExchangeApplyOrder.ORDER_PRICE_TYPE_OPPONENT.equals(order.getOrderPriceType())) {
|
boolean isOpen = MarketOpenChecker.isMarketOpenByItemCloseType(item.getOpenCloseType());
|
if (!isOpen) {
|
order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(9));
|
}
|
}
|
this.walletService.update(wallet.getUserId(), Arith.sub(0, realAmount));
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amountBefore));
|
log.setAmount(BigDecimal.valueOf(-realAmount));
|
log.setAmountAfter(BigDecimal.valueOf(Arith.sub(amountBefore, realAmount)));
|
log.setLog(name + type2 + "现货交易买入" + "，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setWalletType(Constants.WALLET);
|
log.setSymbol(symbol);
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_OPEN);
|
log.setCreateTime(new Date());
|
log.setUpdateTime(new Date());
|
moneyLogService.save(log);
|
order.setFee(fee);
|
order.setCreateTime(new Date());
|
save(order);
|
userDataService.saveBuy(order);
|
}
|
|
/**
|
* 现货交易卖出
|
*/
|
@Override
|
@Transactional
|
public void saveSpotTradClose(ExchangeApplyOrder order) {
|
order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
|
order.setCreateTime(new Date());
|
order.setFee(Arith.mul(order.getVolume(), sysparaService.find("exchange_apply_order_sell_fee").getDouble()));
|
Item item = itemService.findBySymbol(order.getSymbol());
|
// 休市期间，不让下市价卖出单
|
if (ExchangeApplyOrder.ORDER_PRICE_TYPE_OPPONENT.equals(order.getOrderPriceType())) {
|
boolean isOpen = MarketOpenChecker.isMarketOpenByItemCloseType(item.getOpenCloseType());
|
if (!isOpen) {
|
//throw new YamiShopBindException("The current stock market is closed");
|
}
|
}
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amount_before = walletExtend.getAmount();
|
walletService.updateExtend(walletExtend.getPartyId(), walletExtend.getWallettype(), Arith.sub(0, order.getVolume()));
|
String type = item.getType();
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(BigDecimal.valueOf(-order.getVolume()));
|
moneylog.setAmountAfter(BigDecimal.valueOf(Arith.sub(amount_before, order.getVolume())));
|
moneylog.setLog(name + type2 + "现货交易卖出，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(order.getSymbol());
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(type2 + Constants.MONEYLOG_CONTENT_CLOSE);
|
moneylog.setCreateTime(new Date());
|
moneylog.setUpdateTime(new Date());
|
moneyLogService.save(moneylog);
|
save(order);
|
userDataService.saveSell(order);
|
}
|
//================================================闪兑==============================================================
|
|
/**
|
* 生成闪兑订单
|
*/
|
@Override
|
public void saveCreate(ExchangeApplyOrder order) {
|
Realtime realtime = dataService.realtime(order.getSymbol()).get(0);
|
order.setClosePrice(realtime.getClose());
|
if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
|
open(order);
|
} else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
close(order);
|
}
|
}
|
|
/**
|
* 闪兑-买入
|
*/
|
public void open(ExchangeApplyOrder order) {
|
order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
|
order.setFee(Arith.mul(order.getVolume(), sysparaService.find("exchange_apply_order_buy_fee").getDouble()));
|
order.setCreateTime(new Date());
|
// 买入数量 - 手续费 = 到账
|
double sub = Arith.sub(order.getVolume(), order.getFee());
|
// 可以买的数量
|
double amount = Arith.div(sub, order.getClosePrice(), 8);
|
order.setSymbolValue(amount);
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amount_before = wallet.getMoney().doubleValue();
|
if (wallet.getMoney().doubleValue() < order.getVolume()) {
|
throw new YamiShopBindException("余额不足");
|
}
|
this.walletService.update(wallet.getUserId(), Arith.sub(0, order.getVolume()));
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amount_before));
|
log.setAmount(new BigDecimal(Arith.sub(0, order.getVolume().doubleValue())));
|
log.setAmountAfter(new BigDecimal(Arith.sub(wallet.getMoney().doubleValue(), order.getVolume())));
|
log.setLog(name + "闪兑买入，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setWalletType(Constants.WALLET);
|
log.setSymbol(order.getSymbol());
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_OPEN);
|
log.setCreateTime(new Date());
|
log.setUpdateTime(new Date());
|
moneyLogService.save(log);
|
save(order);
|
userDataService.saveBuy(order);
|
}
|
|
/**
|
* 闪兑-卖出
|
*/
|
@Transactional
|
public void close(ExchangeApplyOrder order) {
|
order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
|
order.setCreateTime(new Date());
|
order.setFee(Arith.mul(order.getVolume(), sysparaService.find("exchange_apply_order_sell_fee").getDouble()));
|
double sub = Arith.sub(order.getVolume(), order.getFee());
|
double amount = Arith.mul(sub, order.getClosePrice());
|
order.setSymbolValue(amount);
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amount_before = walletExtend.getAmount();
|
walletService.updateExtend(walletExtend.getPartyId(), walletExtend.getWallettype(), Arith.sub(0, order.getVolume()));
|
Item item = itemService.findBySymbol(order.getSymbol());
|
String type = item.getType();
|
order.setSuccessVolume(order.getVolume());
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amount_before));
|
log.setAmount(new BigDecimal(Arith.sub(0, order.getVolume())));
|
log.setAmountAfter(new BigDecimal(Arith.sub(walletExtend.getAmount(), order.getVolume())));
|
log.setLog(name + "闪兑卖出，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setWalletType(order.getSymbol());
|
log.setSymbol(order.getSymbol());
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_CLOSE);
|
log.setCreateTime(new Date());
|
log.setUpdateTime(new Date());
|
moneyLogService.save(log);
|
save(order);
|
userDataService.saveSell(order);
|
}
|
|
@Override
|
@Transactional
|
public void saveOpenCreated(ExchangeApplyOrder order, Double orderPrice) {
|
// 买入数量-手续费=到账
|
double sub = Arith.sub(order.getVolume(), order.getFee());
|
// 可以买的数量
|
double amount = Arith.div(sub, orderPrice, 8);
|
order.setCloseTime(new Date());
|
order.setClosePrice(orderPrice);
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amountBefore = walletExtend.getAmount();
|
this.walletService.updateExtend(walletExtend.getPartyId(), walletExtend.getWallettype(), amount);
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amountBefore));
|
log.setAmount(new BigDecimal(amount));
|
log.setAmountAfter(new BigDecimal(amountBefore + amount));
|
log.setLog(name + "闪兑买入成交，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setSymbol(order.getSymbol());
|
log.setWalletType(order.getSymbol());
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_OPEN);
|
moneyLogService.save(log);
|
order.setState(ExchangeApplyOrder.STATE_CREATED);
|
order.setAmount(order.getVolume());
|
order.setWalletFee(order.getFee());
|
updateById(order);
|
}
|
|
@Override
|
@Transactional
|
public void saveCloseCreated(ExchangeApplyOrder order, Double orderPrice) {
|
double sub = Arith.sub(order.getVolume(), order.getFee());
|
double amount = Arith.mul(sub, orderPrice);
|
order.setCloseTime(new Date());
|
order.setClosePrice(orderPrice);
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amount_before = wallet.getMoney().doubleValue();
|
String type = itemService.findBySymbol(order.getSymbol()).getType();
|
amount = exchangeRateService.getUsdtByType(BigDecimal.valueOf(amount), type).doubleValue();
|
this.walletService.update(wallet.getUserId(), amount);
|
MoneyLog log = new MoneyLog();
|
log.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
String name = Constants.MONEYLOG_MAP.get(type);
|
String type2 = Constants.MONEYLOG_MAP_TYPE.get(type);
|
log.setAmountBefore(new BigDecimal(amount_before));
|
log.setAmount(new BigDecimal(amount));
|
log.setAmountAfter(wallet.getMoney());
|
log.setLog(name + "闪兑卖出成交，订单号[" + order.getOrderNo() + "]");
|
log.setUserId(order.getPartyId());
|
log.setWalletType(Constants.WALLET);
|
log.setContentType(type2 + Constants.MONEYLOG_CONTENT_CLOSE);
|
log.setSymbol(order.getSymbol());
|
moneyLogService.save(log);
|
order.setAmount(amount);
|
order.setWalletFee(Arith.mul(order.getFee(), orderPrice));
|
order.setState(ExchangeApplyOrder.STATE_CREATED);
|
updateById(order);
|
}
|
|
/**
|
* 闪兑记录列表
|
*/
|
@Override
|
public List<Map<String, Object>> queryExchangeListPage(int pageNo, int size, String userId) {
|
QueryWrapper<ExchangeApplyOrder> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("party_id", userId);
|
queryWrapper.eq("state", ExchangeApplyOrder.STATE_CREATED);
|
queryWrapper.isNotNull("relation_order_no");
|
List<ExchangeApplyOrder> list = exchangeApplyOrderMapper.selectList(queryWrapper);
|
return bulidData(list);
|
}
|
|
private List<Map<String, Object>> bulidData(List<ExchangeApplyOrder> list) {
|
Map<String, ExchangeRecord> recordMap = new HashMap<>();
|
List<Map<String, Object>> data = new ArrayList<>();
|
for (int i = 0; i < list.size(); i++) {
|
ExchangeApplyOrder order = list.get(i);
|
ExchangeRecord record = new ExchangeRecord();
|
if (recordMap.containsKey(order.getRelationOrderNo())) {
|
record = recordMap.get(order.getRelationOrderNo());
|
}
|
record.setClosePrice(order.getClosePrice());
|
record.setState(order.getState());
|
record.setCreate_time(order.getCreateTime());
|
// 开仓 买入**币
|
if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
if (recordMap.containsKey(order.getRelationOrderNo())) {
|
record.setSymbol(order.getSymbol());
|
record.setAmount(order.getVolume());
|
} else {
|
record.setSymbol(order.getSymbol());
|
record.setAmount(order.getVolume());
|
// 针对 **币 --兑换-- usdt
|
record.setAmount_to(order.getSymbolValue());
|
}
|
}
|
// 平仓 卖出**币
|
else if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
|
if (recordMap.containsKey(order.getRelationOrderNo())) {
|
record.setSymbol_to(order.getSymbol());
|
record.setAmount_to(order.getSymbolValue());
|
} else {
|
record.setSymbol_to(order.getSymbol());
|
record.setAmount(order.getVolume());
|
record.setAmount_to(order.getSymbolValue());
|
}
|
}
|
recordMap.put(order.getRelationOrderNo(), record);
|
}
|
for (ExchangeRecord entry : recordMap.values()) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("symbol", entry.getSymbol());
|
map.put("symbol_to", entry.getSymbol_to());
|
map.put("amount", entry.getAmount());
|
map.put("amount_to", entry.getAmount_to());
|
map.put("create_time", entry.getCreate_time());
|
map.put("state", entry.getState());
|
map.put("closePrice", entry.getClosePrice());
|
data.add(map);
|
}
|
if (data.size() > 0) {
|
Collections.sort(data, (o1, o2) -> {
|
String time1 = String.valueOf(o1.get("create_time"));
|
String time2 = String.valueOf(o2.get("create_time"));
|
return time2.compareTo(time1);
|
});
|
return data;
|
}
|
return data;
|
}
|
}
|
