//private T GetListBoxItem<T>(ListBox lb, BitmexOrderData order) where T : OrderModel
//{
// int idx = lb.Items.ContainsOrderItem<StopOrderModel>(order.OrderId);
// return (T)lb.Items[idx];
//}
public void CancelStopLimit(BitmexOrderData order)
{
//if (String.Compare(_trailingStopId, order.OrderId, true) == 0)
//{
// //MainWnd.ChangeControl(() => btnCancelTrail.IsEnabled = false);
// _trailingStopId = null;
//}
MainWnd.RemoveOrder <StopOrderModel>(gridStops, order, lbStopOrders, () =>
{
MainWindow.HandleException(() =>
{
if (order.IsCanceled)
{
order.Message = "Cancel";
}
if (order.IsRejected)
{
order.Message = "Filled";
}
if (order.HasTriggered)
{
order.Message = "Triggered Stop";
order.OrdStatus = order.Triggered;
}
var msg = String.Format("{0} ID{1}", order.Message, order.OrderId.GetOrderId());
MainWnd.LogOrderEvent(msg);
});
});
}
public ApiResult Save(BitmexOrderData order, BitmexUser user)
{
Order = order;
User = user;
return(_api.UserQuery("/v1/order", HttpMethod.Post, JsonConvert.SerializeObject(this), true));
}
public void UpdateStopLimit(BitmexOrderData order, double bidPrice, double askPrice)
{
int idx = MainWnd.ContainsOrder <StopOrderModel>(gridStops, order);
if (idx != -1)
{
var newModel = StopOrderModel.ToModel(order, MainWnd.Controller, bidPrice, askPrice);
if (newModel.StopPx.HasValue)
{
// TODO: ??
//var lbItem = GetListBoxItem<StopOrderModel>(lbStopOrders, order);
//lbItem.StopPx = newModel.StopPx.Value;
}
var model = (StopOrderModel)gridStops.Items[idx];
MainWindow.HandleException(() =>
{
var msg = model.Sync(newModel, MainWnd.Controller);
if (msg != null)
{
order.Message = String.Format("Update Stop{0} ID{1}", msg, order.OrderId.GetOrderId());
MainWnd.LogOrderEvent(order.Message);
MainWnd.UpdateOrder <StopOrderModel>(gridStops, order, model, idx);
}
});
}
}
private void ThrowIfError(BitmexOrderData result, string actionName)
{
if (result.HasError)
{
throw new InvalidOperationException(String.Format("BitMEX '{0}' when {1}: {2}", result.Text, actionName, result.Error));
}
}
public virtual bool OrderFilled(BitmexOrderData ord)
{
if (ord.IsFilled)
{
return(String.Compare(OrderId, ord.OrderId, true) == 0);
}
return(false);
}
public override bool OrderFilled(BitmexOrderData ord)
{
if (!base.OrderFilled(ord))
{
return(false);
}
_order = null;
return(true);
}
public void CancelLimit(BitmexOrderData order)
{
MainWnd.RemoveOrder <ActiveOrderModel>(gridOrders, order, lbActiveOrders, () =>
{
MainWindow.HandleException(() =>
{
order.Message = "Cancel ID" + order.OrderId.GetOrderId();
MainWnd.LogOrderEvent(order.Message);
});
});
}
internal void CreateOrder(BitmexOrderData order, string text)
{
var model = ActiveOrderModel.ToModel(order, MainWnd.Controller);
MainWnd.InsertOrder <ActiveOrderModel>(gridOrders, model, null, lbActiveOrders);
MainWindow.HandleException(() =>
{
order.Message = String.Format("{0} ID{1}", text, order.OrderId.GetOrderId());
MainWnd.LogOrderEvent(order.Message);
});
}
public void SetStopPrice(BitmexOrderData order)
{
if (String.Compare(order.Text, "STOPLS") == 0)
{
_stopPx = order.StopPx.Value;
}
else if (!String.IsNullOrEmpty(order.OrderId))
{
if (order.StopPx.HasValue)
{
_stopPx = order.StopPx;
}
}
}
internal void UpdateLimit(BitmexOrderData order)
{
int idx = MainWnd.ContainsOrder <ActiveOrderModel>(gridOrders, order);
if (idx != -1)
{
var model = (ActiveOrderModel)gridOrders.Items[idx];
MainWindow.HandleException(() =>
{
var msg = model.Sync(ActiveOrderModel.ToModel(order, MainWnd.Controller), MainWnd.Controller);
if (msg != null)
{
order.Message = String.Format("Update{0} ID{1}", msg, order.OrderId.GetOrderId());
MainWnd.LogOrderEvent(order.Message);
MainWnd.UpdateOrder <ActiveOrderModel>(gridOrders, order, model, idx, lbActiveOrders);
}
});
}
}
internal void CreateStopOrder(BitmexOrderData order, double bidPrice, double askPrice)
{
var model = StopOrderModel.ToModel(order, MainWnd.Controller, bidPrice, askPrice);
MainWnd.InsertOrder <StopOrderModel>(gridStops, model, null, lbStopOrders);
//if (order.PegOffsetValue.HasValue)
//{
// MainWnd.ChangeControl(() => btnCancelTrail.IsEnabled = true); //!! may be send event
// _trailingStopId = order.OrderId;
//}
MainWindow.HandleException(() =>
{
var price = MainWnd.Controller.ToStringPrice(order.StopPx.Value, order.Symbol);
var orderId = order.OrderId.GetOrderId();
order.Message = String.Format("Stop Px={0} {1} ID{2}", price, order.Symbol, orderId);
MainWnd.LogOrderEvent(order.Message);
});
}
public string SyncOrderFilled(BitmexOrderData order, MainWindowController ctrl)
{
var str = new StringBuilder();
if (order.CumQty.HasValue) // исполненная часть заявки
{
this.CumQty = order.CumQty.Value;
str.AppendFormat(" CumQty={0}", order.CumQty.Value);
}
if (order.LeavesQty.HasValue) // неисполненная часть заявки
{
this.LeavesQty = order.LeavesQty.Value;
str.AppendFormat(" LeavesQty={0}", order.LeavesQty.Value);
}
if (order.AvgPx.HasValue) // средневзвешенная цена сделок по заявке
{
this.AvgPrice = order.AvgPx.Value;
str.AppendFormat(" AvgPx={0}", ctrl.ToStringPrice(order.AvgPx.Value, this.Symbol));
}
return str.Length == 0 ? null : str.ToString();
}
internal void RemoveOrder <T>(DataGrid grid, BitmexOrderData order, ListBox listBox, Action action = null, bool useMarking = false) where T : OrderModel
{
if (useMarking && !_markAsRemovedOrders.ContainsKey(order.OrderId))
{
_markAsRemovedOrders.Add(order.OrderId, true);
}
if (listBox != null)
{
listBox.Items.RemoveFromCollection <T>(order.OrderId);
}
if (grid.Items.RemoveFromCollection <T>(order.OrderId))
{
if (action != null)
{
action();
}
}
}
public static ActiveOrderModel ToModel(BitmexOrderData data, MainWindowController wndCtrl)
{
var model = new ActiveOrderModel
{
OrderId = data.OrderId,
Symbol = data.Symbol,
Status = data.OrdStatus,
Type = data.OrdType,
Side = data.Side,
Time = data.Timestamp.ToLocalTime().ToLongTimeString(),
FullTime = data.Timestamp.ToLocalTime().ToString()
};
model.SetOrderQty(data.OrderQty);
model.SetPrice(data.Price, wndCtrl);
model.SetExecInst(data.ExecInst);
if (data.OrderQty.HasValue && data.Price.HasValue)
model.OrderValue = wndCtrl.GetOrderValue(data.OrderQty.Value, data.Price.Value, model.Symbol);
return model;
}
public static StopOrderModel ToModel(BitmexOrderData order, MainWindowController wndCtrl, double?bidPrice = null, double?askPrice = null)
{
var model = new StopOrderModel
{
OrderId = order.OrderId,
Symbol = order.Symbol,
Side = order.Side,
Type = order.OrdType,
Status = order.OrdStatus,
Time = order.Timestamp.ToLocalTime().ToLongTimeString(),
FullTime = order.Timestamp.ToLocalTime().ToString()
};
model.SetPrice(order.Price, wndCtrl);
model.SetOrderQty(order.OrderQty);
model.SetStopPrice(order.Side, order.StopPx, wndCtrl);
model.SetTriggeringPrice(bidPrice, askPrice, wndCtrl);
model.SetExecInst(order.ExecInst);
model.SetTrailValue(order.PegOffsetValue, wndCtrl);
return(model);
}
internal void UpdateFilled(BitmexOrderData order)
{
int idx = MainWnd.ContainsOrder <ActiveOrderModel>(gridOrders, order);
if (idx != -1)
{
var model = (ActiveOrderModel)gridOrders.Items[idx];
MainWindow.HandleException(() =>
{
var msg = model.SyncOrderFilled(order, MainWnd.Controller);
if (msg != null)
{
order.Message = String.Format("{0}{1} ({2})", order.OrdStatus, msg, order.OrderId.GetOrderId());
MainWnd.LogOrderEvent(order.Message);
MainWnd.UpdateOrder <ActiveOrderModel>(gridOrders, order, model, idx, lbActiveOrders);
}
if (order.OrdStatus == "Filled")
{
MainWnd.RemoveOrder <ActiveOrderModel>(gridOrders, order, lbActiveOrders);
}
});
}
}
internal int ContainsOrder <T>(DataGrid grid, BitmexOrderData order) where T : OrderModel
{
return(grid.Items.ContainsOrderItem <T>(order.OrderId));
}
internal void UpdateOrder <T>(DataGrid grid, BitmexOrderData order, T model, int idx, ListBox listbox = null) where T : OrderModel
{
RemoveOrder <T>(grid, order, listbox, null, false);
InsertOrder <T>(grid, model, idx, listbox, false);
}
public bool OrderFilled(BitmexOrderData ord)
{
return(false);
}
