package com.yami.trading.api.controller.exchange;
|
|
import com.yami.trading.bean.data.domain.Realtime;
|
import com.yami.trading.bean.exchange.ExchangeApplyOrder;
|
import com.yami.trading.bean.exchange.dto.ExchangeSymbolDto;
|
import com.yami.trading.bean.exchange.dto.SumEtfDto;
|
import com.yami.trading.bean.exchange.dto.TodayTransactionDto;
|
import com.yami.trading.bean.model.User;
|
import com.yami.trading.bean.model.Wallet;
|
import com.yami.trading.bean.model.WalletExtend;
|
import com.yami.trading.bean.purchasing.dto.ExchangeLock;
|
import com.yami.trading.bean.syspara.domain.Syspara;
|
import com.yami.trading.common.domain.Result;
|
import com.yami.trading.common.exception.YamiShopBindException;
|
import com.yami.trading.common.util.Arith;
|
import com.yami.trading.common.util.DateUtil;
|
import com.yami.trading.common.util.StringUtils;
|
import com.yami.trading.common.util.ThreadUtils;
|
import com.yami.trading.security.common.util.SecurityUtils;
|
import com.yami.trading.service.RealNameAuthRecordService;
|
import com.yami.trading.service.SessionTokenService;
|
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.impl.ContractAndFutureProfit;
|
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.UserService;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.CrossOrigin;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.UUID;
|
|
/**
|
* 现货交易
|
*/
|
@RestController
|
@CrossOrigin
|
@Slf4j
|
@Api(tags = "现货交易API")
|
public class ApiExchangeApplyOrderController {
|
private final String action = "/api/exchangeapplyorder!";
|
@Autowired
|
SessionTokenService sessionTokenService;
|
@Autowired
|
UserService userService;
|
@Autowired
|
SysparaService sysparaService;
|
@Autowired
|
DataService dataService;
|
@Autowired
|
ExchangeApplyOrderService exchangeApplyOrderService;
|
@Autowired
|
WalletService walletService;
|
@Autowired
|
RealNameAuthRecordService realNameAuthRecordService;
|
@Autowired
|
ItemService itemService;
|
@Autowired
|
private ExchangeRateService exchangeRateService;
|
|
private double getRealtimePrice(String symbol) {
|
List<Realtime> realtimes = dataService.realtime(symbol);
|
double close = 1;
|
if (realtimes != null && realtimes.size() > 0) {
|
close = realtimes.get(0).getClose();
|
} else {
|
throw new YamiShopBindException("参数错误");
|
}
|
return close;
|
}
|
|
/**
|
* 首次进入页面，传递session_token
|
*/
|
@RequestMapping(action + "view.action")
|
public Result view() {
|
String partyId = SecurityUtils.getUser().getUserId();
|
Map<String, Object> session = new HashMap<>();
|
String session_token = sessionTokenService.savePut(partyId);
|
session.put("session_token", session_token);
|
return Result.succeed(session);
|
}
|
|
|
@PostMapping(action + "todayTransaction")
|
@ApiOperation("当日成交汇总")
|
public Result todayTransaction(String symbol,String startDate,String endDate) {
|
Date now=new Date();
|
Date startStrDate=now;
|
Date endStrDate=now;
|
if (StringUtils.isNotEmpty(startDate)){
|
startStrDate = DateUtil.stringToDate(startDate,"yyyy-MM-dd");
|
endStrDate=DateUtil.stringToDate(endDate,"yyyy-MM-dd");
|
}
|
log.info(startDate+"===="+endDate);
|
log.info(startStrDate+"===="+endStrDate);
|
List<TodayTransactionDto> list= exchangeApplyOrderService.getTodayTransaction(symbol,SecurityUtils.getCurrentUserId(),startStrDate,
|
endStrDate);
|
for (TodayTransactionDto dto:list){
|
String symbolName = itemService.findBySymbol(dto.getSymbol()).getName();
|
dto.setSymbolName(symbolName);
|
}
|
return Result.succeed(list);
|
}
|
|
|
/**
|
* 兑换记录
|
* 委托单记录
|
*/
|
@RequestMapping(action + "list.action")
|
public Result list(HttpServletRequest request) {
|
List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
|
String symbol = request.getParameter("symbol");
|
String type = request.getParameter("type");
|
String isAll = request.getParameter("isAll");
|
String startTime = request.getParameter("startTime");
|
String endTime = request.getParameter("endTime");
|
String symbolType = request.getParameter("symbolType");
|
String orderPriceType = request.getParameter("orderPriceType");
|
String page_no = request.getParameter("page_no");
|
int pageNo = Integer.parseInt(page_no);
|
|
if ("orders".equals(type)) {
|
data = this.exchangeApplyOrderService.getPaged(pageNo, 1000, SecurityUtils.getCurrentUserId(), symbol, type, isAll, startTime, endTime, symbolType, orderPriceType);
|
} else {
|
data = this.exchangeApplyOrderService.getPaged(pageNo, 10, SecurityUtils.getCurrentUserId(), symbol, type, isAll, startTime, endTime, symbolType, orderPriceType);
|
}
|
return Result.succeed(data);
|
}
|
|
/**
|
* 获取etf 总资产
|
*
|
* @return
|
*/
|
@RequestMapping(action + "getETFSum.action")
|
public Result<SumEtfDto> getETFSum(String symbolType) {
|
String userId = SecurityUtils.getCurrentUserId();
|
if (StringUtils.isEmptyString(symbolType)) {
|
symbolType = "indices";
|
}
|
DecimalFormat df2 = new DecimalFormat("#.####");
|
ContractAndFutureProfit contractAndFutureProfit = walletService.calculateContractAndFutureProfit(userId, symbolType);
|
|
Map<String, Object> moneyContract = walletService.getMoneyAll(userId, symbolType);
|
|
SumEtfDto sumEtfDto = new SumEtfDto();
|
sumEtfDto.setSumVolume(df2.format(Double.parseDouble(moneyContract.get("money_wallet").toString())));
|
sumEtfDto.setSumPrice(df2.format(Double.parseDouble(moneyContract.get("symbol_type_asserts").toString())));
|
sumEtfDto.setProfitLoss(df2.format(contractAndFutureProfit.getOrderProfit()));
|
sumEtfDto.setToDayProfitLoss(df2.format(contractAndFutureProfit.getOrderProfitToday()));
|
return Result.succeed(sumEtfDto);
|
}
|
|
/**
|
* 查询现货交易持仓单列表
|
*/
|
@RequestMapping(action + "getETFList.action")
|
public Result<List<ExchangeSymbolDto>> querySpotTradPositionList(String symbolType) {
|
if (StringUtils.isEmptyString(symbolType)) {
|
symbolType = "indices";
|
}
|
List<ExchangeSymbolDto> sumEtfDto = exchangeApplyOrderService.querySpotTradPositionList(SecurityUtils.getCurrentUserId(), symbolType);
|
return Result.succeed(sumEtfDto);
|
}
|
|
/**
|
* 现货交易-买入 开仓页面参数
|
*/
|
@RequestMapping(action + "openview.action")
|
public Result openView(String type) {
|
Map<String, Object> data = new HashMap<>();
|
String partyId = SecurityUtils.getUser().getUserId();
|
Wallet wallet = walletService.saveWalletByPartyId(partyId);
|
DecimalFormat df = new DecimalFormat("#.##");
|
df.setRoundingMode(RoundingMode.FLOOR);
|
data.put("volume", df.format(exchangeRateService.getCurrencyByType(wallet.getMoney(), type)));
|
String session_token = sessionTokenService.savePut(partyId);
|
data.put("session_token", session_token);
|
data.put("fee", sysparaService.find("exchange_apply_order_buy_fee").getSvalue());
|
return Result.succeed(data);
|
}
|
|
/**
|
* 现货交易-卖出 平仓页面参数
|
*/
|
@RequestMapping(action + "closeview.action")
|
public Result closeView(HttpServletRequest request) {
|
Map<String, Object> data = new HashMap<>();
|
String partyId = SecurityUtils.getUser().getUserId();
|
String symbol = request.getParameter("symbol");
|
if (!StringUtils.isNullOrEmpty(partyId)) {
|
WalletExtend walletExtend = walletService.saveExtendByPara(partyId, symbol);
|
data.put("volume", null == walletExtend ? 0 : walletExtend.getAmount());
|
String session_token = sessionTokenService.savePut(partyId);
|
data.put("session_token", session_token);
|
data.put("fee", sysparaService.find("exchange_apply_order_sell_fee").getSvalue());
|
}
|
return Result.succeed(data);
|
}
|
|
/**
|
* 现货交易-买入
|
*/
|
@RequestMapping(action + "open.action")
|
public Object open(String volume, String total, String session_token, String symbol, String price, String order_price_type) {
|
if (StringUtils.isNullOrEmpty(volume) || !StringUtils.isDouble(volume) || Double.parseDouble(volume) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
if (StringUtils.isNullOrEmpty(total) || !StringUtils.isDouble(total) || Double.parseDouble(total) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
String partyId = SecurityUtils.getUser().getUserId();
|
if ((!partyId.equals(object))) {
|
throw new YamiShopBindException("请稍后再试");
|
}
|
User party = userService.getById(partyId);
|
if (!party.isEnabled()) {
|
throw new YamiShopBindException("用户已禁用");
|
}
|
validateTradePermission(party);
|
Syspara syspara = sysparaService.find("stop_user_internet");
|
String stopUserInternet = syspara.getSvalue();
|
if (org.apache.commons.lang3.StringUtils.isNotEmpty(stopUserInternet)) {
|
String[] stopUsers = stopUserInternet.split(",");
|
if (Arrays.asList(stopUsers).contains(party.getUserName())) {
|
throw new YamiShopBindException("无网络");
|
}
|
}
|
Realtime realtime = this.dataService.realtime(symbol).get(0);
|
double priceTemp = Double.parseDouble(price);
|
if (ExchangeApplyOrder.ORDER_PRICE_TYPE_OPPONENT.equals(order_price_type)) {
|
double rate = Math.abs(Arith.sub(realtime.getClose(), priceTemp));
|
if (Arith.div(rate, priceTemp) > 0.05D) {
|
log.error("币种数量异常{},{},{}", symbol, priceTemp, realtime.getClose());
|
throw new YamiShopBindException("请稍后再试");
|
}
|
}
|
|
ExchangeApplyOrder order = new ExchangeApplyOrder();
|
order.setPartyId(partyId);
|
order.setSymbol(symbol);
|
order.setOffset(ExchangeApplyOrder.OFFSET_OPEN);
|
order.setSymbolValue(Double.parseDouble(total));
|
order.setVolume(Double.valueOf(volume));
|
order.setPrice(priceTemp);
|
order.setOrderPriceType(order_price_type);
|
|
order.setClosePrice(realtime.getClose());
|
exchangeApplyOrderService.saveSpotTradOpen(order);
|
return Result.succeed();
|
}
|
|
/**
|
* 币币交易-卖出
|
*/
|
@RequestMapping(action + "close.action")
|
public Object close(HttpServletRequest request) {
|
// 委托数量
|
String volume = request.getParameter("volume");
|
String session_token = request.getParameter("session_token");
|
String symbol = request.getParameter("symbol");
|
// limit order的交易价格
|
String price = request.getParameter("price");
|
String order_price_type = request.getParameter("order_price_type");
|
String partyId = SecurityUtils.getUser().getUserId();
|
if (StringUtils.isNullOrEmpty(volume) || !StringUtils.isDouble(volume) || Double.parseDouble(volume) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((!partyId.equals(object))) {
|
throw new YamiShopBindException("请稍后再试");
|
}
|
User party = userService.getById(partyId);
|
if (!party.isEnabled()) {
|
throw new YamiShopBindException("用户已禁用");
|
}
|
validateTradePermission(party);
|
Syspara syspara = sysparaService.find("stop_user_internet");
|
String stopUserInternet = syspara.getSvalue();
|
if (org.apache.commons.lang3.StringUtils.isNotEmpty(stopUserInternet)) {
|
String[] stopUsers = stopUserInternet.split(",");
|
if (Arrays.asList(stopUsers).contains(party.getUserName())) {
|
throw new YamiShopBindException("无网络");
|
}
|
}
|
ExchangeApplyOrder order = new ExchangeApplyOrder();
|
order.setPartyId(partyId);
|
order.setSymbol(symbol);
|
order.setOffset(ExchangeApplyOrder.OFFSET_CLOSE);
|
order.setVolume(Double.parseDouble(volume));
|
order.setSymbolValue(Double.parseDouble(volume));
|
order.setPrice(Double.parseDouble(price));
|
order.setOrderPriceType(order_price_type);
|
Realtime realtime = this.dataService.realtime(symbol).get(0);
|
order.setClosePrice(realtime.getClose());
|
this.exchangeApplyOrderService.saveSpotTradClose(order);
|
return Result.succeed();
|
}
|
|
/**
|
* 撤单
|
*/
|
@RequestMapping(action + "cancel.action")
|
public Object cancel(HttpServletRequest request) {
|
String order_no = request.getParameter("order_no");
|
|
// 直接开线程的方式不合适，要放到线程池里去做 TODO
|
CancelDelayThread lockDelayThread = new CancelDelayThread(SecurityUtils.getUser().getUserId(), order_no,
|
exchangeApplyOrderService);
|
Thread t = new Thread(lockDelayThread);
|
t.start();
|
|
return Result.succeed();
|
}
|
|
/**
|
* 新线程处理，直接拿到订单锁处理完成后退出
|
*/
|
public class CancelDelayThread implements Runnable {
|
private String partyId;
|
private String order_no;
|
private ExchangeApplyOrderService exchangeApplyOrderService;
|
|
@Override
|
public void run() {
|
try {
|
while (true) {
|
if (ExchangeLock.add(order_no)) {
|
this.exchangeApplyOrderService.saveCancel(partyId, order_no);
|
break;
|
}
|
ThreadUtils.sleep(100);
|
}
|
} catch (Exception e) {
|
log.error("error:", e);
|
} finally {
|
ThreadUtils.sleep(100);
|
ExchangeLock.remove(order_no);
|
}
|
}
|
|
public CancelDelayThread(String partyId, String order_no, ExchangeApplyOrderService exchangeApplyOrderService) {
|
this.partyId = partyId;
|
this.order_no = order_no;
|
this.exchangeApplyOrderService = exchangeApplyOrderService;
|
}
|
}
|
|
/**
|
* 详情接口
|
*/
|
@RequestMapping(action + "get.action")
|
public Object get(HttpServletRequest request) {
|
String order_no = request.getParameter("order_no");
|
ExchangeApplyOrder order = this.exchangeApplyOrderService.findByOrderNoAndPartyId(order_no,
|
SecurityUtils.getUser().getUserId());
|
return Result.succeed(bulidData(order));
|
}
|
|
private Map<String, Object> bulidData(ExchangeApplyOrder order) {
|
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", order.getCreateTime());
|
map.put("create_time_ts", order.getCreateTimeTs());
|
map.put("volume", order.getVolume());
|
map.put("offset", order.getOffset());
|
map.put("price", order.getPrice());
|
map.put("order_price_type", order.getOrderPriceType());
|
map.put("state", order.getState());
|
map.put("fee", order.getFee());
|
map.put("close_price", order.getClosePrice());
|
map.put("close_time", order.getCloseTime());
|
map.put("close_time_ts", order.getCloseTime() == null ? "" : order.getCloseTime().getTime());
|
return map;
|
}
|
|
|
//=============================================闪兑BEGIN================================================================
|
|
/**
|
* 兑换币 如果是使用usdt兑换其他币种，则直接执行正常买币open流程 如果是其他币种--》usdt 则是直接卖币流程
|
* 如果是其他币种到另一个币种，则需要先卖出，然后再买入
|
* 兑换接口
|
*/
|
@RequestMapping(action + "buy_and_sell.action")
|
public Object buyAndSell(HttpServletRequest request) {
|
String volume_temp = request.getParameter("volume");
|
if (StringUtils.isNullOrEmpty(volume_temp) || !StringUtils.isDouble(volume_temp) || Double.parseDouble(volume_temp) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
double volume = Double.parseDouble(volume_temp);
|
String symbol = request.getParameter("symbol");
|
String symbol_to = request.getParameter("symbol_to");
|
if (symbol.equals(symbol_to)) {
|
throw new YamiShopBindException("请选择正确的币种");
|
}
|
String session_token = request.getParameter("session_token");
|
String partyId = SecurityUtils.getUser().getUserId();
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((!partyId.equals(object))) {
|
log.info("sessionToken{}", object);
|
throw new YamiShopBindException("请稍后再试");
|
}
|
User party = userService.getById(partyId);
|
if (!party.isEnabled()) {
|
throw new YamiShopBindException("用户已禁用!");
|
}
|
validateTradePermission(party);
|
symbol = itemService.getCleanSymbol(symbol);
|
symbol_to = itemService.getCleanSymbol(symbol_to);
|
String relation_order_no = UUID.randomUUID().toString();
|
// 如果是使用usdt兑换其他币种，则直接执行正常买币open流程
|
if ("usdt".equals(symbol) || "usdt".equals(symbol_to)) {
|
ExchangeApplyOrder order = new ExchangeApplyOrder();
|
order.setPartyId(partyId);
|
order.setVolume(volume);
|
order.setOrderPriceType(ExchangeApplyOrder.ORDER_PRICE_TYPE_OPPONENT);
|
order.setRelationOrderNo(relation_order_no);
|
if ("usdt".equals(symbol)) {
|
order.setSymbol(symbol_to);
|
double openPrice = getRealtimePrice(symbol_to);
|
order.setPrice(openPrice);
|
order.setOffset(ExchangeApplyOrder.OFFSET_OPEN);
|
} else if ("usdt".equals(symbol_to)) {
|
order.setSymbol(symbol);
|
double closePrice = getRealtimePrice(symbol);
|
order.setPrice(closePrice);
|
order.setOffset(ExchangeApplyOrder.OFFSET_CLOSE);
|
}
|
exchangeApplyOrderService.saveCreate(order);
|
} else {
|
// 非usdt则需要进行一次卖出
|
ExchangeApplyOrder order_sell = new ExchangeApplyOrder();
|
order_sell.setPartyId(partyId);
|
order_sell.setSymbol(symbol);
|
order_sell.setOffset(ExchangeApplyOrder.OFFSET_CLOSE);
|
order_sell.setVolume(volume);
|
order_sell.setOrderPriceType(ExchangeApplyOrder.ORDER_PRICE_TYPE_OPPONENT);
|
order_sell.setRelationOrderNo(relation_order_no);
|
double sellClose = getRealtimePrice(symbol);
|
order_sell.setPrice(sellClose);
|
exchangeApplyOrderService.saveCreate(order_sell);
|
double close = getRealtimePrice(symbol);
|
double sub = Arith.sub(volume,
|
Arith.mul(volume, sysparaService.find("exchange_apply_order_sell_fee").getDouble()));
|
double amount = Arith.mul(sub, close);
|
// 再买入币种
|
ExchangeApplyOrder order_buy = new ExchangeApplyOrder();
|
order_buy.setPartyId(partyId);
|
order_buy.setSymbol(symbol_to);
|
order_buy.setOffset(ExchangeApplyOrder.OFFSET_OPEN);
|
order_buy.setVolume(amount);
|
order_buy.setRelationOrderNo(relation_order_no);
|
order_buy.setOrderPriceType(ExchangeApplyOrder.ORDER_PRICE_TYPE_OPPONENT);
|
double buyClose = getRealtimePrice(symbol_to);
|
order_buy.setPrice(buyClose);
|
exchangeApplyOrderService.saveCreate(order_buy);
|
}
|
return Result.succeed();
|
}
|
|
/**
|
* 兑换汇率
|
*/
|
@RequestMapping(action + "buy_and_sell_fee.action")
|
public Object buy_and_sell_fee(HttpServletRequest request) {
|
// 需兑换币种
|
String symbol = request.getParameter("symbol");
|
// 兑换后的币种
|
String symbol_to = request.getParameter("symbol_to");
|
if (symbol.equals(symbol_to)) {
|
throw new YamiShopBindException("请选择正确的币种");
|
}
|
// 委托数量
|
String volume_temp = request.getParameter("volume");
|
if (StringUtils.isNullOrEmpty(volume_temp)
|
|| !StringUtils.isDouble(volume_temp) || Double.valueOf(volume_temp) < 0) {
|
throw new YamiShopBindException("请输入正确的兑换数量");
|
}
|
Map<String, Object> data = new HashMap<>();
|
symbol = itemService.getCleanSymbol(symbol);
|
symbol_to = itemService.getCleanSymbol(symbol_to);
|
double buy_fee = Double.valueOf(sysparaService.find("exchange_apply_order_buy_fee").getSvalue());
|
double sell_fee = Double.valueOf(sysparaService.find("exchange_apply_order_sell_fee").getSvalue());
|
double volume = Double.valueOf(volume_temp);
|
if ("usdt".equals(symbol) || "usdt".equals(symbol_to)) {
|
if ("usdt".equals(symbol)) {
|
// 如果是使用Usdt 则计算收益
|
Realtime realtime = dataService.realtime(symbol_to).get(0);
|
double symbol_to_price = realtime.getClose();
|
// usdt除以的数量
|
data.put("get_rate", Arith.div(1, symbol_to_price, 5));
|
// 实际兑换数量= 兑换数量-手续费数量
|
double fact_volume = Arith.sub(volume, Arith.mul(volume, buy_fee));
|
// 实际价值 = 实际兑换数量 * 被兑换品种价格
|
double fact_price = Arith.mul(fact_volume, 1);
|
// 实际获取数量 = 实际价值 / 将要兑换的品种的价值
|
data.put("get_volume", Arith.div(fact_price, symbol_to_price, 5));
|
}
|
if ("usdt".equals(symbol_to)) {
|
/**
|
* 如果是转成Usdt 则计算收益
|
*/
|
Realtime realtime = this.dataService.realtime(symbol).get(0);
|
double symbol_price = realtime.getClose();
|
// 对应usdt数量
|
data.put("get_rate", Arith.div(symbol_price, 1, 5));
|
// 实际兑换数量= 兑换数量-手续费数量
|
double fact_volume = Arith.sub(volume, Arith.mul(volume, sell_fee));
|
// 实际价值 = 实际兑换数量 * 被兑换品种价格
|
double fact_price = Arith.mul(Arith.div(symbol_price, 1, 5), fact_volume);
|
// 实际获取数量 = 实际价值 / 将要兑换的品种的价值
|
data.put("get_volume", Arith.div(fact_price, 1, 5));
|
}
|
} else {
|
Realtime realtime = this.dataService.realtime(symbol).get(0);
|
Realtime realtimeTo = this.dataService.realtime(symbol_to).get(0);
|
double symbol_price = realtime.getClose();
|
double symbol_to_price = realtimeTo.getClose();
|
data.put("get_rate", Arith.div(symbol_price, symbol_to_price, 5));
|
// 总手续费比例
|
double all_fee = Arith.add(buy_fee, sell_fee);
|
// 实际兑换数量= 兑换数量-手续费数量
|
double fact_volume = Arith.sub(volume, Arith.mul(volume, all_fee));
|
// 实际价值 = 实际兑换数量 * 被兑换品种价格
|
double fact_price = Arith.mul(fact_volume, symbol_price);
|
// 实际获取数量 = 实际价值 / 将要兑换的品种的价值
|
data.put("get_volume", Arith.div(fact_price, symbol_to_price, 5));
|
}
|
return Result.succeed(data);
|
}
|
|
/**
|
* 闪兑记录列表
|
*/
|
@RequestMapping(action + "queryExchangeList")
|
public Result queryExchangeList(HttpServletRequest request) {
|
List<Map<String, Object>> data = exchangeApplyOrderService.queryExchangeListPage(1, 10, SecurityUtils.getCurrentUserId());
|
return Result.succeed(data);
|
}
|
|
//=============================================闪兑END================================================================
|
|
private void validateTradePermission(User user) {
|
if (user == null) {
|
throw new YamiShopBindException("用户不存在");
|
}
|
// 模拟账户不做二步校验限制
|
if (user.getAccountType() != null && user.getAccountType() == 1) {
|
return;
|
}
|
if (!user.isGoogleAuthBind() || StringUtils.isEmptyString(user.getSafePassword())) {
|
throw new YamiShopBindException("请先完成两步认证并设置资金密码后再交易");
|
}
|
}
|
|
}
|
