public void OnTradeAdded(O2GTradeRow tradeRow) { for (int i = 0; i < mMonitors.Count; i++) { mMonitors[i].OnTradeAdded(tradeRow); } }
/// <summary> /// Attach L or S order to existing entry order /// </summary> private static O2GRequest AddOrderForEntryRequest(O2GSession session, O2GTradeRow trade, string sOrderType, double dRate) { if (!sOrderType.Equals("L") && !sOrderType.Equals("S")) { throw new Exception("Incorrect order type"); } O2GRequest request = null; O2GRequestFactory requestFactory = session.getRequestFactory(); if (requestFactory == null) { throw new Exception("Cannot create request factory"); } O2GValueMap valuemap = requestFactory.createValueMap(); valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder); valuemap.setString(O2GRequestParamsEnum.OrderType, sOrderType); // Must be L or S valuemap.setString(O2GRequestParamsEnum.AccountID, trade.AccountID); valuemap.setString(O2GRequestParamsEnum.OfferID, trade.OfferID); valuemap.setString(O2GRequestParamsEnum.TradeID, trade.TradeID); // TradeID from existing Entry order string sOppositeDirection = trade.BuySell == Constants.Buy ? Constants.Sell : Constants.Buy; valuemap.setString(O2GRequestParamsEnum.BuySell, sOppositeDirection); // The order direction must be opposite to the direction of the order which was used to create the position valuemap.setInt(O2GRequestParamsEnum.Amount, trade.Amount); valuemap.setDouble(O2GRequestParamsEnum.Rate, dRate); valuemap.setString(O2GRequestParamsEnum.CustomID, "AttachedEntryOrder"); request = requestFactory.createOrderRequest(valuemap); if (request == null) { Console.WriteLine(requestFactory.getLastError()); } return(request); }
/// <summary> /// Get orders data for closing all positions /// </summary> /// <param name="tableManager"></param> /// <param name="sAccountID"></param> /// <returns></returns> private static Dictionary <string, CloseOrdersData> GetCloseOrdersData(O2GTableManager tableManager, string sAccountID) { Dictionary <string, CloseOrdersData> closeOrdersData = new Dictionary <string, CloseOrdersData>(); O2GTradeRow trade = null; O2GTradesTable tradesTable = (O2GTradesTable)tableManager.getTable(O2GTableType.Trades); for (int i = 0; i < tradesTable.Count; i++) { trade = tradesTable.getRow(i); string sOfferID = trade.OfferID; string sBuySell = trade.BuySell; // Set opposite side OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy); if (closeOrdersData.ContainsKey(sOfferID)) { OrderSide currentSide = closeOrdersData[sOfferID].Side; if (currentSide != OrderSide.Both && currentSide != side) { closeOrdersData[sOfferID].Side = OrderSide.Both; } } else { CloseOrdersData data = new CloseOrdersData(sAccountID, side); closeOrdersData.Add(sOfferID, data); } } return(closeOrdersData); }
/// <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> /// Get orders data for closing all positions /// </summary> /// <param name="session"></param> /// <param name="sAccountID"></param> /// <param name="sOfferID"></param> /// <param name="responseListener"></param> /// <returns></returns> private static bool GetCloseOrdersData(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener, out CloseOrdersData closeOrdersData) { O2GRequestFactory requestFactory = session.getRequestFactory(); if (requestFactory == null) { throw new Exception("Cannot create request factory"); } O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID); responseListener.SetRequestID(request.RequestID); session.sendRequest(request); if (!responseListener.WaitEvents()) { throw new Exception("Response waiting timeout expired"); } O2GResponse response = responseListener.GetResponse(); bool bIsTradesFound = false; closeOrdersData = new CloseOrdersData(); if (response != null) { O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory(); if (readerFactory != null) { O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response); for (int i = 0; i < tradesResponseReader.Count; i++) { O2GTradeRow trade = tradesResponseReader.getRow(i); if (!trade.OfferID.Equals(sOfferID)) { continue; } bIsTradesFound = true; string sBuySell = trade.BuySell; // Set opposite side OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy); if (closeOrdersData.OfferID.Equals(sOfferID)) { OrderSide currentSide = closeOrdersData.Side; if (currentSide != OrderSide.Both && currentSide != side) { closeOrdersData.Side = OrderSide.Both; } } else { closeOrdersData.OfferID = sOfferID; closeOrdersData.AccountID = sAccountID; closeOrdersData.Side = side; } } } } return(bIsTradesFound); }
/// <summary> /// Get orders data for closing all positions /// </summary> /// <param name="session"></param> /// <param name="sAccountID"></param> /// <param name="responseListener"></param> /// <returns></returns> private static Dictionary <string, CloseOrdersData> GetCloseOrdersData(O2GSession session, string sAccountID, ResponseListener responseListener) { Dictionary <string, CloseOrdersData> closeOrdersData = new Dictionary <string, CloseOrdersData>(); O2GRequestFactory requestFactory = session.getRequestFactory(); if (requestFactory == null) { throw new Exception("Cannot create request factory"); } O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, 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 readerFactory = session.getResponseReaderFactory(); if (readerFactory != null) { O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response); for (int i = 0; i < tradesResponseReader.Count; i++) { O2GTradeRow trade = tradesResponseReader.getRow(i); string sOfferID = trade.OfferID; string sBuySell = trade.BuySell; // Set opposite side OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy); if (closeOrdersData.ContainsKey(sOfferID)) { OrderSide currentSide = closeOrdersData[sOfferID].Side; if (currentSide != OrderSide.Both && currentSide != side) { closeOrdersData[sOfferID].Side = OrderSide.Both; } } else { CloseOrdersData data = new CloseOrdersData(sAccountID, side); closeOrdersData.Add(sOfferID, data); } } } } return(closeOrdersData); }
/* Close True Market Order */ public void PrepareParamsAndCallTrueMarketCloseOrder(O2GTradeRow tradeRow) { //The order direcion of the close order must be opposite to the direction of the trade. string sTradeBuySell = tradeRow.BuySell; if (sTradeBuySell == Constants.Buy) // trade BuySell=Constants.Buy = order BuySell = Constants.Sell { CreateTrueMarketCloseOrder(tradeRow.OfferID, tradeRow.AccountID, tradeRow.TradeID, tradeRow.Amount, Constants.Sell); } else // trade BuySell=Constants.Sell = order BuySell = Constants.Buy { CreateTrueMarketCloseOrder(tradeRow.OfferID, tradeRow.AccountID, tradeRow.TradeID, tradeRow.Amount, Constants.Buy); } }
public void ModelCreateOrder(Session Session, Model CurrentModel, string OrderType, int iAmount, double idRate, double idPointSize, int iAtMarket, string sBuySell) { m_o2gsession = Session.O2GSession; O2GTableManager tableManager = Session.O2GSession.getTableManager(); O2GAccountRow account = GetAccount(tableManager, null); O2GOfferRow offer = GetOffer(tableManager, CurrentModel.Instrument); O2GTradeRow trade = GetTrade(tableManager, account.AccountID, offer.OfferID); switch (OrderType) { case "OpenMarketOrder": CreateTrueMarketOrder(offer.OfferID, account.AccountID, iAmount, sBuySell); break; case "CloseMarketOrder": PrepareParamsAndCallTrueMarketCloseOrder(trade); break; case "OpenLimitOrder": CreateOpenLimitOrder(offer.OfferID, account.AccountID, iAmount, idRate, sBuySell); break; case "CloseLimitOrder": PrepareParamsAndCallLimitCloseOrder(trade); break; case "OpenOpenOrder": CreateMarketOrder(offer.OfferID, account.AccountID, iAmount, idRate, sBuySell); break; case "CloseOpenOrder": // @ here gl PrepareParamsAndCallMarketCloseOrder(trade); break; case "OpenRangeOrder": PrepareParamsAndCallRangeOrder(offer.OfferID, account.AccountID, iAmount, idPointSize, iAtMarket, sBuySell); break; case "CloseRangeOrder": PrepareParamsAndCallRangeCloseOrder(trade, iAtMarket); break; default: break; } }
/// <summary> /// Find the first opened position by AccountID and OfferID /// </summary> /// <param name="session"></param> /// <param name="sAccountID"></param> /// <param name="sOfferID"></param> /// <param name="responseListener"></param> /// <returns></returns> private static O2GTradeRow GetTrade(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener) { O2GTradeRow trade = null; bool bHasTrade = false; O2GRequestFactory requestFactory = session.getRequestFactory(); if (requestFactory == null) { throw new Exception("Cannot create request factory"); } O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, 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 readerFactory = session.getResponseReaderFactory(); if (readerFactory != null) { O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response); for (int i = 0; i < tradesResponseReader.Count; i++) { trade = tradesResponseReader.getRow(i); if (sOfferID.Equals(trade.OfferID)) { bHasTrade = true; break; } } } } if (!bHasTrade) { return(null); } else { return(trade); } }
private void PrintTrades(ReadOnlyCollection <O2GTradeRow> trades, string orderID) { if (trades.Count == 0) { return; } Console.WriteLine("For the order: OrderID = {0} the following positions have been opened:", orderID); for (int i = 0; i < trades.Count; i++) { O2GTradeRow trade = trades[i]; String tradeID = trade.TradeID; int amount = trade.Amount; double rate = trade.OpenRate; Console.WriteLine("Trade ID: {0}; Amount: {1}; Rate: {2}", tradeID, amount, rate); } }
private void PrintUpdatedTrades(ReadOnlyCollection <O2GTradeRow> updatedTrades, string sOrderID) { if (updatedTrades.Count == 0) { return; } Console.WriteLine("For the order: OrderID = {0} the following positions have been updated: ", sOrderID); for (int i = 0; i < updatedTrades.Count; i++) { O2GTradeRow trade = updatedTrades[i]; string sTradeID = trade.TradeID; int iAmount = trade.Amount; double dRate = trade.OpenRate; Console.WriteLine("Trade ID: {0}; Amount: {1}; Rate: {2}", sTradeID, iAmount, dRate); } }
/* Close Open Order */ public void PrepareParamsAndCallMarketCloseOrder(O2GTradeRow tradeRow) { string sTradeBuySell = tradeRow.BuySell; // Close order is opposite to the trade bool bBuyOrder = (sTradeBuySell == Constants.Sell); string sTradeOfferID = tradeRow.OfferID; double dRate = 0; // Ask price for Buy and Bid price for Sell dRate = bBuyOrder ? m_ask : m_bid; CreateMarketCloseOrder(sTradeOfferID, tradeRow.AccountID, tradeRow.TradeID, tradeRow.Amount, dRate, bBuyOrder ? Constants.Buy : Constants.Sell); }
public bool ExistsPositionFor(string symbol) { O2GResponseReaderFactory factory = session.Session.getResponseReaderFactory(); // Gets first account from login. O2GLoginRules loginRules = session.Session.getLoginRules(); O2GResponse response = loginRules.getTableRefeshResponse(O2GTable.ClosedTrades); O2GTradesTableResponseReader tradesReader = factory.createTradesTableReader(response); for (int i = 0; i < tradesReader.Count; i++) { O2GTradeRow tradeRow = tradesReader.getRow(i); Console.WriteLine("Trades---"); Console.WriteLine(tradeRow.OpenQuoteID); Console.WriteLine(tradeRow.OfferID); } return(false); }
/// <summary> /// Process trade updating during order execution /// </summary> public void OnTradeUpdated(O2GTradeRow tradeRow) { string sTradeOrderID = tradeRow.OpenOrderID; string sOrderID = mOrder.OrderID; if (sTradeOrderID.Equals(sOrderID)) { mUpdatedTrades.Add(tradeRow); if (mState == OrderState.OrderExecuted || mState == OrderState.OrderRejected || mState == OrderState.OrderCanceled) { if (IsAllTradesReceived()) { SetResult(true); } } } }
public void ModelCreateLimitOrder(Session Session, Model CurrentModel, string OrderType, int iAmount, double idRate, double idPointSize, int iAtMarket, string sBuySell, double TakeProfit, double StopLoss) { m_o2gsession = Session.O2GSession; O2GTableManager tableManager = Session.O2GSession.getTableManager(); O2GAccountRow account = GetAccount(tableManager, null); O2GOfferRow offer = GetOffer(tableManager, CurrentModel.Instrument); O2GTradeRow trade = GetTrade(tableManager, account.AccountID, offer.OfferID); switch (OrderType) { case "OpenMarketOrder": CreateTrueMarketLimitOrder(offer.OfferID, account.AccountID, iAmount, sBuySell, TakeProfit, StopLoss); break; default: break; } }
/// <summary> /// Process trade adding during order execution /// </summary> public void OnTradeAdded(O2GTradeRow tradeRow) { String tradeOrderID = tradeRow.OpenOrderID; String orderID = mOrder.OrderID; if (tradeOrderID == orderID) { mTrade = tradeRow; if (mState == OrderState.OrderExecuted || mState == OrderState.OrderRejected || mState == OrderState.OrderCanceled) { if (IsAllTradeReceived()) { SetResult(true); } } } }
/* Close Limit Order */ public void PrepareParamsAndCallLimitCloseOrder(O2GTradeRow tradeRow) { string sTradeBuySell = tradeRow.BuySell; // Close order is opposite to the trade bool bBuyOrder = false; if (sTradeBuySell == Constants.Sell) { bBuyOrder = true; } string sTradeOfferID = tradeRow.OfferID; double dCurrentRate = (bBuyOrder) ? m_ask : m_bid; CreateLimitCloseOrder(sTradeOfferID, tradeRow.AccountID, tradeRow.TradeID, tradeRow.Amount, dCurrentRate, bBuyOrder ? Constants.Buy : Constants.Sell); }
/// <summary> /// Print trades table for account /// </summary> /// <param name="session"></param> /// <param name="sAccountID"></param> /// <param name="responseListener"></param> private static void PrintTrades(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.Trades, sAccountID); if (request != null) { Console.WriteLine("Trades 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(); O2GTradesTableResponseReader responseReader = responseReaderFactory.createTradesTableReader(response); for (int i = 0; i < responseReader.Count; i++) { O2GTradeRow tradeRow = responseReader.getRow(i); Console.WriteLine("TradeID: {0}, Amount: {1}, Dividends: {2}", tradeRow.TradeID, tradeRow.Amount, tradeRow.Dividends); } } 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; } }
/// <summary> /// Get trade by order ID /// </summary> private static O2GTradeRow FindPosition(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.Trades, sAccountID); if (request != null) { responseListener.SetRequestID(request.RequestID); session.sendRequest(request); if (!responseListener.WaitEvents()) { throw new Exception("Response waiting timeout expired"); } O2GResponse tradeResponse = responseListener.GetResponse(); if (tradeResponse != null) { if (tradeResponse.Type == O2GResponseType.GetTrades) { O2GResponseReaderFactory responseReaderFactory = session.getResponseReaderFactory(); O2GTradesTableResponseReader responseReader = responseReaderFactory.createTradesTableReader(tradeResponse); for (int i = 0; i < responseReader.Count; i++) { O2GTradeRow tradeRow = responseReader.getRow(i); if (sOrderID.Equals(tradeRow.OpenOrderID)) { return(tradeRow); } } } } } return(null); }
/* Close Range Order */ public void PrepareParamsAndCallRangeCloseOrder(O2GTradeRow tradeRow, int iAtMarket) { string sTradeBuySell = tradeRow.BuySell; // Close order is opposite to the trade bool bBuyOrder = (sTradeBuySell == Constants.Sell); // Get dRate, then calculate dRateMin and dRateMax string sTradeOfferID = tradeRow.OfferID; double dRate = 0; dRate = bBuyOrder ? m_ask : m_bid; double dPointSize = m_pointsize; double dRateMin = dRate - iAtMarket * dPointSize; double dRateMax = dRate + iAtMarket * dPointSize; CreateRangeCloseOrder(sTradeOfferID, tradeRow.AccountID, tradeRow.TradeID, tradeRow.Amount, dRateMin, dRateMax, bBuyOrder ? Constants.Buy : Constants.Sell); }
/// <summary> /// Create close market order request /// </summary> private static O2GRequest CreateCloseMarketOrderRequest(O2GSession session, string sInstrument, O2GTradeRow tradeRow) { O2GRequest request = null; O2GRequestFactory requestFactory = session.getRequestFactory(); if (requestFactory == null) { throw new Exception("Cannot create request factory"); } O2GLoginRules loginRules = session.getLoginRules(); O2GPermissionChecker permissionChecker = loginRules.getPermissionChecker(); O2GValueMap valuemap = requestFactory.createValueMap(); valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder); if (permissionChecker.canCreateMarketCloseOrder(sInstrument) != O2GPermissionStatus.PermissionEnabled) { valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketOpen); // in USA you need to use "OM" to close a position. } else { valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketClose); valuemap.setString(O2GRequestParamsEnum.TradeID, tradeRow.TradeID); } valuemap.setString(O2GRequestParamsEnum.AccountID, tradeRow.AccountID); valuemap.setString(O2GRequestParamsEnum.OfferID, tradeRow.OfferID); valuemap.setString(O2GRequestParamsEnum.BuySell, tradeRow.BuySell.Equals(Constants.Buy) ? Constants.Sell : Constants.Buy); valuemap.setInt(O2GRequestParamsEnum.Amount, tradeRow.Amount); valuemap.setString(O2GRequestParamsEnum.CustomID, "CloseMarketOrder"); request = requestFactory.createOrderRequest(valuemap); if (request == null) { Console.WriteLine(requestFactory.getLastError()); } return request; }
/// <summary> /// Get orders data for closing all positions /// </summary> /// <param name="session"></param> /// <param name="sAccountID"></param> /// <param name="responseListener"></param> /// <returns></returns> private static bool GetCloseOrdersData(O2GTableManager tableManager, string sAccountID, string sOfferID, out CloseOrdersData closeOrdersData) { bool bIsTradesFound = false; closeOrdersData = new CloseOrdersData(); O2GTradesTable tradesTable = (O2GTradesTable)tableManager.getTable(O2GTableType.Trades); for (int i = 0; i < tradesTable.Count; i++) { O2GTradeRow trade = tradesTable.getRow(i); if (!trade.OfferID.Equals(sOfferID)) { continue; } bIsTradesFound = true; string sBuySell = trade.BuySell; // Set opposite side OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy); if (closeOrdersData.OfferID.Equals(sOfferID)) { OrderSide currentSide = closeOrdersData.Side; if (currentSide != OrderSide.Both && currentSide != side) { closeOrdersData.Side = OrderSide.Both; } } else { closeOrdersData.OfferID = sOfferID; closeOrdersData.AccountID = sAccountID; closeOrdersData.Side = side; } } return(bIsTradesFound); }
/// <summary> /// Find the first opened position by AccountID and OfferID /// </summary> /// <param name="session"></param> /// <param name="sAccountID"></param> /// <param name="sOfferID"></param> /// <param name="responseListener"></param> /// <returns></returns> private static O2GTradeRow GetTrade(O2GTableManager tableManager, string sAccountID, string sOfferID) { bool bHasTrade = false; O2GTradeRow trade = null; O2GTradesTable tradesTable = (O2GTradesTable)tableManager.getTable(O2GTableType.Trades); for (int i = 0; i < tradesTable.Count; i++) { trade = tradesTable.getRow(i); if (trade.AccountID.Equals(sAccountID) && trade.OfferID.Equals(sOfferID)) { bHasTrade = true; break; } } if (!bHasTrade) { return(null); } else { return(trade); } }
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)) { if ((OrderMonitorNetting.IsClosingOrder(orderRow) || OrderMonitorNetting.IsOpeningOrder(orderRow)) && mOrderMonitor == null) { Console.WriteLine("The order has been added. Order ID: {0}, Rate: {1}, Time In Force: {2}", orderRow.OrderID, orderRow.Rate, orderRow.TimeInForce); O2GTradeRow trade = null; string sTradeID = orderRow.TradeID; if (mTradesTable != null) { for (int j = 0; j < mTradesTable.Count; j++) { if (sTradeID.Equals(mTradesTable.getRow(j).TradeID)) { trade = mTradesTable.getRow(j); break; } } } if (trade == null) { mOrderMonitor = new OrderMonitorNetting(orderRow); } else { mOrderMonitor = new OrderMonitorNetting(orderRow, trade.Amount); } } } break; case O2GTableType.Trades: O2GTradeRow tradeRow = (O2GTradeRow)rowData; if (mOrderMonitor != null) { mOrderMonitor.OnTradeAdded(tradeRow); if (mOrderMonitor.IsOrderCompleted) { PrintResult(); mResponseListener.StopWaiting(); } } break; case O2GTableType.ClosedTrades: O2GClosedTradeRow closedTradeRow = (O2GClosedTradeRow)rowData; if (mOrderMonitor != null) { mOrderMonitor.OnClosedTradeAdded(closedTradeRow); if (mOrderMonitor.IsOrderCompleted) { PrintResult(); mResponseListener.StopWaiting(); } } break; case O2GTableType.Messages: O2GMessageRow messageRow = (O2GMessageRow)rowData; if (mOrderMonitor != null) { mOrderMonitor.OnMessageAdded(messageRow); if (mOrderMonitor.IsOrderCompleted) { PrintResult(); mResponseListener.StopWaiting(); } } break; } }
public void OnTradeAdded(O2GTradeRow tradeRow) { for (int i = 0; i < mMonitors.Count; i++) mMonitors[i].OnTradeAdded(tradeRow); }
static void Main(string[] args) { O2GSession session = null; try { LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings); SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings); PrintSampleParams("AttachStopLimitToPosition", loginParams, sampleParams); session = O2GTransport.createSession(); SessionStatusListener statusListener = new SessionStatusListener(session, loginParams.SessionID, loginParams.Pin); session.subscribeSessionStatus(statusListener); statusListener.Reset(); session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection); if (statusListener.WaitEvent() && statusListener.Connected) { ResponseListener responseListener = new ResponseListener(session); session.subscribeResponse(responseListener); O2GAccountRow account = GetAccount(session, sampleParams.AccountID); if (account == null) { if (string.IsNullOrEmpty(sampleParams.AccountID)) { throw new Exception("No valid accounts"); } else { throw new Exception(string.Format("The account '{0}' is not valid", sampleParams.AccountID)); } } sampleParams.AccountID = account.AccountID; O2GOfferRow offer = GetOffer(session, sampleParams.Instrument); if (offer == null) { throw new Exception(string.Format("The instrument '{0}' is not valid", sampleParams.Instrument)); } O2GLoginRules loginRules = session.getLoginRules(); if (loginRules == null) { throw new Exception("Cannot get login rules"); } O2GTradingSettingsProvider tradingSettingsProvider = loginRules.getTradingSettingsProvider(); int iBaseUnitSize = tradingSettingsProvider.getBaseUnitSize(sampleParams.Instrument, account); int iAmount = iBaseUnitSize * sampleParams.Lots; double dRate; double dRateStop; double dRateLimit; double dBid = offer.Bid; double dAsk = offer.Ask; double dPointSize = offer.PointSize; // For the purpose of this example we will place entry order 8 pips from the current market price // and attach stop and limit orders 10 pips from an entry order price if (sampleParams.OrderType.Equals(Constants.Orders.LimitEntry)) { if (sampleParams.BuySell.Equals(Constants.Buy)) { dRate = dAsk - 8 * dPointSize; dRateLimit = dRate + 10 * dPointSize; dRateStop = dRate - 10 * dPointSize; } else { dRate = dBid + 8 * dPointSize; dRateLimit = dRate - 10 * dPointSize; dRateStop = dRate + 10 * dPointSize; } } else { if (sampleParams.BuySell.Equals(Constants.Buy)) { dRate = dAsk + 8 * dPointSize; dRateLimit = dRate + 10 * dPointSize; dRateStop = dRate - 10 * dPointSize; } else { dRate = dBid - 8 * dPointSize; dRateLimit = dRate - 10 * dPointSize; dRateStop = dRate + 10 * dPointSize; } } O2GRequest request = CreateTrueMarketOrderRequest(session, offer.OfferID, sampleParams.AccountID, iAmount, sampleParams.BuySell); 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"); } O2GTradeRow tradeOrder = FindPosition(session, sampleParams.AccountID, responseListener.GetLastOrderID(), responseListener); if (tradeOrder == null) { throw new Exception("Order '{0}' not found"); } request = AddOrderForEntryRequest(session, tradeOrder, "L", dRateLimit); 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"); } request = AddOrderForEntryRequest(session, tradeOrder, "S", dRateStop); 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"); } Console.WriteLine("Done!"); statusListener.Reset(); session.logout(); statusListener.WaitEvent(); session.unsubscribeResponse(responseListener); } session.unsubscribeSessionStatus(statusListener); } catch (Exception e) { Console.WriteLine("Exception: {0}", e.ToString()); } finally { if (session != null) { session.Dispose(); } } }
/// <summary> /// Create close market order request /// </summary> private static O2GRequest CreateCloseMarketOrderRequest(O2GSession session, string sInstrument, O2GTradeRow tradeRow) { O2GRequest request = null; O2GRequestFactory requestFactory = session.getRequestFactory(); if (requestFactory == null) { throw new Exception("Cannot create request factory"); } O2GLoginRules loginRules = session.getLoginRules(); O2GPermissionChecker permissionChecker = loginRules.getPermissionChecker(); O2GValueMap valuemap = requestFactory.createValueMap(); valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder); if (permissionChecker.canCreateMarketCloseOrder(sInstrument) != O2GPermissionStatus.PermissionEnabled) { valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketOpen); // in USA you need to use "OM" to close a position. } else { valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketClose); valuemap.setString(O2GRequestParamsEnum.TradeID, tradeRow.TradeID); } valuemap.setString(O2GRequestParamsEnum.AccountID, tradeRow.AccountID); valuemap.setString(O2GRequestParamsEnum.OfferID, tradeRow.OfferID); valuemap.setString(O2GRequestParamsEnum.BuySell, tradeRow.BuySell.Equals(Constants.Buy) ? Constants.Sell : Constants.Buy); valuemap.setInt(O2GRequestParamsEnum.Amount, tradeRow.Amount); valuemap.setString(O2GRequestParamsEnum.CustomID, "CloseMarketOrder"); request = requestFactory.createOrderRequest(valuemap); if (request == null) { Console.WriteLine(requestFactory.getLastError()); } return(request); }
static void Main(string[] args) { O2GSession session = null; try { LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings); SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings); PrintSampleParams("ClosePosition", loginParams, sampleParams); session = O2GTransport.createSession(); session.useTableManager(O2GTableManagerMode.Yes, null); statusListener = new SessionStatusListener(session, loginParams.SessionID, loginParams.Pin); session.subscribeSessionStatus(statusListener); statusListener.Reset(); session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection); if (statusListener.WaitEvents() && statusListener.Connected) { responseListener = new ResponseListener(); TableListener tableListener = new TableListener(responseListener); session.subscribeResponse(responseListener); O2GTableManager tableManager = session.getTableManager(); O2GTableManagerStatus managerStatus = tableManager.getStatus(); while (managerStatus == O2GTableManagerStatus.TablesLoading) { Thread.Sleep(50); managerStatus = tableManager.getStatus(); } if (managerStatus == O2GTableManagerStatus.TablesLoadFailed) { throw new Exception("Cannot refresh all tables of table manager"); } O2GAccountRow account = GetAccount(tableManager, sampleParams.AccountID); if (account == null) { if (string.IsNullOrEmpty(sampleParams.AccountID)) { throw new Exception("No valid accounts"); } else { throw new Exception(string.Format("The account '{0}' is not valid", sampleParams.AccountID)); } } sampleParams.AccountID = account.AccountID; O2GOfferRow offer = GetOffer(tableManager, sampleParams.Instrument); if (offer == null) { throw new Exception(string.Format("The instrument '{0}' is not valid", sampleParams.Instrument)); } O2GTradeRow trade = GetTrade(tableManager, sampleParams.AccountID, offer.OfferID); if (trade == null) { throw new Exception(string.Format("There are no opened positions for instrument '{0}'", sampleParams.Instrument)); } tableListener.SubscribeEvents(tableManager); O2GRequest request = CreateCloseMarketOrderRequest(session, sampleParams.Instrument, trade); if (request == null) { throw new Exception("Cannot create request"); } responseListener.SetRequestID(request.RequestID); tableListener.SetRequestID(request.RequestID); session.sendRequest(request); if (responseListener.WaitEvents()) { Console.WriteLine("Done!"); } else { throw new Exception("Response waiting timeout expired"); } tableListener.UnsubscribeEvents(tableManager); } } catch (Exception e) { Console.WriteLine("Exception: {0}", e.ToString()); } finally { if (session != null) { if (statusListener.Connected) { if (responseListener != null) { session.unsubscribeResponse(responseListener); } statusListener.Reset(); session.logout(); statusListener.WaitEvents(); } session.unsubscribeSessionStatus(statusListener); session.Dispose(); } } }
/// <summary> /// Process trade updating during order execution /// </summary> public void OnTradeUpdated(O2GTradeRow tradeRow) { string sTradeOrderID = tradeRow.OpenOrderID; string sOrderID = mOrder.OrderID; if (sTradeOrderID.Equals(sOrderID)) { mUpdatedTrades.Add(tradeRow); if (mState == OrderState.OrderExecuted || mState == OrderState.OrderRejected || mState == OrderState.OrderCanceled) { if (IsAllTradesReceived()) { SetResult(true); } } } }
static void Main(string[] args) { O2GSession session = null; SessionStatusListener statusListener = null; ResponseListener responseListener = null; try { Console.WriteLine("NetStopLimit sample\n"); ArgumentParser argParser = new ArgumentParser(args, "NetStopLimit"); argParser.AddArguments(ParserArgument.Login, ParserArgument.Password, ParserArgument.Url, ParserArgument.Connection, ParserArgument.SessionID, ParserArgument.Pin, ParserArgument.Instrument, ParserArgument.RateStop, ParserArgument.RateLimit, ParserArgument.AccountID); argParser.ParseArguments(); if (!argParser.AreArgumentsValid) { argParser.PrintUsage(); return; } argParser.PrintArguments(); LoginParams loginParams = argParser.LoginParams; SampleParams sampleParams = argParser.SampleParams; session = O2GTransport.createSession(); statusListener = new SessionStatusListener(session, loginParams.SessionID, loginParams.Pin); session.subscribeSessionStatus(statusListener); statusListener.Reset(); session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection); if (statusListener.WaitEvents() && statusListener.Connected) { responseListener = new ResponseListener(session); session.subscribeResponse(responseListener); O2GAccountRow account = GetAccount(session, sampleParams.AccountID); if (account == null) { if (string.IsNullOrEmpty(sampleParams.AccountID)) { throw new Exception("No valid accounts"); } else { throw new Exception(string.Format("The account '{0}' is not valid", sampleParams.AccountID)); } } sampleParams.AccountID = account.AccountID; O2GOfferRow offer = GetOffer(session, sampleParams.Instrument); if (offer == null) { throw new Exception(string.Format("The instrument '{0}' is not valid", sampleParams.Instrument)); } O2GTradeRow trade = GetTrade(session, sampleParams.AccountID, offer.OfferID, responseListener); if (trade == null) { throw new Exception(string.Format("There are no opened positions for instrument '{0}'", sampleParams.Instrument)); } O2GRequest request; string sBuySell = trade.BuySell.Equals(Constants.Buy) ? Constants.Sell : Constants.Buy; request = CreateNetEntryOrderRequest(session, offer.OfferID, sampleParams.AccountID, sampleParams.RateStop, sBuySell, Constants.Orders.StopEntry); 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"); } request = CreateNetEntryOrderRequest(session, offer.OfferID, sampleParams.AccountID, sampleParams.RateLimit, sBuySell, Constants.Orders.LimitEntry); 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"); } Console.WriteLine("Done!"); } } catch (Exception e) { Console.WriteLine("Exception: {0}", e.ToString()); } finally { if (session != null) { if (statusListener.Connected) { statusListener.Reset(); session.logout(); statusListener.WaitEvents(); if (responseListener != null) { session.unsubscribeResponse(responseListener); } } session.unsubscribeSessionStatus(statusListener); session.Dispose(); } } }
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++) { switch (reader.getUpdateTable(ii)) { case O2GTableType.Accounts: O2GAccountRow account = reader.getAccountRow(ii); //Show balance updates Console.WriteLine("Balance: {0}", account.Balance); break; case O2GTableType.Orders: O2GOrderRow order = reader.getOrderRow(ii); switch (reader.getUpdateType(ii)) { case O2GTableUpdateType.Insert: if (mBatchOrderMonitor != null) { Console.WriteLine("The order has been added. Order ID: {0}, Rate: {1}, Time In Force: {2}", order.OrderID, order.Rate, order.TimeInForce); mBatchOrderMonitor.OnOrderAdded(order); } break; case O2GTableUpdateType.Delete: if (mBatchOrderMonitor != null) { Console.WriteLine("The order has been deleted. Order ID: {0}", order.OrderID); mBatchOrderMonitor.OnOrderDeleted(order); if (mBatchOrderMonitor.IsBatchExecuted()) { PrintResult(); mSyncResponseEvent.Set(); } } break; } break; case O2GTableType.Trades: O2GTradeRow trade = reader.getTradeRow(ii); if (reader.getUpdateType(ii) == O2GTableUpdateType.Insert) { if (mBatchOrderMonitor != null) { mBatchOrderMonitor.OnTradeAdded(trade); if (mBatchOrderMonitor.IsBatchExecuted()) { PrintResult(); mSyncResponseEvent.Set(); } } } break; case O2GTableType.ClosedTrades: O2GClosedTradeRow closedTrade = reader.getClosedTradeRow(ii); if (reader.getUpdateType(ii) == O2GTableUpdateType.Insert) { if (mBatchOrderMonitor != null) { mBatchOrderMonitor.OnClosedTradeAdded(closedTrade); if (mBatchOrderMonitor.IsBatchExecuted()) { PrintResult(); mSyncResponseEvent.Set(); } } } break; case O2GTableType.Messages: O2GMessageRow message = reader.getMessageRow(ii); if (reader.getUpdateType(ii) == O2GTableUpdateType.Insert) { if (mBatchOrderMonitor != null) { mBatchOrderMonitor.OnMessageAdded(message); if (mBatchOrderMonitor.IsBatchExecuted()) { PrintResult(); mSyncResponseEvent.Set(); } } } break; } } } }