private void PrintOrder(string sCaption, O2GOrderRow orderRow)
{
Console.WriteLine("{0}: OrderID='{1}', TradeID='{2}', Status='{3}', " +
"Amount='{4}', OriginAmount='{5}', FilledAmount='{6}'",
sCaption, orderRow.OrderID, orderRow.TradeID, orderRow.Status,
orderRow.Amount, orderRow.OriginAmount, orderRow.FilledAmount);
}
public void onTablesUpdates(O2GResponse data)
{
O2GResponseReaderFactory factory = mSession.getResponseReaderFactory();
if (factory != null)
{
O2GTablesUpdatesReader reader = factory.createTablesUpdatesReader(data);
for (int ii = 0; ii < reader.Count; ii++)
{
if (reader.getUpdateTable(ii) == O2GTableType.Orders)
{
O2GOrderRow orderRow = reader.getOrderRow(ii);
if (reader.getUpdateType(ii) == O2GTableUpdateType.Update)
{
if (mOrderIDs.Contains(orderRow.OrderID))
{
Console.WriteLine("The order has been updated. OrderID={0}, ContingentOrderID={1}, ContingencyType={2}", orderRow.OrderID, orderRow.ContingentOrderID, orderRow.ContingencyType);
mOrderIDs.Remove(orderRow.OrderID);
}
if (mOrderIDs.Count == 0)
{
mSyncResponseEvent.Set();
}
}
}
}
}
}
public void SetRequestID(string sRequestID)
{
mResponse = null;
mLastOrderID = string.Empty;
mLastOrder = null;
mRequestID = sRequestID;
}
private void AddToMonitoring(O2GOrderRow order)
{
OrderMonitor monitor = new OrderMonitor(order);
monitor.OrderCompleted += new EventHandler(monitor_OrderCompleted);
mMonitors.Add(monitor);
}
public void OnOrderDeleted(O2GOrderRow order)
{
for (int i = 0; i < mMonitors.Count; i++)
{
mMonitors[i].OnOrderDeleted(order);
}
}
public void onTablesUpdates(O2GResponse data)
{
O2GResponseReaderFactory factory = mSession.getResponseReaderFactory();
if (factory != null)
{
O2GTablesUpdatesReader reader = factory.createTablesUpdatesReader(data);
for (int ii = 0; ii < reader.Count; ii++)
{
if (reader.getUpdateTable(ii) == O2GTableType.Orders)
{
O2GOrderRow orderRow = reader.getOrderRow(ii);
if (reader.getUpdateType(ii) == O2GTableUpdateType.Insert)
{
if (mRequestID.Equals(orderRow.RequestID))
{
Console.WriteLine("The order has been added. OrderID={0}, Type={1}, BuySell={2}, Rate={3}, TimeInForce={4}",
orderRow.OrderID, orderRow.Type, orderRow.BuySell, orderRow.Rate, orderRow.TimeInForce);
mSyncResponseEvent.Set();
break;
}
}
}
}
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
public OrderMonitor(O2GOrderRow order)
{
mOrder = order;
mRejectAmount = 0;
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mTrade = null;
}
public void onAdded(string sRowID, O2GRow rowData)
{
O2GTableType type = rowData.TableType;
switch (type)
{
case O2GTableType.Orders:
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mBatchOrderMonitor != null && mRequestIDs.Contains(orderRow.RequestID))
{
Console.WriteLine("The order has been added. Order ID: {0}, Rate: {1}, Time In Force: {2}",
orderRow.OrderID,
orderRow.Rate,
orderRow.TimeInForce);
mBatchOrderMonitor.OnOrderAdded(orderRow);
}
break;
case O2GTableType.Trades:
O2GTradeRow tradeRow = (O2GTradeRow)rowData;
if (mBatchOrderMonitor != null)
{
mBatchOrderMonitor.OnTradeAdded(tradeRow);
if (mBatchOrderMonitor.IsBatchExecuted())
{
PrintResult();
mResponseListener.StopWaiting();
}
}
break;
case O2GTableType.ClosedTrades:
O2GClosedTradeRow closedTradeRow = (O2GClosedTradeRow)rowData;
if (mBatchOrderMonitor != null)
{
mBatchOrderMonitor.OnClosedTradeAdded(closedTradeRow);
if (mBatchOrderMonitor.IsBatchExecuted())
{
PrintResult();
mResponseListener.StopWaiting();
}
}
break;
case O2GTableType.Messages:
O2GMessageRow messageRow = (O2GMessageRow)rowData;
if (mBatchOrderMonitor != null)
{
mBatchOrderMonitor.OnMessageAdded(messageRow);
if (mBatchOrderMonitor.IsBatchExecuted())
{
PrintResult();
mResponseListener.StopWaiting();
}
}
break;
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="session"></param>
public ResponseListener(O2GSession session)
{
mRequestID = string.Empty;
mResponse = null;
mLastOrderID = string.Empty;
mLastOrder = null;
mSyncResponseEvent = new EventWaitHandle(false, EventResetMode.AutoReset);
mSession = session;
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
public OrderMonitor(O2GOrderRow order)
{
mOrder = order;
mTrades = new List<O2GTradeRow>();
mClosedTrades = new List<O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
public OrderMonitor(O2GOrderRow order)
{
mOrder = order;
mTrades = new List <O2GTradeRow>();
mClosedTrades = new List <O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
public void OnOrderAdded(O2GOrderRow order)
{
string sRequestID = order.RequestID;
if (IsOwnRequest(sRequestID))
{
if (OrderMonitor.IsClosingOrder(order) || OrderMonitor.IsOpeningOrder(order))
{
AddToMonitoring(order);
}
}
}
// Implementation of IO2GTableListener interface public method onAdded
public void onAdded(string sRowID, O2GRow rowData)
{
if (rowData.TableType == O2GTableType.Orders)
{
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mRequestID.Equals(orderRow.RequestID))
{
Console.WriteLine("The order has been added. OrderID={0}, Type={1}, Rate={2}", orderRow.OrderID, orderRow.Type, orderRow.Rate);
mResponseListener.StopWaiting();
}
}
}
public void OnOrderAdded(O2GOrderRow order)
{
string sRequestID = order.RequestID;
if (IsOwnRequest(sRequestID))
{
if (OrderMonitor.IsClosingOrder(order) || OrderMonitor.IsOpeningOrder(order))
{
AddToMonitoring(order);
}
}
}
private void PrintResult()
{
if (mOrderMonitor != null)
{
OrderMonitorNetting.ExecutionResult result = mOrderMonitor.Result;
ReadOnlyCollection <O2GTradeRow> trades;
ReadOnlyCollection <O2GTradeRow> updatedTrades;
ReadOnlyCollection <O2GClosedTradeRow> closedTrades;
O2GOrderRow order = mOrderMonitor.Order;
string sOrderID = order.OrderID;
trades = mOrderMonitor.Trades;
updatedTrades = mOrderMonitor.UpdatedTrades;
closedTrades = mOrderMonitor.ClosedTrades;
switch (result)
{
case OrderMonitorNetting.ExecutionResult.Canceled:
if (trades.Count > 0)
{
PrintTrades(trades, sOrderID);
PrintClosedTrades(closedTrades, sOrderID);
Console.WriteLine("A part of the order has been canceled. Amount = {0}", mOrderMonitor.RejectAmount);
}
else
{
Console.WriteLine("The order: OrderID = {0} has been canceled.", sOrderID);
Console.WriteLine("The cancel amount = {0}.", mOrderMonitor.RejectAmount);
}
break;
case OrderMonitorNetting.ExecutionResult.FullyRejected:
Console.WriteLine("The order has been rejected. OrderID = {0}", sOrderID);
Console.WriteLine("The rejected amount = {0}", mOrderMonitor.RejectAmount);
Console.WriteLine("Rejection cause: {0}", mOrderMonitor.RejectMessage);
break;
case OrderMonitorNetting.ExecutionResult.PartialRejected:
PrintTrades(trades, sOrderID);
PrintUpdatedTrades(updatedTrades, sOrderID);
PrintClosedTrades(closedTrades, sOrderID);
Console.WriteLine("A part of the order has been rejected. Amount = {0}", mOrderMonitor.RejectAmount);
Console.WriteLine("Rejection cause: {0} ", mOrderMonitor.RejectMessage);
break;
case OrderMonitorNetting.ExecutionResult.Executed:
PrintTrades(trades, sOrderID);
PrintUpdatedTrades(updatedTrades, sOrderID);
PrintClosedTrades(closedTrades, sOrderID);
break;
}
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
/// <param name="iNetPositionAmount">Initial amount of trade</param>
public OrderMonitorNetting(O2GOrderRow order, int iNetPositionAmount)
{
mOrder = order;
mTrades = new List <O2GTradeRow>();
mUpdatedTrades = new List <O2GTradeRow>();
mClosedTrades = new List <O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mInitialAmount = iNetPositionAmount;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
/// <param name="iNetPositionAmount">Initial amount of trade</param>
public OrderMonitorNetting(O2GOrderRow order, int iNetPositionAmount)
{
mOrder = order;
mTrades = new List<O2GTradeRow>();
mUpdatedTrades = new List<O2GTradeRow>();
mClosedTrades = new List<O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mInitialAmount = iNetPositionAmount;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
public void onChanged(string sRowID, O2GRow rowData)
{
if (rowData.TableType == O2GTableType.Accounts)
{
O2GAccountTableRow account = (O2GAccountTableRow)rowData;
Console.WriteLine("Balance: {0}, Equity: {1}", account.Balance, account.Equity);
}
if (rowData.TableType == O2GTableType.Orders)
{
O2GOrderRow orderRow = (O2GOrderRow)rowData;
PrintOrder("An order is changed", orderRow);
}
}
/// <summary>
/// Find order by id and print it
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOrderID"></param>
/// <param name="responseListener"></param>
private static void FindOrder(O2GSession session, string sAccountID, string sOrderID, ResponseListener responseListener)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Orders, sAccountID);
if (request != null)
{
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse orderResponse = responseListener.GetResponse();
if (orderResponse != null)
{
if (orderResponse.Type == O2GResponseType.GetOrders)
{
O2GResponseReaderFactory responseReaderFactory = session.getResponseReaderFactory();
bool bFound = false;
O2GOrdersTableResponseReader responseReader = responseReaderFactory.createOrdersTableReader(orderResponse);
for (int i = 0; i < responseReader.Count; i++)
{
O2GOrderRow orderRow = responseReader.getRow(i);
if (sOrderID.Equals(orderRow.OrderID))
{
Console.WriteLine("OrderID={0}; AccountID={1}; Type={2}; Status={3}; OfferID={4}; Amount={5}; BuySell={6}; Rate={7}",
orderRow.OrderID, orderRow.AccountID, orderRow.Type, orderRow.Status, orderRow.OfferID,
orderRow.Amount, orderRow.BuySell, orderRow.Rate);
bFound = true;
break;
}
}
if (!bFound)
{
Console.WriteLine("OrderID={0} is not found!", sOrderID);
}
}
}
}
else
{
Console.WriteLine("Cannot create request");
}
}
// Implementation of IO2GTableListener interface public method onDeleted
public void onDeleted(string sRowID, O2GRow rowData)
{
if (rowData.TableType == O2GTableType.Orders)
{
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mRequestID.Equals(orderRow.RequestID))
{
if (!string.IsNullOrEmpty(mOrderID))
{
Console.WriteLine("The order has been deleted. Order ID: {0}", orderRow.OrderID);
mResponseListener.StopWaiting();
}
}
}
}
// Implementation of IO2GTableListener interface public method onAdded
public void onAdded(string sRowID, O2GRow rowData)
{
if (rowData.TableType == O2GTableType.Orders)
{
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mRequestID.Equals(orderRow.RequestID))
{
if (IsLimitEntryOrder(orderRow) && string.IsNullOrEmpty(mOrderID))
{
mOrderID = orderRow.OrderID;
Console.WriteLine("The order has been added. Order ID: {0}, Rate: {1}, Time In Force: {2}",
orderRow.OrderID,
orderRow.Rate,
orderRow.TimeInForce);
mResponseListener.StopWaiting();
}
}
}
}
/// <summary>
/// Find order by ID and print information about it
/// </summary>
/// <param name="session"></param>
/// <param name="sOrderID"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
private static void FindOrder(O2GSession session, string sOrderID, string sAccountID, ResponseListener responseListener)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Orders, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GOrdersTableResponseReader ordersReader = responseFactory.createOrdersTableReader(response);
for (int i = 0; i < ordersReader.Count; i++)
{
O2GOrderRow order = ordersReader.getRow(i);
if (sOrderID.Equals(order.OrderID))
{
Console.WriteLine("Information for OrderID = {0}", sOrderID);
Console.WriteLine("Account: {0}", order.AccountID);
Console.WriteLine("Amount: {0}", order.Amount);
Console.WriteLine("Rate: {0}", order.Rate);
Console.WriteLine("Type: {0}", order.Type);
Console.WriteLine("Buy/Sell: {0}", order.BuySell);
Console.WriteLine("Stage: {0}", order.Stage);
Console.WriteLine("Status: {0}", order.Status);
}
}
}
else
{
throw new Exception("Cannot get response");
}
}
/// <summary>
/// Process order deletion as result of execution
/// </summary>
public void OnOrderDeleted(O2GOrderRow orderRow)
{
String deletedOrderID = orderRow.OrderID;
String orderID = mOrder.OrderID;
if (deletedOrderID == orderID)
{
// Store Reject amount
if (OrderRowStatus.Rejected.Equals(orderRow.Status))
{
mState = OrderState.OrderRejected;
mRejectAmount = orderRow.Amount;
mTotalAmount = orderRow.OriginAmount - mRejectAmount;
if (!string.IsNullOrEmpty(mRejectMessage) && IsAllTradeReceived())
{
SetResult(true);
}
}
else if (OrderRowStatus.Canceled.Equals(orderRow.Status))
{
mState = OrderState.OrderCanceled;
mRejectAmount = orderRow.Amount;
mTotalAmount = orderRow.OriginAmount - mRejectAmount;
if (IsAllTradeReceived())
{
SetResult(false);
}
}
else
{
mRejectAmount = 0;
mTotalAmount = orderRow.OriginAmount;
mState = OrderState.OrderExecuted;
if (IsAllTradeReceived())
{
SetResult(true);
}
}
}
}
public void onDeleted(string sRowID, O2GRow rowData)
{
if (rowData.TableType == O2GTableType.Orders)
{
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mRequestID.Equals(orderRow.RequestID))
{
string sStatus = orderRow.Status;
if (sStatus.Equals("R"))
{
PrintOrder("An order has been rejected", orderRow);
}
else
{
PrintOrder("An order is going to be removed", orderRow);
}
mResponseListener.StopWaiting();
}
}
}
public void onDeleted(string sRowID, O2GRow rowData)
{
if (rowData.TableType == O2GTableType.Orders)
{
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mRequestIDs.Contains(orderRow.RequestID))
{
Console.WriteLine("The order has been deleted. Order ID: {0}", orderRow.OrderID);
if (mBatchOrderMonitor != null)
{
mBatchOrderMonitor.OnOrderDeleted(orderRow);
if (mBatchOrderMonitor.IsBatchExecuted())
{
PrintResult();
mResponseListener.StopWaiting();
}
}
}
}
}
/// <summary>
/// Print orders table for account
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
private static void PrintOrders(O2GSession session, string sAccountID, ResponseListener responseListener)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Orders, sAccountID);
if (request != null)
{
Console.WriteLine("Orders table for account {0}", sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory responseReaderFactory = session.getResponseReaderFactory();
O2GOrdersTableResponseReader responseReader = responseReaderFactory.createOrdersTableReader(response);
for (int i = 0; i < responseReader.Count; i++)
{
O2GOrderRow orderRow = responseReader.getRow(i);
Console.WriteLine("OrderID: {0}, Status: {1}, Amount: {2}", orderRow.OrderID, orderRow.Status, orderRow.Amount);
}
}
else
{
throw new Exception("Cannot get response");
}
}
else
{
throw new Exception("Cannot create request");
}
}
public void onAdded(string sRowID, O2GRow rowData)
{
O2GTableType type = rowData.TableType;
switch (type)
{
case O2GTableType.Orders:
O2GOrderRow orderRow = (O2GOrderRow)rowData;
if (mRequestID.Equals(orderRow.RequestID))
{
mOrderID = orderRow.OrderID;
PrintOrder("New order is added", orderRow);
}
break;
case O2GTableType.Trades:
O2GTradeRow tradeRow = (O2GTradeRow)rowData;
Console.WriteLine("Position is opened: TradeID='{0}', TradeIDOrigin='{1}'",
tradeRow.TradeID, tradeRow.TradeIDOrigin);
break;
case O2GTableType.ClosedTrades:
O2GClosedTradeRow closedTradeRow = (O2GClosedTradeRow)rowData;
Console.WriteLine("Position is closed: TradeID='{0}'",
closedTradeRow.TradeID);
break;
case O2GTableType.Messages:
O2GMessageRow messageRow = (O2GMessageRow)rowData;
string text = messageRow.Text;
int findPos = text.IndexOf(mOrderID);
if (findPos >= 0)
{
Console.WriteLine("Feature='{0}', Message='{1}'",
messageRow.Feature, text);
}
break;
}
}
public void onTablesUpdates(O2GResponse data)
{
O2GResponseReaderFactory factory = mSession.getResponseReaderFactory();
if (factory != null)
{
O2GTablesUpdatesReader reader = factory.createTablesUpdatesReader(data);
for (int ii = 0; ii < reader.Count; ii++)
{
if (reader.getUpdateTable(ii) == O2GTableType.Orders)
{
O2GOrderRow orderRow = reader.getOrderRow(ii);
if (reader.getUpdateType(ii) == O2GTableUpdateType.Insert)
{
mOrderID = orderRow.OrderID;
mSyncResponseEvent.Set();
break;
}
}
}
}
}
public void onTablesUpdates(O2GResponse data)
{
O2GResponseReaderFactory factory = mSession.getResponseReaderFactory();
if (factory != null)
{
O2GTablesUpdatesReader reader = factory.createTablesUpdatesReader(data);
for (int ii = 0; ii < reader.Count; ii++)
{
if (reader.getUpdateTable(ii) == O2GTableType.Orders)
{
O2GOrderRow orderRow = reader.getOrderRow(ii);
if (orderRow.RequestID.Equals(mRequestID))
{
switch (reader.getUpdateType(ii))
{
case O2GTableUpdateType.Insert:
if (IsLimitEntryOrder(orderRow) && string.IsNullOrEmpty(mOrderID))
{
mOrderID = orderRow.OrderID;
Console.WriteLine("The order has been added. Order ID: {0}, Rate: {1}, Time In Force: {2}",
orderRow.OrderID,
orderRow.Rate,
orderRow.TimeInForce);
mSyncResponseEvent.Set();
}
break;
case O2GTableUpdateType.Delete:
Console.WriteLine("The order has been deleted. Order ID: {0}", orderRow.OrderID);
mSyncResponseEvent.Set();
break;
}
}
}
}
}
}
/// <summary>
/// Check if order exists
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOrderID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static bool IsOrderExists(O2GSession session, string sAccountID, string sOrderID, ResponseListener responseListener)
{
bool bHasOrder = false;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Orders, sAccountID);
if (request == null)
{
throw new Exception("Cannot create request");
}
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
O2GResponseReaderFactory responseReaderFactory = session.getResponseReaderFactory();
O2GOrdersTableResponseReader responseReader = responseReaderFactory.createOrdersTableReader(response);
for (int i = 0; i < responseReader.Count; i++)
{
O2GOrderRow orderRow = responseReader.getRow(i);
if (sOrderID.Equals(orderRow.OrderID))
{
bHasOrder = true;
break;
}
}
return(bHasOrder);
}
private void AddToMonitoring(O2GOrderRow order)
{
OrderMonitor monitor = new OrderMonitor(order);
monitor.OrderCompleted += new EventHandler(monitor_OrderCompleted);
mMonitors.Add(monitor);
}
public void OnOrderDeleted(O2GOrderRow order)
{
for (int i = 0; i < mMonitors.Count; i++)
mMonitors[i].OnOrderDeleted(order);
}
/// <summary>
/// Process order data changing during execution
/// </summary>
public void OnOrderChanged(O2GOrderRow orderRow)
{
//STUB
}
private bool IsLimitEntryOrder(O2GOrderRow order)
{
return order.Type.StartsWith("LE");
}
static public bool IsClosingOrder(O2GOrderRow order)
{
return(order.Type.StartsWith("C"));
}
static public bool IsOpeningOrder(O2GOrderRow order)
{
return(order.Type.StartsWith("O"));
}
private void PrintOrder(string sCaption, O2GOrderRow orderRow)
{
Console.WriteLine("{0}: OrderID='{1}', TradeID='{2}', Status='{3}', " +
"Amount='{4}', OriginAmount='{5}', FilledAmount='{6}'",
sCaption, orderRow.OrderID, orderRow.TradeID, orderRow.Status,
orderRow.Amount, orderRow.OriginAmount, orderRow.FilledAmount);
}
public static bool IsClosingOrder(O2GOrderRow order)
{
return order.Type.StartsWith("C");
}
public static bool IsOpeningOrder(O2GOrderRow order)
{
return order.Type.StartsWith("O");
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
public OrderMonitorNetting(O2GOrderRow order)
: this(order, 0)
{
}
/// <summary>
/// Process order deletion as result of execution
/// </summary>
public void OnOrderDeleted(O2GOrderRow orderRow)
{
string sDeletedOrderID = orderRow.OrderID;
string sOrderID = mOrder.OrderID;
if (sDeletedOrderID.Equals(sOrderID))
{
// Store Reject amount
if (OrderRowStatus.Rejected.Equals(orderRow.Status))
{
mState = OrderState.OrderRejected;
mRejectAmount = orderRow.Amount;
mTotalAmount = orderRow.OriginAmount - mRejectAmount;
if (!string.IsNullOrEmpty(mRejectMessage) && IsAllTradesReceived())
SetResult(true);
}
else if (OrderRowStatus.Canceled.Equals(orderRow.Status))
{
mState = OrderState.OrderCanceled;
mRejectAmount = orderRow.Amount;
mTotalAmount = orderRow.OriginAmount - mRejectAmount;
if (IsAllTradesReceived())
SetResult(false);
}
else
{
mRejectAmount = 0;
mTotalAmount = orderRow.OriginAmount;
mState = OrderState.OrderExecuted;
if (IsAllTradesReceived())
SetResult(true);
}
}
}
/// <summary>
/// Process order data changing during execution
/// </summary>
public void OnOrderChanged(O2GOrderRow orderRow)
{
//STUB
}
