public void CreateRangeCloseOrder(string sOfferID, string sAccountID, string sTradeID, int iAmount, double dRateMin, double dRateMax, string sBuySell)
{
O2GRequestFactory factory = m_o2gsession.getRequestFactory();
if (factory == null)
{
return;
}
O2GValueMap valuemap = factory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.MarketCloseRange);
valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID); // The identifier of the instrument the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.TradeID, sTradeID); // The identifier of the trade to be closed.
valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell); // The order direction (Constants.Buy for Buy, Constants.Sell for Sell). Must be opposite to the direction of the trade.
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount); // The quantity of the instrument to be bought or sold. Must be <= size of the position (Lot of the trade). Must be divisible by baseUnitSize.
valuemap.setDouble(O2GRequestParamsEnum.RateMin, dRateMin); // The minimum dRate at which the order can be filled.
valuemap.setDouble(O2GRequestParamsEnum.RateMax, dRateMax); // The maximum dRate at which the order can be filled.
valuemap.setString(O2GRequestParamsEnum.CustomID, "CloseRangeOrder"); // The custom identifier of the order.
O2GRequest request = factory.createOrderRequest(valuemap);
m_o2gsession.sendRequest(request);
SaveOrders(sOfferID, sAccountID, sTradeID, iAmount, sBuySell);
}
/// <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);
}
/***************************************************************************************************************/
/***** TRUE MARKET ORDERS *****/
/***************************************************************************************************************/
/* True Market Order */
public void CreateTrueMarketOrder(string sOfferID, string sAccountID, int iAmount, string sBuySell)
{
try
{
O2GRequestFactory factory = m_o2gsession.getRequestFactory();
if (factory == null)
{
return;
}
O2GValueMap valuemap = factory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketOpen);
valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID); // The identifier of the account the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID); // The identifier of the instrument the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell); // The order direction: Constants.Sell for "Sell", Constants.Buy for "Buy".
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount); // The quantity of the instrument to be bought or sold.
valuemap.setString(O2GRequestParamsEnum.CustomID, "TrueMarketOrder"); // The custom identifier of the order.
if (sBuySell == "Buy")
{
valuemap.setString(O2GRequestParamsEnum.BuySell, Constants.Buy);
}
else
{
valuemap.setString(O2GRequestParamsEnum.BuySell, Constants.Sell);
}
O2GRequest request = factory.createOrderRequest(valuemap);
m_o2gsession.sendRequest(request);
}
catch
{
}
}
// Change subscription status
public void CreateSetSubscriptionStatusRequest(string sOfferID, string sStatus)
{
O2GRequestFactory factory = Session.getRequestFactory();
O2GValueMap valuemap = factory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.SetSubscriptionStatus);
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemap.setString(O2GRequestParamsEnum.SubscriptionStatus, sStatus);
O2GRequest request = factory.createOrderRequest(valuemap);
if (request != null)
{
try
{
mRequestID = request.RequestID;
Session.sendRequest(request);
}
catch (Exception subErr)
{
Console.WriteLine(subErr);
}
}
else
{
Console.WriteLine("Cannot create request; probably some arguments are missing or incorrect");
}
}
/// <summary>
/// Create true market order request
/// </summary>
private static O2GRequest CreateTrueMarketOrderRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, string sBuySell)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemap = requestFactory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketOpen);
valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
valuemap.setString(O2GRequestParamsEnum.CustomID, "TrueMarketOrder");
request = requestFactory.createOrderRequest(valuemap);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
/// <summary>
/// Create request for join two existing entry orders into a new contingency group
/// </summary>
private static O2GRequest JoinToNewGroupRequest(O2GSession session, string sAccountID, string sPrimaryID, string sSecondaryID, int iContingencyType)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemapMain = requestFactory.createValueMap();
valuemapMain.setString(O2GRequestParamsEnum.Command, Constants.Commands.JoinToNewContingencyGroup);
valuemapMain.setInt(O2GRequestParamsEnum.ContingencyGroupType, iContingencyType);
O2GValueMap valuemapChild;
valuemapChild = requestFactory.createValueMap();
valuemapChild.setString(O2GRequestParamsEnum.OrderID, sPrimaryID);
valuemapChild.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapMain.appendChild(valuemapChild);
valuemapChild = requestFactory.createValueMap();
valuemapChild.setString(O2GRequestParamsEnum.OrderID, sSecondaryID);
valuemapChild.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapMain.appendChild(valuemapChild);
request = requestFactory.createOrderRequest(valuemapMain);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
/// <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>
/// Create entry order with attached stop and limit orders request
/// </summary>
private static O2GRequest CreateELSRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRate, double dRateLimit, double dRateStop, string sBuySell, string sOrderType)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemap = requestFactory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, sOrderType);
valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
valuemap.setDouble(O2GRequestParamsEnum.Rate, dRate);
valuemap.setDouble(O2GRequestParamsEnum.RateLimit, dRateLimit);
valuemap.setDouble(O2GRequestParamsEnum.RateStop, dRateStop);
valuemap.setString(O2GRequestParamsEnum.CustomID, "EntryOrderWithStopLimit");
request = requestFactory.createOrderRequest(valuemap);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return request;
}
/// <summary>
/// Attach L or S order to existing entry order
/// </summary>
private static O2GRequest AddOrderForEntryRequest(O2GSession session, O2GTradeRow trade, string sOrderType, double dRate)
{
if (!sOrderType.Equals("L") && !sOrderType.Equals("S"))
{
throw new Exception("Incorrect order type");
}
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemap = requestFactory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, sOrderType); // Must be L or S
valuemap.setString(O2GRequestParamsEnum.AccountID, trade.AccountID);
valuemap.setString(O2GRequestParamsEnum.OfferID, trade.OfferID);
valuemap.setString(O2GRequestParamsEnum.TradeID, trade.TradeID); // TradeID from existing Entry order
string sOppositeDirection = trade.BuySell == Constants.Buy ? Constants.Sell : Constants.Buy;
valuemap.setString(O2GRequestParamsEnum.BuySell, sOppositeDirection); // The order direction must be opposite to the direction of the order which was used to create the position
valuemap.setInt(O2GRequestParamsEnum.Amount, trade.Amount);
valuemap.setDouble(O2GRequestParamsEnum.Rate, dRate);
valuemap.setString(O2GRequestParamsEnum.CustomID, "AttachedEntryOrder");
request = requestFactory.createOrderRequest(valuemap);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
// Place live market OPEN order
public void CreateTrueOpenMarketOrder(string sOfferID, string sAccountID, int iAmount, string sBuySell)
{
try
{
O2GRequestFactory factory = Session.getRequestFactory();
O2GValueMap valuemap = factory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.TrueMarketOpen);
// The identifier of the account the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
// The identifier of the instrument the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
// The order direction: Constants.Sell for "Sell", Constants.Buy for "Buy".
valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
// The quantity of the instrument to be bought or sold.
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
// The custom identifier of the order.
valuemap.setString(O2GRequestParamsEnum.CustomID, "TrueMarketOrder");
O2GRequest request = factory.createOrderRequest(valuemap);
if (request != null)
{
mRequestID = request.RequestID;
Session.sendRequest(request);
}
else
{
Console.WriteLine("Cannot create request; probably some arguments are missing or incorrect");
}
}
catch (Exception openErr)
{
Console.WriteLine(openErr);
}
}
/// <summary>
/// Sends a request for the history
/// </summary>
public string RequestHistory(TransportHistoryRequest request)
{
O2GRequestFactory factory = mSession.getRequestFactory();
O2GTimeframeCollection timeframes = factory.Timeframes;
O2GTimeframe timeframe = timeframes[request.Timeframe];
int count = request.Count > 300 ? 300 : request.Count;
O2GRequest rq = factory.createMarketDataSnapshotRequestInstrument(request.Instrument, timeframe, count);
if (request.From != factory.ZERODATE || request.To != factory.ZERODATE)
{
DateTime from, to;
from = request.From;
to = request.To;
/*
* if (request.From != factory.ZERODATE)
* from = mTimeConverter.convert(request.From, O2GTimeConverterTimeZone.EST, O2GTimeConverterTimeZone.UTC);
* else
* from = factory.ZERODATE;
*
* if (request.To != factory.ZERODATE)
* to = mTimeConverter.convert(request.To, O2GTimeConverterTimeZone.EST, O2GTimeConverterTimeZone.UTC);
* else
* to = factory.ZERODATE;
*/
factory.fillMarketDataSnapshotRequestTime(rq, from, to, false);
}
mHistoryRequests[rq.RequestID] = request;
mSession.sendRequest(rq);
return(rq.RequestID);
}
/// <summary>
/// Create entry order request
/// </summary>
private static O2GRequest CreateEntryOrderRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRate, string sBuySell, string sOrderType, string sExpireDate)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemap = requestFactory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, sOrderType);
valuemap.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemap.setString(O2GRequestParamsEnum.BuySell, sBuySell);
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount);
valuemap.setDouble(O2GRequestParamsEnum.Rate, dRate);
valuemap.setString(O2GRequestParamsEnum.CustomID, "EntryOrder");
if (!string.IsNullOrEmpty(sExpireDate))
{
valuemap.setString(O2GRequestParamsEnum.TimeInForce, Constants.TIF.GTD);
valuemap.setString(O2GRequestParamsEnum.ExpireDayTime, sExpireDate); // UTCTimestamp format: "yyyyMMdd-HH:mm:ss.SSS" (milliseconds are optional)
}
request = requestFactory.createOrderRequest(valuemap);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
/// <summary>
/// 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");
}
}
}
private void btnGetHistoricPrices_Click(object sender, EventArgs e)
{
try
{
m_datetimestart = monthCalendarStart.SelectionRange.Start.Date;
m_datetimeend = monthCalendarEnd.SelectionRange.Start.Date;
m_instrument = cbInstrument.SelectedItem.ToString();
m_interval = cbInterval.SelectedItem.ToString();
ResponseListener responseListener = new ResponseListener(m_session);
m_session.subscribeResponse(responseListener);
O2GRequestFactory factory = m_session.getRequestFactory();
O2GTimeframeCollection timeframecollection = factory.Timeframes;
O2GTimeframe stimeframe = timeframecollection[m_interval];
GetHistoryPrices(m_session, m_instrument, m_interval, m_datetimestart, m_datetimeend, responseListener);
MessageBox.Show("Historic Data Received", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
LogDirector.DoAction(2, ex);
MessageBox.Show("Unable to connect to server", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Create request for removing order from existing contingency group
/// </summary>
private static O2GRequest RemoveOrderFromGroupRequest(O2GSession session, string sAccountID, string sOrderID)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemapMain = requestFactory.createValueMap();
valuemapMain.setString(O2GRequestParamsEnum.Command, Constants.Commands.RemoveFromContingencyGroup);
O2GValueMap valuemapChild = requestFactory.createValueMap();
valuemapChild.setString(O2GRequestParamsEnum.Command, Constants.Commands.RemoveFromContingencyGroup);
valuemapChild.setString(O2GRequestParamsEnum.OrderID, sOrderID);
valuemapChild.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapMain.appendChild(valuemapChild);
request = requestFactory.createOrderRequest(valuemapMain);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
/// <summary>
/// Get orders data for closing all positions
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="sOfferID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static bool GetCloseOrdersData(O2GSession session, string sAccountID, string sOfferID, ResponseListener responseListener, out CloseOrdersData closeOrdersData)
{
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GRequest request = requestFactory.createRefreshTableRequestByAccount(O2GTableType.Trades, sAccountID);
responseListener.SetRequestID(request.RequestID);
session.sendRequest(request);
if (!responseListener.WaitEvents())
{
throw new Exception("Response waiting timeout expired");
}
O2GResponse response = responseListener.GetResponse();
bool bIsTradesFound = false;
closeOrdersData = new CloseOrdersData();
if (response != null)
{
O2GResponseReaderFactory readerFactory = session.getResponseReaderFactory();
if (readerFactory != null)
{
O2GTradesTableResponseReader tradesResponseReader = readerFactory.createTradesTableReader(response);
for (int i = 0; i < tradesResponseReader.Count; i++)
{
O2GTradeRow trade = tradesResponseReader.getRow(i);
if (!trade.OfferID.Equals(sOfferID))
{
continue;
}
bIsTradesFound = true;
string sBuySell = trade.BuySell;
// Set opposite side
OrderSide side = (sBuySell.Equals(Constants.Buy) ? OrderSide.Sell : OrderSide.Buy);
if (closeOrdersData.OfferID.Equals(sOfferID))
{
OrderSide currentSide = closeOrdersData.Side;
if (currentSide != OrderSide.Both && currentSide != side)
{
closeOrdersData.Side = OrderSide.Both;
}
}
else
{
closeOrdersData.OfferID = sOfferID;
closeOrdersData.AccountID = sAccountID;
closeOrdersData.Side = side;
}
}
}
}
return(bIsTradesFound);
}
/// <summary>
/// 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>
/// Create OTO request
/// </summary>
private static O2GRequest CreateOTO_ELSRequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRateOTO, double dRateELS, double dRateELS_stop, double dRateELS_limit)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
// Create OTO command
O2GValueMap valuemapMain = requestFactory.createValueMap();
valuemapMain.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOTO);
// ValueMap for if-then
O2GValueMap valuemapIf = requestFactory.createValueMap();
valuemapIf.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemapIf.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.LimitEntry);
valuemapIf.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapIf.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemapIf.setString(O2GRequestParamsEnum.BuySell, Constants.Sell);
valuemapIf.setInt(O2GRequestParamsEnum.Amount, 0);
valuemapIf.setDouble(O2GRequestParamsEnum.Rate, dRateOTO);
valuemapIf.setString(O2GRequestParamsEnum.CustomID, "if-then-order");
valuemapMain.appendChild(valuemapIf);
//valuemapELS for ELS order
O2GValueMap valuemapELS = requestFactory.createValueMap();
valuemapELS.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemapELS.setString(O2GRequestParamsEnum.OrderType, "LE");
valuemapELS.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapELS.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemapELS.setString(O2GRequestParamsEnum.BuySell, "B");
valuemapELS.setInt(O2GRequestParamsEnum.Amount, iAmount);
valuemapELS.setDouble(O2GRequestParamsEnum.Rate, dRateELS);
valuemapELS.setDouble(O2GRequestParamsEnum.RateLimit, dRateELS_limit);
valuemapELS.setDouble(O2GRequestParamsEnum.RateStop, dRateELS_stop);
valuemapELS.setString(O2GRequestParamsEnum.CustomID, "ELS-order");
valuemapMain.appendChild(valuemapELS);
request = requestFactory.createOrderRequest(valuemapMain);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
/// <summary>
/// Get orders data for closing all positions
/// </summary>
/// <param name="session"></param>
/// <param name="sAccountID"></param>
/// <param name="responseListener"></param>
/// <returns></returns>
private static 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 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");
}
}
// Request
public void GetHistoryPrices(DateTime timeFrom, DateTime timeTo)
{
O2GRequestFactory factory = mSession.getRequestFactory();
O2GTimeframeCollection timeframes = factory.Timeframes;
O2GTimeframe tfo = timeframes["D1"];
O2GRequest request = factory.createMarketDataSnapshotRequestInstrument("GBP/NZD", tfo, 7);
timeFrom = today;
timeTo = DateTime.Today;
factory.fillMarketDataSnapshotRequestTime(request, timeFrom, timeTo, false);
mSession.sendRequest(request);
Thread.Sleep(5000);
}
/// <summary>
/// Get list of the supported time frames
/// </summary>
public IEnumerable <string> GetTimeframes()
{
if (!mReady)
{
return(null);
}
O2GRequestFactory factory = mSession.getRequestFactory();
O2GTimeframeCollection timeframes = factory.Timeframes;
List <string> list = new List <string>();
for (int i = 0; i < timeframes.Count; i++)
{
list.Add(timeframes[i].ID);
}
return(list);
}
/// <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);
}
}
public void CreateTrueMarketOrder(string accountID, string sOfferID, int iAmount, string sBuySell)
{
O2GRequestFactory factory = _session.Session.getRequestFactory();
O2GValueMap valuemap = factory.createValueMap();
valuemap.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemap.setString(O2GRequestParamsEnum.OrderType, Constants.Order.TrueMarketOpen);
valuemap.setString(O2GRequestParamsEnum.AccountID, accountID); // The identifier of the account the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.OfferID, sOfferID); // The identifier of the instrument the order should be placed for.
valuemap.setString(O2GRequestParamsEnum.BuySell, (sBuySell.Equals("Buy")?Constants.Buy:Constants.Sell)); // The order direction: Constants.Sell for "Sell", Constants.Buy for "Buy".
valuemap.setInt(O2GRequestParamsEnum.Amount, iAmount); // The quantity of the instrument to be bought or sold.
valuemap.setString(O2GRequestParamsEnum.CustomID, "TrueMarketOrder"); // The custom identifier of the order.
O2GRequest request = factory.createOrderRequest(valuemap);
_session.Session.sendRequest(request);
}
/// <summary>
/// Create GetLastOrderUpdate request
/// </summary>
/// <param name="session"></param>
/// <param name="sOrderID"></param>
/// <param name="sAccountName"></param>
/// <returns></returns>
private static O2GRequest GetLastOrderUpdateRequest(O2GSession session, string sOrderID, string sAccountName)
{
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.GetLastOrderUpdate);
valuemap.setString(O2GRequestParamsEnum.Key, Constants.KeyType.OrderID);
valuemap.setString(O2GRequestParamsEnum.Id, sOrderID); // value of Key
valuemap.setString(O2GRequestParamsEnum.AccountName, sAccountName); // Account name, not Account ID
request = requestFactory.createOrderRequest(valuemap);
return(request);
}
/// <summary>
/// Create OTO request
/// </summary>
private static O2GRequest CreateOTORequest(O2GSession session, string sOfferID, string sAccountID, int iAmount, double dRatePrimary, double dRateSecondary)
{
O2GRequest request = null;
O2GRequestFactory requestFactory = session.getRequestFactory();
if (requestFactory == null)
{
throw new Exception("Cannot create request factory");
}
O2GValueMap valuemapMain = requestFactory.createValueMap();
valuemapMain.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOTO);
// ValueMap for primary order
O2GValueMap valuemapPrimary = requestFactory.createValueMap();
valuemapPrimary.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemapPrimary.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.StopEntry);
valuemapPrimary.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapPrimary.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemapPrimary.setString(O2GRequestParamsEnum.BuySell, Constants.Sell);
valuemapPrimary.setInt(O2GRequestParamsEnum.Amount, iAmount);
valuemapPrimary.setDouble(O2GRequestParamsEnum.Rate, dRatePrimary);
valuemapMain.appendChild(valuemapPrimary);
// ValueMap for secondary order
O2GValueMap valuemapSecondary = requestFactory.createValueMap();
valuemapSecondary.setString(O2GRequestParamsEnum.Command, Constants.Commands.CreateOrder);
valuemapSecondary.setString(O2GRequestParamsEnum.OrderType, Constants.Orders.StopEntry);
valuemapSecondary.setString(O2GRequestParamsEnum.AccountID, sAccountID);
valuemapSecondary.setString(O2GRequestParamsEnum.OfferID, sOfferID);
valuemapSecondary.setString(O2GRequestParamsEnum.BuySell, Constants.Buy);
valuemapSecondary.setInt(O2GRequestParamsEnum.Amount, iAmount);
valuemapSecondary.setDouble(O2GRequestParamsEnum.Rate, dRateSecondary);
valuemapMain.appendChild(valuemapSecondary);
request = requestFactory.createOrderRequest(valuemapMain);
if (request == null)
{
Console.WriteLine(requestFactory.getLastError());
}
return(request);
}
/// <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");
}
}
public void GetLongHistoricPrices(string symbol, string timeframe, int ticks)
{
_mktData = new Quantum();
Symbol = new Symbol(symbol);
session.AttachHandler(mHandler);
DateTime dateNow = DateTime.Now;
TimeSpan time = Timeframe.StringToTimeSpan(timeframe);
DateTime startDate = dateNow.AddMinutes(-ticks * Timeframe.TimeframeToMinutes(timeframe));
O2GRequestFactory factory = session.Session.getRequestFactory();
O2GTimeframeCollection timeframes = factory.Timeframes;
O2GTimeframe tfo = timeframes[timeframe];
int counter = ticks;
lock (locker)
{
while (counter > 0)
{
_completeCounter++;
int subticks = (counter >= QSConstants.MAX_FXCM_API_TICKS)
? QSConstants.MAX_FXCM_API_TICKS
: counter;
O2GRequest request = factory.createMarketDataSnapshotRequestInstrument(symbol, tfo, subticks);
factory.fillMarketDataSnapshotRequestTime(request, startDate,
startDate.AddMinutes(2 * subticks * Timeframe.TimeframeToMinutes(timeframe)));
session.Session.sendRequest(request);
startDate = startDate.AddMinutes(subticks * Timeframe.TimeframeToMinutes(timeframe));
counter -= (counter >= QSConstants.MAX_FXCM_API_TICKS) ? QSConstants.MAX_FXCM_API_TICKS : counter;
}
}
int timeCounter = 0;
while (!Complete || timeCounter++ < 3000) //max timeout 30 seconds
{
Thread.Sleep(100);
}
}
/// <summary>
/// Get the latest offer to which the user is subscribed
/// </summary>
private void GetLatestOffer()
{
// get the list of the offers to which the user is subscribed
O2GLoginRules loginRules = mSession.getLoginRules();
O2GResponse response = loginRules.getSystemPropertiesResponse();
if (loginRules.isTableLoadedByDefault(O2GTableType.Offers))
{
// if it is already loaded - just handle them
response = loginRules.getTableRefreshResponse(O2GTableType.Offers);
onRequestCompleted(null, response);
}
else
{
// otherwise create the request to get offers from the server
O2GRequestFactory factory = mSession.getRequestFactory();
O2GRequest offerRequest = factory.createRefreshTableRequest(O2GTableType.Offers);
mSession.sendRequest(offerRequest);
}
}
