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.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.Realtime;
|
import com.yami.trading.bean.exchange.ExchangeLeverApplyOrder;
|
import com.yami.trading.bean.exchange.dto.ExchangeLeverOrderDto;
|
import com.yami.trading.bean.exchangelever.ExchangeLeverOrder;
|
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.common.constants.Constants;
|
import com.yami.trading.common.exception.BusinessException;
|
import com.yami.trading.common.util.Arith;
|
import com.yami.trading.common.util.DateUtil;
|
import com.yami.trading.common.util.DateUtils;
|
import com.yami.trading.common.util.StringUtils;
|
import com.yami.trading.dao.exchangelever.ExchangeLeverOrderMapper;
|
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.ExchangeLeverOrderService;
|
import com.yami.trading.service.item.ItemService;
|
import com.yami.trading.service.syspara.SysparaService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.time.Duration;
|
import java.time.Instant;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.util.*;
|
|
@Service
|
public class ExchangeLeverOrderServiceImpl extends ServiceImpl<ExchangeLeverOrderMapper, ExchangeLeverOrder> implements ExchangeLeverOrderService {
|
// @Autowired
|
// ExchangeLeverApplyOrderService exchangeLeverApplyOrderService;
|
@Autowired
|
ItemService itemService;
|
@Autowired
|
MoneyLogService moneyLogService;
|
@Autowired
|
WalletService walletService;
|
|
@Autowired
|
DataService dataService;
|
|
@Autowired
|
SysparaService sysparaService;
|
|
public ExchangeLeverOrder findByOrderNo(String order_no) {
|
return getOne(Wrappers.<ExchangeLeverOrder>query().lambda().eq(ExchangeLeverOrder::getOrderNo, order_no));
|
}
|
|
@Override
|
public Page<ExchangeLeverOrderDto> listPage(Page page, String roleName,
|
String status,
|
String userName,
|
Date startTime,
|
Date endTime,
|
String orderNo,
|
List<String> userIds) {
|
return baseMapper.listPage(page, roleName, status, userName, startTime, endTime, orderNo, userIds);
|
}
|
|
@Override
|
@Transactional
|
public ExchangeLeverOrder saveClose(String partyId, String order_no) {
|
/*
|
* 平仓
|
*/
|
ExchangeLeverOrder order = this.findByOrderNo(order_no);
|
if (order == null || !ExchangeLeverOrder.STATE_SUBMITTED.equals(order.getState())
|
|| !partyId.equals(order.getPartyId().toString()) || order.getVolume() <= 0) {
|
/**
|
* 状态已改变，退出处理
|
*/
|
return null;
|
}
|
double interestRate = sysparaService.find("exchange_lever_interest_rate").getDouble();// 利率
|
/**
|
* 收益
|
*/
|
double volume = order.getVolume();
|
double profit = this.settle(order, order.getVolume());
|
double unpaidInterest=compute(order.getCreateTime(),new Date(),interestRate,order.getDeposit()-
|
order.getDepositOpen());
|
payCloseOrder(order, profit+ order.getDepositOpen(), volume);
|
payInterestOrder(order,unpaidInterest);
|
order.setState(ExchangeLeverOrder.STATE_CREATED);
|
order.setVolume(0D);
|
order.setDeposit(0);
|
order.setDepositOpen(0);
|
order.setCloseTime(new Date());
|
updateById(order);
|
return order;
|
}
|
|
public void payInterestOrder(ExchangeLeverOrder order ,double unpaidInterest){
|
if (unpaidInterest<=0){
|
return;
|
}
|
double amountBefore = 0;
|
String paySymbol = Constants.WALLET;
|
// 买涨 用U 则 对应的保证金也是U
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
amountBefore = wallet.getMoney().doubleValue();
|
if (Arith.add(wallet.getMoney().doubleValue(), unpaidInterest) < 0) {
|
unpaidInterest = Arith.sub(0, wallet.getMoney().doubleValue());
|
}
|
this.walletService.update(wallet.getUserId().toString(), unpaidInterest);
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE_LEVER);
|
moneylog.setAmountBefore(new BigDecimal(amountBefore));
|
moneylog.setAmount(new BigDecimal(unpaidInterest));
|
moneylog.setAmountAfter(new BigDecimal(Arith.add(amountBefore, unpaidInterest)));
|
moneylog.setLog("全仓杠杆平仓支付利息["+unpaidInterest+"],订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(paySymbol);
|
moneylog.setContent_type(Constants.MONEYLOG_CONTENT_EXCHANGE_LEVER_INTEREST);
|
moneyLogService.save(moneylog);
|
}
|
|
/**
|
* 支付平仓订单
|
*
|
* @param order
|
* @param profit
|
* @param volume
|
*/
|
public void payCloseOrder(ExchangeLeverOrder order, double profit, double volume) {
|
double amountBefore = 0;
|
String paySymbol = Constants.WALLET;
|
// 买涨 用U 则 对应的保证金也是U
|
if (ExchangeLeverOrder.DIRECTION_BUY.equals(order.getDirection())) {
|
Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
|
amountBefore = wallet.getMoney().doubleValue();
|
if (Arith.add(wallet.getMoney().doubleValue(), profit) < 0) {
|
profit = Arith.sub(0, wallet.getMoney().doubleValue());
|
}
|
this.walletService.update(wallet.getUserId().toString(), profit);
|
|
} else {// 买跌 用指定币种 则 对应的保证金也是指定币种
|
paySymbol = order.getSymbol();
|
WalletExtend walletExtend = this.walletService.saveExtendByPara(order.getPartyId(), paySymbol);
|
amountBefore = walletExtend.getAmount();
|
if (Arith.add(walletExtend.getAmount(), profit) < 0) {
|
profit = Arith.sub(0, walletExtend.getAmount());
|
}
|
this.walletService.updateExtend(order.getPartyId().toString(), paySymbol, profit);
|
|
}
|
|
MoneyLog moneylog = new MoneyLog();
|
moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE_LEVER);
|
moneylog.setAmountBefore(new BigDecimal(amountBefore));
|
moneylog.setAmount(new BigDecimal(profit));
|
moneylog.setAmountAfter(new BigDecimal(Arith.add(amountBefore, profit)));
|
moneylog.setLog("平仓，平仓全仓杠杆[" + volume + "],订单号[" + order.getOrderNo() + "]");
|
moneylog.setUserId(order.getPartyId());
|
moneylog.setWalletType(paySymbol);
|
moneylog.setContent_type(Constants.MONEYLOG_CONTENT_EXCHANGE_LEVER_CLOSE);
|
moneyLogService.save(moneylog);
|
|
}
|
|
|
|
/**
|
* 收益结算，平仓时计算
|
*
|
* @param volume 平仓的张数
|
*/
|
public double settle(ExchangeLeverOrder order, double volume) {
|
double profit = 0;
|
/**
|
* 平仓比率
|
*/
|
List<Realtime> realtimes = dataService.realtime(order.getSymbol());
|
if (CollectionUtil.isEmpty(realtimes)) {
|
throw new BusinessException(order.getSymbol()+"未获取行情数据");
|
}
|
Realtime realtime= realtimes.get(0);
|
profit= (realtime.getClose()*order.getVolumeOpen())- (order.getTradeAvgPrice() * order.getVolumeOpen()) ;
|
order.setAmountClose(Arith.add(order.getDepositOpen(), profit));
|
|
// order.setVolume(Arith.sub(order.getVolume(), volume));
|
// order.setDeposit(Arith.sub(order.getDeposit(), Arith.mul(order.getDepositOpen(), rate)));
|
|
if (order.getVolume() <= 0) {
|
order.setState(ExchangeLeverOrder.STATE_CREATED);
|
}
|
|
return profit;
|
|
}
|
|
@Override
|
public List<ExchangeLeverOrder> findSubmitted() {
|
return list(Wrappers.<ExchangeLeverOrder>query().lambda()
|
.eq(ExchangeLeverOrder::getState,ExchangeLeverOrder.STATE_SUBMITTED));
|
}
|
|
@Override
|
public ExchangeLeverOrder findBySymbol(String partyId, String symbol) {
|
List<ExchangeLeverOrder> exchangeLeverOrders= list(Wrappers.<ExchangeLeverOrder>query().lambda()
|
.eq(ExchangeLeverOrder::getPartyId,partyId)
|
.eq(ExchangeLeverOrder::getSymbol,symbol)
|
.eq(ExchangeLeverOrder::getState,ExchangeLeverOrder.STATE_SUBMITTED));
|
if (CollectionUtil.isNotEmpty(exchangeLeverOrders)){
|
return exchangeLeverOrders.get(0);
|
}
|
return null;
|
}
|
|
|
|
@Override
|
public double sumVolume(String currentUserId,String symbol) {
|
LambdaQueryWrapper<ExchangeLeverOrder> lambdaQueryWrapper= Wrappers.<ExchangeLeverOrder>query().lambda()
|
.eq(ExchangeLeverOrder::getState,ExchangeLeverOrder.STATE_SUBMITTED);
|
if (StringUtils.isNotEmpty(symbol)){
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getSymbol,symbol);
|
}
|
|
List<ExchangeLeverOrder> list= list(lambdaQueryWrapper);
|
double volume=0;
|
for (ExchangeLeverOrder exchangeLeverOrder: list){
|
volume+=exchangeLeverOrder.getVolume();
|
}
|
return volume;
|
}
|
|
@Override
|
public List<ExchangeLeverOrder> findSubmitted(String partyId, String symbol, String direction) {
|
LambdaQueryWrapper<ExchangeLeverOrder> lambdaQueryWrapper = Wrappers.<ExchangeLeverOrder>query().lambda();
|
if (!StringUtils.isNullOrEmpty(partyId)) {
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getPartyId, partyId);
|
}
|
if (!StringUtils.isNullOrEmpty(symbol)) {
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getSymbol, symbol);
|
}
|
if (!StringUtils.isNullOrEmpty(direction)) {
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getDirection, direction);
|
}
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getState, "submitted");
|
return list(lambdaQueryWrapper);
|
}
|
|
public List<Map<String, Object>> getPaged(int pageNo, int pageSize, String partyId, String symbol, String type) {
|
Page page = new Page(pageNo, pageSize);
|
LambdaQueryWrapper<ExchangeLeverOrder> lambdaQueryWrapper = Wrappers.<ExchangeLeverOrder>query().lambda();
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getPartyId, partyId);
|
if (!StringUtils.isNullOrEmpty(symbol)) {
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getSymbol, symbol);
|
}
|
Date date = DateUtils.addDay(new Date(), -1);
|
if ("orders".equals(type)) {
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getState, "submitted");
|
} else if ("hisorders".equals(type)) {
|
lambdaQueryWrapper.eq(ExchangeLeverOrder::getState, "created");
|
}
|
lambdaQueryWrapper.orderByDesc(ExchangeLeverOrder::getCreateTime);
|
page(page,lambdaQueryWrapper);
|
Wallet wallet= walletService.findByUserId(partyId);
|
double sumVolume= sumVolume(partyId,null);
|
sumVolume+=wallet.getMoney().doubleValue();
|
|
List<Map<String, Object>> data = this.bulidData(page.getRecords(),new BigDecimal(sumVolume));
|
return data;
|
}
|
|
private List<Map<String, Object>> bulidData(List<ExchangeLeverOrder> list,BigDecimal money) {
|
List<Map<String, Object>> data = new ArrayList<>();
|
for (int i = 0; i < list.size(); i++) {
|
ExchangeLeverOrder order = list.get(i);
|
Map<String, Object> map = bulidOne(order,money.doubleValue());
|
data.add(map);
|
}
|
return data;
|
}
|
|
public Map<String, Object> bulidOne(ExchangeLeverOrder order,double money) {
|
DecimalFormat df = new DecimalFormat("#.##");
|
DecimalFormat df8 = new DecimalFormat("#.########");
|
Map<String, Object> map = new HashMap<>();
|
map.put("order_no", order.getOrderNo());
|
map.put("name", itemService.findBySymbol(order.getSymbol()).getName());
|
map.put("symbol", order.getSymbol());
|
map.put("create_time", DateUtils.format(order.getCreateTime(), DateUtils.DF_yyyyMMddHHmmss));
|
if (order.getCloseTime() != null) {
|
map.put("close_time", DateUtils.format(order.getCloseTime(), DateUtils.DF_yyyyMMddHHmmss));
|
} else {
|
map.put("close_time", "");
|
}
|
map.put("direction", order.getDirection());
|
map.put("lever_rate", order.getLeverRate());
|
map.put("trade_avg_price", order.getTradeAvgPrice());
|
map.put("close_avg_price", order.getCloseAvgPrice());
|
map.put("stop_price_profit", order.getStopPriceProfit());
|
map.put("stop_price_loss", order.getStopPriceLoss());
|
List<Realtime> list= dataService.realtime(order.getSymbol());
|
double closePrice= CollectionUtil.isEmpty(list)?0:list.get(0).getClose();
|
map.put("close_price",closePrice);
|
map.put("state", order.getState());
|
double debt=order.getDeposit()-
|
order.getDepositOpen();
|
map.put("debt",debt);//负债
|
map.put("deposit_open", order.getDepositOpen());
|
//风险率
|
double interestRate = sysparaService.find("exchange_lever_interest_rate").getDouble();// 利率
|
double unpaidInterest= compute(order.getCreateTime(),new Date(),interestRate,order.getDeposit()-
|
order.getDepositOpen());
|
map.put("deposit_open", order.getDepositOpen()-unpaidInterest);
|
map.put("riskRate", new BigDecimal(calculateRiskRate(order.getDeposit(),
|
debt,unpaidInterest)).setScale(2,BigDecimal.ROUND_UP));
|
|
if (order.getVolume().compareTo(order.getVolumeOpen()) != 0) {// 不相等
|
map.put("amount", Arith.mul(order.getDeposit(), order.getLeverRate()));
|
} else {
|
map.put("amount", Arith.mul(order.getDepositOpen(), order.getLeverRate()));
|
}
|
map.put("amount_open", Arith.mul(order.getDepositOpen(), order.getLeverRate()));
|
map.put("fee", order.getFee());
|
map.put("deposit", order.getDeposit());
|
map.put("change_ratio", order.getChangeRatio());
|
map.put("liquidationPrice", calculateLiquidationPrice(money+order.getDepositOpen(),closePrice,order.getVolume()));
|
double profit=0;
|
if (!CollectionUtil.isEmpty(list)){
|
profit = (list.get(0).getClose()*order.getVolumeOpen())- (order.getTradeAvgPrice() * order.getVolumeOpen());
|
}
|
map.put("profit",new BigDecimal(profit).setScale(4,BigDecimal.ROUND_UP));
|
map.put("volume", order.getVolume());
|
map.put("volume_open", order.getVolumeOpen());
|
if (CollectionUtil.isEmpty(list)){
|
throw new BusinessException(order.getSymbol()+"获取行情数据失败");
|
}
|
map.put("profit_rate", calculateProfitPercentage(order.getTradeAvgPrice(),list.get(0).getClose()));
|
return map;
|
}
|
|
|
|
public static long getHours(Date startDate, Date endDate) {
|
Instant startInstant = startDate.toInstant();
|
LocalDateTime startTime = LocalDateTime.ofInstant(startInstant, ZoneId.systemDefault());
|
Instant instant = endDate.toInstant();
|
LocalDateTime endTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
|
Duration duration = Duration.between(startTime, endTime);
|
// 获取小时数
|
long hours = duration.toHours();
|
return hours;
|
}
|
|
public static double compute(Date startDate, Date endDate,
|
double interestRate, double deposit) {
|
// 获取小时数
|
long hours = getHours(startDate, endDate);
|
System.out.println(hours + "");
|
// 借款金額 *5* 小時利率 * 借款小時數
|
return deposit * (hours * interestRate);
|
}
|
|
/**
|
* @param positionAssetValue 仓位总资产估值
|
* @param totalLiabilities 总负债
|
* @param unpaidInterest 未归还利息
|
* @return
|
*/
|
// 计算风险率
|
public static double calculateRiskRate(double positionAssetValue, double totalLiabilities, double unpaidInterest) {
|
|
return ((positionAssetValue) / (totalLiabilities + unpaidInterest) - 1) * 100;
|
}
|
|
public static void main(String[] args) {
|
double interestRate =0.0016;// 利率
|
double debt=400;
|
double positionAssetValue=100;
|
Date date= DateUtil.stringToDate("2023-12-30 12:00:00","yyyy-MM-dd HH:mm:ss");
|
double unpaidInterest= compute(date,new Date(),interestRate,400);
|
System.out.println(unpaidInterest);
|
|
double dd= calculateRiskRate(10000,debt,unpaidInterest);
|
System.out.println(dd);
|
}
|
|
/**
|
* 计算强平价格
|
* @param initMargin 仓位初始保证金
|
* @param currentPrice 当前价格
|
*@param currentPrice 维持保证金
|
* @param positionQty 仓位数量
|
*/
|
public static double calculateLiquidationPrice(double initMargin, double currentPrice,
|
double positionQty) {
|
// 定义变量和常量
|
double maintenanceMarginRate =calculateMaintenanceMarginRate(initMargin,currentPrice,positionQty);
|
// 计算强平价格
|
double liquidationPrice = (initMargin + (currentPrice * positionQty - initMargin) * maintenanceMarginRate) / positionQty;
|
if (liquidationPrice<=0){
|
return 0;
|
}
|
return liquidationPrice;
|
}
|
|
/**
|
* 维持保证金率
|
* @return
|
*/
|
public static double calculateMaintenanceMarginRate(double maintenanceMargin,
|
double currentPrice,double positionQty ){
|
|
|
// 计算维持保证金率
|
double maintenanceMarginRate = maintenanceMargin / (currentPrice * positionQty);
|
return maintenanceMarginRate;
|
}
|
|
/**
|
* 计算收益
|
* @param buyPrice
|
* @param currentPrice
|
* @return
|
*/
|
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();
|
}
|
|
/**
|
* 计算负债
|
* @param positionValue
|
* @param leverageRatio
|
* @return
|
*/
|
public static double calculateDebt(double positionValue, double leverageRatio) {
|
// 计算负债
|
double debt = positionValue * (leverageRatio - 1);
|
|
return debt;
|
}
|
}
|
