/// <summary>
/// 주문 취소
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("uuid", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiDelete1Async($"/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <UPlaceOrderItem>(_json_value.Content);
{
_json_data.amount = _json_data.quantity * _json_data.price;
_result.result = _json_data;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Update an order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public async Task <MyOrder> UpdateOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(
new Dictionary <string, object>
{
{ "orderID", order_id },
{ "orderQty", quantity },
{ "price", price }
},
args
);
var _json_value = await tradeClient.CallApiPut1Async("/api/v1/order", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BPlaceOrderItem>(_json_value.Content);
_result.result = _json_data;
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancel an Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiPut1Async($"/orders/{order_id}/cancel", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <QPlaceOrderItem>(_json_value.Content);
{
_order.amount = (_order.quantity * _order.price).Normalize();
_order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order;
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Get the status of an order. Is it active? Was it cancelled? To what extent has it been executed? etc.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> FetchMyOrderAsync(string base_name, string quote_name, string order_id = "", Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("order_id", Convert.ToInt64(order_id));
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v1/order/status", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderItem = tradeClient.DeserializeObject <BMyOrderItem>(_json_value.Content);
{
_orderItem.amount = _orderItem.price * _orderItem.quantity;
_result.result = _orderItem;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// 개별 주문 조회
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> FetchMyOrder(string base_name, string quote_name, string order_id, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("uuid", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/order", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <UMyOrderItem>(_json_value.Content);
{
_order.amount = _order.price * _order.quantity;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public ActionResult Update(MyOrder model)
{
if (ModelState.IsValid == false)
{
return(Content("数据有误~！请不要恶意禁用浏览器脚本~~~！"));
}
else
{
int id = Convert.ToInt32(Request.Params["Id"]);
String datetime = Request.Params["OrderDate"];
String status = Request.Params["Status"];
int customerId = Convert.ToInt32(Request.Params["CustomerId"]);
MyOrder updated_order = (from x in db.MyOrders where x.Id == id select x).FirstOrDefault();
updated_order.OrderDate = Convert.ToDateTime(datetime);
updated_order.Status = status;
updated_order.CustomerId = customerId;
db.SaveChanges();
return(Redirect("/Order/Index"));
}
}
public ActionResult OrderHistory(ShoppingCart cart)
{
DateTime df = DateTime.Now.AddDays(-14);
DateTime dt = DateTime.Now;
df = DateTime.Parse(df.ToShortDateString());
dt = DateTime.Parse(dt.AddDays(1).ToShortDateString());
MyOrder mo = new MyOrder();
mo.Orders = OrderRepository.GetOrdersByDateRangeWithLogonName(df, dt, UserName);
mo.PeriodSubtotal = mo.Orders.Sum(e => e.SubTotal);
mo.PeriodTotal = mo.Orders.Sum(e => e.OrderTotal);
mo.PeriodOrderTax = mo.Orders.Sum(e => e.OrderTax);
mo.PeriodServiceCharge = mo.Orders.Sum(e => e.ServiceCharge);
mo.PeriodDriverTip = mo.Orders.Sum(e => e.DriverTip);
mo.PeriodDiscountAmount = mo.Orders.Sum(e => e.DiscountAmount);
mo.PeriodDeliveryCharge = mo.Orders.Sum(e => e.DeliveryCharge);
ViewBag.note = " from " + df.ToShortDateString() + " to " + dt.AddDays(-1).ToShortDateString() + " (" + mo.Orders.Count.ToString() + ")";
ViewBag.bagitems = GetCartItems(cart);
return(View(mo));
}
/// <summary>
/// 주문하기: 주문 요청을 한다.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">주문 수량</param>
/// <param name="price">유닛당 주문 가격</param>
/// <param name="sideType">주문 타입</param>
/// <returns></returns>
public async ValueTask <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType)
{
var _result = new MyOrder();
var _params = new Dictionary <string, object>();
{
_params.Add("market", $"{quote_name}-{base_name}");
_params.Add("side", sideType == SideType.Bid ? "bid" : "ask");
_params.Add("volume", quantity);
_params.Add("price", price);
_params.Add("ord_type", "limit");
}
var _response = await privateClient.CallApiPost2Async("/orders", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _order = privateClient.DeserializeObject <UPlaceOrderItem>(_response.Content);
{
_order.orderType = OrderType.Limit;
_order.amount = _order.quantity * _order.price;
_result.result = _order;
}
_result.SetSuccess();
}
else
{
var _message = privateClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
/// <summary>
/// Close a position
/// </summary>
/// <param name="symbol">Instrument symbol. e.g. 'XBTUSD'.</param>
/// <param name="orderType">The type of order is limit, market or position</param>
/// <param name="price">price of coin</param>
/// <returns></returns>
public async ValueTask <MyOrder> ClosePosition(string symbol, OrderType orderType, decimal price = 0.0m)
{
var _result = new MyOrder();
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", symbol);
_params.Add("execInst", "Close");
if (orderType == OrderType.Limit)
{
_params.Add("price", price);
}
}
var _response = await privateClient.CallApiPost2Async("/api/v1/order", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _order = privateClient.DeserializeObject <BMyOrderItem>(_response.Content);
if (_order != null)
{
_result.result = _order;
_result.SetSuccess();
}
}
else
{
var _message = privateClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
/// <summary>
/// Amend the quantity or price of an open order.
/// </summary>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="execInst">Optional execution instructions.</param>
/// <returns></returns>
public async ValueTask <MyOrder> UpdateOrder(string order_id, decimal quantity, decimal price, string execInst = "")
{
var _result = new MyOrder();
var _params = new Dictionary <string, object>();
{
_params.Add("orderID", order_id);
_params.Add("orderQty", quantity);
_params.Add("price", price);
if (String.IsNullOrEmpty(execInst) == false)
{
_params.Add("execInst", execInst);
}
}
var _response = await privateClient.CallApiPut2Async("/api/v1/order", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _order = privateClient.DeserializeObject <BPlaceOrderItem>(_response.Content);
if (_order != null)
{
_result.result = _order;
_result.SetSuccess();
}
}
else
{
var _message = privateClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
public MyMarketOrder(MyOrder isxEveOrderObject, List <MyMarketOrder> orderList, Config config)
: base(isxEveOrderObject)
{
_orderList = orderList;
_config = config;
EvaluateCoolDownEndTime = System.DateTime.UtcNow;
DateTime lastModifiedTime = new System.DateTime(1601, 1, 1).AddSeconds(isxEveOrderObject.TimeStampWhenIssued / 10000000);
ModifyCoolDownEndTime = lastModifiedTime.AddMilliseconds(_config.RandomizedOrderModifyIntervalInMilliSec);
Status = OrderStatus.Unknown;
ID = isxEveOrderObject.ID;
_skip = false;
foreach (long id in _config.OrderIDsToSkip)
{
// When we load orders for first time, we need to retrive the saved "Skip" mark from config file.
if (ID == id)
{
_skip = true;
}
}
}
public TCom.EF.MyOrder getData()
{
MyOrder o = new MyOrder();
o.orderno = Pub.ID();
o.idmerc = this.idmerc;
o.iduser = this.iduser;
o.idmerc = this.idmerc;
o.merc = this.merc;
o.idspec = this.idspec;
o.spec = this.spec;
o.month = this.month;
o.attmonth = this.attmonth;
o.price = this.price;
o.totalfee = this.count * this.price;
o.count = this.count;
o.contact = this.contact;
o.addr = this.addr;
o.phone = this.phone;
o.cretime = DateTime.Now;
o.stime = DateTime.Now;
o.entime = DateTime.Now.AddMonths((this.month + this.attmonth) * o.count);
if (this.otype == "merc")
{
o.otype = OrderType.Merc;
}
else if (this.otype == "setup")
{
o.otype = OrderType.Setup;
}
o.idc = this.idc;
o.idc_img1 = this.idc_img1;
o.idc_img2 = this.idc_img2;
o.status = OrderStatus.WaitPay;
o.notes = this.notes;
o.img = this.img;
o.inuse = true;
return(o);
}
public Result <CreateOrderResult> Create(CreateOrderData data)
{
Result <CreateOrderResult> result = new Result <CreateOrderResult>();
try
{
using (TN db = new TN())
{
MyOrder o = data.getData();
db.MyOrders.Add(o);
MyOrderPress s = getMyOrderPress(o.orderno.ToString(), OrderStatus.Create, "用户");
db.MyOrderPresses.Add(s);
s = getMyOrderPress(o.orderno.ToString(), OrderStatus.Confirm, "系统");
db.MyOrderPresses.Add(s);
if (db.SaveChanges() > 0)
{
result.Data = new CreateOrderResult();
result.Data.orderno = o.orderno;
result.Code = R.Ok;
}
else
{
result.Code = R.Error;
}
// result.Data = m;
}
}
catch (Exception)
{
result.Code = R.Error;
result.Msg = "出现异常";
}
return(result);
}
public static MyOrderViewModel GetViewModel(long orderno)
{
MyOrder order = GetOrder(orderno);
MyOrderViewModel viewModel = null;
if (order != null)
{
viewModel = new MyOrderViewModel();
viewModel.CopyFromBase(order);
TN db = new TN();
List <TCom.EF.User> users = db.Users.Where(en => en.iduser == viewModel.iduser).ToList();
viewModel.user_name = (users == null || users.Count == 0) ? "" : users.First().name;
List <MyOrderPress> orderPresses = db.MyOrderPresses.Where(en => en.orderno == viewModel.orderno.ToString()).ToList();
List <MyOrderPressViewModel> orderPressViewModels = orderPresses.Select(mod => {
MyOrderPressViewModel orderPressViewModel = new MyOrderPressViewModel();
orderPressViewModel.CopyFromBase(mod);
return(orderPressViewModel);
}).ToList();
viewModel.OrderPresses = orderPressViewModels;
}
return(viewModel);
}
/// <summary>
/// Get Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> FetchMyOrderAsync(string base_name, string quote_name, string order_id = "", Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiGet1Async($"/v1/wallets/{__wallet_id}/orders/{order_id}", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <TMyOrderItem>(_json_value.Content);
{
_order.amount = _order.price * _order.quantity;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="userGuid"></param>
/// <param name="userRoles"></param>
/// <returns></returns>
public MyOrder GetMyOrderCounts(Guid userGuid, UserRoles userRoles)
{
MyOrder myOrder = new MyOrder();
if (userRoles == UserRoles.Buyer)
{
var orderData = (from odr in bringlyEntities.tblOrders
where odr.FK_CreatedByGuid == userGuid && odr.IsDeleted == false
select odr);
var data = orderData.DistinctBy(x => x.OrderGuid).ToList();
myOrder.CompletedOrderCount = data.Where(x => (int)OrderStatus.Completed == x.FK_OrderStatusId).Count();
myOrder.CancelledOrderCount = data.Where(x => (int)OrderStatus.Cancelled == x.FK_OrderStatusId).Count();
myOrder.PendingOrderCount = data.Where(x => (int)OrderStatus.Pending == x.FK_OrderStatusId).Count();
myOrder.TotalOrderCount = data.Count();
}
else if (userRoles == UserRoles.Merchant)
{
var orderData = (from odr in bringlyEntities.tblOrders
where odr.IsDeleted == false
where odr.tblBusiness.FK_CreatedByGuid == userGuid
select odr);
var data = orderData.DistinctBy(x => x.OrderGuid).ToList();
myOrder.CompletedOrderCount = data.Where(x => (int)OrderStatus.Completed == x.FK_OrderStatusId).Count();
myOrder.CancelledOrderCount = data.Where(x => (int)OrderStatus.Cancelled == x.FK_OrderStatusId).Count();
myOrder.PendingOrderCount = data.Where(x => (int)OrderStatus.Pending == x.FK_OrderStatusId).Count();
myOrder.RejectedOrderCount = data.Where(x => (int)OrderStatus.Rejected == x.FK_OrderStatusId).Count();
myOrder.TotalOrderCount = data.Count();
}
return(myOrder);
}
static void Run()
{
MessageQueue queue = null;
MessageQueueTransaction trans = null;
try
{
queue = new MessageQueue();
queue.Path = Constants.QUEUE_PATH;
queue.DefaultPropertiesToSend.Recoverable = true;
trans = new MessageQueueTransaction();
trans.Begin();
MyOrder order = new MyOrder();
order.ID = DateTime.Now.Ticks.ToString();
order.Name = "Order_" + order.ID;
Message msg = new Message(order);
queue.Send(msg, trans);
trans.Commit();
}
catch (Exception ex)
{
trans.Abort();
}
finally
{
queue.Close();
}
Console.WriteLine("message sent..");
}
public ActionResult Retrieve_Single_Order(int id)
{
MyOrder target = (from x in db.MyOrders where x.Id == id select x).FirstOrDefault();
List <MyCustomer> customer_list = (from y in db.MyCustomers select y).ToList();
ViewBag.Customer_list = customer_list;
ViewBag.Index = Request.Params["index"];
List <SelectListItem> items = new List <SelectListItem>();
foreach (var i in customer_list)
{
items.Add(new SelectListItem {
Value = i.Id.ToString(),
Text = i.Name,
Selected = false
});
}
//SelectList sl = new SelectList(items);
ViewBag.sl = items;
return(View(target));
}
/// <summary>
/// create new market order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("pair", _market.result.symbol);
_params.Add("type", _buy_sell);
_params.Add("ordertype", "market");
//_params.Add("price", price); // (optional. dependent upon ordertype)
//_params.Add("price2", "?"); // secondary price (optional. dependent upon ordertype)
_params.Add("volume", quantity); // order volume in lots
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/0/private/AddOrder", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <KResponse <KMyPlaceOrder> >(_json_value.Content);
{
foreach (var _p in _json_data.result.transactionIds)
{
var _order = new KMyPlaceOrderItem
{
orderId = _p,
symbol = _market.result.symbol,
timestamp = CUnixTime.NowMilli,
orderType = OrderType.Market,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _order;
break;
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// 주문 취소
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("order_id", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v1/cancel_order.do", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <OCancelOrders>(_json_value.Content);
var _cancel = _json_data.result.FirstOrDefault();
if (_cancel != null && _cancel.success == true)
{
var _order = new OPlaceOrderItem
{
symbol = _market.result.symbol,
orderId = order_id,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Canceled,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli,
success = true
};
_result.result = _order;
}
else
{
_json_result.SetFailure(errorCode: ErrorCode.OrderNotFound);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Send in a new order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy_market" : "sell_market";
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol); // token_krw (ex. btc_krw)
_params.Add("type", _buy_sell); // buy,sell
if (sideType == SideType.Bid)
{
_params.Add("price", price); // 1호 매수가격보다 커야 함.
}
else
{
_params.Add("amount", quantity); // 1호 매도가격보다 커야 함.
}
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v1/trade.do", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <OPlaceOrder>(_json_value.Content);
{
var _order = new OPlaceOrderItem
{
orderId = _json_data.result.orderId,
symbol = _market.result.symbol,
orderType = OrderType.Market,
orderStatus = OrderStatus.Open,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli
};
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Check an order's status.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="args">Add additional attributes for each exchange: (require) type</param>
/// <returns></returns>
public override async ValueTask <MyOrder> FetchMyOrder(string base_name, string quote_name, string order_id, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("order_id", order_id);
_params.Add("type", "");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/info/order_detail", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BMyOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _type = (_params.ContainsKey("type") == true) ? _params["type"].ToString() : "";
var _order = new BMyOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
payment_currency = quote_name,
sideType = SideTypeConverter.FromString(_type),
makerType = MakerType.Unknown,
orderStatus = OrderStatus.Closed,
orderType = OrderType.Limit,
timestamp = CUnixTime.NowMilli
};
foreach (var _o in _json_data.result)
{
//if (String.IsNullOrEmpty(_order.contract_id) == true)
// _order.contract_id = _o.contract_id;
if (_order.sideType != _o.sideType)
{
continue;
}
if (_order.timestamp > _o.timestamp)
{
_order.timestamp = _o.timestamp;
}
_order.quantity += _o.quantity;
_order.fee += _o.fee;
_order.amount += _o.amount;
_order.count++;
}
_order.price = _order.amount / _order.quantity;
_result.result = _order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// bithumb 회원 판/구매 거래 취소
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "bid" : "ask";
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("order_id", order_id);
_params.Add("type", _buy_sell);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/trade/cancel", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BPlaceOrder>(_json_value.Content);
if (_json_data.success == true)
{
var _cancel_order = new BPlaceOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
orderStatus = OrderStatus.Canceled,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _cancel_order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.baseId);
_params.Add("units", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/trade/market_{_buy_sell}", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BPlaceOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _market_order = new BPlaceOrderItem
{
orderId = _json_data.orderId,
sideType = sideType,
orderType = OrderType.Market,
orderStatus = OrderStatus.Open,
timestamp = Convert.ToInt64(_json_data.orderId),
price = price,
quantity = quantity,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
filled = 0m,
cost = 0m
};
foreach (var _trade in _json_data.data)
{
_market_order.filled += _trade.quantity;
_market_order.cost += _trade.amount + _trade.fee;
}
_result.result = _market_order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public void Modify(double newPrice)
{
Debug.Assert(newPrice > 0);
Log.WriteLog("Trying to confirm order " + this.ID.ToString() + ": \"" + this.Type.ToString() + "\" before modifying.");
List <MyOrder> retrivedOrders = null;
Me me;
bool success;
using (new FrameLock(true))
{
EVE.ISXEVE.EVE eve = new EVE.ISXEVE.EVE();
// me is not persistent, we can't just keep a static reference somewhere, have to renew every frame;
me = new Me();
success = me.UpdateMyOrders();
}
if (success)
{
Log.WriteLog("Fired update order request, wait to get result.");
int counter = 0;
while (retrivedOrders == null && counter < 100)
{
Frame.Wait(false);
using (new FrameLock(true))
{
counter++;
// me is not persistent, we can't just keep a static reference somewhere,have to renew every frame;
me = new Me();
EVE.ISXEVE.Character.OrderType orderType = this.OrderType == OrderType.Buy ? EVE.ISXEVE.Character.OrderType.Buy : EVE.ISXEVE.Character.OrderType.Sell;
// IMPORTANT: This is shallow copy, we need to finish all DEEP copy value operations while locked, otherwise the memory will be flushed;
retrivedOrders = me.GetMyOrders(orderType, this.TypeID);
if (retrivedOrders != null)
{
if (MarketOrderSet.ValidateOrderData(retrivedOrders))
{
MyOrder orderToModify = null;
foreach (MyOrder o in retrivedOrders)
{
if (o.ID == ID)
{
orderToModify = o;
break;
}
}
if (orderToModify != null)
{
Log.WriteLog("Confirmed order with (" + counter.ToString() + ") attempts.");
DateTime lastModifiedTime = new System.DateTime(1601, 1, 1).AddSeconds(orderToModify.TimeStampWhenIssued / 10000000);
//real cool down takes 5 minutes
if (lastModifiedTime.AddMilliseconds(301000) < System.DateTime.UtcNow)
{
orderToModify.Modify(newPrice);
Price = newPrice;
ModifyCoolDownEndTime = System.DateTime.UtcNow.AddMilliseconds(_config.RandomizedOrderModifyIntervalInMilliSec);
//I think the date, time and timestamp dont need updating.
Log.WriteLog("Order " + this.ID.ToString() + ": \"" + this.Type.ToString() + "\" modified");
}
else
{
ModifyCoolDownEndTime = lastModifiedTime.AddMilliseconds(_config.RandomizedOrderModifyIntervalInMilliSec);
Log.WriteLog("Order cooldown not finished yet. Job \"Modify\" cancelled.");
}
}
else
{
Log.WriteLog("Failed to find order to modify with (" + counter.ToString() + ") attempts. Job \"Modify\" cancelled.");
}
}
else
{
Log.WriteLog("Found invalid data in retrived order, retrying.");
// Enter next loop;
retrivedOrders = null;
}
}
}
}
}
else
{
Log.WriteLog("Failed to send update order request. Job \"Modify\" cancelled.");
}
}
/// <summary>
/// Cancel Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("order_id", Convert.ToInt64(order_id));
tradeClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexClient.CheckFuturesUrl(_market.result, "/cancel_order.do", "/future_cancel.do", _params);
var _json_value = await okexClient.CallApiPost1Async(_end_point.endPoint, _end_point.args);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = okexClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = okexClient.DeserializeObject <OCancelOrderItem>(_json_value.Content);
{
var _order_id = "";
var _order_status = OrderStatus.Unknown;
{
if (String.IsNullOrEmpty(_json_data.success) == false)
{
_order_id = _json_data.success;
_order_status = OrderStatus.Canceled;
}
else if (String.IsNullOrEmpty(_json_data.failure) == false)
{
_order_id = _json_data.failure;
_order_status = OrderStatus.Unknown;
}
}
if (String.IsNullOrEmpty(_order_id) == false)
{
var _order = new OMyOrderItem
{
symbol = _market.result.symbol,
orderId = _order_id,
orderType = OrderType.Limit,
orderStatus = _order_status,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli
};
_result.result = _order;
}
else
{
_json_result.SetFailure();
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Place Market Order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy_market" : "sell_market";
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("type", _buy_sell);
_params.Add("amount", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexClient.CheckFuturesUrl(_market.result, "/trade.do", "/future_trade.do", _params);
var _json_value = await okexClient.CallApiPost1Async(_end_point.endPoint, _end_point.args);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = okexClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = okexClient.DeserializeObject <OPlaceOrderItem>(_json_value.Content);
if (_json_data.result == true)
{
var _order = new OPlaceOrderItem
{
orderId = _json_data.orderId.ToUpper(),
timestamp = CUnixTime.NowMilli,
orderType = OrderType.Market,
orderStatus = OrderStatus.Open,
sideType = sideType,
price = price,
quantity = quantity,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker
};
_result.result = _order;
}
else
{
_result.SetFailure();
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Places a limit order in a given market.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("command", sideType == SideType.Bid ? "buy" : "sell");
_params.Add("currencyPair", _market.result.symbol);
_params.Add("rate", price.ToStringNormalized());
_params.Add("amount", quantity.ToStringNormalized());
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <PPlaceOrders>(_json_value.Content);
{
var _order = new PPlaceOrderItem
{
orderId = _json_data.orderId,
sideType = sideType,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Open,
timestamp = _json_data.resultingTrades.Max(t => t.timestamp),
price = price,
quantity = quantity,
amount = quantity * price,
filled = 0m,
cost = 0m
};
foreach (var _trade in _json_data.resultingTrades)
{
_order.filled += _trade.quantity;
_order.cost += _trade.price * _trade.quantity;
}
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancels an order you have placed in a given market.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("command", "cancelOrder");
_params.Add("currencyPair", _market.result.symbol);
_params.Add("orderNumber", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <JToken>(_json_value.Content);
{
var _order = new MyOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
timestamp = CUnixTime.NowMilli,
orderStatus = OrderStatus.Canceled,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _order;
var _status = _json_data["success"].Value <int>() == 1;
if (_status == false)
{
_json_result.SetFailure();
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Submit a new Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
if (args.ContainsKey("account-id") && args["account-id"].ToString() != "")
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("account-id", args["account-id"].ToString());
_params.Add("amount", quantity.ToString());
//_params.Add("source", ); // 'api' for spot trade and 'margin-api' for margin trade
_params.Add("symbol", _market.result.symbol);
_params.Add("type", _buy_sell + "-market");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/orders/place", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <HPlaceOrder>(_json_value.Content);
{
_order.result.orderType = OrderType.Market;
//_order.result.price = price;
_order.result.quantity = quantity;
_order.result.sideType = sideType;
_order.result.symbol = _market.result.symbol;
_order.result.timestamp = CUnixTime.NowMilli;
//_order.result.amount = (_order.result.quantity * _order.result.price).Normalize();
_order.result.fee = _order.result.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order.result;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetFailure("required args[account-id]");
}
}
else
{
_result.SetResult(_market);
}
return(_result);
}
