internal static void CancelOrder(SingleOrder order)
{
if (order.Provider == null)
{
throw new ApplicationException("Provider is null");
}
OrderCancelRequest request = new OrderCancelRequest();
request.OrigClOrdID = order.ClOrdID;
request.ClOrdID = OrderManager.GetOrdId();
request.Side = order.Side;
request.TransactTime = Clock.Now;
request.Symbol = order.Symbol;
request.SecurityType = order.SecurityType;
request.SecurityID = order.SecurityID;
request.SecurityExchange = order.SecurityExchange;
if (order.ContainsField(37))
{
request.OrderID = order.OrderID;
}
request.Account = order.Account;
request.OrderQty = order.OrderQty;
request.SetStringValue(109, order.GetStringValue(109));
order.Provider.SendOrderCancelRequest(request);
}
public virtual SingleOrder Execute(Signal signal)
{
SingleOrder singleOrder = new SingleOrder();
singleOrder.Instrument = signal.Instrument;
singleOrder.Strategy = signal.Strategy.Name;
singleOrder.StrategyComponent = ((object) signal.Sender).ToString();
singleOrder.StrategyFill = signal.StrategyFill;
singleOrder.StrategyPrice = signal.StrategyPrice;
singleOrder.ForceMarketOrder = signal.QvSj2cjRxv;
if (signal.Fuwj5CvMiW)
singleOrder.FillOnBarMode = (int) signal.R2djQy947W;
switch (signal.Side)
{
case SignalSide.Buy:
singleOrder.Side = Side.Buy;
break;
case SignalSide.BuyCover:
singleOrder.Side = Side.Buy;
break;
case SignalSide.Sell:
singleOrder.Side = Side.Sell;
break;
case SignalSide.SellShort:
singleOrder.Side = Side.SellShort;
break;
default:
throw new NotSupportedException();
}
switch (signal.Type)
{
case SignalType.Market:
singleOrder.OrdType = OrdType.Market;
break;
case SignalType.Limit:
singleOrder.OrdType = OrdType.Limit;
singleOrder.Price = signal.LimitPrice;
break;
case SignalType.Stop:
singleOrder.OrdType = OrdType.Stop;
singleOrder.StopPx = signal.StopPrice;
break;
case SignalType.StopLimit:
singleOrder.OrdType = OrdType.StopLimit;
singleOrder.StopPx = signal.StopPrice;
singleOrder.Price = signal.LimitPrice;
break;
case SignalType.TrailingStop:
singleOrder.OrdType = OrdType.TrailingStop;
singleOrder.TrailingAmt = signal.StopPrice;
break;
default:
throw new NotSupportedException();
}
singleOrder.OrderQty = signal.Qty;
singleOrder.TimeInForce = signal.TimeInForce;
singleOrder.Text = signal.Text;
this.MetaStrategyBase.cWMWqoTObJ((StrategyBase) signal.Strategy, singleOrder);
singleOrder.Send();
return singleOrder;
}
public OrderRecord(SingleOrder order)
{
this.order = order;
this.avgPx = 0.0;
this.leavesQty = (int)((FIXNewOrderSingle)order).OrderQty;
this.cumQty = 0;
}
private void EmitNewOrder(SingleOrder order)
{
if (this.NewOrder != null)
{
this.NewOrder(new OrderEventArgs(order));
}
}
public static void RemoveOrders(int tag, object value)
{
int count = OrderManager.orders.Count;
int index = 0;
while (index < OrderManager.orders.Count)
{
SingleOrder order = OrderManager.orders.All[index] as SingleOrder;
object obj = order.GetValue(tag);
if (obj != null && obj.ToString() == value.ToString())
{
if (order.OrdStatus != OrdStatus.Cancelled && order.OrdStatus != OrdStatus.PendingCancel && order.OrdStatus != OrdStatus.Filled)
{
order.Cancel();
}
OrderManager.orders.Remove(order);
if (order.Persistent)
{
OrderManager.server.Remove((IOrder)order);
}
}
else
{
++index;
}
}
if (count == OrderManager.orders.Count || OrderManager.OrderListUpdated == null)
{
return;
}
OrderManager.OrderListUpdated(typeof(OrderManager), EventArgs.Empty);
}
public void RemoveOrders(int tag, object value)
{
int count = this.orders.Count;
int index = 0;
while (index < this.orders.Count)
{
SingleOrder singleOrder = this.orders[index];
if (singleOrder.ContainsField(tag))
{
object obj = singleOrder.GetValue(tag);
if (obj != null && obj.ToString() == value.ToString())
{
this.orders.Remove(index);
continue;
}
}
++index;
}
if (count <= this.orders.Count)
{
return;
}
this.EmitOrderListUpdated();
}
private static void EmitOrderDone(SingleOrder order)
{
if (OrderManager.OrderDone != null)
{
OrderManager.OrderDone(new OrderEventArgs(order));
}
}
private static void EmitOrderRemoved(SingleOrder order)
{
if (OrderManager.OrderRemoved != null)
{
OrderManager.OrderRemoved(new OrderEventArgs(order));
}
}
private static void EmitNewOrder(SingleOrder order)
{
if (OrderManager.NewOrder != null)
{
OrderManager.NewOrder(new OrderEventArgs(order));
}
}
internal static void SendOrder(SingleOrder order)
{
if (order.Provider == null)
{
throw new ApplicationException("order.Provider == null");
}
if (order.Persistent)
{
OrderManager.server.AddOrder(order);
}
OrderManager.orders.Add(order);
OrderManager.EmitNewOrder(order);
if (order.OCAGroup != "" && (int)order.Provider.Id != 4 && OrderManager.oca.Contains((object)order.OCAGroup))
{
ExecutionReport report = new ExecutionReport();
report.TransactTime = DateTime.Now;
report.ClOrdID = order.ClOrdID;
report.OrigClOrdID = order.ClOrdID;
report.ExecType = ExecType.Rejected;
report.OrdStatus = OrdStatus.Rejected;
report.Symbol = order.Symbol;
report.Side = order.Side;
report.OrdType = order.OrdType;
report.Currency = order.Currency;
report.Text = "" + order.OCAGroup;
OrderManager.ExecutionReport(null, new ExecutionReportEventArgs(report));
}
else
{
order.Provider.SendNewOrderSingle((NewOrderSingle)order);
}
}
private static void EmitOrderStatusChanged(SingleOrder order)
{
if (OrderManager.OrderStatusChanged == null)
{
return;
}
OrderManager.OrderStatusChanged(new OrderEventArgs(order));
}
public virtual void Update(SingleOrder order)
{
this.newOrders = null;
this.pendingOrders = null;
this.cancelledOrders = null;
this.rejectedOrders = null;
this.filledOrders = null;
}
public virtual void Remove(SingleOrder order)
{
this.allOrders.Remove(order);
this.newOrders = null;
this.pendingOrders = null;
this.cancelledOrders = null;
this.rejectedOrders = null;
this.filledOrders = null;
}
private static void YUArMfFNj(SingleOrder order)
{
OrderManager.EmitOrderDone(order);
if (!OrderManager.RemoveDoneOrders)
{
return;
}
OrderManager.orders.Remove(order);
OrderManager.EmitOrderRemoved(order);
}
private void EmitNewOrderSingle(object sender, NewOrderSingleEventArgs e)
{
SingleOrder singleOrder = e.Order as SingleOrder;
if (singleOrder.OrderID == string.Empty)
{
singleOrder.OrderID = this.GetNextOrderID();
}
this.orders.Add(singleOrder);
this.EmitNewOrder(singleOrder);
}
private static void OnOrderCancelReject(object sender, OrderCancelRejectEventArgs e)
{
OrderCancelReject orderCancelReject = e.OrderCancelReject;
SingleOrder order = OrderManager.orders.All[orderCancelReject.OrigClOrdID] as SingleOrder;
if (orderCancelReject.OrdStatus == OrdStatus.Undefined)
{
orderCancelReject.OrdStatus = OrdStatus.New;
ArrayList arrayList = new ArrayList((ICollection)order.Reports);
arrayList.Reverse();
foreach (ExecutionReport executionReport in arrayList)
{
switch (executionReport.OrdStatus)
{
case OrdStatus.PendingCancel:
case OrdStatus.PendingNew:
case OrdStatus.PendingReplace:
continue;
default:
orderCancelReject.OrdStatus = executionReport.OrdStatus;
goto label_10;
}
}
}
label_10:
OrdStatus ordStatus = order.OrdStatus;
order.EmitCancelReject(orderCancelReject);
if (OrderManager.OrderCancelReject != null)
{
OrderManager.OrderCancelReject(sender, new OrderCancelRejectEventArgs(order, orderCancelReject));
}
if (order.IsDone)
{
if (!OrderManager.EnablePartialTransactions)
{
OrderManager.nf3XP7Xf3(order, orderCancelReject.TransactTime, order.AvgPx, order.CumQty);
}
OrderManager.YUArMfFNj(order);
}
else
{
if (ordStatus == order.OrdStatus)
{
return;
}
OrderManager.orders.Update(order);
order.EmitStatusChanged();
OrderManager.EmitOrderStatusChanged(order);
}
}
public void Add(Instrument instrument, string name, SingleOrder order)
{
NamedOrderTable namedOrderTable;
if (this.orders.ContainsKey(instrument))
{
namedOrderTable = this.orders[instrument] as NamedOrderTable;
}
else
{
namedOrderTable = new NamedOrderTable();
this.orders.Add(instrument, namedOrderTable);
}
namedOrderTable.vxbiSOygU5(name, order);
}
public OrderView(SingleOrder order, Pad pad) : base()
{
this.hO3wgSeHU8 = true;
this.aoOwHWbfJ4 = Color.Gold;
this.vfIwYklUGT = Color.SpringGreen;
this.VEIwC98m6Z = Color.Crimson;
this.GM4wmd54o9 = Color.Crimson;
this.BuyColor = Color.Blue;
this.SellColor = Color.Red;
this.SellShortColor = Color.Yellow;
this.TextEnabled = true;
this.ToolTipEnabled = true;
this.ToolTipFormat = "";
this.order = order;
this.pad = pad;
}
internal void EmitExecutionReport(ExecutionReport report)
{
if ((report.OrdStatus == OrdStatus.New || report.OrdStatus == OrdStatus.PendingNew) && report.ContainsField(37))
{
this.OrderID = report.OrderID;
}
if (report.Text == "")
{
report.Text = this.Text;
}
this.CumQty = report.CumQty;
this.LeavesQty = report.LeavesQty;
this.AvgPx = report.AvgPx;
this.OrdStatus = report.OrdStatus;
if (report.ExecType == ExecType.PartialFill || report.ExecType == ExecType.Fill || report.ExecType == ExecType.Trade)
{
this.LastPx = report.LastPx;
this.LastQty = report.LastQty;
if (report.ContainsField(13))
{
double num1 = 0.0;
// switch (report.CommType)
// {
// case CommType.PerShare:
// num1 = report.Commission * report.LastQty;
// break;
// case CommType.Percent:
// num1 = report.Commission * (report.LastPx * report.LastQty);
// break;
// case CommType.Absolute:
// num1 = report.Commission;
// break;
// }
SingleOrder singleOrder = this;
double num2 = singleOrder.Commission + num1;
singleOrder.Commission = num2;
}
}
this.reports.Add(report);
if (this.ExecutionReport != null)
{
this.ExecutionReport((object)this, new ExecutionReportEventArgs(report));
}
}
private static void nf3XP7Xf3(SingleOrder obj0, DateTime obj1, double obj2, double obj3)
{
if (obj0.LastQty <= 0.0 || obj0.Portfolio == null)
{
return;
}
Transaction transaction = new Transaction();
transaction.DateTime = obj1;
transaction.ClOrdID = obj0.ClOrdID;
transaction.Instrument = obj0.Instrument;
transaction.Side = obj0.Side;
transaction.Price = obj2;
transaction.Qty = obj3;
transaction.Strategy = obj0.Strategy;
transaction.Text = obj0.Text;
FreeQuant.Instruments.Currency currency = (CurrencyManager.Currencies[obj0.Currency] ?? CurrencyManager.Currencies[obj0.Instrument.Currency]) ?? CurrencyManager.DefaultCurrency;
transaction.Currency = currency;
transaction.TransactionCost.Set(CommType.Absolute, obj0.Commission);
obj0.Portfolio.Add(transaction);
}
protected override void OnOrderDone(SingleOrder order)
{
this.klBiFcxZsD.OnOrderDone(order);
this.csNiLdTRqH[order.Instrument].OnOrderDone(order);
}
protected override void OnOrderStatusChanged(SingleOrder order)
{
this.klBiFcxZsD.OnOrderStatusChanged(order);
this.csNiLdTRqH[order.Instrument].OnOrderStatusChanged(order);
}
protected override void OnOrderPartiallyFilled(SingleOrder order)
{
this.klBiFcxZsD.OnOrderPartiallyFilled(order);
this.csNiLdTRqH[order.Instrument].OnOrderPartiallyFilled(order);
}
protected override void OnExecutionReport(SingleOrder order, ExecutionReport report)
{
this.klBiFcxZsD.OnExecutionReport(order, report);
this.csNiLdTRqH[order.Instrument].OnExecutionReport(order, report);
}
internal void EB2iXBUSFK(SingleOrder order)
{
order.Strategy = this.Name;
order.StrategyComponent = ((object)ComponentType.ATSComponent).ToString();
this.MetaStrategyBase.cWMWqoTObJ(this, order);
}
internal void Add(SingleOrder order)
{
this.ordersById.Add(order.OrderID, order);
this.ordersByIndex.Add(order);
}
internal void cWMWqoTObJ(StrategyBase obj0, SingleOrder obj1)
{
obj1.Portfolio = this.portfolio;
switch (this.metaStrategyMode)
{
case MetaStrategyMode.Simulation:
obj1.Provider = ProviderManager.ExecutionSimulator;
break;
case MetaStrategyMode.Live:
obj1.Provider = obj0.MarketManager.UyiAAd6ITD[obj1.Instrument];
if (this.saveOrders)
{
obj1.Persistent = true;
break;
}
else
break;
}
obj1.StrategyMode = MetaStrategyBase.FIX_MODES[this.metaStrategyMode];
this.DKMWNa8OX5.Add(obj1, obj0);
}
internal void h8htoZ5ih(SingleOrder obj0)
{
switch (obj0.OrdStatus)
{
case OrdStatus.Filled:
this.OnOrderFilled(obj0);
break;
case OrdStatus.Cancelled:
this.OnOrderCancelled(obj0);
break;
case OrdStatus.Rejected:
this.OnOrderRejected(obj0);
break;
}
this.OnOrderDone(obj0);
}
internal void zQxocsRCM(SingleOrder obj0)
{
this.OnOrderPartiallyFilled(obj0);
}
internal void fuDu5XiFd(SingleOrder obj0)
{
Instrument instrument = obj0.Instrument;
if (obj0.Text != "")
this.orders.Add(instrument, obj0.Text, obj0);
this.OnNewOrder(obj0);
}
protected virtual void OnNewOrder(SingleOrder order)
{
}
private void j7FeG7ltt3(OrderEntry entry)
{
SingleOrder order = new SingleOrder();
order.TransactTime = DateTime.Now;
order.Instrument = entry.Instrument;
order.Side = entry.Side;
order.OrdType = entry.OrdType;
order.Price = entry.Price;
order.StopPx = entry.StopPx;
order.OrderQty = entry.OrderQty;
order.Text = entry.Text;
if (this.NewOrderSingle != null)
this.NewOrderSingle(this, new FIXNewOrderSingleEventArgs(order));
}
protected override void OnNewClientOrder(SingleOrder order)
{
this.klBiFcxZsD.mfbpeU3YGv(order);
}
protected virtual void OnOrderPartiallyFilled(SingleOrder order)
{
}
protected virtual void OnOrderFilled(SingleOrder order)
{
}
internal void acOvnqFOo(SingleOrder obj0)
{
if (!this.isActive)
return;
this.OnNewClientOrder(obj0);
}
protected virtual void OnOrderRejected(SingleOrder order)
{
}
protected virtual void OnExecutionReport(SingleOrder order, ExecutionReport report)
{
}
internal static void ReplaceOrder(SingleOrder order)
{
if (order.Provider == null)
{
throw new ApplicationException("null");
}
OrderCancelReplaceRequest request = new OrderCancelReplaceRequest();
request.ClOrdID = OrderManager.GetOrdId();
request.OrigClOrdID = order.ClOrdID;
if (order.ContainsField(37))
{
request.OrderID = order.OrderID;
}
request.Side = order.Side;
request.OrdType = !order.ReplaceOrder.ContainsField(40) ? order.OrdType : order.ReplaceOrder.OrdType;
request.TimeInForce = !order.ReplaceOrder.ContainsField(59) ? order.TimeInForce : order.ReplaceOrder.TimeInForce;
if (order.ReplaceOrder.ContainsField(126))
{
request.ExpireTime = order.ReplaceOrder.ExpireTime;
}
if (order.ReplaceOrder.ContainsField(44))
{
request.Price = order.ReplaceOrder.Price;
}
else
{
request.Price = order.Price;
}
if (order.ReplaceOrder.ContainsField(99))
{
request.StopPx = order.ReplaceOrder.StopPx;
}
else
{
request.StopPx = order.StopPx;
}
if (order.ReplaceOrder.ContainsField(10701))
{
request.TrailingAmt = order.ReplaceOrder.TrailingAmt;
}
else
{
request.TrailingAmt = order.TrailingAmt;
}
if (order.ReplaceOrder.ContainsField(38))
{
request.OrderQty = order.ReplaceOrder.OrderQty;
}
else
{
request.OrderQty = order.OrderQty;
}
request.TransactTime = Clock.Now;
request.Account = order.Account;
request.HandlInst = order.HandlInst;
request.Symbol = order.Symbol;
request.SecurityType = order.SecurityType;
request.SecurityExchange = order.SecurityExchange;
request.SecurityID = order.SecurityID;
request.Currency = order.Currency;
request.SetStringValue(109, order.GetStringValue(109));
order.Provider.SendOrderCancelReplaceRequest(request);
}
protected virtual void OnOrderStatusChanged(SingleOrder order)
{
}
public override void Add(SingleOrder order)
{
base.Add(order);
this[order.Instrument].Add(order);
}
protected virtual void OnOrderCancelled(SingleOrder order)
{
}
public override void Remove(SingleOrder order)
{
base.Remove(order);
this[order.Instrument].Remove(order);
}
protected virtual void OnOrderDone(SingleOrder order)
{
}
public override void Update(SingleOrder order)
{
base.Update(order);
this[order.Instrument].Update(order);
}
internal void a9XY5Muph(SingleOrder obj0, ExecutionReport obj1)
{
this.OnExecutionReport(obj0, obj1);
}
protected override void OnExecutionReport(SingleOrder order, ExecutionReport report)
{
Instrument instrument = order.Instrument;
this.HeHpDewVKD.OnExecutionReport(order, report);
this.A6MpF2380O.OnExecutionReport(order, report);
this.entries[instrument].OnExecutionReport(order, report);
this.exits[instrument].OnExecutionReport(order, report);
}
internal void VLka0XAdb(SingleOrder obj0)
{
this.OnOrderStatusChanged(obj0);
}
protected override void OnOrderDone(SingleOrder order)
{
Instrument instrument = order.Instrument;
this.HeHpDewVKD.OnOrderDone(order);
this.A6MpF2380O.OnOrderDone(order);
this.entries[instrument].OnOrderDone(order);
this.exits[instrument].OnOrderDone(order);
}
public void DrawOrder(SingleOrder order, int padNumber)
{
}
private double VirF0ddUxQ(SingleOrder obj0, Quote obj1, Trade obj2, Bar obj3)
{
bool flag = !obj0.IsStopLimitReady && (obj0.OrdType == OrdType.TrailingStop || obj0.OrdType == OrdType.TrailingStopLimit || obj0.OrdType == OrdType.StopLimit);
if (obj1 != null && this.A8bFJItyyx.PartialFills && (this.A8bFJItyyx.FillOnQuote && !flag || this.A8bFJItyyx.TriggerOnQuote && flag))
{
if (!this.A8bFJItyyx.FillAtWorstQuoteRate || obj1.Bid <= obj1.Ask)
{
switch (obj0.Side)
{
case Side.Buy:
if (obj1.AskSize > 0)
return (double) obj1.AskSize;
else
break;
case Side.Sell:
case Side.SellShort:
if (obj1.BidSize > 0)
return (double) obj1.BidSize;
else
break;
default:
return obj0.OrderQty;
}
}
else
{
switch (obj0.Side)
{
case Side.Buy:
if (obj1.BidSize > 0)
return (double) obj1.BidSize;
else
break;
case Side.Sell:
case Side.SellShort:
if (obj1.Ask > 0.0)
return (double) obj1.AskSize;
else
break;
default:
return obj0.OrderQty;
}
}
}
if ((this.A8bFJItyyx.FillOnTrade && !flag || this.A8bFJItyyx.TriggerOnTrade && flag) && obj2 != null)
{
if ((obj0.OrdType == OrdType.Limit || (obj0.OrdType == OrdType.StopLimit || obj0.OrdType == OrdType.TrailingStopLimit) && obj0.IsStopLimitReady) && (obj0.CumQty == 0.0 && Math.Abs(obj2.Price - obj0.Price) < 0.001 && (obj0.TradeVolumeDelay != 0 && !this.gxTF8gufMx)))
{
this.w02FZf7vnP += obj2.Size;
if (this.w02FZf7vnP <= obj0.TradeVolumeDelay)
return 0.0;
this.gxTF8gufMx = true;
if (this.A8bFJItyyx.PartialFills)
return (double) (this.w02FZf7vnP - obj0.TradeVolumeDelay);
else
return obj0.OrderQty;
}
else if (this.A8bFJItyyx.PartialFills)
return (double) obj2.Size;
}
return obj0.OrderQty;
}
