static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("CreateOCO", 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));
}
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;
// For the purpose of this example we will place entry orders 30 pips from the current market price
double dRateUp = offer.Ask + 30.0 * offer.PointSize;
double dRateDown = offer.Bid - 30.0 * offer.PointSize;
O2GRequest request = CreateOCORequest(session, offer.OfferID, account.AccountID, iAmount, dRateUp, dRateDown);
if (request == null)
{
throw new Exception("Cannot create request");
}
tableListener.SubscribeEvents(tableManager);
List <string> requestIDList = new List <string>();
for (int i = 0; i < request.ChildrenCount; i++)
{
requestIDList.Add(request.getChildRequest(i).RequestID);
}
responseListener.SetRequestIDs(requestIDList);
tableListener.SetRequestIDs(requestIDList);
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
PrintSampleParams("PrintTableListener", loginParams);
session = O2GTransport.createSession();
TableManagerListener managerListener = new TableManagerListener();
session.useTableManager(O2GTableManagerMode.Yes, managerListener);
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)
{
O2GTableManager tableManager = session.getTableManager();
if (managerListener.WaitEvents() && managerListener.IsLoaded)
{
Console.WriteLine("All tables are loaded");
}
else
{
throw new Exception("Cannot refresh all tables of table manager");
}
O2GAccountRow account = GetAccount(tableManager);
if (account == null)
{
throw new Exception("No valid accounts");
}
managerListener.Reset();
O2GTableManager tableManagerByAccount = session.getTableManagerByAccount(account.AccountID);
if (managerListener.WaitEvents() && managerListener.IsLoaded)
{
Console.WriteLine(string.Format("All tables are loaded (account {0})", account.AccountID));
}
else
{
throw new Exception(string.Format("Cannot refresh all tables of table manager (account {0})", account.AccountID));
}
PrintOrders(tableManagerByAccount, account.AccountID);
Console.WriteLine("Done!");
}
}
catch (Exception e)
{
Console.WriteLine(string.Format("Exception: {0}", e.ToString()));
}
finally
{
if (session != null)
{
if (statusListener.Connected)
{
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
}
session.unsubscribeSessionStatus(statusListener);
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("OpenPositionNetting", 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.WaitEvents() && 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));
}
O2GTradesTableResponseReader tradesTable = GetTradesTable(session, sampleParams.AccountID, responseListener);
if (tradesTable == null)
{
throw new Exception("Cannot get trades table");
}
responseListener.SetTradesTable(tradesTable);
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;
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())
{
Thread.Sleep(1000); // Wait for the balance update
Console.WriteLine("Done!");
}
else
{
throw new Exception("Response waiting timeout expired");
}
session.unsubscribeResponse(responseListener);
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
ResponseListener responseListener = null;
try
{
Console.WriteLine("GetHistPrices sample\n");
ArgumentParser argParser = new ArgumentParser(args, "GetHistPrices");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Pin,
ParserArgument.Instrument,
ParserArgument.TimeFrame,
ParserArgument.DateFrom,
ParserArgument.DateTo);
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);
GetHistoryPrices(session, sampleParams.Instrument, sampleParams.Timeframe, sampleParams.DateFrom, sampleParams.DateTo, responseListener);
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("OpenPosition", loginParams, sampleParams);
session = O2GTransport.createSession();
session.useTableManager(O2GTableManagerMode.Yes, null);
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.WaitEvents() && statusListener.Connected)
{
ResponseListener 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));
}
}
else
{
if (!account.AccountID.Equals(sampleParams.AccountID))
{
sampleParams.AccountID = account.AccountID;
Console.WriteLine("AccountID='{0}'",
sampleParams.AccountID);
}
}
O2GOfferRow offer = GetOffer(tableManager, 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;
tableListener.SubscribeEvents(tableManager);
O2GRequest request = CreateTrueMarketOrderRequest(session, offer.OfferID, sampleParams.AccountID, iAmount, sampleParams.BuySell);
if (request == null)
{
throw new Exception("Cannot create request");
}
responseListener.SetRequestID(request.RequestID);
tableListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
PrintOrders(tableManager);
tableListener.UnsubscribeEvents(tableManager);
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
public void SetNumberOfReconnections(SetNumberOfReconnectionsRequest request)
{
this.Validator.Validate(request);
O2GTransport.setNumberOfReconnections(request.Number);
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
try
{
Console.WriteLine("SearchInTable sample\n");
ArgumentParser argParser = new ArgumentParser(args, "SearchInTable");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Pin,
ParserArgument.OrderID,
ParserArgument.AccountID);
argParser.ParseArguments();
if (!argParser.AreArgumentsValid)
{
argParser.PrintUsage();
return;
}
argParser.PrintArguments();
LoginParams loginParams = argParser.LoginParams;
SampleParams sampleParams = argParser.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)
{
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));
}
}
else
{
if (!account.AccountID.Equals(sampleParams.AccountID))
{
sampleParams.AccountID = account.AccountID;
Console.WriteLine("AccountID='{0}'",
sampleParams.AccountID);
}
}
FindOrder(tableManager, sampleParams.AccountID, sampleParams.OrderID);
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();
session.unsubscribeSessionStatus(statusListener);
}
session.Dispose();
}
}
}
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("NetStopLimit", loginParams, sampleParams);
session = O2GTransport.createSession();
session.useTableManager(O2GTableManagerMode.Yes, null);
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.WaitEvents() && statusListener.Connected)
{
ResponseListener 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));
}
O2GRequest request;
string sBuySell = trade.BuySell.Equals(Constants.Buy) ? Constants.Sell : Constants.Buy;
tableListener.SubscribeEvents(tableManager);
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);
tableListener.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);
tableListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
Console.WriteLine("Done!");
tableListener.UnsubscribeEvents(tableManager);
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
try
{
Console.WriteLine("ShowCommissionDetails sample\n");
ArgumentParser argParser = new ArgumentParser(args, "ShowCommissionDetails");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.AccountID,
ParserArgument.BuySell,
ParserArgument.Instrument);
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);
session.subscribeSessionStatus(statusListener);
statusListener.Reset();
session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection);
if (statusListener.WaitEvents() && statusListener.Connected)
{
PrintCommissionDetails(session, sampleParams);
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();
}
session.unsubscribeSessionStatus(statusListener);
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("CreateAndFindEntry", 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.WaitEvents() && 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 = CalculateRate(sampleParams.OrderType, sampleParams.BuySell, offer.Ask, offer.Bid, offer.PointSize);
O2GRequest request = CreateEntryOrderRequest(session, offer.OfferID, account.AccountID, iAmount, dRate, sampleParams.BuySell, sampleParams.OrderType);
if (request == null)
{
throw new Exception("Cannot create request; probably some arguments are missing or incorrect");
}
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (responseListener.WaitEvents())
{
string sOrderID = responseListener.GetOrderID();
if (!string.IsNullOrEmpty(sOrderID))
{
Console.WriteLine("You have successfully created an entry order for instrument {0}", sampleParams.Instrument);
Console.WriteLine("Your order ID is {0}", sOrderID);
FindOrder(session, sOrderID, sampleParams.AccountID, responseListener);
Console.WriteLine("Done!");
}
}
else
{
throw new Exception("Response waiting timeout expired");
}
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
ResponseListener responseListener = null;
try
{
Console.WriteLine("CreateELS sample\n");
ArgumentParser argParser = new ArgumentParser(args, "CreateELS");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Pin,
ParserArgument.Instrument,
ParserArgument.AccountID,
ParserArgument.BuySell,
ParserArgument.OrderType,
ParserArgument.Lots,
ParserArgument.AccountID
);
argParser.ParseArguments();
if (!argParser.AreArgumentsValid)
{
argParser.PrintUsage();
return;
}
argParser.PrintArguments();
LoginParams loginParams = argParser.LoginParams;
SampleParams sampleParams = argParser.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));
}
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;
}
}
tableListener.SubscribeEvents(tableManager);
O2GRequest request = CreateELSRequest(session, offer.OfferID, sampleParams.AccountID, iAmount, dRate, dRateLimit, dRateStop, sampleParams.BuySell, sampleParams.OrderType);
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)
{
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
if (responseListener != null)
{
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
try
{
Console.WriteLine("PrintRollover sample\n");
ArgumentParser argParser = new ArgumentParser(args, "PrintRollover");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Instrument,
ParserArgument.AccountID,
ParserArgument.Pin);
argParser.ParseArguments();
if (!argParser.AreArgumentsValid)
{
argParser.PrintUsage();
return;
}
argParser.PrintArguments();
LoginParams loginParams = argParser.LoginParams;
SampleParams sampleParams = argParser.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);
O2GRolloverProvider rolloverProvider = session.getRolloverProvider();
AutoResetEvent autoEvent = new AutoResetEvent(false);
RolloverProviderListener rolloverProviderListener = new RolloverProviderListener(autoEvent);
rolloverProvider.subscribe(rolloverProviderListener);
if (statusListener.WaitEvents() && statusListener.Connected)
{
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));
}
if (autoEvent.WaitOne(10000)) //wait 10s
{
PrintRollover(rolloverProvider, account, offer);
}
else
{
Console.WriteLine("Waiting time expired: Rollover is not avaliavle");
}
rolloverProvider.unsubscribe(rolloverProviderListener);
}
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
if (statusListener.Connected)
{
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeSessionStatus(statusListener);
}
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
IPriceHistoryCommunicator communicator = null;
SessionStatusListener statusListener = null;
bool loggedIn = false;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("RemoveQuotes", loginParams, sampleParams);
// use the application module path as a base path for quotes storage
string storagePath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "History");
// create the ForexConnect trading session
session = O2GTransport.createSession();
statusListener = new SessionStatusListener(session, loginParams.SessionID, loginParams.Pin);
// subscribe IO2GSessionStatus interface implementation for the status events
session.subscribeSessionStatus(statusListener);
statusListener.Reset();
// create an instance of IPriceHistoryCommunicator
communicator = PriceHistoryCommunicatorFactory.createCommunicator(session, storagePath);
// log in to ForexConnect
session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection);
if (statusListener.WaitEvents() && statusListener.Connected)
{
loggedIn = true;
CommunicatorStatusListener communicatorStatusListener = new CommunicatorStatusListener();
communicator.addStatusListener(communicatorStatusListener);
// wait until the communicator signals that it is ready
if (communicator.isReady() ||
(communicatorStatusListener.WaitEvents() && communicatorStatusListener.Ready))
{
// set open price candles mode, it must be called after login
QuotesManager quotesManager = communicator.getQuotesManager();
RemoveQuotes(quotesManager, sampleParams);
Console.WriteLine();
ShowLocalQuotes(quotesManager);
}
communicator.removeStatusListener(communicatorStatusListener);
}
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (communicator != null)
{
communicator.Dispose();
}
if (session != null)
{
try
{
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
}
catch (Exception ee)
{
}
session.unsubscribeSessionStatus(statusListener);
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
ResponseListener responseListener = null;
try
{
Console.WriteLine("CreateOTOCO sample\n");
ArgumentParser argParser = new ArgumentParser(args, "CreateOTOCO");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Pin,
ParserArgument.Instrument,
ParserArgument.Lots,
ParserArgument.AccountID);
argParser.ParseArguments();
if (!argParser.AreArgumentsValid)
{
argParser.PrintUsage();
return;
}
argParser.PrintArguments();
LoginParams loginParams = argParser.LoginParams;
SampleParams sampleParams = argParser.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));
}
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 dRatePrimary = offer.Bid - 30.0 * offer.PointSize;
double dRateOcoFirst = offer.Ask + 15.0 * offer.PointSize;
double dRateOcoSecond = dRatePrimary - 15.0 * offer.PointSize;
O2GRequest request = CreateOTOCORequest(session, offer.OfferID, account.AccountID, iAmount, dRatePrimary, dRateOcoFirst, dRateOcoSecond);
if (request == null)
{
throw new Exception("Cannot create request");
}
tableListener.SubscribeEvents(tableManager);
List <string> requestIDList = new List <string>();
FillRequestIDs(requestIDList, request);
responseListener.SetRequestIDs(requestIDList);
tableListener.SetRequestIDs(requestIDList);
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)
{
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
if (responseListener != null)
{
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("SubscriptionStatus", 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.WaitEvents() && statusListener.Connected)
{
ResponseListener responseListener = new ResponseListener();
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));
}
O2GRequest request = CreateSetSubscriptionStatusRequest(session, offer.OfferID, sampleParams.Status, responseListener);
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();
if (response != null && response.Type == O2GResponseType.CommandResponse)
{
Console.WriteLine("Subscription status for '{0}' is set to '{1}'", sampleParams.Instrument, sampleParams.Status);
}
PrintMargins(session, account, offer);
UpdateMargins(session, responseListener);
PrintMargins(session, account, offer);
Console.WriteLine("Done!");
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
private void DoWork()
{
O2GSession session = null;
O2GTableManager tableManager = null;
StatusListener statusListener = null;
TableListener tableListener = null;
bool canUnsubscribeSessionStatus = false;
try
{
session = O2GTransport.createSession();
session.useTableManager(O2GTableManagerMode.Yes, null);
var sessionId = Guid.NewGuid().ToString("N");
statusListener = new StatusListener(session, sessionId);
statusListener.OnStatus += (s, e) =>
{
var status = e.Item.ToStatus();
OnStatus?.Invoke(this, new GenericArgs <Status>(status));
if (status == Status.Disconnected)
{
OnDisconnected?.Invoke(this, EventArgs.Empty);
}
};
session.subscribeSessionStatus(statusListener);
session.login(userName, password, URL, connection.ToString());
if (statusListener.WaitEvents() && statusListener.Connected)
{
tableListener = new TableListener(testingMode);
tableListener.OnOffer += (s, e) =>
OnOffer?.Invoke(this, new GenericArgs <Offer>(e.Item));
// improve this plus get rid of response listener
tableListener.OnOfferIds += (s, e) =>
{
//var request = GetSetSubscriptionStatusRequest(session, e.Item);
//if (request == null)
// throw new Exception("Cannot create request");
//var responseListener = new ResponseListener();
//session.subscribeResponse(responseListener);
//responseListener.SetRequestID(request.RequestID);
//session.sendRequest(request);
//if (!responseListener.WaitEvents())
// throw new Exception("Response waiting timeout expired");
};
tableManager = session.getTableManager();
var managerStatus = tableManager.getStatus();
// max wait
while (managerStatus == O2GTableManagerStatus.TablesLoading)
{
Thread.Sleep(50);
managerStatus = tableManager.getStatus();
}
if (managerStatus == O2GTableManagerStatus.TablesLoadFailed)
{
throw new Exception("TableManager refresh failed!");
}
tableListener.SetSymbols(
Enum.GetValues(typeof(Symbol)).Cast <Symbol>().ToList());
tableListener.SubscribeEvents(tableManager);
O2GOffersTable offers = null;
offers = (O2GOffersTable)tableManager.getTable(O2GTableType.Offers);
tableListener.HandleOffers(offers);
cancelEvent.WaitOne();
OnCancelled?.Invoke(this, EventArgs.Empty);
}
}
catch (Exception error)
{
OnError?.Invoke(this, new GenericArgs <Exception>(error));
}
finally
{
Shutdown(session, statusListener, tableListener, tableManager);
if (canUnsubscribeSessionStatus)
{
session.unsubscribeSessionStatus(statusListener);
}
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
try
{
Console.WriteLine("CalculateTradingCommissions sample\n");
ArgumentParser argParser = new ArgumentParser(args, "CalculateTradingCommissions");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Pin,
ParserArgument.BuySell,
ParserArgument.AccountID);
argParser.ParseArguments();
if (!argParser.AreArgumentsValid)
{
argParser.PrintUsage();
return;
}
argParser.PrintArguments();
LoginParams loginParams = argParser.LoginParams;
SampleParams sampleParams = argParser.SampleParams;
session = O2GTransport.createSession();
session.useTableManager(O2GTableManagerMode.Yes, null);
statusListener = new SessionStatusListener(session, loginParams);
session.subscribeSessionStatus(statusListener);
statusListener.Reset();
session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection);
if (statusListener.WaitEvents() && statusListener.Connected)
{
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)
{
throw new Exception(string.IsNullOrEmpty(sampleParams.AccountID) ? "No valid accounts" : string.Format("The account '{0}' is not valid", sampleParams.AccountID));
}
O2GOfferRow offer = GetOffer(tableManager, 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;
printEstimatedTradingCommissions(session, offer, account, iAmount, sampleParams.BuySell);
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();
session.unsubscribeSessionStatus(statusListener);
}
session.Dispose();
}
}
}
public void SetProxy(SetProxyRequest request)
{
this.Validator.Validate(request);
O2GTransport.setProxy(request.Host, request.Port, request.User, request.Password);
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("SearchInTable", loginParams, 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;
FindOrder(session, sampleParams.AccountID, sampleParams.OrderID, responseListener);
Console.WriteLine("Done!");
}
}
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("GetOffers", 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.WaitEvents() && statusListener.Connected)
{
ResponseListener responseListener = new ResponseListener(session);
responseListener.SetInstrument(sampleParams.Instrument);
session.subscribeResponse(responseListener);
O2GLoginRules loginRules = session.getLoginRules();
if (loginRules == null)
{
throw new Exception("Cannot get login rules");
}
O2GResponse response;
if (loginRules.isTableLoadedByDefault(O2GTableType.Offers))
{
response = loginRules.getTableRefreshResponse(O2GTableType.Offers);
if (response != null)
{
responseListener.PrintOffers(session, response, null);
}
}
else
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory != null)
{
O2GRequest offersRequest = requestFactory.createRefreshTableRequest(O2GTableType.Offers);
responseListener.SetRequestID(offersRequest.RequestID);
session.sendRequest(offersRequest);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
response = responseListener.GetResponse();
if (response != null)
{
responseListener.PrintOffers(session, response, null);
}
}
}
// Do nothing 10 seconds, let offers print
Thread.Sleep(100000);
Console.WriteLine("Done!");
session.unsubscribeResponse(responseListener);
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
string sOrderType = Constants.Orders.LimitEntry;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("FindRowByColumnValue", loginParams, sampleParams);
session = O2GTransport.createSession();
session.useTableManager(O2GTableManagerMode.Yes, null);
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.WaitEvents() && statusListener.Connected)
{
ResponseListener 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));
}
}
else
{
if (!sampleParams.AccountID.Equals(account.AccountID))
{
sampleParams.AccountID = account.AccountID;
Console.WriteLine("AccountID='{0}'",
sampleParams.AccountID);
}
}
O2GOfferRow offer = GetOffer(tableManager, 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 (sOrderType.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;
}
}
tableListener.SubscribeEvents(tableManager);
O2GRequest request = CreateELSRequest(session, offer.OfferID, sampleParams.AccountID, iAmount, dRate, dRateLimit, dRateStop, sampleParams.BuySell, sOrderType);
if (request == null)
{
throw new Exception("Cannot create request");
}
string sRequestID = request.RequestID;
responseListener.SetRequestID(sRequestID);
tableListener.SetRequestID(sRequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
Console.WriteLine("Search by RequestID:{0}", sRequestID);
FindOrders(tableManager, sRequestID);
Console.WriteLine("Search by Type:{0} and BuySell:{1}", sOrderType, sampleParams.BuySell);
FindOrdersByTypeAndDirection(tableManager, sOrderType, sampleParams.BuySell);
Console.WriteLine("Search conditional orders");
FindConditionalOrders(tableManager);
Console.WriteLine("Done!");
tableListener.UnsubscribeEvents(tableManager);
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("If-Then", loginParams, sampleParams);
session = O2GTransport.createSession();
statusListener = new SessionStatusListener(session, loginParams.SessionID, loginParams.Pin);
session.subscribeSessionStatus(statusListener);
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));
}
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;
// For the purpose of this example we will place IF-THEN order 30 pips below the current market price
// and our stop entry order 15 pips below the current market price
double dRateIf = offer.Ask - 30.0 * offer.PointSize;
double dRateStop = offer.Ask - 15.0 * offer.PointSize;
O2GRequest request = CreateIfThenRequest(session, offer.OfferID, account.AccountID, iAmount, dRateIf, dRateStop);
if (request == null)
{
throw new Exception("Cannot create request");
}
List <string> requestIDList = new List <string>();
for (int i = 0; i < request.ChildrenCount; i++)
{
requestIDList.Add(request.getChildRequest(i).RequestID);
}
responseListener.SetRequestIDs(requestIDList);
session.sendRequest(request);
if (responseListener.WaitEvents())
{
Console.WriteLine("Done!");
}
else
{
throw new Exception("Response waiting timeout expired");
}
}
}
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("GetLastOrderUpdate", 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;
O2GRequest request;
request = CreateTrueMarketOrderRequest(session, offer.OfferID, account.AccountID, iAmount, sampleParams.BuySell);
if (request == null)
{
throw new Exception("Cannot create request; probably some arguments are missing or incorrect");
}
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
string sOrderID = responseListener.GetOrderID();
if (!string.IsNullOrEmpty(sOrderID))
{
Console.WriteLine("You have successfully created a true market order.");
Console.WriteLine("Your order ID is {0}", sOrderID);
request = GetLastOrderUpdateRequest(session, sOrderID, account.AccountName);
if (request == null)
{
throw new Exception("Cannot create request; probably some arguments are missing or incorrect");
}
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null && response.Type == O2GResponseType.GetLastOrderUpdate)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GLastOrderUpdateResponseReader reader = readerFactory.createLastOrderUpdateResponseReader(response);
Console.WriteLine("Last order update: UpdateType={0}, OrderID={1}, Status={2}, StatusTime={3}",
reader.UpdateType.ToString(), reader.Order.OrderID, reader.Order.Status.ToString(),
reader.Order.StatusTime.ToString("yyyy-MM-dd HH:mm:ss"));
}
}
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();
}
}
}
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();
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 = CreateCloseMarketOrderRequest(session, sampleParams.Instrument, trade);
if (request == null)
{
throw new Exception("Cannot create request");
}
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (responseListener.WaitEvents())
{
Thread.Sleep(1000); // Wait for the balance update
Console.WriteLine("Done!");
}
else
{
throw new Exception("Response waiting timeout expired");
}
}
}
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("CloseAllPositionsByInstrument", loginParams, 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));
}
CloseOrdersData closeOrdersData;
if (!GetCloseOrdersData(session, sampleParams.AccountID, offer.OfferID, responseListener, out closeOrdersData))
{
throw new Exception("There are no opened positions");
}
O2GRequest request = CreateCloseMarketNettingOrderRequest(session, closeOrdersData);
if (request == null)
{
throw new Exception("Cannot create request; probably some arguments are missing or incorrect");
}
List <string> requestIDs = new List <string>();
for (int i = 0; i < request.ChildrenCount; i++)
{
requestIDs.Add(request.getChildRequest(i).RequestID);
}
responseListener.SetRequestIDs(requestIDs);
session.sendRequest(request);
if (responseListener.WaitEvents())
{
Thread.Sleep(1000); // Wait for the balance update
Console.WriteLine("Done!");
}
else
{
throw new Exception("Response waiting timeout expired");
}
}
}
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();
}
}
}
public void login()
{
// Strings for session variables
sessionTextBox.Text = "Connecting...";
sUserID = userIDbox.Text.ToString();
sPassword = passwordBox.Text.ToString();
sURL = "http://www.fxcorporate.com/Hosts.jsp";
Settings.Default.sUserID = sUserID;
Settings.Default.sPassword = sPassword;
Settings.Default.Save();
//Try to create a session and connect to FXCM servers.
try
{
//Session creation
mSession = O2GTransport.createSession();
//Session Listener
SessionStatusListener statusListener = new SessionStatusListener(mSession);
mSession.subscribeSessionStatus(statusListener);
//Table Listener
TableListener tableListener = new TableListener();
mSession.useTableManager(O2GTableManagerMode.Yes, null);
// Response Listener
ResponseListener responseListener = new ResponseListener(mSession);
mSession.subscribeResponse(responseListener);
// LOG-IN
statusListener.login(sUserID, sPassword, sURL, sConnection);
Thread.Sleep(100);
//Confirm Connected
if (statusListener.Connected)
{
sessionTextBox.BackColor = Color.Green;
actiBox.AppendText("***CONNECTED***" + Environment.NewLine);
sessionTextBox.Text = "CONNECTED";
}
else if (statusListener.Disconnected)
{
for (int i = 0; i < 25; i++)
{
login();
}
}
// Confirm Error, then end login
else if (statusListener.Error)
{
mSession.logout();
while (!statusListener.Disconnected)
{
Thread.Sleep(50);
}
sessionTextBox.BackColor = Color.Red;
sessionTextBox.Text = "DISCONNECTED";
actiBox.AppendText("Login Failed!" + Environment.NewLine);
}
O2GSessionDescriptorCollection descs = mSession.getTradingSessionDescriptors();
foreach (O2GSessionDescriptor desc in descs)
{
mSession.setTradingSession("sessionID", "pin");
}
priceBW.RunWorkerAsync();
}
catch (Exception loginErr)
{
Console.WriteLine("Exception: {0}", loginErr.ToString());
}
}
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();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
try
{
LoginParams loginParams = new LoginParams(ConfigurationManager.AppSettings);
SampleParams sampleParams = new SampleParams(ConfigurationManager.AppSettings);
PrintSampleParams("RemoveFromGroup", loginParams, sampleParams);
session = O2GTransport.createSession();
SessionStatusListener statusListener = new SessionStatusListener(session, loginParams.SessionID, loginParams.Pin);
session.subscribeSessionStatus(statusListener);
session.login(loginParams.Login, loginParams.Password, loginParams.URL, loginParams.Connection);
if (statusListener.WaitEvents() && 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;
O2GRequest request = RemoveOrderFromGroupRequest(session, sampleParams.AccountID, sampleParams.OrderID);
if (request == null)
{
throw new Exception("Cannot create request");
}
List <string> orderIDList = new List <string>();
orderIDList.Add(sampleParams.OrderID);
foreach (string sOrderID in orderIDList)
{
if (!IsOrderExists(session, sampleParams.AccountID, sOrderID, responseListener))
{
throw new Exception(string.Format("Order '{0}' does not exist", sOrderID));
}
}
responseListener.SetOrderIDs(orderIDList);
session.sendRequest(request);
if (responseListener.WaitEvents())
{
Console.WriteLine("Done!");
}
else
{
throw new Exception("Response waiting timeout expired");
}
statusListener.Reset();
session.logout();
statusListener.WaitEvents();
session.unsubscribeResponse(responseListener);
}
session.unsubscribeSessionStatus(statusListener);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
if (session != null)
{
session.Dispose();
}
}
}
static void Main(string[] args)
{
O2GSession session = null;
SessionStatusListener statusListener = null;
ResponseListener responseListener = null;
try
{
Console.WriteLine("PrintTable sample\n");
ArgumentParser argParser = new ArgumentParser(args, "PrintTable");
argParser.AddArguments(ParserArgument.Login,
ParserArgument.Password,
ParserArgument.Url,
ParserArgument.Connection,
ParserArgument.SessionID,
ParserArgument.Pin,
ParserArgument.TableType);
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)
{
O2GResponseType responseType = string.Equals(sampleParams.TableType, SampleParams.OrdersTable) == true ?
O2GResponseType.GetOrders : O2GResponseType.GetTrades;
responseListener = new ResponseListener(responseType);
session.subscribeResponse(responseListener);
O2GAccountRow account = GetAccount(session);
if (account != null)
{
if (responseType == O2GResponseType.GetOrders)
{
PrintOrders(session, account.AccountID, responseListener);
}
else
{
PrintTrades(session, account.AccountID, responseListener);
}
Console.WriteLine("Done!");
}
else
{
throw new Exception("No valid accounts");
}
}
}
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();
}
}
}