package com.yami.trading.api.controller.exchange;
|
|
import cn.hutool.core.util.ObjectUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
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.item.domain.Item;
|
import com.yami.trading.bean.model.*;
|
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.domain.UUIDEntity;
|
import com.yami.trading.common.exception.YamiShopBindException;
|
import com.yami.trading.common.util.Arith;
|
import com.yami.trading.common.util.DateUtils;
|
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.CapitaltWalletService;
|
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.item.ItemService;
|
import com.yami.trading.service.syspara.SysparaService;
|
import com.yami.trading.service.user.UserService;
|
import com.yami.trading.service.user.WalletExtendService;
|
import io.swagger.annotations.Api;
|
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.RequestMapping;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.util.*;
|
|
/**
|
* 兑换
|
* 币币交易 低买高卖
|
*/
|
@RestController
|
@CrossOrigin
|
@Slf4j
|
@Api(tags = " 币币交易 -api")
|
public class ApiExchangeApplyOrderController {
|
private final String action = "/api/exchangeapplyorder!";
|
@Autowired
|
private SessionTokenService sessionTokenService;
|
@Autowired
|
UserService userService;
|
@Autowired
|
private SysparaService sysparaService;
|
@Autowired
|
private DataService dataService;
|
@Autowired
|
private ExchangeApplyOrderService exchangeApplyOrderService;
|
@Autowired
|
WalletService walletService;
|
@Autowired
|
RealNameAuthRecordService realNameAuthRecordService;
|
@Autowired
|
ItemService itemService;
|
@Autowired
|
CapitaltWalletService capitaltWalletService;
|
@Autowired
|
WalletExtendService walletExtendService;
|
/**
|
* 兑换币 如果是使用usdt兑换其他币种，则直接执行正常买币open流程 如果是其他币种--》usdt 则是直接卖币流程
|
* 如果是其他币种到另一个币种，则需要先卖出，然后再买入
|
* <p>
|
* 兑换接口
|
*/
|
@RequestMapping(action + "buy_and_sell.action")
|
public Object buy_and_sell(HttpServletRequest request) {
|
String volume_temp = request.getParameter("volume");
|
if (StringUtils.isNullOrEmpty(volume_temp)
|
|| !StringUtils.isDouble(volume_temp) || Double.valueOf(volume_temp) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
double volume = Double.valueOf(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 ((object == null) || (!partyId.equals((String) object))) {
|
log.info("sessionToken{}", object);
|
System.out.println("sessionToken " + object);
|
throw new YamiShopBindException("请稍后再试");
|
}
|
User party = userService.getById(partyId);
|
if (!party.isEnabled()) {
|
throw new YamiShopBindException("用户已禁用!");
|
}
|
symbol = symbol.toLowerCase();
|
symbol_to = symbol_to.toLowerCase();
|
|
Map<String, Object> parities = parities(symbol, symbol_to, volume_temp);
|
Object getVolume = parities.get("get_volume");
|
if(symbol.equals("usdt")){
|
CapitaltWallet userIdWallet = capitaltWalletService.getUserIdWallet(partyId);
|
if(userIdWallet.getMoney().compareTo(new BigDecimal(volume_temp)) < 0){
|
throw new YamiShopBindException("not sufficient funds");
|
}
|
Double value = Double.valueOf(volume_temp);
|
capitaltWalletService.update(userIdWallet, -value);
|
|
WalletExtend walletExtend = walletExtendService.getOne(new LambdaQueryWrapper<>(WalletExtend.class)
|
.eq(WalletExtend::getWallettype, symbol_to)
|
.eq(WalletExtend::getPartyId,partyId)
|
.last(" limit 1"));
|
if(ObjectUtil.isNotEmpty(walletExtend)){
|
Double valueOf = Double.valueOf(getVolume.toString());
|
walletExtend.setAmount(walletExtend.getAmount() + valueOf);
|
System.out.println("-----------------------:"+walletExtend.toString());
|
walletExtendService.update(walletExtend,new LambdaUpdateWrapper<WalletExtend>().eq(UUIDEntity::getUuid,walletExtend.getUuid()));
|
}else{
|
WalletExtend extend = new WalletExtend();
|
extend.setPartyId(partyId);
|
extend.setWallettype(symbol_to);
|
extend.setAmount(Double.valueOf(getVolume.toString()));
|
walletExtendService.save(extend);
|
}
|
}else if(symbol_to.equals("usdt")){
|
|
|
WalletExtend walletExtend = walletExtendService.getOne(new LambdaQueryWrapper<>(WalletExtend.class)
|
.eq(WalletExtend::getWallettype, symbol)
|
.eq(WalletExtend::getPartyId,partyId)
|
.last(" limit 1"));
|
if(ObjectUtil.isEmpty(walletExtend) || walletExtend.getAmount() < Double.valueOf(volume_temp)){
|
throw new YamiShopBindException("not sufficient funds");
|
}
|
Double valueOf = Double.valueOf(volume_temp);
|
walletExtend.setAmount(walletExtend.getAmount() - valueOf);
|
walletExtendService.update(walletExtend,new LambdaUpdateWrapper<WalletExtend>().eq(UUIDEntity::getUuid,walletExtend.getUuid()));
|
|
|
CapitaltWallet userIdWallet = capitaltWalletService.getUserIdWallet(partyId);
|
capitaltWalletService.update(userIdWallet,Double.valueOf(getVolume.toString()));
|
}else{
|
WalletExtend walletExtend = walletExtendService.getOne(new LambdaQueryWrapper<>(WalletExtend.class)
|
.eq(WalletExtend::getWallettype, symbol)
|
.eq(WalletExtend::getPartyId,partyId)
|
.last(" limit 1"));
|
if(ObjectUtil.isEmpty(walletExtend) || walletExtend.getAmount() < Double.valueOf(volume_temp)){
|
throw new YamiShopBindException("not sufficient funds");
|
}
|
Double valueOf = Double.valueOf(volume_temp);
|
walletExtend.setAmount(walletExtend.getAmount() - valueOf);
|
walletExtendService.update(walletExtend,new LambdaUpdateWrapper<WalletExtend>().eq(UUIDEntity::getUuid,walletExtend.getUuid()));
|
|
WalletExtend toWalletExtend = walletExtendService.getOne(new LambdaQueryWrapper<>(WalletExtend.class)
|
.eq(WalletExtend::getWallettype, symbol_to)
|
.eq(WalletExtend::getPartyId,partyId)
|
.last(" limit 1"));
|
Double value = Double.valueOf(getVolume.toString());
|
if(ObjectUtil.isNotEmpty(toWalletExtend)){
|
toWalletExtend.setAmount(toWalletExtend.getAmount() + value);
|
walletExtendService.update(toWalletExtend,new LambdaUpdateWrapper<WalletExtend>().eq(UUIDEntity::getUuid,toWalletExtend.getUuid()));
|
}else{
|
WalletExtend extend = new WalletExtend();
|
extend.setPartyId(partyId);
|
extend.setWallettype(symbol_to);
|
extend.setAmount(value);
|
walletExtendService.save(extend);
|
}
|
}
|
return Result.succeed();
|
}
|
|
public Map<String,Object> parities(String symbol,String symbol_to,String volume_temp){
|
Map<String, Object> data = new HashMap<String, Object>();
|
symbol = symbol.toLowerCase();
|
symbol_to = symbol_to.toLowerCase();
|
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 则计算收益
|
List<Realtime> realtime_list = this.dataService.realtime(symbol_to);
|
Realtime realtime = null;
|
if (realtime_list.size() > 0) {
|
realtime = realtime_list.get(0);
|
} else {
|
throw new YamiShopBindException("系统错误，请稍后重试");
|
}
|
double symbol_to_price = realtime.getClose().doubleValue();
|
// 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 则计算收益
|
*/
|
List<Realtime> realtime_list = this.dataService.realtime(symbol);
|
Realtime realtime = null;
|
if (realtime_list.size() > 0) {
|
realtime = realtime_list.get(0);
|
} else {
|
throw new YamiShopBindException("系统错误，请稍后重试");
|
}
|
double symbol_price = realtime.getClose().doubleValue();
|
// 对应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 {
|
double symbol_price = 0;
|
double symbol_to_price = 0;
|
// 获取币种最新价格
|
List<Realtime> realtime_list = this.dataService.realtime(symbol);
|
Realtime realtime = null;
|
if (realtime_list.size() > 0) {
|
realtime = realtime_list.get(0);
|
symbol_price = realtime.getClose().doubleValue();
|
} else {
|
throw new YamiShopBindException("系统错误，请稍后重试");
|
}
|
// 获取币种最新价格
|
List<Realtime> realtime_list_to = this.dataService.realtime(symbol_to);
|
Realtime realtime_to = null;
|
if (realtime_list_to.size() > 0) {
|
realtime_to = realtime_list_to.get(0);
|
symbol_to_price = realtime_to.getClose().doubleValue();
|
} else {
|
throw new YamiShopBindException("系统错误，请稍后重试");
|
}
|
if (symbol_to_price == 0) {
|
symbol_to_price = 1;
|
}
|
if (symbol_price == 0) {
|
symbol_price = 1;
|
}
|
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 data;
|
}
|
|
|
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().doubleValue();
|
} 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, Object>();
|
String session_token = sessionTokenService.savePut(partyId);
|
session.put("session_token", session_token);
|
return Result.succeed(session);
|
}
|
|
/**
|
* 兑换汇率
|
*/
|
@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> parities = parities(symbol, symbol_to, volume_temp);
|
return Result.succeed(parities);
|
}
|
|
/**
|
* 兑换记录
|
* 委托单记录
|
*/
|
@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.valueOf(page_no);
|
if ("orders".equals(type)) {
|
// 页条数配成1000达到不分页的效果
|
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";
|
}
|
SumEtfDto sumEtfDto=exchangeApplyOrderService.getProfitLossByUserId(userId,symbolType);
|
return Result.succeed(sumEtfDto);
|
}
|
/**
|
* 获取etf 持仓比例
|
* @return
|
*/
|
@RequestMapping(action + "getETFList.action")
|
public Result< List<ExchangeSymbolDto>> getETFList( String symbolType) {
|
String userId = SecurityUtils.getCurrentUserId();
|
if (StringUtils.isEmptyString(symbolType)){
|
symbolType="indices";
|
}
|
List<ExchangeSymbolDto> sumEtfDto=exchangeApplyOrderService.getETFListByUserId(userId,symbolType);
|
return Result.succeed(sumEtfDto);
|
}
|
|
/**
|
* 币币交易-买入
|
* 开仓页面参数
|
*/
|
@RequestMapping(action + "openview.action")
|
public Result openview() {
|
Map<String, Object> data = new HashMap<String, Object>();
|
String partyId = SecurityUtils.getUser().getUserId();
|
// Wallet wallet = walletService.saveWalletByPartyId(partyId);
|
CapitaltWallet userIdWallet = capitaltWalletService.getUserIdWallet(partyId);
|
// 账户剩余资金
|
DecimalFormat df = new DecimalFormat("#.##");
|
df.setRoundingMode(RoundingMode.FLOOR);// 向下取整
|
data.put("volume", df.format(userIdWallet.getMoney()));
|
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, Object>();
|
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
|
: new BigDecimal(String.valueOf(walletExtend.getAmount())).toPlainString());
|
String session_token = sessionTokenService.savePut(partyId);
|
data.put("session_token", session_token);
|
data.put("fee", sysparaService.find("exchange_apply_order_sell_fee").getSvalue());
|
/*Item item = itemService.findCurrBySymbol(symbol);
|
data.put("status", item.getStatus() == null || item.getStatus() == 1 ? 1 :0);*/
|
data.put("status", 1);
|
}
|
return Result.succeed(data);
|
}
|
|
/**
|
* 币币交易-买入
|
*/
|
@RequestMapping(action + "open.action")
|
public Object open(HttpServletRequest request) {
|
// 委托数量
|
String volume = request.getParameter("volume");
|
String session_token = request.getParameter("session_token");
|
String symbol = request.getParameter("symbol");
|
// Item bySymbol = itemService.findBySymbol(symbol);
|
// if(bySymbol == null){
|
// throw new YamiShopBindException("当前币对不存在");
|
// }
|
// boolean isOpen = MarketOpenChecker.isMarketOpenByItemCloseType(bySymbol.getOpenCloseType());
|
// if(!isOpen){
|
// throw new YamiShopBindException("当前已经休市");
|
// }
|
// limit order的交易价格
|
String price = request.getParameter("price");
|
// 计划委托 是之前火币那边拷贝学过来的一个功能 只是只有一个盘在用，暂时注释不用
|
// 是否计划委托
|
String is_trigger_order = request.getParameter("is_trigger_order");
|
// 计划委托的触发价
|
String trigger_price = request.getParameter("trigger_price");
|
// 订单报价类型。 "limit":限价 "opponent":对手价（市价）
|
String order_price_type = request.getParameter("order_price_type");
|
String partyId = SecurityUtils.getUser().getUserId();
|
if (StringUtils.isNullOrEmpty(volume)
|
|| !StringUtils.isDouble(volume)
|
|| Double.valueOf(volume) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((object == null) || (!partyId.equals((String) object))) {
|
throw new YamiShopBindException("请稍后再试");
|
}
|
User party = userService.getById(partyId);
|
if (!party.isEnabled()) {
|
throw new YamiShopBindException("用户已禁用");
|
}
|
|
String userName = party.getUserName();
|
|
Syspara syspara = sysparaService.find("stop_user_internet");
|
String stopUserInternet = syspara.getSvalue();
|
if(org.apache.commons.lang3.StringUtils.isNotEmpty(stopUserInternet)) {
|
String[] stopUsers = stopUserInternet.split(",");
|
|
System.out.println("userName = " + userName);
|
System.out.println("stopUserInternet = " + stopUserInternet);
|
|
if(Arrays.asList(stopUsers).contains(userName.trim())){
|
throw new YamiShopBindException("无网络");
|
}
|
}
|
|
|
|
RealNameAuthRecord party_kyc = realNameAuthRecordService.getByUserId(partyId);
|
if (party_kyc != null) {
|
if (!(party_kyc.getStatus() == 2) && "true".equals(sysparaService.find("exchange_by_kyc").getSvalue())) {
|
throw new YamiShopBindException("无权限");
|
}
|
}
|
List<Realtime> realtimes = this.dataService.realtime(symbol);
|
double close = 1;
|
if (realtimes != null) {
|
close = realtimes.get(0).getClose().doubleValue();
|
} else {
|
throw new YamiShopBindException("参数错误");
|
}
|
ExchangeApplyOrder order = new ExchangeApplyOrder();
|
order.setPartyId(partyId);
|
order.setSymbol(symbol);
|
order.setOffset(ExchangeApplyOrder.OFFSET_OPEN);
|
order.setVolume(Double.valueOf(volume));
|
order.setPrice(StringUtils.isNullOrEmpty(price) ? 0 : Double.valueOf(price));
|
order.setTriggerOrder(StringUtils.isNullOrEmpty(is_trigger_order) ? false : Boolean.valueOf(is_trigger_order));
|
order.setTriggerPrice(StringUtils.isNullOrEmpty(trigger_price) ? 0 : Double.valueOf(trigger_price));
|
order.setOrderPriceType(order_price_type);
|
order.setRelationOrderNo(UUID.randomUUID().toString());
|
order.setClosePrice(close);
|
// 限价单 && limit order的交易价格 为空
|
if ("limit".equals(order.getOrderPriceType()) && order.getPrice() == null) {
|
order.setPrice(close);
|
}
|
exchangeApplyOrderService.saveCreate(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 is_trigger_order = request.getParameter("is_trigger_order");
|
// 计划委托的触发价
|
String trigger_price = request.getParameter("trigger_price");
|
// 订单报价类型。 "limit":限价 "opponent":市价
|
String order_price_type = request.getParameter("order_price_type");
|
String partyId = SecurityUtils.getUser().getUserId();
|
boolean lock = false;
|
if (StringUtils.isNullOrEmpty(volume)
|
|| !StringUtils.isDouble(volume)
|
|| Double.valueOf(volume) <= 0) {
|
throw new YamiShopBindException("请输入正确的货币数量");
|
}
|
lock = true;
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((object == null) || (!partyId.equals((String) object))) {
|
throw new YamiShopBindException("请稍后再试");
|
}
|
User party = userService.getById(partyId);
|
if (!party.isEnabled()) {
|
throw new YamiShopBindException("用户已禁用");
|
}
|
|
Syspara syspara = sysparaService.find("stop_user_internet");
|
String stopUserInternet = syspara.getSvalue();
|
if(org.apache.commons.lang3.StringUtils.isNotEmpty(stopUserInternet)) {
|
String[] stopUsers = stopUserInternet.split(",");
|
|
System.out.println("userName = " + party.getUserName());
|
System.out.println("stopUserInternet = " + stopUserInternet);
|
|
if(Arrays.asList(stopUsers).contains(party.getUserName())){
|
throw new YamiShopBindException("无网络");
|
}
|
}
|
|
List<Realtime> realtimes = this.dataService.realtime(symbol);
|
double close = 1;
|
if (realtimes != null) {
|
close = realtimes.get(0).getClose().doubleValue();
|
} else {
|
throw new YamiShopBindException("参数错误");
|
}
|
ExchangeApplyOrder order = new ExchangeApplyOrder();
|
order.setPartyId(partyId);
|
order.setSymbol(symbol);
|
order.setOffset(ExchangeApplyOrder.OFFSET_CLOSE);
|
order.setVolume(Double.valueOf(volume));
|
order.setPrice(StringUtils.isNullOrEmpty(price) ? 0 : Double.valueOf(price));
|
order.setTriggerOrder(StringUtils.isNullOrEmpty(is_trigger_order) ? false : Boolean.valueOf(is_trigger_order));
|
order.setTriggerPrice(StringUtils.isNullOrEmpty(trigger_price) ? 0 : Double.valueOf(trigger_price));
|
order.setOrderPriceType(order_price_type);
|
order.setRelationOrderNo(UUID.randomUUID().toString());
|
order.setClosePrice(close);
|
// 限价单 && limit order的交易价格 为空
|
if ("limit".equals(order.getOrderPriceType()) && order.getPrice() == null) {
|
order.setPrice(close);
|
}
|
this.exchangeApplyOrderService.saveCreate(order);
|
return Result.succeed();
|
}
|
|
/**
|
* 撤单
|
*/
|
@RequestMapping(action + "cancel.action")
|
public Object cancel(HttpServletRequest request) {
|
String order_no = request.getParameter("order_no");
|
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;
|
|
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) {
|
DecimalFormat df = new DecimalFormat("#.##");
|
Map<String, Object> map = new HashMap<String, Object>();
|
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));
|
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("amount", order.getAmount());
|
map.put("close_price", order.getClosePrice());
|
map.put("close_time", DateUtils.format(order.getCloseTime(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("trigger_price", order.getTriggerPrice());
|
map.put("is_trigger_order", order.isTriggerOrder());
|
return map;
|
}
|
}
|
