package com.yami.trading.service.exchange.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.json.JSONUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
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.google.gson.Gson;
|
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.SumEtfDto;
|
import com.yami.trading.bean.item.domain.Item;
|
import com.yami.trading.bean.model.CapitaltWallet;
|
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.*;
|
import com.yami.trading.dao.exchange.ExchangeApplyOrderMapper;
|
import com.yami.trading.service.CapitaltWalletService;
|
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.syspara.SysparaService;
|
import com.yami.trading.service.user.UserDataService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.xml.crypto.Data;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.yami.trading.bean.item.domain.ItemConstants.*;
|
|
@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;
|
@Autowired
|
CapitaltWalletService capitaltWalletService;
|
|
@Override
|
public List<ExchangeApplyOrder> findSubmitted() {
|
|
return list(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_SUBMITTED));
|
}
|
|
@Override
|
@Transactional
|
public void saveOpen(ExchangeApplyOrder order, Realtime realtime) {
|
|
double sub = Arith.sub(order.getVolume(), order.getFee());// 买入数量-手续费=到账
|
double amount = Arith.div(sub, realtime.getClose().doubleValue(), 8);// 可以买的数量
|
// order.setCreate_time(new Date());
|
order.setCloseTime(new Date());
|
order.setClosePrice(realtime.getClose().doubleValue());
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amount_before = walletExtend.getAmount();
|
|
this.walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(), amount);
|
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog_deposit = new MoneyLog();
|
moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
|
moneylog_deposit.setAmount(new BigDecimal(amount));
|
moneylog_deposit.setAmountAfter(new BigDecimal(walletExtend.getAmount()));
|
moneylog_deposit.setLog("委托单，订单号[" + order.getOrderNo() + "]");
|
moneylog_deposit.setUserId(order.getPartyId());
|
moneylog_deposit.setSymbol(order.getSymbol());
|
moneylog_deposit.setWalletType(order.getSymbol());
|
moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_OPEN);
|
moneyLogService.save(moneylog_deposit);
|
order.setState(ExchangeApplyOrder.STATE_CREATED);
|
order.setAmount(order.getVolume());
|
order.setWalletFee(order.getFee());
|
updateById(order);
|
}
|
|
@Override
|
@Transactional
|
public void saveClose(ExchangeApplyOrder order, Realtime realtime) {
|
|
double sub = Arith.sub(order.getVolume(), order.getFee());
|
double amount = Arith.mul(sub, realtime.getClose().doubleValue());
|
order.setCloseTime(new Date());
|
order.setClosePrice(realtime.getClose().doubleValue());
|
// Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
CapitaltWallet capitaltWallet = capitaltWalletService.getUserIdWallet(order.getPartyId());
|
double amount_before = capitaltWallet.getMoney().doubleValue();
|
// this.walletService.update(userIdWallet.getUserId().toString(), amount);
|
this.capitaltWalletService.update(capitaltWallet, amount);
|
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog_deposit = new MoneyLog();
|
moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
|
moneylog_deposit.setAmount(new BigDecimal(amount));
|
moneylog_deposit.setAmountAfter(capitaltWallet.getMoney());
|
moneylog_deposit.setLog("委托单，订单号[" + order.getOrderNo() + "]");
|
moneylog_deposit.setUserId(order.getPartyId());
|
moneylog_deposit.setWalletType(Constants.WALLET);
|
moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CLOSE);
|
moneylog_deposit.setSymbol(order.getSymbol());
|
moneyLogService.save(moneylog_deposit);
|
order.setAmount(amount);
|
order.setWalletFee(Arith.mul(order.getFee(), realtime.getClose().doubleValue()));
|
order.setState(ExchangeApplyOrder.STATE_CREATED);
|
updateById(order);
|
}
|
|
@Override
|
public void saveCreate(ExchangeApplyOrder order) {
|
|
boolean order_open = sysparaService.find("exchange_order_open").getBoolean();
|
if (!order_open) {
|
throw new YamiShopBindException("不在交易时段");
|
}
|
Item item = itemService.findBySymbol(order.getSymbol());
|
if (item == null) {
|
throw new YamiShopBindException("参数错误");
|
}
|
List<Realtime> realtimes = dataService.realtime(order.getSymbol());
|
double close = 1;
|
if (realtimes != null && realtimes.size() > 0) {
|
close = realtimes.get(0).getClose().doubleValue();
|
}
|
order.setClosePrice(close);
|
if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
|
open(order);
|
} else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
close(order);
|
}
|
}
|
|
@Override
|
public ExchangeApplyOrder findByOrderNo(String orderNo) {
|
|
return getOne(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getOrderNo, orderNo));
|
}
|
|
@Override
|
public List<ExchangeSymbolDto> getETFListByUserId(String userId, String type) {
|
|
List<String> symbols = itemService.findByType(type).stream().map(Item::getSymbol).collect(Collectors.toList());
|
symbols.add("-1");
|
log.info(JSONUtil.toJsonStr(symbols));
|
LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
|
lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, symbols);
|
lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOffset, ExchangeApplyOrder.OFFSET_CLOSE);
|
// lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
|
lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
|
List<ExchangeApplyOrder> list = list(lambdaQueryWrapper);
|
return getDataList(list);
|
}
|
|
private static List<ExchangeApplyOrder> getData() {
|
|
List<ExchangeApplyOrder> exchangeApplyOrders = new ArrayList<>();
|
ExchangeApplyOrder exchangeApplyOrder = new ExchangeApplyOrder();
|
exchangeApplyOrder.setSymbol("usdt");
|
exchangeApplyOrder.setVolume(1000.0);
|
exchangeApplyOrder.setClosePrice(100.0);
|
exchangeApplyOrders.add(exchangeApplyOrder);
|
//
|
// ExchangeApplyOrder exchangeApplyOrder2=new ExchangeApplyOrder();
|
// exchangeApplyOrder2.setSymbol("usdt");
|
// exchangeApplyOrder2.setVolume(1000.0);
|
// exchangeApplyOrder2.setClosePrice(50.0);
|
// exchangeApplyOrders.add(exchangeApplyOrder2);
|
return exchangeApplyOrders;
|
}
|
|
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<>();
|
}
|
// Realtime realtime = new Realtime();
|
// realtime.setClose(new BigDecimal(99));
|
// realtime.setOpen(new BigDecimal(100));
|
// ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
// exchangeSymbolDto.setVolume(order.getVolume());
|
// exchangeSymbolDto.setName("test");
|
// exchangeSymbolDto.setOpenPrice(realtime.getOpen().doubleValue());
|
// exchangeSymbolDto.setCurrentPrice(realtime.getClose().doubleValue());
|
// exchangeSymbolDto.setPrice(order.getClosePrice());
|
// exchangeSymbolDtos.add(exchangeSymbolDto);
|
// map.put(order.getSymbol(), exchangeSymbolDtos);
|
List<Realtime> symbolList = dataService.realtime(order.getSymbol());
|
if (!CollectionUtil.isEmpty(symbolList)) {
|
Realtime realtime = symbolList.get(0);
|
ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
exchangeSymbolDto.setVolume(order.getVolume());
|
exchangeSymbolDto.setName(realtime.getName());
|
exchangeSymbolDto.setOpenPrice(realtime.getOpen().doubleValue());
|
exchangeSymbolDto.setCurrentPrice(realtime.getClose().doubleValue());
|
exchangeSymbolDto.setPrice(order.getClosePrice());
|
exchangeSymbolDtos.add(exchangeSymbolDto);
|
map.put(order.getSymbol(), exchangeSymbolDtos);
|
}
|
}
|
for (String key : map.keySet()) {
|
List<ExchangeSymbolDto> list = map.get(key);
|
double volume = 0; //可用
|
double cost = 0.0;
|
double marketValue = 0; //市值
|
double currentPrice = 0; //当前价格
|
double profitLoss = 0; //总盈亏
|
double toDayProfitLoss = 0; //今日总盈亏
|
double openPrice = 0;
|
String name = "";
|
for (ExchangeSymbolDto dto : list) {
|
volume += dto.getVolume();
|
name = dto.getName();
|
cost += (dto.getVolume() * dto.getPrice());
|
currentPrice = dto.getCurrentPrice();
|
openPrice = dto.getOpenPrice();
|
marketValue += (dto.getCurrentPrice() * dto.getVolume());
|
}
|
double price = 0;
|
if (volume == 0) {
|
price = 0;
|
} else {
|
price = cost / volume;
|
}
|
toDayProfitLoss = (marketValue - (openPrice * volume));
|
profitLoss = marketValue - cost;
|
ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
|
exchangeSymbolDto.setVolume(new BigDecimal(volume).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setPositionVolume(new BigDecimal(volume).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setPrice(new BigDecimal(price).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setName(name);
|
exchangeSymbolDto.setSymbol(key);
|
exchangeSymbolDto.setToDayProfitLoss(new BigDecimal(toDayProfitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setToDayProfitLossPercentage(calculateProfitPercentage(openPrice, currentPrice));
|
exchangeSymbolDto.setCurrentPrice(new BigDecimal(currentPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setOpenPrice(new BigDecimal(openPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setMarketValue(new BigDecimal(marketValue).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setProfitLoss(new BigDecimal(profitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
exchangeSymbolDto.setProfitLossPercentage(calculateProfitPercentage(price, currentPrice));
|
result.add(exchangeSymbolDto);
|
}
|
return result;
|
}
|
|
public static double calculateProfitPercentage(double buyPrice, double currentPrice) {
|
|
double profit = currentPrice - buyPrice;
|
double profitPercentage = (profit / buyPrice) * 100;
|
System.out.println(profitPercentage);
|
return new BigDecimal(profitPercentage).setScale(2, RoundingMode.HALF_UP).doubleValue();
|
}
|
|
public static void test() {
|
|
|
// System.out.printf(new Gson().toJson(getDataList(getData())));
|
}
|
|
public static void main(String[] args) {
|
|
test();
|
}
|
|
@Override
|
public SumEtfDto getProfitLossByUserId(String userId, String type) {
|
|
List<ExchangeSymbolDto> list = getETFListByUserId(userId, type);
|
|
double profitLoss = 0; //盈亏
|
double toDayProfitLoss = 0; //今日盈亏
|
double sumPrice = 0; //总资产
|
double sumVolume = 0; //可用
|
for (ExchangeSymbolDto order : list) {
|
profitLoss += order.getProfitLoss();
|
toDayProfitLoss += order.getToDayProfitLoss();
|
sumPrice += order.getMarketValue();
|
sumVolume += order.getVolume();
|
|
}
|
SumEtfDto sumEtfDto = new SumEtfDto();
|
sumEtfDto.setProfitLoss(new BigDecimal(profitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
sumEtfDto.setSumPrice(new BigDecimal(sumPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
sumEtfDto.setToDayProfitLoss(new BigDecimal(toDayProfitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
// usdt余额
|
Wallet wallet = new Wallet();
|
if (!"".equals(userId) && userId != null) {
|
wallet = walletService.findByUserId(userId.toString());
|
}
|
sumEtfDto.setSumVolume(wallet.getMoney().setScale(2, RoundingMode.HALF_UP).doubleValue());
|
return sumEtfDto;
|
}
|
|
@Override
|
public void saveCancel(String partyId, String order_no) {
|
|
ExchangeApplyOrder order = findByOrderNo(order_no);
|
if (order == null || !"submitted".equals(order.getState()) || !partyId.equals(order.getPartyId().toString())) {
|
return;
|
}
|
// 如果是计划委托则不返回余额
|
if (order.isTriggerOrder()) {
|
if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amount_before = wallet.getMoney().doubleValue();
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(new BigDecimal(0));
|
moneylog.setAmountAfter(new BigDecimal(amount_before));
|
moneylog.setLog("币币交易计划委托单撤单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(Constants.WALLET);
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
|
moneyLogService.save(moneylog);
|
} else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amount_before = walletExtend.getAmount();
|
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(new BigDecimal(0));
|
moneylog.setAmountAfter(new BigDecimal(amount_before));
|
moneylog.setLog("币币交易计划委托单撤单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(order.getSymbol());
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
|
moneyLogService.save(moneylog);
|
}
|
order.setState(ExchangeApplyOrder.STATE_CANCELED);
|
}
|
if (!order.isTriggerOrder()) {
|
if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
double amount_before = wallet.getMoney().doubleValue();
|
// wallet.setMoney(Arith.add(wallet.getMoney(), order.getVolume()));
|
// walletService.update(wallet);
|
walletService.update(wallet.getUserId().toString(), order.getVolume());
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(new BigDecimal(order.getVolume()));
|
moneylog.setAmount_after(wallet.getMoney());
|
moneylog.setLog("币币交易撤单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(Constants.WALLET);
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
|
moneylog.setSymbol(order.getSymbol());
|
moneyLogService.save(moneylog);
|
} else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amount_before = walletExtend.getAmount();
|
// walletExtend.setAmount(Arith.add(walletExtend.getAmount(), order.getVolume()));
|
// walletService.update(walletExtend);
|
walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(),
|
order.getVolume());
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(new BigDecimal(order.getVolume()));
|
moneylog.setAmountAfter(new BigDecimal(Arith.add(walletExtend.getAmount(), order.getVolume())));
|
moneylog.setLog("币币交易撤单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(order.getSymbol());
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
|
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) {
|
|
return baseMapper.listPage(page, rolename, userName, orderNo, state, offset, symbolType, userCode , symbol);
|
}
|
|
@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<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.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_SUBMITTED);
|
} else if ("hisorders".equals(type)) {
|
// lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
|
lambdaQueryWrapper.in(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED, ExchangeApplyOrder.STATE_CANCELED);
|
} else if ("opponent".equals(type)) {
|
// lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
|
} else if ("canceled".equals(type)) {
|
// lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
|
lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CANCELED);
|
}
|
if (!StringUtils.isNullOrEmpty(startTime)) {
|
lambdaQueryWrapper.ge(ExchangeApplyOrder::getCreateTime, DateUtil.minDate(DateUtil.stringToDate(startTime, "yyyy-MM-dd")));
|
// parameters.put("startTime",DateUtils.toDate(startTime));
|
}
|
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);
|
List<Map<String, Object>> data;
|
if (!StringUtils.isNullOrEmpty(symbol) || null != isAll) {
|
// if (StringUtils.isNullOrEmpty(type)) {
|
// 币币交易的记录
|
data = this.entrustBulidData(page.getRecords());
|
} else {
|
// 兑换记录
|
data = this.bulidData(page.getRecords());
|
}
|
return data;
|
}
|
|
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.getOrderNo())) {
|
record = recordMap.get(order.getOrderNo());
|
}
|
record.setClosePrice(order.getClosePrice());
|
record.setState(order.getState());
|
record.setCreate_time(DateUtils.format(order.getCreateTime(), DateUtils.DF_yyyyMMddHHmmss));
|
// 开仓 买入**币
|
if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
|
if (recordMap.containsKey(order.getOrderNo())) {
|
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())) {
|
// new BigDecimal(String.valueOf(value)).toPlainString()
|
if (recordMap.containsKey(order.getOrderNo())) {
|
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.getOrderNo(), record);
|
}
|
for (ExchangeRecord entry : recordMap.values()) {
|
Map<String, Object> map = new HashMap<String, Object>();
|
map.put("symbol", entry.getSymbol());
|
Item bySymbol = itemService.findBySymbol(entry.getSymbol());
|
if (bySymbol != null) {
|
map.put("symbol_data", bySymbol.getSymbolData());
|
}
|
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, new Comparator<Map<String, Object>>() {
|
@Override
|
public int compare(Map<String, Object> o1, Map<String, Object> 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;
|
}
|
|
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().doubleValue() * 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", DateUtil.formatDate(order.getCreateTime(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("volume", new BigDecimal(order.getVolume()).setScale(6, RoundingMode.HALF_UP));
|
// 买的时候total 为volume，卖的时候total = volume*closeTime
|
if("open".equalsIgnoreCase(order.getOffset())){
|
map.put("total", new BigDecimal(order.getVolume()).setScale(6, RoundingMode.HALF_UP));
|
}else{
|
map.put("total", new BigDecimal(order.getVolume()*order.getClosePrice()).setScale(2, RoundingMode.HALF_UP));
|
}
|
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());
|
map.put("create_time_ts", order.getCreateTimeTs());
|
map.put("update_time_ts", order.getUpdateTimeTs());
|
// map.put("amount", Arith.mul(order.getVolume(), order.getUnit_amount()));
|
map.put("trigger_price", order.getTriggerPrice());
|
map.put("is_trigger_order", order.isTriggerOrder());
|
data.add(map);
|
}
|
return data;
|
}
|
|
/**
|
* 开仓委托
|
*/
|
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());
|
CapitaltWallet userIdWallet = capitaltWalletService.getUserIdWallet(order.getPartyId());
|
double amount_before = userIdWallet.getMoney().doubleValue();
|
// 如果是计划委托，则先不扣钱
|
if (order.isTriggerOrder()) {
|
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog_deposit = new MoneyLog();
|
moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
|
moneylog_deposit.setAmount(new BigDecimal(0));
|
moneylog_deposit.setAmountAfter(new BigDecimal(amount_before));
|
moneylog_deposit.setLog("币币交易计划委托订单，订单号[" + order.getOrderNo() + "]");
|
moneylog_deposit.setUserId(order.getPartyId());
|
moneylog_deposit.setWalletType(Constants.WALLET);
|
moneylog_deposit.setSymbol(order.getSymbol());
|
moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_OPEN);
|
moneyLogService.save(moneylog_deposit);
|
save(order);
|
}
|
if (!order.isTriggerOrder()) {
|
if (userIdWallet.getMoney().doubleValue() < order.getVolume().doubleValue()) {
|
throw new YamiShopBindException("余额不足");
|
}
|
// this.walletService.update(userIdWallet.getUserId().toString(), Arith.sub(0, order.getVolume()));
|
capitaltWalletService.update(userIdWallet, Arith.sub(0, order.getVolume()));
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog_deposit = new MoneyLog();
|
moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
|
moneylog_deposit.setAmount(new BigDecimal(Arith.sub(0, order.getVolume().doubleValue())));
|
moneylog_deposit.setAmountAfter(new BigDecimal(Arith.sub(userIdWallet.getMoney().doubleValue(), order.getVolume())));
|
moneylog_deposit.setLog("币币交易，订单号[" + order.getOrderNo() + "]");
|
moneylog_deposit.setUserId(order.getPartyId());
|
moneylog_deposit.setWalletType(Constants.WALLET);
|
moneylog_deposit.setSymbol(order.getSymbol());
|
moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_OPEN);
|
moneyLogService.save(moneylog_deposit);
|
save(order);
|
userDataService.saveBuy(order);
|
}
|
}
|
|
/**
|
* 卖币
|
*/
|
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);
|
// .close
|
WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
|
double amount_before = walletExtend.getAmount();
|
// 如果是计划委托，则先不扣钱
|
if (order.isTriggerOrder()) {
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(new BigDecimal(0));
|
moneylog.setAmountAfter(new BigDecimal(amount_before));
|
moneylog.setLog("币币交易计划委托订单，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(order.getSymbol());
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CLOSE);
|
moneyLogService.save(moneylog);
|
save(order);
|
}
|
if (!order.isTriggerOrder()) {
|
if (order.getVolume() > walletExtend.getAmount()) {
|
throw new YamiShopBindException("仓位不足");
|
}
|
walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(),
|
Arith.sub(0, order.getVolume()));
|
/*
|
* 保存资金日志
|
*/
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
|
moneylog.setAmountBefore(new BigDecimal(amount_before));
|
moneylog.setAmount(new BigDecimal(Arith.sub(0, order.getVolume())));
|
moneylog.setAmountAfter(new BigDecimal(Arith.sub(walletExtend.getAmount(), order.getVolume())));
|
moneylog.setLog("币币交易，订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(order.getSymbol());
|
moneylog.setSymbol(order.getSymbol());
|
moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CLOSE);
|
moneyLogService.save(moneylog);
|
save(order);
|
userDataService.saveSell(order);
|
}
|
}
|
|
}
|
