private void Session_TablesUpdates(object sender, TablesUpdatesEventArgs e)
{
var responseFactory = _session.getResponseReaderFactory();
var responsGTablesUpdatesReader = responseFactory.createTablesUpdatesReader(e.Response);
for (int i = 0; i < responsGTablesUpdatesReader.Count; i++)
{
if (responsGTablesUpdatesReader.getUpdateTable(i) == O2GTableType.Offers)
{
if (responsGTablesUpdatesReader.getUpdateType(i) == O2GTableUpdateType.Update)
{
O2GOfferRow offer = responsGTablesUpdatesReader.getOfferRow(i);
var _offerID = offer.OfferID;
var _currentSymbol = offer.Instrument;
PriceUpdate pu = new PriceUpdate
{
Symbol = offer.Instrument,
TradeDateTime = offer.Time,
Price = (offer.Bid + offer.Ask) / 2,
Volume = offer.Volume,
Bid = offer.Bid,
Ask = offer.Ask
};
priceUpdates.Add(pu);
}
}
}
}
public void storeHistoryPriceToDataTable(O2GSession session, O2GResponse response, string sInstrument)
{
// string ss = string.Format("Request with RequestID={0} is completed:", response.RequestID);
// updateLogDelegate(ss);
DataTable tmpTable = InstrumentDT.Clone();
O2GResponseReaderFactory factory = session.getResponseReaderFactory();
if (factory != null)
{
O2GMarketDataSnapshotResponseReader reader = factory.createMarketDataSnapshotReader(response);
for (int ii = reader.Count - 1; ii >= 0; ii--)
{
if (reader.isBar)
{
InstrumentDT.Rows.Add(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));
tmpTable.Rows.Add(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
{
InstrumentDT.Rows.Add(reader.getDate(ii), reader.getBidClose(ii), reader.getAskClose(ii));
tmpTable.Rows.Add(reader.getDate(ii), reader.getBidClose(ii), reader.getAskClose(ii));
}
}
SaveDataToFile(tmpTable, sInstrument);
}
}
/// <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 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");
updateLogDelegate(string.Format("0 rows received"));
break;
}
}
// PrintPrices(session, response);
storeHistoryPriceToDataTable(session, response, sInstrument);
// DateTime.Subtraction(dtTo, dtFirst)/ Subtraction
long percent = (dtTo.Ticks - dtFirst.Ticks) * 100 / (dtTo.Ticks - dtFrom.Ticks);
updateProcessDelegate((int)percent, this.InstrumentDT.Rows.Count);
}
else
{
break;
}
} while (dtFirst > dtFrom);
}
/// <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);
}
}
}
private List <Tick> ReadTicks(O2GSession session, O2GResponse response, Symbol symbol, int blockId)
{
var ticks = new List <Tick>();
var factory = session.getResponseReaderFactory();
if (factory != null)
{
var reader = factory.createMarketDataSnapshotReader(response);
for (int i = reader.Count - 1; i >= 0; i--)
{
if (reader.isBar)
{
throw new Exception(
"The prices were unexpectedly returned in \"bar\" format!");
}
var tick = new Tick()
{
Symbol = symbol,
TickOn = new DateTime(reader.getDate(i).Ticks,
DateTimeKind.Utc).ToEstFromUtc(),
BidRate = reader.getBid(i).ToRoundedRate(symbol),
AskRate = reader.getAsk(i).ToRoundedRate(symbol)
};
ticks.Add(tick);
}
}
return(ticks);
}
/* Prepare Params for Orders */
public void PrepareParamsFromLoginRules(O2GLoginRules loginRules)
{
O2GResponseReaderFactory factory = m_o2gsession.getResponseReaderFactory();
if (factory == null)
{
return;
}
// Gets first account from login.
O2GResponse accountsResponse = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
O2GAccountsTableResponseReader accountsReader = factory.createAccountsTableReader(accountsResponse);
O2GAccountRow account = accountsReader.getRow(0);
// Store account id
m_accountid = account.AccountID;
// Store base iAmount
m_baseamount = account.BaseUnitSize;
// Get offers for eur/usd
O2GResponse offerResponse = loginRules.getTableRefreshResponse(O2GTableType.Offers);
O2GOffersTableResponseReader offersReader = factory.createOffersTableReader(offerResponse);
for (int i = 0; i < offersReader.Count; i++)
{
O2GOfferRow offer = offersReader.getRow(i);
if (string.Compare(offer.Instrument, m_instrument /*"EUR/USD"*/, true) == 0)
{
m_offerid = offer.OfferID;
m_ask = offer.Ask;
m_bid = offer.Bid;
m_pointsize = offer.PointSize;
break;
}
}
}
/// <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 (string.IsNullOrEmpty(sAccountID) || sAccountID.Equals(account.AccountID))
{
bHasAccount = true;
break;
}
}
if (!bHasAccount)
{
return(null);
}
else
{
return(account);
}
}
/// <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);
Uri url = new Uri(session.getReportURL(account.AccountID, DateTime.Now.AddMonths(-1), DateTime.Now, "html", null));
Console.WriteLine("AccountID={0}; Balance={1}; Report URL={2}",
account.AccountID, account.Balance, url);
string content = webClient.DownloadString(url);
string prefix = url.Scheme + Uri.SchemeDelimiter + url.Host;
string report = O2GHtmlContentUtils.ReplaceRelativePathWithAbsolute(content, prefix);
string filename = account.AccountID + ".html";
System.IO.File.WriteAllText(filename, report);
Console.WriteLine("Report is saved to {0}", filename);
}
}
public static O2GAccountRow GetAccount(this O2GSession session)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory == null)
{
throw new Exception("Cannot create response reader factory");
}
var loginRules = session.getLoginRules();
var response = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
var accountsResponseReader = readerFactory.createAccountsTableReader(response);
for (int i = 0; i < accountsResponseReader.Count; i++)
{
var account = accountsResponseReader.getRow(i);
string sAccountKind = account.AccountKind;
if (sAccountKind.Equals("32") || sAccountKind.Equals("36"))
{
if (account.MarginCallFlag.Equals("N"))
{
return(account);
}
}
}
return(null);
}
public async Task <bool> ConnectToDataFeedAsync(string username, string password, Connection connection)
{
return(await Task.Run(() =>
{
IsConnceted = false;
try
{
_session = O2GTransport.createSession();
_session.LoginFailed += Session_LoginFailed;
_session.SessionStatusChanged += Session_SessionStatusChanged;
IsConnceted = Login(username, password, connection.ToString());
_session.RequestCompleted += Session_RequestCompleted;
_session.RequestFailed += Session_RequestFailed;
_session.TablesUpdates += Session_TablesUpdates;
_factory = _session.getResponseReaderFactory();
}
catch (Exception ex)
{
Stop();
MessageBox.Show(ex.Message);
IsConnceted = false;
}
return IsConnceted;
}));
}
/// <summary>
/// Print history data from response
/// </summary>
/// <param name="session"></param>
/// <param name="response"></param>
/// <param name="request"></param>
private void ExtractPrices(O2GSession session, O2GResponse response, HistoricDataRequest request)
{
O2GResponseReaderFactory factory = session.getResponseReaderFactory();
if (factory != null)
{
O2GMarketDataSnapshotResponseReader reader = factory.createMarketDataSnapshotReader(response);
for (int decrement = reader.Count - 1; decrement >= 0; decrement--)
{
if (reader.isBar)
{
// Extract Time
var dateTime = reader.getDate(decrement);
// Create new Bar object
Bar bar = new Bar(request.Security, request.MarketDataProvider, request.Id, dateTime);
// Set bar fields
bar.High = Convert.ToDecimal(reader.getBidHigh(decrement));
bar.Low = Convert.ToDecimal(reader.getBidLow(decrement));
bar.Open = Convert.ToDecimal(reader.getBidOpen(decrement));
bar.Close = Convert.ToDecimal(reader.getBidClose(decrement));
bar.Volume = reader.getVolume(decrement);
// Add to local collection
_barCollection.Add(bar);
}
}
}
}
public void onTablesUpdates(O2GResponse data)
{
O2GResponseReaderFactory factory = mSession.getResponseReaderFactory();
if (factory != null)
{
O2GTablesUpdatesReader reader = factory.createTablesUpdatesReader(data);
for (int ii = 0; ii < reader.Count; ii++)
{
if (reader.getUpdateTable(ii) == O2GTableType.Orders)
{
O2GOrderRow orderRow = reader.getOrderRow(ii);
if (reader.getUpdateType(ii) == O2GTableUpdateType.Insert)
{
if (mRequestID.Equals(orderRow.RequestID))
{
Console.WriteLine("The order has been added. OrderID={0}, Type={1}, BuySell={2}, Rate={3}, TimeInForce={4}",
orderRow.OrderID, orderRow.Type, orderRow.BuySell, orderRow.Rate, orderRow.TimeInForce);
mSyncResponseEvent.Set();
break;
}
}
}
}
}
}
/// <summary>
/// Update margin requirements
/// </summary>
/// <param name="session"></param>
/// <param name="responseListener"></param>
private static void UpdateMargins(O2GSession session, ResponseListener responseListener)
{
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.UpdateMarginRequirements);
request = requestFactory.createOrderRequest(valueMap);
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.MarginRequirementsResponse)
{
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
if (responseFactory != null)
{
responseFactory.processMarginRequirementsResponse(response);
Console.WriteLine("Margin requirements have been updated");
}
}
}
/// <summary>
/// Find valid offer by instrument name
/// </summary>
/// <param name="session"></param>
/// <param name="sInstrument"></param>
/// <returns>offer</returns>
private static O2GOfferRow GetOffer(O2GSession session, string sInstrument)
{
O2GOfferRow offer = null;
bool bHasOffer = 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.Offers);
O2GOffersTableResponseReader offersResponseReader = readerFactory.createOffersTableReader(response);
for (int i = 0; i < offersResponseReader.Count; i++)
{
offer = offersResponseReader.getRow(i);
if (offer.Instrument.Equals(sInstrument))
{
if (offer.SubscriptionStatus.Equals("T"))
{
bHasOffer = true;
break;
}
}
}
if (!bHasOffer)
{
return(null);
}
else
{
return(offer);
}
}
/// <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>
/// 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;
}
public void onTablesUpdates(O2GResponse data)
{
O2GResponseReaderFactory factory = mSession.getResponseReaderFactory();
if (factory != null)
{
O2GTablesUpdatesReader reader = factory.createTablesUpdatesReader(data);
for (int ii = 0; ii < reader.Count; ii++)
{
if (reader.getUpdateTable(ii) == O2GTableType.Orders)
{
O2GOrderRow orderRow = reader.getOrderRow(ii);
if (reader.getUpdateType(ii) == O2GTableUpdateType.Update)
{
if (mOrderIDs.Contains(orderRow.OrderID))
{
Console.WriteLine("The order has been updated. OrderID={0}, ContingentOrderID={1}, ContingencyType={2}", orderRow.OrderID, orderRow.ContingentOrderID, orderRow.ContingencyType);
mOrderIDs.Remove(orderRow.OrderID);
}
if (mOrderIDs.Count == 0)
{
mSyncResponseEvent.Set();
}
}
}
}
}
}
/// <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>
/// Get initial Trades state
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
/// <returns>TradesTable</returns>
private static O2GTradesTableResponseReader GetTradesTable(O2GSession session, string sAccountID, ResponseListener responseListener)
{
O2GTradesTableResponseReader tradesTable = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest refreshTrades = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(refreshTrades.RequestID);
session.sendRequest(refreshTrades);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse tradeResponse = responseListener.GetResponse();
if (tradeResponse != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
tradesTable = readerFactory.createTradesTableReader(tradeResponse);
}
}
return(tradesTable);
}
/// <summary>
/// Get orders data for closing all positions
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOfferID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static bool GetCloseOrdersData(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener, out CloseOrdersData closeOrdersData)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
bool bIsTradesFound = false;
closeOrdersData = new CloseOrdersData();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
O2GTradeRow trade = tradesResponseReader.getRow(i);
if (!trade.OfferID.Equals(sOfferID))
{
continue;
}
bIsTradesFound = true;
string sBuySell = trade.BuySell;
// Set opposite side
OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy);
if (closeOrdersData.OfferID.Equals(sOfferID))
{
OrderSide currentSide = closeOrdersData.Side;
if (currentSide != OrderSide.Both && currentSide != side)
{
closeOrdersData.Side = OrderSide.Both;
}
}
else
{
closeOrdersData.OfferID = sOfferID;
closeOrdersData.AccountID = sAccountID;
closeOrdersData.Side = side;
}
}
}
}
return(bIsTradesFound);
}
private void Session_RequestCompleted(object sender, RequestCompletedEventArgs e)
{
switch (e.Response.Type)
{
case O2GResponseType.GetLastOrderUpdate:
break;
case O2GResponseType.MarginRequirementsResponse:
break;
case O2GResponseType.CommandResponse:
break;
case O2GResponseType.GetSystemProperties:
break;
case O2GResponseType.CreateOrderResponse:
break;
case O2GResponseType.GetMessages:
break;
case O2GResponseType.GetClosedTrades:
break;
case O2GResponseType.GetTrades:
break;
case O2GResponseType.GetOrders:
break;
case O2GResponseType.GetOffers:
break;
case O2GResponseType.GetAccounts:
var accountsReader = _factory.createAccountsTableReader(e.Response);
//_accountRow = GetAccountRow(accountsReader);
_syncResponseEvent.Set();
break;
case O2GResponseType.MarketDataSnapshot:
var readerFactory = _session.getResponseReaderFactory();
_marketDataSnapshotResponse = _factory.createMarketDataSnapshotReader(e.Response);
_syncHistoryEvent.Set();
break;
case O2GResponseType.TablesUpdates:
_session.TablesUpdates += Session_TablesUpdates;
break;
case O2GResponseType.ResponseUnknown:
Stop();
break;
}
}
/// <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, O2GCandleOpenPriceMode.PreviousClose);
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);
}
private List <FxBar> getHistoryPrices(O2GSession session, string instrument, Resolution resolution, DateTime startDateTime, DateTime endDateTime, int maxBars, GetHistoricalDataResponseListener responseListener)
{
O2GRequestFactory factory = session.getRequestFactory();
var tf = convert_Resolution_To_string(resolution);
O2GTimeframe timeframe = factory.Timeframes[tf];
if (timeframe == null)
{
throw new TimeframeNotFoundException($"Timeframe '{resolution.TimeFrame}:{resolution.Size}' is incorrect!");
}
O2GRequest request = factory.createMarketDataSnapshotRequestInstrument(instrument, timeframe, maxBars);
factory.fillMarketDataSnapshotRequestTime(request, startDateTime, endDateTime, false);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception($"{responseListener.Error}");
}
O2GResponse response = responseListener.GetResponse();
List <FxBar> barList = new List <FxBar>();
if (response != null && response.Type == O2GResponseType.MarketDataSnapshot)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GMarketDataSnapshotResponseReader reader = readerFactory.createMarketDataSnapshotReader(response);
if (reader.Count > 0)
{
for (int i = 0; i < reader.Count; i++)
{
barList.Add(new FxBar
{
Open = reader.getBidOpen(i),
High = reader.getBidHigh(i),
Low = reader.getBidLow(i),
Close = reader.getBidClose(i),
Volume = reader.getVolume(i),
DateTime = reader.getDate(i)
});
}
}
}
}
return(barList);
}
/// <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>
/// Get orders data for closing all positions
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static Dictionary <string, CloseOrdersData> GetCloseOrdersData(O2GSession session, string sAccountID, ResponseListener responseListener)
{
Dictionary <string, CloseOrdersData> closeOrdersData = new Dictionary <string, CloseOrdersData>();
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
O2GTradeRow trade = tradesResponseReader.getRow(i);
string sOfferID = trade.OfferID;
string sBuySell = trade.BuySell;
// Set opposite side
OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy);
if (closeOrdersData.ContainsKey(sOfferID))
{
OrderSide currentSide = closeOrdersData[sOfferID].Side;
if (currentSide != OrderSide.Both && currentSide != side)
{
closeOrdersData[sOfferID].Side = OrderSide.Both;
}
}
else
{
CloseOrdersData data = new CloseOrdersData(sAccountID, side);
closeOrdersData.Add(sOfferID, data);
}
}
}
}
return(closeOrdersData);
}
public string PrintPrices(O2GSession session, O2GResponse response, string newPast)
{
Console.WriteLine();
O2GResponseReaderFactory factory = session.getResponseReaderFactory();
if (factory != null)
{
O2GMarketDataSnapshotResponseReader reader = factory.createMarketDataSnapshotReader(response);
for (int ii = 0; ii < reader.Count; ii++)
{
}
}
return(newPast);
}
/// <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>
/// 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");
}
}
public void onRequestCompleted(String requestID, O2GResponse response)
{
O2GResponseReaderFactory responseFactory = mSession.getResponseReaderFactory();
if (responseFactory != null)
{
O2GMarketDataSnapshotResponseReader reader = responseFactory.createMarketDataSnapshotReader(response);
for (int i = 0; i < reader.Count; i++)
{
System.Console.WriteLine("\n\tAskOpen =" + reader.getAskOpen(i) +
"\n\tAskHigh = " + reader.getAskHigh(i) +
"\n\tAskLow = " + reader.getAskLow(i) +
"\n\tAskClose =" + reader.getAskClose(i));
}
}
}
/// <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>
/// Find the first opened position by AccountID and OfferID
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOfferID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static O2GTradeRow GetTrade(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener)
{
O2GTradeRow trade = null;
bool bHasTrade = false;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
trade = tradesResponseReader.getRow(i);
if (sOfferID.Equals(trade.OfferID))
{
bHasTrade = true;
break;
}
}
}
}
if (!bHasTrade)
{
return(null);
}
else
{
return(trade);
}
}
/// <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}", accountRow.AccountID, accountRow.Balance);
}
}
public string PrintPrices(O2GSession session, O2GResponse response, string newPast)
{
Console.WriteLine();
O2GResponseReaderFactory factory = session.getResponseReaderFactory();
if (factory != null)
{
O2GMarketDataSnapshotResponseReader reader = factory.createMarketDataSnapshotReader(response);
for (int ii = 0; ii < reader.Count; ii++)
{
newPast = Convert.ToString(reader.getAskOpen(ii));
double newDouble = reader.getAskOpen(ii);
gbpnzdPast = newDouble;
gbpnzdPastBox.Text = newPast;
Console.WriteLine(newPast);
}
}
return(newPast);
}
/// <summary>
/// Find order by ID and print information about it
/// </summary>
/// <param name="session"></param>
/// <param name="sOrderID"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
private static void FindOrder(O2GSession session, string sOrderID, string sAccountID, ResponseListener responseListener)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Orders, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GOrdersTableResponseReader ordersReader = responseFactory.createOrdersTableReader(response);
for (int i = 0; i < ordersReader.Count; i++)
{
O2GOrderRow order = ordersReader.getRow(i);
if (sOrderID.Equals(order.OrderID))
{
Console.WriteLine("Information for OrderID = {0}", sOrderID);
Console.WriteLine("Account: {0}", order.AccountID);
Console.WriteLine("Amount: {0}", order.Amount);
Console.WriteLine("Rate: {0}", order.Rate);
Console.WriteLine("Type: {0}", order.Type);
Console.WriteLine("Buy/Sell: {0}", order.BuySell);
Console.WriteLine("Stage: {0}", order.Stage);
Console.WriteLine("Status: {0}", order.Status);
}
}
}
else
{
throw new Exception("Cannot get response");
}
}
/// <summary>
/// Print offers and find offer by instrument name
/// </summary>
/// <param name="session"></param>
/// <param name="sInstrument"></param>
/// <returns>offer</returns>
private static O2GOfferRow GetOffer(O2GSession session, string sInstrument)
{
O2GOfferRow offer = null;
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory == null)
{
throw new Exception("Cannot create response reader factory");
}
O2GLoginRules loginRules = session.getLoginRules();
O2GResponse response = loginRules.getTableRefreshResponse(O2GTableType.Offers);
O2GOffersTableResponseReader offersResponseReader = readerFactory.createOffersTableReader(response);
for (int i = 0; i < offersResponseReader.Count; i++)
{
O2GOfferRow offerRow = offersResponseReader.getRow(i);
if (offerRow.Instrument.Equals(sInstrument))
{
offer = offerRow;
}
switch (offerRow.SubscriptionStatus)
{
case Constants.SubscriptionStatuses.ViewOnly:
Console.WriteLine("{0} : [V]iew only", offerRow.Instrument);
break;
case Constants.SubscriptionStatuses.Disable:
Console.WriteLine("{0} : [D]isabled", offerRow.Instrument);
break;
case Constants.SubscriptionStatuses.Tradable:
Console.WriteLine("{0} : Available for [T]rade", offerRow.Instrument);
break;
default:
Console.WriteLine("{0} : {1}", offerRow.Instrument, offerRow.SubscriptionStatus);
break;
}
}
return(offer);
}
/// <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);
using (System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient())
{
for (int i = 0; i < accountsReader.Count; i++)
{
O2GAccountRow account = accountsReader.getRow(i);
Uri url = new Uri(session.getReportURL(account.AccountID, DateTime.Now.AddMonths(-1), DateTime.Now, "html", null));
Console.WriteLine("AccountID={0}; Balance={1}; BaseUnitSize={2}; Report URL={3}",
account.AccountID, account.Balance, account.BaseUnitSize, url);
var response = httpClient.GetAsync(url).Result;
if (response.IsSuccessStatusCode)
{
var responseContent = response.Content;
// by calling .Result you are synchronously reading the result
string content = responseContent.ReadAsStringAsync().Result;
string filename = account.AccountID + ".html";
string prefix = url.Scheme + "://" + url.Host + "/";
string report = O2GHtmlContentUtils.ReplaceRelativePathWithAbsolute(content, prefix);
System.IO.File.WriteAllText(filename, report);
Console.WriteLine("Report is saved to {0}", filename);
}
else
{
throw new Exception("Report is not received.");
}
}
}
}
/// <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>
/// 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>
/// Get initial Trades state
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
/// <returns>TradesTable</returns>
private static O2GTradesTableResponseReader GetTradesTable(O2GSession session, string sAccountID, ResponseListener responseListener)
{
O2GTradesTableResponseReader tradesTable = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest refreshTrades = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(refreshTrades.RequestID);
session.sendRequest(refreshTrades);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse tradeResponse = responseListener.GetResponse();
if (tradeResponse != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
tradesTable = readerFactory.createTradesTableReader(tradeResponse);
}
}
return tradesTable;
}
// Print trading settings of the first account
private static void PrintTradingSettings(O2GSession session)
{
O2GLoginRules loginRules = session.getLoginRules();
if (loginRules == null)
{
throw new Exception("Cannot get login rules");
}
O2GResponse accountsResponse = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
if (accountsResponse == null)
{
throw new Exception("Cannot get response");
}
O2GResponse offersResponse = loginRules.getTableRefreshResponse(O2GTableType.Offers);
if (offersResponse == null)
{
throw new Exception("Cannot get response");
}
O2GTradingSettingsProvider tradingSettingsProvider = loginRules.getTradingSettingsProvider();
O2GResponseReaderFactory factory = session.getResponseReaderFactory();
if (factory == null)
{
throw new Exception("Cannot create response reader factory");
}
O2GAccountsTableResponseReader accountsReader = factory.createAccountsTableReader(accountsResponse);
O2GOffersTableResponseReader instrumentsReader = factory.createOffersTableReader(offersResponse);
O2GAccountRow account = accountsReader.getRow(0);
for (int i = 0; i < instrumentsReader.Count; i++)
{
O2GOfferRow instrumentRow = instrumentsReader.getRow(i);
string instrument = instrumentRow.Instrument;
int condDistStopForTrade = tradingSettingsProvider.getCondDistStopForTrade(instrument);
int condDistLimitForTrade = tradingSettingsProvider.getCondDistLimitForTrade(instrument);
int condDistEntryStop = tradingSettingsProvider.getCondDistEntryStop(instrument);
int condDistEntryLimit = tradingSettingsProvider.getCondDistEntryLimit(instrument);
int minQuantity = tradingSettingsProvider.getMinQuantity(instrument, account);
int maxQuantity = tradingSettingsProvider.getMaxQuantity(instrument, account);
int baseUnitSize = tradingSettingsProvider.getBaseUnitSize(instrument, account);
O2GMarketStatus marketStatus = tradingSettingsProvider.getMarketStatus(instrument);
int minTrailingStep = tradingSettingsProvider.getMinTrailingStep();
int maxTrailingStep = tradingSettingsProvider.getMaxTrailingStep();
double mmr = tradingSettingsProvider.getMMR(instrument, account);
double mmr2=0, emr=0, lmr=0;
bool threeLevelMargin = tradingSettingsProvider.getMargins(instrument, account, ref mmr2, ref emr, ref lmr);
string sMarketStatus = "unknown";
switch (marketStatus)
{
case O2GMarketStatus.MarketStatusOpen:
sMarketStatus = "Market Open";
break;
case O2GMarketStatus.MarketStatusClosed:
sMarketStatus = "Market Close";
break;
}
Console.WriteLine("Instrument: {0}, Status: {1}", instrument, sMarketStatus);
Console.WriteLine("Cond.Dist: ST={0}; LT={1}", condDistStopForTrade, condDistLimitForTrade);
Console.WriteLine("Cond.Dist entry stop={0}; entry limit={1}", condDistEntryStop,
condDistEntryLimit);
Console.WriteLine("Quantity: Min={0}; Max={1}. Base unit size={2}; MMR={3}", minQuantity,
maxQuantity, baseUnitSize, mmr);
if (threeLevelMargin)
{
Console.WriteLine("Three level margin: MMR={0}; EMR={1}; LMR={2}", mmr2, emr, lmr);
}
else
{
Console.WriteLine("Single level margin: MMR={0}; EMR={1}; LMR={2}", mmr2, emr, lmr);
}
Console.WriteLine("Trailing step: {0}-{1}", minTrailingStep, maxTrailingStep);
}
}
// Get current prices and calculate order price
private void GetOfferRate(O2GSession session, string sInstrument, string mBuySell, string mOrderType,
int stopPips, int limitPips)
{
double dBid = 0.0;
double dAsk = 0.0;
double dPointSize = 0.0;
try
{
O2GLoginRules loginRules = session.getLoginRules();
O2GTradingSettingsProvider tsp = loginRules.getTradingSettingsProvider();
condDistEntryLimit = tsp.getCondDistEntryLimit(sInstrument);
condDistLimitTrade = tsp.getCondDistLimitForTrade(sInstrument);
if (loginRules != null && loginRules.isTableLoadedByDefault(O2GTableType.Offers))
{
O2GResponse offersResponse = loginRules.getTableRefreshResponse(O2GTableType.Offers);
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GOffersTableResponseReader offersReader = responseFactory.createOffersTableReader(offersResponse);
for (int i = 0; i < offersReader.Count; i++)
{
O2GOfferRow offer = offersReader.getRow(i);
if (sInstrument == offer.Instrument)
{
if (offer.InstrumentType != 1)
{ // validity check, TODO-what else?
log.debug("Instrument type = " + offer.InstrumentType + " for " + sInstrument);
//return;
}
// TODO--sometimes pointsize is zero, but since not doing limits, it doesn't matter
// returning at this point is causing other failures!!!
//
if (offer.PointSize == 0.0)
{ // validity check, TODO-what else?
log.debug("PointSize = " + offer.PointSize + " for " + sInstrument);
//return;
}
mOfferID = offer.OfferID;
dBid = offer.Bid;
dAsk = offer.Ask;
dPointSize = offer.PointSize;
mBid = dBid;
mAsk = dAsk;
mPointSize = dPointSize;
// limit -- The offset must be negative for a sell position and positive for a buy position.
if (mBuySell == Constants.Buy)
{
//mRateLimit = dBid + limitPips * dPointSize;
pegStopOffset = -stopPips;
pegLimitOffset = limitPips;
}
else if (mBuySell == Constants.Sell)
{
//mRateLimit = dAsk - limitPips * dPointSize;
pegStopOffset = stopPips;
pegLimitOffset = -limitPips;
}
mHasOffer = true;
break;
}
}
}
if (!mHasOffer)
log.debug("You specified invalid instrument. No action will be taken.");
}
catch (Exception e)
{
log.debug("Exception in GetOfferRate().\n\t " + e.Message);
}
}
/// <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");
}
}
// Get account for trade
public void GetAccount(O2GSession session)
{
try
{
O2GLoginRules loginRules = session.getLoginRules();
if (loginRules != null && loginRules.isTableLoadedByDefault(O2GTableType.Accounts))
{
string sAccountID = string.Empty;
string sAccountKind = string.Empty;
O2GResponse accountsResponse = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GAccountsTableResponseReader accountsReader = responseFactory.createAccountsTableReader(accountsResponse);
for (int i = 0; i < accountsReader.Count; i++)
{
O2GAccountRow account = accountsReader.getRow(i);
sAccountID = account.AccountID;
sAccountKind = account.AccountKind;
if (sAccountKind == "32" || sAccountKind == "36")
{
mAccountID = sAccountID;
mHasAccount = true;
break;
}
}
if (!mHasAccount)
log.debug("You don't have any accounts available for trading. No action will be taken.");
}
}
catch (Exception e)
{
log.debug("Exception in GetAccounts():\n\t " + e.Message);
}
}
// Get current prices and calculate order price
public void GetOfferRate(O2GSession session, string sInstrument, string mBuySell, string mOrderType, int entryPips,int stopPips)
{
double dBid = 0.0;
double dAsk = 0.0;
double dPointSize = 0.0;
try
{
O2GLoginRules loginRules = session.getLoginRules();
if (loginRules != null && loginRules.isTableLoadedByDefault(O2GTableType.Offers))
{
O2GResponse offersResponse = loginRules.getTableRefreshResponse(O2GTableType.Offers);
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GOffersTableResponseReader offersReader = responseFactory.createOffersTableReader(offersResponse);
for (int i = 0; i < offersReader.Count; i++)
{
O2GOfferRow offer = offersReader.getRow(i);
if (sInstrument == offer.Instrument)
{
mOfferID = offer.OfferID;
dBid = offer.Bid;
dAsk = offer.Ask;
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 (mOrderType == Constants.Orders.LimitEntry)
{
if (mBuySell == Constants.Buy)
{
mRate = dAsk - entryPips * dPointSize;
// mRateLimit = mRate + 10 * dPointSize;
mRateStop = mRate - stopPips * dPointSize;
pegStopOffset = stopPips;
}
else
{
mRate = dBid + entryPips * dPointSize;
// mRateLimit = mRate - 10 * dPointSize;
mRateStop = mRate + stopPips * dPointSize;
pegStopOffset = -stopPips;
}
}
else // use StopEntry!
{
if (mBuySell == Constants.Buy)
{
mRate = dAsk + entryPips * dPointSize;
//mRateLimit = mRate + 10 * dPointSize;
mRateStop = mRate - stopPips * dPointSize;
pegStopOffset = -stopPips;
}
else // Sell
{
mRate = dBid - entryPips * dPointSize;
//mRateLimit = mRate - 10 * dPointSize;
mRateStop = mRate + stopPips * dPointSize;
pegStopOffset = stopPips;
}
}
mHasOffer = true;
break;
}
}
if (!mHasOffer)
log.debug("You specified invalid instrument. No action will be taken.");
}
}
catch (Exception e)
{
log.debug("Exception in GetOfferRate().\n\t " + e.Message);
}
}
/// <summary>
/// Find the first opened position by AccountID and OfferID
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOfferID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static O2GTradeRow GetTrade(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener)
{
O2GTradeRow trade = null;
bool bHasTrade = false;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
trade = tradesResponseReader.getRow(i);
if (sOfferID.Equals(trade.OfferID))
{
bHasTrade = true;
break;
}
}
}
}
if(!bHasTrade)
{
return null;
}
else
{
return trade;
}
}
/// <summary>
/// Find order by ID and print information about it
/// </summary>
/// <param name="session"></param>
/// <param name="sOrderID"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
private static void FindOrder(O2GSession session, string sOrderID, string sAccountID, ResponseListener responseListener)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Orders, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GOrdersTableResponseReader ordersReader = responseFactory.createOrdersTableReader(response);
for (int i = 0; i < ordersReader.Count; i++)
{
O2GOrderRow order = ordersReader.getRow(i);
if (sOrderID.Equals(order.OrderID))
{
Console.WriteLine("Information for OrderID = {0}", sOrderID);
Console.WriteLine("Account: {0}", order.AccountID);
Console.WriteLine("Amount: {0}", order.Amount);
Console.WriteLine("Rate: {0}", order.Rate);
Console.WriteLine("Type: {0}", order.Type);
Console.WriteLine("Buy/Sell: {0}", order.BuySell);
Console.WriteLine("Stage: {0}", order.Stage);
Console.WriteLine("Status: {0}", order.Status);
}
}
}
else
{
throw new Exception("Cannot get response");
}
}
/// <summary>
/// Get orders data for closing all positions
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static Dictionary<string, CloseOrdersData> GetCloseOrdersData(O2GSession session, string sAccountID, ResponseListener responseListener)
{
Dictionary<string, CloseOrdersData> closeOrdersData = new Dictionary<string, CloseOrdersData>();
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
O2GTradeRow trade = tradesResponseReader.getRow(i);
string sOfferID = trade.OfferID;
string sBuySell = trade.BuySell;
// Set opposite side
OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy);
if (closeOrdersData.ContainsKey(sOfferID))
{
OrderSide currentSide = closeOrdersData[sOfferID].Side;
if (currentSide != OrderSide.Both && currentSide != side)
{
closeOrdersData[sOfferID].Side = OrderSide.Both;
}
}
else
{
CloseOrdersData data = new CloseOrdersData(sAccountID, side);
closeOrdersData.Add(sOfferID, data);
}
}
}
}
return closeOrdersData;
}
/// <summary>
/// Find valid offer by instrument name
/// </summary>
/// <param name="session"></param>
/// <param name="sInstrument"></param>
/// <returns>offer</returns>
private static O2GOfferRow GetOffer(O2GSession session, string sInstrument)
{
O2GOfferRow offer = null;
bool bHasOffer = 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.Offers);
O2GOffersTableResponseReader offersResponseReader = readerFactory.createOffersTableReader(response);
for (int i = 0; i < offersResponseReader.Count; i++)
{
offer = offersResponseReader.getRow(i);
if (offer.Instrument.Equals(sInstrument))
{
if (offer.SubscriptionStatus.Equals("T"))
{
bHasOffer = true;
break;
}
}
}
if (!bHasOffer)
{
return null;
}
else
{
return offer;
}
}
private void GetAccount(O2GSession session)
{
try
{
O2GLoginRules loginRules = session.getLoginRules();
if (loginRules != null && loginRules.isTableLoadedByDefault(O2GTableType.Accounts))
{
string sAccountID = string.Empty;
string sAccountKind = string.Empty;
O2GResponse accountsResponse = loginRules.getTableRefreshResponse(O2GTableType.Accounts);
O2GResponseReaderFactory responseFactory = session.getResponseReaderFactory();
O2GAccountsTableResponseReader accountsReader = responseFactory.createAccountsTableReader(accountsResponse);
for (int i = 0; i < accountsReader.Count; i++)
{
O2GAccountRow account = accountsReader.getRow(i);
sAccountID = account.AccountID;
sAccountKind = account.AccountKind;
if (sAccountKind == "32" || sAccountKind == "36")
{
accountID = sAccountID;
break;
}
}
}
}
catch (Exception e)
{
log.debug("Exception in GetAccounts():\n\t " + e.Message);
}
}
// Get system properties
private void getSystemProperties(O2GSession session)
{
O2GLoginRules loginRules = session.getLoginRules();
O2GResponse response = loginRules.getSystemPropertiesResponse();
O2GResponseReaderFactory factory = session.getResponseReaderFactory();
if (factory == null)
return;
O2GSystemPropertiesReader systemResponseReader = factory.createSystemPropertiesReader(response);
if (systemResponseReader == null)
return;
SystemProperties = systemResponseReader.Properties;
}
/// <summary>
/// Get orders data for closing all positions
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOfferID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static bool GetCloseOrdersData(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener, out CloseOrdersData closeOrdersData)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
bool bIsTradesFound = false;
closeOrdersData = new CloseOrdersData();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
O2GTradeRow trade = tradesResponseReader.getRow(i);
if (!trade.OfferID.Equals(sOfferID))
{
continue;
}
bIsTradesFound = true;
string sBuySell = trade.BuySell;
// Set opposite side
OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy);
if (closeOrdersData.OfferID.Equals(sOfferID))
{
OrderSide currentSide = closeOrdersData.Side;
if (currentSide != OrderSide.Both && currentSide != side)
{
closeOrdersData.Side = OrderSide.Both;
}
}
else
{
closeOrdersData.OfferID = sOfferID;
closeOrdersData.AccountID = sAccountID;
closeOrdersData.Side = side;
}
}
}
}
return bIsTradesFound;
}
