/** Request update data received data handler. */ void ResponseListener::onTablesUpdates(IO2GResponse *data) { if (data) { O2G2Ptr<IO2GResponseReaderFactory> factory = mSession->getResponseReaderFactory(); if (factory) { O2G2Ptr<IO2GTablesUpdatesReader> reader = factory->createTablesUpdatesReader(data); if (reader) { for (int i = 0; i < reader->size(); ++i) { if (reader->getUpdateTable(i) == Orders) { O2G2Ptr<IO2GOrderRow> order = reader->getOrderRow(i); if (reader->getUpdateType(i) == Insert) { if (mRequestID == order->getRequestID()) { std::cout << "The order has been added. OrderID='" << order->getOrderID() << "', " << "Type='" << order->getType() << "', " << "BuySell='" << order->getBuySell() << "', " << "Rate='" << order->getRate() << "', " << "TimeInForce='" << order->getTimeInForce() << "'" << std::endl; SetEvent(mResponseEvent); } } } } } } } }
void printPrices(IO2GSession *session, IO2GResponse *response) { if (response != 0) { if (response->getType() == MarketDataSnapshot) { std::cout << "Request with RequestID='" << response->getRequestID() << "' is completed:" << std::endl; O2G2Ptr<IO2GResponseReaderFactory> factory = session->getResponseReaderFactory(); if (factory) { O2G2Ptr<IO2GMarketDataSnapshotResponseReader> reader = factory->createMarketDataSnapshotReader(response); if (reader) { char sTime[20]; for (int ii = reader->size() - 1; ii >= 0; ii--) { DATE dt = reader->getDate(ii); formatDate(dt, sTime); if (reader->isBar()) { printf("DateTime=%s, BidOpen=%f, BidHigh=%f, BidLow=%f, BidClose=%f, AskOpen=%f, AskHigh=%f, AskLow=%f, AskClose=%f, Volume=%i\n", sTime, 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 { printf("DateTime=%s, Bid=%f, Ask=%f\n", sTime, reader->getBid(ii), reader->getAsk(ii)); } } } } } } }
std::vector<Prices> ForexConnectClient::getPricesFromResponse(IO2GResponse* response) { std::vector<Prices> prices; if (!response || response->getType() != MarketDataSnapshot) { return prices; } BOOST_LOG_TRIVIAL(debug) << "Request with RequestID='" << response->getRequestID() << "' is completed:"; O2G2Ptr<IO2GMarketDataSnapshotResponseReader> reader = mpResponseReaderFactory->createMarketDataSnapshotReader(response); if (!reader) { return prices; } for (int ii = reader->size() - 1; ii >= 0; ii--) { DATE dt = reader->getDate(ii); if (reader->isBar()) { prices.push_back(Prices(toPtime(dt), reader->getAskOpen(ii), reader->getAskHigh(ii), reader->getAskLow(ii), reader->getAskClose(ii))); } else { prices.push_back(Prices(toPtime(dt), reader->getAsk(ii))); } } return prices; }
bool getHistoryPrices(IO2GSession *session, const char *sInstrument, const char *sTimeframe, DATE dtFrom, DATE dtTo, ResponseListener *responseListener) { O2G2Ptr<IO2GRequestFactory> factory = session->getRequestFactory(); if (!factory) { std::cout << "Cannot create request factory" << std::endl; return false; } //find timeframe by identifier O2G2Ptr<IO2GTimeframeCollection> timeframeCollection = factory->getTimeFrameCollection(); O2G2Ptr<IO2GTimeframe> timeframe = timeframeCollection->get(sTimeframe); if (!timeframe) { std::cout << "Timeframe '" << sTimeframe << "' is incorrect!" << std::endl; return false; } O2G2Ptr<IO2GRequest> request = factory->createMarketDataSnapshotRequestInstrument(sInstrument, timeframe, timeframe->getQueryDepth()); DATE dtFirst = dtTo; // there is limit for returned candles amount do { factory->fillMarketDataSnapshotRequestTime(request, dtFrom, dtFirst, false); responseListener->setRequestID(request->getRequestID()); session->sendRequest(request); if (!responseListener->waitEvents()) { std::cout << "Response waiting timeout expired" << std::endl; return false; } // shift "to" bound to oldest datetime of returned data O2G2Ptr<IO2GResponse> response = responseListener->getResponse(); if (response && response->getType() == MarketDataSnapshot) { O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory(); if (readerFactory) { O2G2Ptr<IO2GMarketDataSnapshotResponseReader> reader = readerFactory->createMarketDataSnapshotReader(response); if (reader->size() > 0) { if (abs(dtFirst - reader->getDate(0)) > 0.0001) dtFirst = reader->getDate(0); // earliest datetime of returned data else break; } else { std::cout << "0 rows received" << std::endl; break; } } printPrices(session, response); } else { break; } } while (dtFirst - dtFrom > 0.0001); return true; }
std::vector<Prices> ForexConnectClient::getHistoricalPrices(const std::string& instrument, const boost::posix_time::ptime& from, const boost::posix_time::ptime& to, const std::string& timeFrame) { std::vector<Prices> prices; O2G2Ptr<IO2GTimeframeCollection> timeframeCollection = mpRequestFactory->getTimeFrameCollection(); O2G2Ptr<IO2GTimeframe> timeframe = timeframeCollection->get(timeFrame.c_str()); if (!timeframe) { BOOST_LOG_TRIVIAL(error) << "Timeframe '" << timeFrame << "' is incorrect!"; return prices; } O2G2Ptr<IO2GRequest> request = mpRequestFactory->createMarketDataSnapshotRequestInstrument(instrument.c_str(), timeframe, timeframe->getQueryDepth()); DATE dtFrom = toOleTime(from); DATE dtTo = toOleTime(to); DATE dtFirst = dtTo; do { mpRequestFactory->fillMarketDataSnapshotRequestTime(request, dtFrom, dtFirst, false); mpResponseListener->setRequestID(request->getRequestID()); mpSession->sendRequest(request); if (!mpResponseListener->waitEvents()) { BOOST_LOG_TRIVIAL(error) << "Response waiting timeout expired"; return prices; } // shift "to" bound to oldest datetime of returned data O2G2Ptr<IO2GResponse> response = mpResponseListener->getResponse(); if (response && response->getType() == MarketDataSnapshot) { O2G2Ptr<IO2GMarketDataSnapshotResponseReader> reader = mpResponseReaderFactory->createMarketDataSnapshotReader(response); if (reader->size() > 0) { if (fabs(dtFirst - reader->getDate(0)) > 0.0001) dtFirst = reader->getDate(0); // earliest datetime of returned data else break; } else { BOOST_LOG_TRIVIAL(warning) << "0 rows received"; break; } std::vector<Prices> prc = getPricesFromResponse(response); prices.insert(prices.end(), prc.begin(), prc.end()); } else { break; } } while (dtFirst - dtFrom > 0.0001); return prices; }
bool getCloseOrdersData(IO2GSession *session, ResponseListener *responseListener, const char *sAccountID, const char *sOfferID, CloseOrderData &closeOrdersData) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return false; } O2G2Ptr<IO2GRequest> request = requestFactory->createRefreshTableRequestByAccount(Trades, sAccountID); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return false; } responseListener->setRequestID(request->getRequestID()); session->sendRequest(request); if (!responseListener->waitEvents()) { std::cout << "Response waiting timeout expired" << std::endl; return false; } O2G2Ptr<IO2GResponse> response = responseListener->getResponse(); bool bIsTradesFound = false; if (response) { O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory(); O2G2Ptr<IO2GTradesTableResponseReader> responseReader = readerFactory->createTradesTableReader(response); for (int i = 0; i < responseReader->size(); ++i) { O2G2Ptr<IO2GTradeRow> trade = responseReader->getRow(i); if (strcmp(sOfferID, trade->getOfferID()) != 0) continue; bIsTradesFound = true; std::string sBuySell = trade->getBuySell(); // Set opposite side OrderSide side = (sBuySell == O2G2::Buy) ? Sell : Buy; if (closeOrdersData.offerID != sOfferID) { closeOrdersData.offerID = sOfferID; closeOrdersData.account = sAccountID; closeOrdersData.side = side; } else { OrderSide currentSide = closeOrdersData.side; if (currentSide != Both && currentSide != side) closeOrdersData.side = Both; } } } return bIsTradesFound; }
// Print orders table using IO2GEachRowListener void printOrders(IO2GTableManager *tableManager, const char *sAccountID) { O2G2Ptr<IO2GOrdersTable> ordersTable = (IO2GOrdersTable *)tableManager->getTable(Orders); if (ordersTable->size() == 0) { std::cout << "Table is empty!" << std::endl; } else { ordersTable->forEachRow(new EachRowListener(sAccountID)); } }
// Find the first opened position by AccountID and OfferID IO2GTradeRow *getTrade(IO2GTableManager *tableManager, const char *sAccountID, const char *sOfferID) { O2G2Ptr<IO2GTradesTable> tradesTable = (IO2GTradesTable *)tableManager->getTable(Trades); for (int i = 0; i < tradesTable->size(); ++i) { O2G2Ptr<IO2GTradeRow> trade = tradesTable->getRow(i); if (strcmp(sAccountID, trade->getAccountID()) == 0 && strcmp(sOfferID, trade->getOfferID()) == 0) return trade.Detach(); } return NULL; }
IO2GOfferRow *getOfferAndPrint(IO2GSession *session, const char *sInstrument) { if (!session || !sInstrument) return NULL; IO2GOfferRow *resultOffer = NULL; O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules(); if (loginRules) { O2G2Ptr<IO2GResponse> response = loginRules->getTableRefreshResponse(Offers); if (response) { O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory(); if (readerFactory) { O2G2Ptr<IO2GOffersTableResponseReader> reader = readerFactory->createOffersTableReader(response); for (int i = 0; i < reader->size(); ++i) { O2G2Ptr<IO2GOfferRow> offer = reader->getRow(i); if (offer) { if (strcmp(offer->getSubscriptionStatus(), O2G2::SubscriptionStatuses::ViewOnly) == 0) printf("%s : [V]iew only\n", offer->getInstrument()); else if (strcmp(offer->getSubscriptionStatus(), O2G2::SubscriptionStatuses::Disable) == 0) printf("%s : [D]isabled\n", offer->getInstrument()); else if (strcmp(offer->getSubscriptionStatus(), O2G2::SubscriptionStatuses::Tradable) == 0) printf("%s : Available for [T]rade\n", offer->getInstrument()); else printf("%s : %s\n", offer->getInstrument(), offer->getSubscriptionStatus()); if (strcmp(offer->getInstrument(), sInstrument) == 0) resultOffer = offer.Detach(); } } } } } return resultOffer; }
bool isOrderExists(IO2GSession *session, const char *sAccountID, const char *sOrderID, ResponseListener *responseListener) { if (!session || !responseListener || !sAccountID) return false; O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return false; } O2G2Ptr<IO2GRequest> request = requestFactory->createRefreshTableRequestByAccount(Orders, sAccountID); responseListener->setRequestID(request->getRequestID()); session->sendRequest(request); if (!responseListener->waitEvents()) { std::cout << "Response waiting timeout expired" << std::endl; return false; } O2G2Ptr<IO2GResponse> response = responseListener->getResponse(); if (response) { O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory(); if (readerFactory) { O2G2Ptr<IO2GOrdersTableResponseReader> ordersResponseReader = readerFactory->createOrdersTableReader(response); for (int i = 0; i < ordersResponseReader->size(); ++i) { O2G2Ptr<IO2GOrderRow> order = ordersResponseReader->getRow(i); if (sOrderID && strcmp(order->getOrderID(), sOrderID) == 0) return true; } } } return false; }
void SessionStatusListener::onSessionStatusChanged(IO2GSessionStatus::O2GSessionStatus status) { BOOST_LOG_TRIVIAL(trace) << __PRETTY_FUNCTION__; switch (status) { case IO2GSessionStatus::Disconnected: BOOST_LOG_TRIVIAL(info) << "status::disconnected"; mConnected = false; mDisconnected = true; SetEvent(mSessionEvent); break; case IO2GSessionStatus::Connecting: BOOST_LOG_TRIVIAL(info) << "status::connecting"; break; case IO2GSessionStatus::TradingSessionRequested: { BOOST_LOG_TRIVIAL(info) << "status::trading session requested"; O2G2Ptr<IO2GSessionDescriptorCollection> descriptors = mSession->getTradingSessionDescriptors(); bool found = false; if (descriptors) { if (mPrintSubsessions) BOOST_LOG_TRIVIAL(info) << "descriptors available:"; for (int i = 0; i < descriptors->size(); ++i) { O2G2Ptr<IO2GSessionDescriptor> descriptor = descriptors->get(i); if (mPrintSubsessions) BOOST_LOG_TRIVIAL(info) << " id:='" << descriptor->getID() << "' name='" << descriptor->getName() << "' description='" << descriptor->getDescription() << "' " << (descriptor->requiresPin() ? "requires pin" : ""); if (mSessionID == descriptor->getID()) { found = true; break; } } } if (!found) { onLoginFailed("The specified sub session identifier is not found"); } else { mSession->setTradingSession(mSessionID.c_str(), mPin.c_str()); } } break; case IO2GSessionStatus::Connected: BOOST_LOG_TRIVIAL(info) << "status::connected"; mConnected = true; mDisconnected = false; SetEvent(mSessionEvent); break; case IO2GSessionStatus::Reconnecting: BOOST_LOG_TRIVIAL(info) << "status::reconnecting"; break; case IO2GSessionStatus::Disconnecting: BOOST_LOG_TRIVIAL(info) << "status::disconnecting"; break; case IO2GSessionStatus::SessionLost: BOOST_LOG_TRIVIAL(info) << "status::session lost"; break; } }
/** Request update data received data handler. */ void ResponseListener::onTablesUpdates(IO2GResponse *data) { if (data) { O2G2Ptr<IO2GResponseReaderFactory> factory = mSession->getResponseReaderFactory(); if (factory) { O2G2Ptr<IO2GTablesUpdatesReader> reader = factory->createTablesUpdatesReader(data); if (reader) { for (int i = 0; i < reader->size(); ++i) { switch (reader->getUpdateTable(i)) { case Orders: { O2G2Ptr<IO2GOrderRow> order = reader->getOrderRow(i); if (mRequestID != order->getRequestID()) break; switch (reader->getUpdateType(i)) { case Insert: if ((isClosingOrder(order) || isOpeningOrder(order)) && mOrderMonitorNetting == NULL) { std::cout << "The order has been added. OrderID='" << order->getOrderID() << "', " << "Rate='" << order->getRate() << "', " << "TimeInForce='" << order->getTimeInForce() << "'" << std::endl; O2G2Ptr<IO2GTradeRow> trade = NULL; std::string sTradeID = std::string(order->getTradeID()); if (mTradesTable) { for (int j = 0; j < mTradesTable->size(); ++j) { if (sTradeID == mTradesTable->getRow(j)->getTradeID()) { trade = mTradesTable->getRow(j); break; } } } if (trade) mOrderMonitorNetting = new OrderMonitorNetting(order, trade->getAmount()); else mOrderMonitorNetting = new OrderMonitorNetting(order, 0); } break; case Delete: if (mOrderMonitorNetting) { std::cout << "The order has been deleted. OrderID='" << order->getOrderID() << "'" << std::endl; mOrderMonitorNetting->onOrderDeleted(order); if (mOrderMonitorNetting->isOrderCompleted()) { printResult(); SetEvent(mResponseEvent); } } break; } } break; case Trades: { O2G2Ptr<IO2GTradeRow> trade = reader->getTradeRow(i); switch (reader->getUpdateType(i)) { case Insert: { if (mOrderMonitorNetting) { mOrderMonitorNetting->onTradeAdded(trade); if (mOrderMonitorNetting->isOrderCompleted()) { printResult(); SetEvent(mResponseEvent); } } } break; case Update: { if (mOrderMonitorNetting) { mOrderMonitorNetting->onTradeUpdated(trade); if (mOrderMonitorNetting->isOrderCompleted()) { printResult(); SetEvent(mResponseEvent); } } } break; } } break; case ClosedTrades: { if (reader->getUpdateType(i) == Insert) { O2G2Ptr<IO2GClosedTradeRow> closedTrade = reader->getClosedTradeRow(i); if (mOrderMonitorNetting) { mOrderMonitorNetting->onClosedTradeAdded(closedTrade); if (mOrderMonitorNetting->isOrderCompleted()) { printResult(); SetEvent(mResponseEvent); } } } } break; case Messages: { if (reader->getUpdateType(i) == Insert) { O2G2Ptr<IO2GMessageRow> message = reader->getMessageRow(i); if (mOrderMonitorNetting) { mOrderMonitorNetting->onMessageAdded(message); if (mOrderMonitorNetting->isOrderCompleted()) { printResult(); SetEvent(mResponseEvent); } } } } break; case Accounts: { if (reader->getUpdateType(i) == Update && reader->getUpdateTable(i) == Accounts) { O2G2Ptr<IO2GAccountRow> account = reader->getAccountRow(i); std::cout << "The balance has been changed. AccountID=" << account->getAccountID() << ", " << "Balance=" << std::fixed << account->getBalance() << std::endl; } } break; } } } } } }
// Print trading settings of the first account bool printTradingSettings(IO2GSession *session) { O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules(); if (!loginRules) { std::cout << "Cannot get login rules" << std::endl; return false; } O2G2Ptr<IO2GResponse> accountsResponse = loginRules->getTableRefreshResponse(Accounts); if (!accountsResponse) { std::cout << "Cannot get response" << std::endl; return false; } O2G2Ptr<IO2GResponse> offersResponse = loginRules->getTableRefreshResponse(Offers); if (!offersResponse) { std::cout << "Cannot get response" << std::endl; return false; } O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider(); O2G2Ptr<IO2GResponseReaderFactory> factory = session->getResponseReaderFactory(); if (!factory) { std::cout << "Cannot create response reader factory" << std::endl; return false; } O2G2Ptr<IO2GAccountsTableResponseReader> accountsReader = factory->createAccountsTableReader(accountsResponse); O2G2Ptr<IO2GOffersTableResponseReader> instrumentsReader = factory->createOffersTableReader(offersResponse); O2G2Ptr<IO2GAccountRow> account = accountsReader->getRow(0); for (int i = 0; i < instrumentsReader->size(); ++i) { O2G2Ptr<IO2GOfferRow> instrumentRow = instrumentsReader->getRow(i); const char *sInstrument = instrumentRow->getInstrument(); int condDistStopForTrade = tradingSettingsProvider->getCondDistStopForTrade(sInstrument); int condDistLimitForTrade = tradingSettingsProvider->getCondDistLimitForTrade(sInstrument); int condDistEntryStop = tradingSettingsProvider->getCondDistEntryStop(sInstrument); int condDistEntryLimit = tradingSettingsProvider->getCondDistEntryLimit(sInstrument); int minQuantity = tradingSettingsProvider->getMinQuantity(sInstrument, account); int maxQuantity = tradingSettingsProvider->getMaxQuantity(sInstrument, account); int baseUnitSize = tradingSettingsProvider->getBaseUnitSize(sInstrument, account); O2GMarketStatus marketStatus = tradingSettingsProvider->getMarketStatus(sInstrument); int minTrailingStep = tradingSettingsProvider->getMinTrailingStep(); int maxTrailingStep = tradingSettingsProvider->getMaxTrailingStep(); double mmr = tradingSettingsProvider->getMMR(sInstrument, account); std::string sMarketStatus = "unknown"; switch (marketStatus) { case MarketStatusOpen: sMarketStatus = "Market Open"; break; case MarketStatusClosed: sMarketStatus = "Market Close"; break; } std::cout << "Instrument: " << sInstrument << ", Status: " << sMarketStatus << std::endl; std::cout << "Cond.Dist: ST=" << condDistStopForTrade << "; LT=" << condDistLimitForTrade << std::endl; std::cout << "Cond.Dist entry stop=" << condDistEntryStop << "; entry limit=" << condDistEntryLimit << std::endl; std::cout << "Quantity: Min=" << minQuantity << "; Max=" << maxQuantity << "; Base unit size=" << baseUnitSize << "; MMR=" << mmr << std::endl; double mmr2=0, emr=0, lmr=0; if (tradingSettingsProvider->getMargins(sInstrument, account, mmr2, emr, lmr)) { std::cout << "Three level margin: MMR=" << mmr2 << "; EMR=" << emr << "; LMR=" << lmr << std::endl; } else { std::cout << "Single level margin: MMR=" << mmr2 << "; EMR=" << emr << "; LMR=" << lmr << std::endl; } std::cout << "Trailing step: " << minTrailingStep << "-" << maxTrailingStep << std::endl; } return true; }
/** Request update data received data handler. */ void ResponseListener::onTablesUpdates(IO2GResponse *data) { if (data) { O2G2Ptr<IO2GResponseReaderFactory> factory = mSession->getResponseReaderFactory(); if (factory) { O2G2Ptr<IO2GTablesUpdatesReader> reader = factory->createTablesUpdatesReader(data); if (reader) { for (int i = 0; i < reader->size(); ++i) { switch (reader->getUpdateTable(i)) { case Orders: { O2G2Ptr<IO2GOrderRow> order = reader->getOrderRow(i); if (reader->getUpdateType(i) == Insert) { if (mBatchOrderMonitor) { std::cout << "The order has been added. OrderID='" << order->getOrderID() << "', " << "Rate='" << order->getRate() << "', " << "TimeInForce='" << order->getTimeInForce() << "'" << std::endl; mBatchOrderMonitor->onOrderAdded(order); } } else if (reader->getUpdateType(i) == Delete) { if (mBatchOrderMonitor) { std::cout << "The order has been deleted. OrderID='" << order->getOrderID() << "'" << std::endl; mBatchOrderMonitor->onOrderDeleted(order); if (mBatchOrderMonitor->isBatchExecuted()) { printResult(); SetEvent(mResponseEvent); } } } } break; case Trades: { if (reader->getUpdateType(i) == Insert) { O2G2Ptr<IO2GTradeRow> trade = reader->getTradeRow(i); if (mBatchOrderMonitor) { mBatchOrderMonitor->onTradeAdded(trade); if (mBatchOrderMonitor->isBatchExecuted()) { printResult(); SetEvent(mResponseEvent); } } } } break; case ClosedTrades: { if (reader->getUpdateType(i) == Insert) { O2G2Ptr<IO2GClosedTradeRow> closedTrade = reader->getClosedTradeRow(i); if (mBatchOrderMonitor) { mBatchOrderMonitor->onClosedTradeAdded(closedTrade); if (mBatchOrderMonitor->isBatchExecuted()) { printResult(); SetEvent(mResponseEvent); } } } } break; case Messages: { if (reader->getUpdateType(i) == Insert) { O2G2Ptr<IO2GMessageRow> message = reader->getMessageRow(i); if (mBatchOrderMonitor) { mBatchOrderMonitor->onMessageAdded(message); if (mBatchOrderMonitor->isBatchExecuted()) { printResult(); SetEvent(mResponseEvent); } } } } break; case Accounts: { if (reader->getUpdateType(i) == Update && reader->getUpdateTable(i) == Accounts) { O2G2Ptr<IO2GAccountRow> account = reader->getAccountRow(i); std::cout << "The balance has been changed. AccountID=" << account->getAccountID() << ", " << "Balance=" << std::fixed << account->getBalance() << std::endl; } } break; } } } } } }