package project.project.web.api;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.UUID;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import kernel.web.BaseAction;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
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 kernel.exception.BusinessException;
|
import kernel.sessiontoken.SessionTokenService;
|
import kernel.util.Arith;
|
import kernel.util.DateUtils;
|
import kernel.util.StringUtils;
|
import kernel.util.ThreadUtils;
|
import kernel.web.ResultObject;
|
import project.data.DataService;
|
import project.data.model.Realtime;
|
import project.exchange.ExchangeApplyOrder;
|
import project.exchange.ExchangeApplyOrderService;
|
import project.exchange.ExchangeLock;
|
import project.item.ItemService;
|
import project.party.PartyService;
|
import project.party.model.Party;
|
import project.syspara.SysparaService;
|
import project.user.kyc.Kyc;
|
import project.user.kyc.KycService;
|
import project.wallet.Wallet;
|
import project.wallet.WalletExtend;
|
import project.wallet.WalletService;
|
|
/**
|
* 兑换
|
* 币币交易 低买高卖
|
*
|
*/
|
@RestController
|
@CrossOrigin
|
public class ExchangeApplyOrderController extends BaseAction {
|
@Autowired
|
private KycService kycService;
|
|
@Autowired
|
private DataService dataService;
|
|
@Autowired
|
private ItemService itemService;
|
|
@Autowired
|
private PartyService partyService;
|
|
@Autowired
|
private WalletService walletService;
|
|
@Autowired
|
private SysparaService sysparaService;
|
|
@Autowired
|
private SessionTokenService sessionTokenService;
|
|
private final String action = "/api/exchangeapplyorder!";
|
|
@Autowired
|
private ExchangeApplyOrderService exchangeApplyOrderService;
|
|
private static final Logger logger = LoggerFactory.getLogger(ExchangeApplyOrderController.class);
|
|
/**
|
* 兑换币 如果是使用usdt兑换其他币种，则直接执行正常买币open流程 如果是其他币种--》usdt 则是直接卖币流程
|
* 如果是其他币种到另一个币种，则需要先卖出，然后再买入
|
*
|
* 兑换接口
|
*/
|
@RequestMapping(action + "buy_and_sell.action")
|
public Object buy_and_sell(HttpServletRequest request) {
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
|
String volume_temp = request.getParameter("volume");
|
if (StringUtils.isNullOrEmpty(volume_temp)
|
|| !StringUtils.isDouble(volume_temp) || Double.valueOf(volume_temp) <= 0) {
|
throw new BusinessException("请输入正确的货币数量");
|
}
|
|
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 BusinessException("请选择正确的币种");
|
}
|
|
String session_token = request.getParameter("session_token");
|
|
String partyId = this.getLoginPartyId();
|
boolean lock = false;
|
try {
|
if (!ExchangeLock.add(partyId)) {
|
logger.error("ExchangeLock{}", partyId);
|
System.out.println("ExchangeLock " + partyId);
|
throw new BusinessException(1, "请稍后再试");
|
}
|
lock = true;
|
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((object == null) || (!this.getLoginPartyId().equals((String) object))) {
|
logger.error("sessionToken{}", object);
|
System.out.println("sessionToken " + object);
|
resultObject.setCode("1");
|
resultObject.setMsg("请稍后再试");
|
return resultObject;
|
}
|
|
Party party = this.partyService.cachePartyBy(partyId, false);
|
if (!party.getEnabled()) {
|
resultObject.setCode("506");
|
resultObject.setMsg(error);
|
return resultObject;
|
}
|
|
symbol = symbol.toLowerCase();
|
symbol_to = symbol_to.toLowerCase();
|
|
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.setOrder_price_type("opponent");
|
order.setRelation_order_no(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);
|
}
|
this.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.setOrder_price_type("opponent");
|
order_sell.setRelation_order_no(relation_order_no);
|
double sellClose = getRealtimePrice(symbol);
|
order_sell.setPrice(sellClose);
|
|
this.exchangeApplyOrderService.saveCreate(order_sell);
|
ThreadUtils.sleep(1000);
|
|
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.setRelation_order_no(relation_order_no);
|
order_buy.setOrder_price_type("opponent");
|
double buyClose = getRealtimePrice(symbol_to);
|
order_buy.setPrice(buyClose);
|
|
this.exchangeApplyOrderService.saveCreate(order_buy);
|
}
|
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
} finally {
|
if (lock) {
|
ThreadUtils.sleep(100);
|
ExchangeLock.remove(partyId);
|
}
|
}
|
return resultObject;
|
}
|
|
/**
|
* 首次进入页面，传递session_token
|
*/
|
@RequestMapping(action + "view.action")
|
public Object view() {
|
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
|
try {
|
|
String partyId = getLoginPartyId();
|
if (!StringUtils.isNullOrEmpty(partyId)) {
|
Map<String, Object> session = new HashMap<String, Object>();
|
String session_token = sessionTokenService.savePut(partyId);
|
session.put("session_token", session_token);
|
resultObject.setData(session);
|
}
|
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Throwable t) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", t);
|
}
|
return resultObject;
|
}
|
|
/**
|
* 兑换汇率
|
*/
|
@RequestMapping(action + "buy_and_sell_fee.action")
|
public Object buy_and_sell_fee(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
try {
|
|
// 需兑换币种
|
String symbol = request.getParameter("symbol");
|
// 兑换后的币种
|
String symbol_to = request.getParameter("symbol_to");
|
if (symbol.equals(symbol_to)) {
|
throw new BusinessException("请选择正确的币种");
|
}
|
|
// 委托数量
|
String volume_temp = request.getParameter("volume");
|
if (StringUtils.isNullOrEmpty(volume_temp)
|
|| !StringUtils.isDouble(volume_temp) || Double.valueOf(volume_temp) < 0) {
|
throw new BusinessException("请输入正确的兑换数量");
|
}
|
|
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").getValue());
|
double sell_fee = Double.valueOf(sysparaService.find("exchange_apply_order_sell_fee").getValue());
|
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 BusinessException("系统错误，请稍后重试");
|
}
|
double symbol_to_price = realtime.getClose();
|
// usdt除以的数量
|
data.put("get_rate", Arith.div(1, symbol_to_price));
|
|
// 实际兑换数量= 兑换数量-手续费数量
|
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));
|
}
|
|
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 BusinessException("系统错误，请稍后重试");
|
}
|
double symbol_price = realtime.getClose();
|
// 对应usdt数量
|
data.put("get_rate", Arith.div(symbol_price, 1));
|
|
// 实际兑换数量= 兑换数量-手续费数量
|
double fact_volume = Arith.sub(volume, Arith.mul(volume, sell_fee));
|
|
// 实际价值 = 实际兑换数量 * 被兑换品种价格
|
double fact_price = Arith.mul(Arith.div(symbol_price, 1), fact_volume);
|
|
// 实际获取数量 = 实际价值 / 将要兑换的品种的价值
|
data.put("get_volume", Arith.div(fact_price, 1));
|
}
|
} 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();
|
} else {
|
throw new BusinessException("系统错误，请稍后重试");
|
}
|
|
// 获取币种最新价格
|
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();
|
} else {
|
throw new BusinessException("系统错误，请稍后重试");
|
}
|
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));
|
|
// 总手续费比例
|
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));
|
}
|
resultObject.setData(data);
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
}
|
return resultObject;
|
}
|
|
/**
|
* 兑换记录
|
* 委托单记录
|
*
|
*/
|
@RequestMapping(action + "list.action")
|
public Object list(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
|
if (!"0".equals(resultObject.getCode())) {
|
resultObject.setData(data);
|
return resultObject;
|
}
|
|
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");
|
try {
|
|
String page_no = request.getParameter("page_no");
|
int pageNo = Integer.valueOf(page_no);
|
|
if ("orders".equals(type)) {
|
// 页条数配成1000达到不分页的效果
|
data = this.exchangeApplyOrderService.getPaged(pageNo, 1000, this.getLoginPartyId(), symbol, type, isAll,startTime,endTime);
|
} else {
|
data = this.exchangeApplyOrderService.getPaged(pageNo, 10, this.getLoginPartyId(), symbol, type, isAll,startTime,endTime);
|
}
|
|
resultObject.setData(data);
|
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
}
|
return resultObject;
|
}
|
|
/**
|
* 币币交易-买入
|
* 开仓页面参数
|
*/
|
@RequestMapping(action + "openview.action")
|
public Object openview() {
|
|
ResultObject resultObject = new ResultObject();
|
try {
|
Map<String, Object> data = new HashMap<String, Object>();
|
String partyId = this.getLoginPartyId();
|
if (!StringUtils.isNullOrEmpty(partyId)) {
|
Wallet wallet = walletService.saveWalletByPartyId(this.getLoginPartyId());
|
|
// 账户剩余资金
|
DecimalFormat df = new DecimalFormat("#.##");
|
df.setRoundingMode(RoundingMode.FLOOR);// 向下取整
|
data.put("volume", df.format(wallet.getMoney()));
|
String session_token = sessionTokenService.savePut(partyId);
|
data.put("session_token", session_token);
|
data.put("fee", sysparaService.find("exchange_apply_order_buy_fee").getValue());
|
}
|
|
resultObject.setData(data);
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
return resultObject;
|
}
|
|
/**
|
* 币币交易-卖出
|
* 平仓页面参数
|
*/
|
@RequestMapping(action + "closeview.action")
|
public Object closeview(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
try {
|
Map<String, Object> data = new HashMap<String, Object>();
|
String partyId = this.getLoginPartyId();
|
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").getValue());
|
}
|
resultObject.setData(data);
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
}
|
return resultObject;
|
}
|
|
/**
|
* 币币交易-买入
|
*
|
*/
|
@RequestMapping(action + "open.action")
|
public Object open(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
// 委托数量
|
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 = this.getLoginPartyId();
|
boolean lock = false;
|
try {
|
|
if (StringUtils.isNullOrEmpty(volume)
|
|| !StringUtils.isDouble(volume)
|
|| Double.valueOf(volume) <= 0) {
|
throw new BusinessException("请输入正确的货币数量");
|
}
|
|
if (!ExchangeLock.add(partyId)) {
|
throw new BusinessException(1, "请稍后再试");
|
}
|
|
lock = true;
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((object == null) || (!this.getLoginPartyId().equals((String) object))) {
|
resultObject.setCode("1");
|
resultObject.setMsg("请稍后再试");
|
return resultObject;
|
}
|
Party party = this.partyService.cachePartyBy(partyId, false);
|
if (!party.getEnabled()) {
|
resultObject.setCode("506");
|
resultObject.setMsg(error);
|
return resultObject;
|
}
|
|
Kyc party_kyc = kycService.get(party.getId().toString());
|
if (!(party_kyc.getStatus() == 2) && "true".equals(sysparaService.find("exchange_by_kyc").getValue())) {
|
throw new BusinessException(401, "无权限");
|
}
|
|
List<Realtime> realtimes = this.dataService.realtime(symbol);
|
double close = 1;
|
if (realtimes != null) {
|
close = realtimes.get(0).getClose();
|
} else {
|
throw new BusinessException("参数错误");
|
}
|
|
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.setIs_trigger_order(StringUtils.isNullOrEmpty(is_trigger_order) ? false : Boolean.valueOf(is_trigger_order));
|
order.setTrigger_price(StringUtils.isNullOrEmpty(trigger_price) ? 0 : Double.valueOf(trigger_price));
|
order.setOrder_price_type(order_price_type);
|
order.setRelation_order_no(UUID.randomUUID().toString());
|
order.setClose_price(close);
|
|
// 限价单 && limit order的交易价格 为空
|
if ("limit".equals(order.getOrder_price_type()) && order.getPrice() == null) {
|
order.setPrice(close);
|
}
|
|
exchangeApplyOrderService.saveCreate(order);
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
} finally {
|
if (lock) {
|
ThreadUtils.sleep(100);
|
ExchangeLock.remove(partyId);
|
}
|
}
|
return resultObject;
|
}
|
|
/**
|
* 币币交易-卖出
|
*/
|
@RequestMapping(action + "close.action")
|
public Object close(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
|
// 委托数量
|
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 = this.getLoginPartyId();
|
boolean lock = false;
|
try {
|
if (StringUtils.isNullOrEmpty(volume)
|
|| !StringUtils.isDouble(volume)
|
|| Double.valueOf(volume) <= 0) {
|
throw new BusinessException("请输入正确的货币数量");
|
}
|
if (!ExchangeLock.add(partyId)) {
|
throw new BusinessException(1, "请稍后再试");
|
}
|
lock = true;
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((object == null) || (!this.getLoginPartyId().equals((String) object))) {
|
resultObject.setCode("1");
|
resultObject.setMsg("请稍后再试");
|
return resultObject;
|
}
|
Party party = this.partyService.cachePartyBy(partyId, false);
|
if (!party.getEnabled()) {
|
resultObject.setCode("506");
|
resultObject.setMsg(error);
|
return resultObject;
|
}
|
|
List<Realtime> realtimes = this.dataService.realtime(symbol);
|
double close = 1;
|
if (realtimes != null) {
|
close = realtimes.get(0).getClose();
|
} else {
|
throw new BusinessException("参数错误");
|
}
|
|
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.setIs_trigger_order(StringUtils.isNullOrEmpty(is_trigger_order) ? false : Boolean.valueOf(is_trigger_order));
|
order.setTrigger_price(StringUtils.isNullOrEmpty(trigger_price) ? 0 : Double.valueOf(trigger_price));
|
order.setOrder_price_type(order_price_type);
|
order.setRelation_order_no(UUID.randomUUID().toString());
|
order.setClose_price(close);
|
|
// 限价单 && limit order的交易价格 为空
|
if ("limit".equals(order.getOrder_price_type()) && order.getPrice() == null) {
|
order.setPrice(close);
|
}
|
|
this.exchangeApplyOrderService.saveCreate(order);
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
} finally {
|
if (lock) {
|
ThreadUtils.sleep(100);
|
ExchangeLock.remove(partyId);
|
}
|
}
|
return resultObject;
|
}
|
|
/**
|
* 撤单
|
*/
|
@RequestMapping(action + "cancel.action")
|
public Object cancel(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
try {
|
String order_no = request.getParameter("order_no");
|
CancelDelayThread lockDelayThread = new CancelDelayThread(this.getLoginPartyId(), order_no,
|
exchangeApplyOrderService);
|
Thread t = new Thread(lockDelayThread);
|
t.start();
|
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
|
return resultObject;
|
}
|
|
/**
|
* 新线程处理，直接拿到订单锁处理完成后退出
|
*
|
*/
|
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) {
|
logger.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) {
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
try {
|
String order_no = request.getParameter("order_no");
|
ExchangeApplyOrder order = this.exchangeApplyOrderService.findByOrderNoAndPartyId(order_no,
|
this.getLoginPartyId());
|
resultObject.setData(bulidData(order));
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
return resultObject;
|
}
|
|
private Map<String, Object> bulidData(ExchangeApplyOrder order) {
|
DecimalFormat df = new DecimalFormat("#.##");
|
Map<String, Object> map = new HashMap<String, Object>();
|
map.put("order_no", order.getOrder_no());
|
map.put("name", itemService.cacheBySymbol(order.getSymbol(), false).getName());
|
map.put("symbol", order.getSymbol());
|
map.put("create_time", DateUtils.format(order.getCreate_time(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("volume", order.getVolume());
|
map.put("offset", order.getOffset());
|
map.put("price", order.getPrice());
|
map.put("order_price_type", order.getOrder_price_type());
|
map.put("state", order.getState());
|
map.put("fee", order.getFee());
|
map.put("amount", order.getAmount());
|
map.put("close_price", order.getClose_price());
|
map.put("close_time", DateUtils.format(order.getClose_time(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("trigger_price", order.getTrigger_price());
|
map.put("is_trigger_order", order.isIs_trigger_order());
|
return map;
|
}
|
|
private double getRealtimePrice(String symbol) {
|
List<Realtime> realtimes = this.dataService.realtime(symbol);
|
double close = 1;
|
if (realtimes != null && realtimes.size() > 0) {
|
close = realtimes.get(0).getClose();
|
} else {
|
throw new BusinessException("参数错误");
|
}
|
return close;
|
}
|
}
|
