/// <summary>
 /// Create entry order with attached stop and limit orders request
 /// </summary>
 private static O2GRequest CreateELSRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRate, double dRateLimit, double dRateStop, string sBuySell, string sOrderType)
 {
     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);
     valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
     valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
     valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
     valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
     valuemap.setDouble(O2GRequestParamsEnum.Rate, dRate);
     valuemap.setDouble(O2GRequestParamsEnum.RateLimit, dRateLimit);
     valuemap.setDouble(O2GRequestParamsEnum.RateStop, dRateStop);
     valuemap.setString(O2GRequestParamsEnum.CustomID, "EntryOrderWithStopLimit");
     request = requestFactory.createOrderRequest(valuemap);
     if (request == null)
     {
         Console.WriteLine(requestFactory.getLastError());
     }
     return request;
 }

 /// <summary>
 /// ctor
 /// </summary>
 /// <param name="session"></param>
 public ResponseListener(O2GSession session)
 {
     mRequestID = string.Empty;
     mResponse = null;
     mSyncResponseEvent = new EventWaitHandle(false, EventResetMode.AutoReset);
     mSession = session;
 }

 /// <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;
 }

        /// <summary>
        /// Get reports for all accounts
        /// </summary>
        /// <param name="session"></param>
        public static void GetReports(O2GSession session)
        {
            O2GLoginRules loginRules = session.getLoginRules();
            if (loginRules == null)
            {
                throw new Exception("Cannot get login rules");
            }
            O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
            O2GResponse accountsResponse = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
            O2GAccountsTableResponseReader accountsReader = responseFactory.createAccountsTableReader(accountsResponse);
            System.Net.WebClient webClient = new System.Net.WebClient();
            for (int i = 0; i < accountsReader.Count; i++)
            {
                O2GAccountRow account = accountsReader.getRow(i);
                string url = session.getReportURL(account, DateTime.Now.AddMonths(-1), DateTime.Now, "html", null, null, 0);

                Console.WriteLine("AccountID={0}; Balance={1}; UsedMargin={2}; Report URL={3}",
                        account.AccountID, account.Balance, account.UsedMargin, url);

                string content = webClient.DownloadString(url);
                string filename = account.AccountID + ".html";
                System.IO.File.WriteAllText(filename, content);
                Console.WriteLine("Report is saved to {0}", filename);
            }
        }

        /// <summary>
        /// Create entry order request
        /// </summary>
        private static O2GRequest CreateEntryOrderRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRate, string sBuySell, string sOrderType, string sExpireDate)
        {
            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);
            valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
            valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
            valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
            valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
            valuemap.setDouble(O2GRequestParamsEnum.Rate, dRate);
            valuemap.setString(O2GRequestParamsEnum.CustomID, "EntryOrder");

            if (!string.IsNullOrEmpty(sExpireDate))
            {
                valuemap.setString(O2GRequestParamsEnum.TimeInForce, Constants.TIF.GTD);
                valuemap.setString(O2GRequestParamsEnum.ExpireDateTime, sExpireDate); // UTCTimestamp format: "yyyyMMdd-HH:mm:ss.SSS" (milliseconds are optional)
            }

            request = requestFactory.createOrderRequest(valuemap);
            if (request == null)
            {
                Console.WriteLine(requestFactory.getLastError());
            }
            return request;
        }

        /// <summary>
        /// Create request for adding existing order into existing contingency group
        /// </summary>
        private static O2GRequest AddOrderIntoGroupRequest(O2GSession session, string sAccountID, string sContingencyID, string sOrderID, int iContingencyType)
        {
            O2GRequest request = null;
            O2GRequestFactory requestFactory = session.getRequestFactory();
            if (requestFactory == null)
            {
                throw new Exception("Cannot create request factory");
            }
            O2GValueMap valuemapMain = requestFactory.createValueMap();
            valuemapMain.setString(O2GRequestParamsEnum.Command, Constants.Commands.JoinToExistingContingencyGroup);
            valuemapMain.setInt(O2GRequestParamsEnum.ContingencyGroupType, iContingencyType);
            valuemapMain.setString(O2GRequestParamsEnum.ContingencyID, sContingencyID);

            O2GValueMap valuemapChild = requestFactory.createValueMap();
            valuemapChild.setString(O2GRequestParamsEnum.OrderID, sOrderID);
            valuemapChild.setString(O2GRequestParamsEnum.AccountID, sAccountID);
            valuemapMain.appendChild(valuemapChild);

            request = requestFactory.createOrderRequest(valuemapMain);
            if (request == null)
            {
                Console.WriteLine(requestFactory.getLastError());
            }
            return request;
        }

 public Connection(O2GSession session, LoginParams loginParams, SampleParams sampleParams, bool bIsFirstAccount)
 {
     mSession = session;
     mLoginParams = loginParams;
     mSampleParams = sampleParams;
     mIsFirstAccount = bIsFirstAccount;
 }

 /// <summary>
 /// Store offers data from response and print it
 /// </summary>
 /// <param name="session"></param>
 /// <param name="response"></param>
 /// <param name="sInstrument"></param>
 public void PrintOffers(O2GSession session, O2GResponse response, string sInstrument)
 {
     O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
     if (readerFactory == null)
     {
         throw new Exception("Cannot create response reader factory");
     }
     O2GOffersTableResponseReader responseReader = readerFactory.createOffersTableReader(response);
     for (int i = 0; i < responseReader.Count; i++)
     {
         O2GOfferRow offerRow = responseReader.getRow(i);
         Offer offer;
         if (mOffers.FindOffer(offerRow.OfferID, out offer))
         {
             if (offerRow.isTimeValid && offerRow.isBidValid && offerRow.isAskValid)
             {
                 offer.Date = offerRow.Time;
                 offer.Bid = offerRow.Bid;
                 offer.Ask = offerRow.Ask;
             }
         }
         else
         {
             offer = new Offer(offerRow.OfferID, offerRow.Instrument,
                              offerRow.Digits, offerRow.PointSize, offerRow.Time,
                              offerRow.Bid, offerRow.Ask);
             mOffers.AddOffer(offer);
         }
         if (string.IsNullOrEmpty(sInstrument) || offerRow.Instrument.Equals(sInstrument))
         {
             Console.WriteLine("{0}, {1}, Bid={2}, Ask={3}", offer.OfferID, offer.Instrument, offer.Bid, offer.Ask);
         }
     }
 }

 /// <summary>
 /// ctor
 /// </summary>
 /// <param name="session"></param>
 public SessionStatusListener(O2GSession session, string sSessionID, string sPin)
 {
     mSession = session;
     mSessionID = sSessionID;
     mPin = sPin;
     Reset();
     mSyncSessionEvent = new EventWaitHandle(false, EventResetMode.AutoReset);
 }

 /// <summary>
 /// Request historical prices for the specified timeframe of the specified period
 /// </summary>
 /// <param name="session"></param>
 /// <param name="sInstrument"></param>
 /// <param name="sTimeframe"></param>
 /// <param name="dtFrom"></param>
 /// <param name="dtTo"></param>
 /// <param name="responseListener"></param>
 public static void GetHistoryPrices(O2GSession session, string sInstrument, string sTimeframe, DateTime dtFrom, DateTime dtTo, ResponseListener responseListener)
 {
     O2GRequestFactory factory = session.getRequestFactory();
     O2GTimeframe timeframe = factory.Timeframes[sTimeframe];
     if (timeframe == null)
     {
         throw new Exception(string.Format("Timeframe '{0}' is incorrect!", sTimeframe));
     }
     O2GRequest request = factory.createMarketDataSnapshotRequestInstrument(sInstrument, timeframe, 300);
     DateTime dtFirst = dtTo;
     do // cause there is limit for returned candles amount
     {
         factory.fillMarketDataSnapshotRequestTime(request, dtFrom, dtFirst, false);
         responseListener.SetRequestID(request.RequestID);
         session.sendRequest(request);
         if (!responseListener.WaitEvents())
         {
             throw new Exception("Response waiting timeout expired");
         }
         // shift "to" bound to oldest datetime of returned data
         O2GResponse response = responseListener.GetResponse();
         if (response != null && response.Type == O2GResponseType.MarketDataSnapshot)
         {
             O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
             if (readerFactory != null)
             {
                 O2GMarketDataSnapshotResponseReader reader = readerFactory.createMarketDataSnapshotReader(response);
                 if (reader.Count > 0)
                 {
                     if (DateTime.Compare(dtFirst, reader.getDate(0)) != 0)
                     {
                         dtFirst = reader.getDate(0); // earliest datetime of returned data
                     }
                     else
                     {
                         break;
                     }
                 }
                 else
                 {
                     Console.WriteLine("0 rows received");
                     break;
                 }
             }
             PrintPrices(session, response);
         }
         else
         {
             break;
         }
     } while (dtFirst > dtFrom);
 }

 /// <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");
     }
 }

 /// <summary>
 /// Print accounts table
 /// </summary>
 /// <param name="session"></param>
 private static void PrintAccounts(O2GSession session)
 {
     O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
     if (readerFactory == null)
     {
         throw new Exception("Cannot create response reader factory");
     }
     O2GLoginRules loginRules = session.getLoginRules();
     O2GResponse response = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
     O2GAccountsTableResponseReader accountsResponseReader = readerFactory.createAccountsTableReader(response);
     for (int i = 0; i < accountsResponseReader.Count; i++)
     {
         O2GAccountRow accountRow = accountsResponseReader.getRow(i);
         Console.WriteLine("AccountID: {0}, Balance: {1}, Used margin: {2}", accountRow.AccountID, accountRow.Balance, accountRow.UsedMargin);
     }
 }

 /// <summary>
 /// Create true market order request
 /// </summary>
 private static O2GRequest CreateTrueMarketOrderRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, string sBuySell)
 {
     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, Constants.Orders.TrueMarketOpen);
     valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
     valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
     valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
     valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
     valuemap.setString(O2GRequestParamsEnum.CustomID, "TrueMarketOrder");
     request = requestFactory.createOrderRequest(valuemap);
     return request;
 }

 /// <summary>
 /// Find valid account by ID or get the first valid account
 /// </summary>
 /// <param name="session"></param>
 /// <returns>account</returns>
 private static O2GAccountRow GetAccount(O2GSession session, string sAccountID)
 {
     O2GAccountRow account = null;
     bool bHasAccount = false;
     O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
     if (readerFactory == null)
     {
         throw new Exception("Cannot create response reader factory");
     }
     O2GLoginRules loginRules = session.getLoginRules();
     O2GResponse response = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
     O2GAccountsTableResponseReader accountsResponseReader = readerFactory.createAccountsTableReader(response);
     for (int i = 0; i < accountsResponseReader.Count; i++)
     {
         account = accountsResponseReader.getRow(i);
         string sAccountKind = account.AccountKind;
         if (account.MaintenanceType.Equals("0"))  // netting account
         {
             if (sAccountKind.Equals("32") || sAccountKind.Equals("36"))
             {
                 if (account.MarginCallFlag.Equals("N"))
                 {
                     if (string.IsNullOrEmpty(sAccountID) || sAccountID.Equals(account.AccountID))
                     {
                         bHasAccount = true;
                         break;
                     }
                 }
             }
         }
     }
     if (!bHasAccount)
     {
         return null;
     }
     else
     {
         return account;
     }
 }

        /// <summary>
        /// Create OCO request
        /// </summary>
        private static O2GRequest CreateOCORequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRateUp, double dRateDown)
        {
            O2GRequest request = null;
            O2GRequestFactory requestFactory = session.getRequestFactory();
            if (requestFactory == null)
            {
                throw new Exception("Cannot create request factory");
            }
            O2GValueMap valuemapMain = requestFactory.createValueMap();
            valuemapMain.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOCO);

            // ValueMap for upswing
            O2GValueMap valuemapUp = requestFactory.createValueMap();
            valuemapUp.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
            valuemapUp.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.StopEntry);
            valuemapUp.setString(O2GRequestParamsEnum.AccountID, sAccountID);
            valuemapUp.setString(O2GRequestParamsEnum.OfferID, sOfferID);
            valuemapUp.setString(O2GRequestParamsEnum.BuySell, Constants.Buy);
            valuemapUp.setInt(O2GRequestParamsEnum.Amount, iAmount);
            valuemapUp.setDouble(O2GRequestParamsEnum.Rate, dRateUp);
            valuemapMain.appendChild(valuemapUp);

            // ValueMap for downswing
            O2GValueMap valuemapDown = requestFactory.createValueMap();
            valuemapDown.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
            valuemapDown.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.StopEntry);
            valuemapDown.setString(O2GRequestParamsEnum.AccountID, sAccountID);
            valuemapDown.setString(O2GRequestParamsEnum.OfferID, sOfferID);
            valuemapDown.setString(O2GRequestParamsEnum.BuySell, Constants.Sell);
            valuemapDown.setInt(O2GRequestParamsEnum.Amount, iAmount);
            valuemapDown.setDouble(O2GRequestParamsEnum.Rate, dRateDown);
            valuemapMain.appendChild(valuemapDown);

            request = requestFactory.createOrderRequest(valuemapMain);
            if (request == null)
            {
                Console.WriteLine(requestFactory.getLastError());
            }
            return request;
        }

 /// <summary>
 /// Print history data from response
 /// </summary>
 /// <param name="session"></param>
 /// <param name="response"></param>
 public static void PrintPrices(O2GSession session, O2GResponse response)
 {
     Console.WriteLine("Request with RequestID={0} is completed:", response.RequestID);
     O2GResponseReaderFactory factory = session.getResponseReaderFactory();
     if (factory != null)
     {
         O2GMarketDataSnapshotResponseReader reader = factory.createMarketDataSnapshotReader(response);
         for (int ii = reader.Count - 1; ii >= 0; ii--)
         {
             if (reader.isBar)
             {
                 Console.WriteLine("DateTime={0}, BidOpen={1}, BidHigh={2}, BidLow={3}, BidClose={4}, AskOpen={5}, AskHigh={6}, AskLow={7}, AskClose={8}, Volume={9}",
                         reader.getDate(ii), reader.getBidOpen(ii), reader.getBidHigh(ii), reader.getBidLow(ii), reader.getBidClose(ii),
                         reader.getAskOpen(ii), reader.getAskHigh(ii), reader.getAskLow(ii), reader.getAskClose(ii), reader.getVolume(ii));
             }
             else
             {
                 Console.WriteLine("DateTime={0}, Bid={1}, Ask={2}", reader.getDate(ii), reader.getBidClose(ii), reader.getAskClose(ii));
             }
         }
     }
 }

 /// <summary>
 /// Show permissions for the particular instrument
 /// </summary>
 public static void CheckPermissions(O2GSession session, string sInstrument)
 {
     O2GLoginRules loginRules = session.getLoginRules();
     O2GPermissionChecker permissionChecker = loginRules.getPermissionChecker();
     Console.WriteLine("canCreateMarketOpenOrder = {0}", permissionChecker.canCreateMarketOpenOrder(sInstrument));
     Console.WriteLine("canChangeMarketOpenOrder = {0}", permissionChecker.canChangeMarketOpenOrder(sInstrument));
     Console.WriteLine("canDeleteMarketOpenOrder = {0}", permissionChecker.canDeleteMarketOpenOrder(sInstrument));
     Console.WriteLine("canCreateMarketCloseOrder = {0}", permissionChecker.canCreateMarketCloseOrder(sInstrument));
     Console.WriteLine("canChangeMarketCloseOrder = {0}", permissionChecker.canChangeMarketCloseOrder(sInstrument));
     Console.WriteLine("canDeleteMarketCloseOrder = {0}", permissionChecker.canDeleteMarketCloseOrder(sInstrument));
     Console.WriteLine("canCreateEntryOrder = {0}", permissionChecker.canCreateEntryOrder(sInstrument));
     Console.WriteLine("canChangeEntryOrder = {0}", permissionChecker.canChangeEntryOrder(sInstrument));
     Console.WriteLine("canDeleteEntryOrder = {0}", permissionChecker.canDeleteEntryOrder(sInstrument));
     Console.WriteLine("canCreateStopLimitOrder = {0}", permissionChecker.canCreateStopLimitOrder(sInstrument));
     Console.WriteLine("canChangeStopLimitOrder = {0}", permissionChecker.canChangeStopLimitOrder(sInstrument));
     Console.WriteLine("canDeleteStopLimitOrder = {0}", permissionChecker.canDeleteStopLimitOrder(sInstrument));
     Console.WriteLine("canRequestQuote = {0}", permissionChecker.canRequestQuote(sInstrument));
     Console.WriteLine("canAcceptQuote = {0}", permissionChecker.canAcceptQuote(sInstrument));
     Console.WriteLine("canDeleteQuote = {0}", permissionChecker.canDeleteQuote(sInstrument));
     Console.WriteLine("canJoinToNewContingencyGroup = {0}", permissionChecker.canJoinToNewContingencyGroup(sInstrument));
     Console.WriteLine("canJoinToExistingContingencyGroup = {0}", permissionChecker.canJoinToExistingContingencyGroup(sInstrument));
     Console.WriteLine("canRemoveFromContingencyGroup = {0}", permissionChecker.canRemoveFromContingencyGroup(sInstrument));
     Console.WriteLine("canChangeOfferSubscription = {0}", permissionChecker.canChangeOfferSubscription(sInstrument));
     Console.WriteLine("canCreateNetCloseOrder = {0}", permissionChecker.canCreateNetCloseOrder(sInstrument));
     Console.WriteLine("canChangeNetCloseOrder = {0}", permissionChecker.canChangeNetCloseOrder(sInstrument));
     Console.WriteLine("canDeleteNetCloseOrder = {0}", permissionChecker.canDeleteNetCloseOrder(sInstrument));
     Console.WriteLine("canCreateNetStopLimitOrder = {0}", permissionChecker.canCreateNetStopLimitOrder(sInstrument));
     Console.WriteLine("canChangeNetStopLimitOrder = {0}", permissionChecker.canChangeNetStopLimitOrder(sInstrument));
     Console.WriteLine("canDeleteNetStopLimitOrder = {0}", permissionChecker.canDeleteNetStopLimitOrder(sInstrument));
     Console.WriteLine("canUseDynamicTrailingForStop = {0}", permissionChecker.canUseDynamicTrailingForStop());
     Console.WriteLine("canUseDynamicTrailingForLimit = {0}", permissionChecker.canUseDynamicTrailingForLimit());
     Console.WriteLine("canUseDynamicTrailingForEntryStop = {0}", permissionChecker.canUseDynamicTrailingForEntryStop());
     Console.WriteLine("canUseDynamicTrailingForEntryLimit = {0}", permissionChecker.canUseDynamicTrailingForEntryLimit());
     Console.WriteLine("canUseFluctuateTrailingForStop = {0}", permissionChecker.canUseFluctuateTrailingForStop());
     Console.WriteLine("canUseFluctuateTrailingForLimit = {0}", permissionChecker.canUseFluctuateTrailingForLimit());
     Console.WriteLine("canUseFluctuateTrailingForEntryStop = {0}", permissionChecker.canUseFluctuateTrailingForEntryStop());
     Console.WriteLine("canUseFluctuateTrailingForEntryLimit = {0}", permissionChecker.canUseFluctuateTrailingForEntryLimit());
 }

        /// <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;
        }

 public ELSResponseListener(O2GSession session, Display display)
 {
     this.mSession = session;
     this.display = display;
     manualEvent = new ManualResetEvent(false);
 }

 /// <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");
     }
 }