void ResponseListener::printResult() { if (mOrderMonitorNetting) { OrderMonitorNetting::ExecutionResult result = mOrderMonitorNetting->getResult(); std::vector<IO2GTradeRow*> trades; std::vector<IO2GTradeRow*> updatedTrades; std::vector<IO2GClosedTradeRow*> closedTrades; O2G2Ptr<IO2GOrderRow> order = mOrderMonitorNetting->getOrder(); std::string orderID = order->getOrderID(); mOrderMonitorNetting->getTrades(trades); mOrderMonitorNetting->getUpdatedTrades(updatedTrades); mOrderMonitorNetting->getClosedTrades(closedTrades); switch (result) { case OrderMonitorNetting::Canceled: { if (trades.size() > 0) { printTrades(trades, orderID); printUpdatedTrades(updatedTrades, orderID); printClosedTrades(closedTrades, orderID); std::cout << "A part of the order has been canceled. " << "Amount = " << mOrderMonitorNetting->getRejectAmount() << std::endl; } else { std::cout << "The order: OrderID=" << orderID << " has been canceled" << std::endl; std::cout << "The cancel amount = " << mOrderMonitorNetting->getRejectAmount() << std::endl; } } break; case OrderMonitorNetting::FullyRejected: { std::cout << "The order has been rejected. OrderID = " << orderID << std::endl; std::cout << "The rejected amount = " << mOrderMonitorNetting->getRejectAmount() << std::endl;; std::cout << "Rejection cause: " << mOrderMonitorNetting->getRejectMessage() << std::endl; } break; case OrderMonitorNetting::PartialRejected: { printTrades(trades, orderID); printUpdatedTrades(updatedTrades, orderID); printClosedTrades(closedTrades, orderID); std::cout << "A part of the order has been rejected. " << "Amount = " << mOrderMonitorNetting->getRejectAmount() << std::endl; std::cout << "Rejection cause: " << mOrderMonitorNetting->getRejectMessage() << std::endl; } break; case OrderMonitorNetting::Executed: { printTrades(trades, orderID); printUpdatedTrades(updatedTrades, orderID); printClosedTrades(closedTrades, orderID); } break; } } }
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; }
// 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)); } }
void TableListener::printTrades(std::vector<IO2GTradeRow*> &trades, std::string &sOrderID) { if (trades.size() == 0) return; std::cout << "For the order: OrderID=" << sOrderID << " the following positions have been opened: " << std::endl; for (size_t i = 0; i < trades.size(); ++i) { O2G2Ptr<IO2GTradeRow> trade = trades[i]; std::string tradeID = trade->getTradeID(); int amount = trade->getAmount(); double rate = trade->getOpenRate(); std::cout << "Trade ID: " << tradeID << ", " << "Amount: " << amount << ", " << "Rate: " << rate << std::endl; } }
void TableListener::unsubscribeEvents(IO2GTableManager *manager) { O2G2Ptr<IO2GAccountsTable> accountsTable = (IO2GAccountsTable *)manager->getTable(Accounts); O2G2Ptr<IO2GOrdersTable> ordersTable = (IO2GOrdersTable *)manager->getTable(Orders); O2G2Ptr<IO2GTradesTable> tradesTable = (IO2GTradesTable *)manager->getTable(Trades); O2G2Ptr<IO2GMessagesTable> messagesTable = (IO2GMessagesTable *)manager->getTable(Messages); O2G2Ptr<IO2GClosedTradesTable> closedTradesTable = (IO2GClosedTradesTable *)manager->getTable(ClosedTrades); accountsTable->unsubscribeUpdate(Update, this); ordersTable->unsubscribeUpdate(Insert, this); ordersTable->unsubscribeUpdate(Delete, this); tradesTable->unsubscribeUpdate(Insert, this); tradesTable->unsubscribeUpdate(Update, this); closedTradesTable->unsubscribeUpdate(Insert, this); messagesTable->unsubscribeUpdate(Insert, this); }
// Get and print margin requirements void printMargins(IO2GSession *session, IO2GAccountRow *account, IO2GOfferRow *offer) { O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules(); if (!loginRules) { std::cout << "Cannot create request" << std::endl; return; } O2G2Ptr<IO2GTradingSettingsProvider> tradingSettings = loginRules->getTradingSettingsProvider(); double dMmr = 0; double dEmr = 0; double dLmr = 0; tradingSettings->getMargins(offer->getInstrument(), account, dMmr, dEmr, dLmr); std::cout << "Margin requirements: MMR=" << std::fixed << dMmr << "; EMR=" << std::fixed << dEmr << "; LMR=" << std::fixed << dLmr << std::endl; }
// Subscribe or unsubscribe an instrument IO2GRequest *createSetSubscriptionStatusRequest(IO2GSession *session, const char *sOfferID, const char *sStatus, ResponseListener *responseListener) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return NULL; } O2G2Ptr<IO2GValueMap> valuemap = requestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::SetSubscriptionStatus); valuemap->setString(SubscriptionStatus, sStatus); valuemap->setString(OfferID, sOfferID); O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); }
// 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; }
void ForexConnectClient::init() { mpSession = CO2GTransport::createSession(); mpListener = new SessionStatusListener(mpSession, false); mpSession->subscribeSessionStatus(mpListener); mpSession->useTableManager(Yes, 0); if (!login()) { throw std::runtime_error("Login fail."); } mpLoginRules = mpSession->getLoginRules(); if (!mpLoginRules->isTableLoadedByDefault(Accounts)) { logout(); throw std::runtime_error("Accounts table not loaded"); } O2G2Ptr<IO2GResponse> response = mpLoginRules->getTableRefreshResponse(Accounts); if(!response) { logout(); throw std::runtime_error("No response to refresh accounts table request"); } mpResponseReaderFactory = mpSession->getResponseReaderFactory(); O2G2Ptr<IO2GAccountsTableResponseReader> accountsResponseReader = mpResponseReaderFactory->createAccountsTableReader(response); mpAccountRow = accountsResponseReader->getRow(0); mAccountID = mpAccountRow->getAccountID(); mpResponseListener = new ResponseListener(mpSession); mpSession->subscribeResponse(mpResponseListener); mpRequestFactory = mpSession->getRequestFactory(); }
IO2GRequest *createEntryOrderRequest(IO2GSession *session, const char *sOfferID, const char *sAccountID, int iAmount, double dRate, const char *sBuySell, const char *sOrderType, const char *expDate) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return NULL; } O2G2Ptr<IO2GValueMap> valuemap = requestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::CreateOrder); valuemap->setString(OrderType, sOrderType); valuemap->setString(AccountID, sAccountID); valuemap->setString(OfferID, sOfferID); valuemap->setString(BuySell, sBuySell); valuemap->setInt(Amount, iAmount); valuemap->setDouble(Rate, dRate); valuemap->setString(CustomID, "EntryOrder"); if(strcmp(expDate, "") != 0) { valuemap->setString(TimeInForce, "GTD"); // 'Good till Date' valuemap->setString(ExpireDateTime, expDate); // FIX UTCTimestamp format: "yyyyMMdd- HH:mm:ss.SSS" (milliseconds are optional) } O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); }
int main(int argc, char *argv[]) { std::string procName = "CreateEntry"; if (argc == 1) { printHelp(procName); return -1; } bool bWasError = false; LoginParams *loginParams = new LoginParams(argc, argv); SampleParams *sampleParams = new SampleParams(argc, argv); printSampleParams(procName, loginParams, sampleParams); if (!checkObligatoryParams(loginParams, sampleParams)) return -1; IO2GSession *session = CO2GTransport::createSession(); SessionStatusListener *sessionListener = new SessionStatusListener(session, true, loginParams->getSessionID(), loginParams->getPin()); session->subscribeSessionStatus(sessionListener); bool bConnected = login(session, sessionListener, loginParams); if (bConnected) { bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0; O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount()); ResponseListener *responseListener = new ResponseListener(session); session->subscribeResponse(responseListener); if (account) { if (bIsAccountEmpty) { sampleParams->setAccount(account->getAccountID()); std::cout << "Account: " << sampleParams->getAccount() << std::endl; } O2G2Ptr<IO2GOfferRow> offer = getOffer(session, sampleParams->getInstrument()); if (offer) { O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules(); if (loginRules) { O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider(); int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account); int iAmount = iBaseUnitSize * sampleParams->getLots(); int iCondDistEntryLimit = tradingSettingsProvider->getCondDistEntryLimit(sampleParams->getInstrument()); int iCondDistEntryStop = tradingSettingsProvider->getCondDistEntryStop(sampleParams->getInstrument()); std::string sOrderType = getEntryOrderType(offer->getBid(), offer->getAsk(), sampleParams->getRate(), sampleParams->getBuySell(), offer->getPointSize(), iCondDistEntryLimit, iCondDistEntryStop); O2G2Ptr<IO2GRequest> request = createEntryOrderRequest(session, offer->getOfferID(), account->getAccountID(), iAmount, sampleParams->getRate(), sampleParams->getBuySell(), sOrderType.c_str(), sampleParams->getExpDate()); if (request) { responseListener->setRequestID(request->getRequestID()); session->sendRequest(request); if (responseListener->waitEvents()) { std::cout << "Done!" << std::endl; } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } else { std::cout << "Cannot get login rules" << std::endl; bWasError = true; } } else { std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl; bWasError = true; } } else { std::cout << "No valid accounts" << std::endl; bWasError = true; } session->unsubscribeResponse(responseListener); responseListener->release(); logout(session, sessionListener); } else { bWasError = true; } session->unsubscribeSessionStatus(sessionListener); sessionListener->release(); session->release(); if (bWasError) return -1; return 0; }
/** 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); } } } } } } } }
IO2GRequest *createNetEntryOrderRequest(IO2GSession *session, const char *sOfferID, const char *sAccountID, double dRate, const char *sBuySell, const char *sOrderType) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return NULL; } O2G2Ptr<IO2GValueMap> valuemap = requestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::CreateOrder); valuemap->setString(OrderType, sOrderType); valuemap->setString(AccountID, sAccountID); valuemap->setString(OfferID, sOfferID); valuemap->setString(BuySell, sBuySell); valuemap->setString(NetQuantity, "Y"); valuemap->setDouble(Rate, dRate); valuemap->setString(CustomID, "EntryOrder"); O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); }
int main(int argc, char* argv[]) { std::string procName = "CloseAllPositionsByInstrument"; if (argc == 1) { printHelp(procName); return -1; } LoginParams *loginParams = new LoginParams(argc, argv); SampleParams *sampleParams = new SampleParams(argc, argv); printSampleParams(procName, loginParams, sampleParams); if (!checkObligatoryParams(loginParams, sampleParams)) return -1; IO2GSession *session = CO2GTransport::createSession(); SessionStatusListener *sessionListener = new SessionStatusListener(session, false, loginParams->getSessionID(), loginParams->getPin()); session->subscribeSessionStatus(sessionListener); bool bConnected = login(session, sessionListener, loginParams); bool bWasError = false; if (bConnected) { bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0; O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount()); ResponseListener *responseListener = new ResponseListener(session); session->subscribeResponse(responseListener); if (account) { if (bIsAccountEmpty) { sampleParams->setAccount(account->getAccountID()); std::cout << "Account: " << sampleParams->getAccount() << std::endl; } O2G2Ptr<IO2GOfferRow> offer = getOffer(session, sampleParams->getInstrument()); if (offer) { CloseOrderData closeOrdersData; if (getCloseOrdersData(session, responseListener, sampleParams->getAccount(), offer->getOfferID(), closeOrdersData)) { O2G2Ptr<IO2GRequest> request = createCloseMarketNettingOrderRequest(session, &closeOrdersData); if (request) { std::vector<std::string> requestIDs(request->getChildrenCount()); for (int i = 0; i < request->getChildrenCount(); ++i) { IO2GRequest *requestChild = request->getChildRequest(i); requestIDs[i] = requestChild->getRequestID(); requestChild->release(); } responseListener->setRequestIDs(requestIDs); session->sendRequest(request); if (responseListener->waitEvents()) { Sleep(1000); // Wait for the balance update std::cout << "Done!" << std::endl; } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } else { std::cout << "There are no opened positions for instrument '" << sampleParams->getInstrument() << "'" << std::endl; } } else { std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl; bWasError = true; } } else { std::cout << "No valid accounts" << std::endl; bWasError = true; } session->unsubscribeResponse(responseListener); responseListener->release(); logout(session, sessionListener); } else { bWasError = true; } session->unsubscribeSessionStatus(sessionListener); sessionListener->release(); session->release(); if (bWasError) return -1; return 0; }
int main(int argc, char *argv[]) { std::string procName = "PrintTable"; if (argc == 1) { printHelp(procName); return -1; } bool bWasError = false; LoginParams *loginParams = new LoginParams(argc, argv); SampleParams *sampleParams = new SampleParams(argc, argv); printSampleParams(procName, loginParams, sampleParams); if (!checkObligatoryParams(loginParams, sampleParams)) return -1; IO2GSession *session = CO2GTransport::createSession(); session->useTableManager(Yes, 0); SessionStatusListener *sessionListener = new SessionStatusListener(session, true, loginParams->getSessionID(), loginParams->getPin()); session->subscribeSessionStatus(sessionListener); bool bConnected = login(session, sessionListener, loginParams); if (bConnected) { bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0; O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager(); O2GTableManagerStatus managerStatus = tableManager->getStatus(); while (managerStatus == TablesLoading) { Sleep(50); managerStatus = tableManager->getStatus(); } if (managerStatus == TablesLoadFailed) { std::cout << "Cannot refresh all tables of table manager" << std::endl; } O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount()); if (account) { if (bIsAccountEmpty) { sampleParams->setAccount(account->getAccountID()); std::cout << "Account: " << sampleParams->getAccount() << std::endl; } } else { std::cout << "No valid accounts" << std::endl; bWasError = true; } printOrders(tableManager, sampleParams->getAccount()); std::cout << "Done!" << std::endl; logout(session, sessionListener); } else { bWasError = true; } session->unsubscribeSessionStatus(sessionListener); sessionListener->release(); session->release(); if (bWasError) return -1; return 0; }
void TableListener::subscribeEvents(IO2GTableManager *manager) { O2G2Ptr<IO2GOffersTable> offersTable = (IO2GOffersTable *)manager->getTable(Offers); offersTable->subscribeUpdate(Update, this); }
IO2GRequest *createCloseMarketNettingOrderRequest(IO2GSession *session, CloseOrderData *closeOrdersData) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); O2G2Ptr<IO2GValueMap> batchValuemap = requestFactory->createValueMap(); batchValuemap->setString(Command, O2G2::Commands::CreateOrder); std::string sOfferID = closeOrdersData->offerID; std::string sAccountID = closeOrdersData->account; OrderSide side = closeOrdersData->side; std::string sOrderType = O2G2::Orders::TrueMarketClose; switch (side) { case Buy: { O2G2Ptr<IO2GValueMap> childValuemap = requestFactory->createValueMap(); childValuemap->setString(Command, O2G2::Commands::CreateOrder); childValuemap->setString(NetQuantity, "Y"); childValuemap->setString(OrderType, sOrderType.c_str()); childValuemap->setString(AccountID, sAccountID.c_str()); childValuemap->setString(OfferID, sOfferID.c_str()); childValuemap->setString(BuySell, O2G2::Buy); batchValuemap->appendChild(childValuemap); } break; case Sell: { O2G2Ptr<IO2GValueMap> childValuemap = requestFactory->createValueMap(); childValuemap->setString(Command, O2G2::Commands::CreateOrder); childValuemap->setString(NetQuantity, "Y"); childValuemap->setString(OrderType, sOrderType.c_str()); childValuemap->setString(AccountID, sAccountID.c_str()); childValuemap->setString(OfferID, sOfferID.c_str()); childValuemap->setString(BuySell, O2G2::Sell); batchValuemap->appendChild(childValuemap); } break; case Both: { O2G2Ptr<IO2GValueMap> buyValuemap = requestFactory->createValueMap(); buyValuemap->setString(Command, O2G2::Commands::CreateOrder); buyValuemap->setString(NetQuantity, "Y"); buyValuemap->setString(OrderType, sOrderType.c_str()); buyValuemap->setString(AccountID, sAccountID.c_str()); buyValuemap->setString(OfferID, sOfferID.c_str()); buyValuemap->setString(BuySell, O2G2::Buy); batchValuemap->appendChild(buyValuemap); O2G2Ptr<IO2GValueMap> sellValuemap = requestFactory->createValueMap(); sellValuemap->setString(Command, O2G2::Commands::CreateOrder); sellValuemap->setString(NetQuantity, "Y"); sellValuemap->setString(OrderType, sOrderType.c_str()); sellValuemap->setString(AccountID, sAccountID.c_str()); sellValuemap->setString(OfferID, sOfferID.c_str()); sellValuemap->setString(BuySell, O2G2::Sell); batchValuemap->appendChild(sellValuemap); } break; } IO2GRequest *request = requestFactory->createOrderRequest(batchValuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request; }
/** 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; } } } } } }
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)); } } } } } } }
IO2GRequest *createOTORequest(IO2GSession *session, const char *sOfferID, const char *sAccountID, int iAmount, double dRatePrimary, double dRateSecondary) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return NULL; } O2G2Ptr<IO2GValueMap> valuemap = requestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::CreateOTO); O2G2Ptr<IO2GValueMap> valuemapPrimary = requestFactory->createValueMap(); valuemapPrimary->setString(Command, O2G2::Commands::CreateOrder); valuemapPrimary->setString(OrderType, O2G2::Orders::StopEntry); valuemapPrimary->setString(AccountID, sAccountID); valuemapPrimary->setString(OfferID, sOfferID); valuemapPrimary->setString(BuySell, O2G2::Sell); valuemapPrimary->setInt(Amount, iAmount); valuemapPrimary->setDouble(Rate, dRatePrimary); valuemap->appendChild(valuemapPrimary); O2G2Ptr<IO2GValueMap> valuemapSecondary = requestFactory->createValueMap(); valuemapSecondary->setString(Command, O2G2::Commands::CreateOrder); valuemapSecondary->setString(OrderType, O2G2::Orders::StopEntry); valuemapSecondary->setString(AccountID, sAccountID); valuemapSecondary->setString(OfferID, sOfferID); valuemapSecondary->setString(BuySell, O2G2::Buy); valuemapSecondary->setInt(Amount, iAmount); valuemapSecondary->setDouble(Rate, dRateSecondary); valuemap->appendChild(valuemapSecondary); O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); }
int main(int argc, char *argv[]) { std::string procName = "CreateOTO"; if (argc == 1) { printHelp(procName); return -1; } LoginParams *loginParams = new LoginParams(argc, argv); SampleParams *sampleParams = new SampleParams(argc, argv); printSampleParams(procName, loginParams, sampleParams); if (!checkObligatoryParams(loginParams, sampleParams)) return -1; IO2GSession *session = CO2GTransport::createSession(); session->useTableManager(Yes, 0); SessionStatusListener *sessionListener = new SessionStatusListener(session, false, loginParams->getSessionID(), loginParams->getPin()); session->subscribeSessionStatus(sessionListener); bool bConnected = login(session, sessionListener, loginParams); bool bWasError = false; if (bConnected) { bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0; ResponseListener *responseListener = new ResponseListener(); TableListener *tableListener = new TableListener(responseListener); session->subscribeResponse(responseListener); O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager(); O2GTableManagerStatus managerStatus = tableManager->getStatus(); while (managerStatus == TablesLoading) { Sleep(50); managerStatus = tableManager->getStatus(); } if (managerStatus == TablesLoadFailed) { std::cout << "Cannot refresh all tables of table manager" << std::endl; } O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount()); if (account) { if (bIsAccountEmpty) { sampleParams->setAccount(account->getAccountID()); std::cout << "Account: " << sampleParams->getAccount() << std::endl; } O2G2Ptr<IO2GOfferRow> offer = getOffer(tableManager, sampleParams->getInstrument()); if (offer) { O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules(); if (loginRules) { O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider(); int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account); int iAmount = iBaseUnitSize * sampleParams->getLots(); // For the purpose of this example we will place primary order 30 pips below the current market price // and our secondary order 15 pips below the current market price double dRatePrimary = offer->getAsk() - 30.0 * offer->getPointSize(); double dRateSecondary = offer->getAsk() - 15.0 * offer->getPointSize(); O2G2Ptr<IO2GRequest> request = createOTORequest(session, offer->getOfferID(), account->getAccountID(), iAmount, dRatePrimary, dRateSecondary); if (request) { tableListener->subscribeEvents(tableManager); std::vector<std::string> requestIDs(request->getChildrenCount()); for (int i=0; i<request->getChildrenCount(); ++i) { requestIDs[i] = request->getChildRequest(i)->getRequestID(); } responseListener->setRequestIDs(requestIDs); tableListener->setRequestIDs(requestIDs); session->sendRequest(request); if (responseListener->waitEvents()) { std::cout << "Done!" << std::endl; } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } tableListener->unsubscribeEvents(tableManager); tableListener->release(); } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } else { std::cout << "Cannot get login rules" << std::endl; bWasError = true; } } else { std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl; bWasError = true; } } else { std::cout << "No valid accounts" << std::endl; bWasError = true; } session->unsubscribeResponse(responseListener); responseListener->release(); logout(session, sessionListener); } else { bWasError = true; } session->unsubscribeSessionStatus(sessionListener); sessionListener->release(); session->release(); if (bWasError) return -1; return 0; }
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; }
int main(int argc, char *argv[]) { std::string procName = "NetStopLimit"; if (argc == 1) { printHelp(procName); return -1; } LoginParams *loginParams = new LoginParams(argc, argv); SampleParams *sampleParams = new SampleParams(argc, argv); printSampleParams(procName, loginParams, sampleParams); if (!checkObligatoryParams(loginParams, sampleParams)) return -1; IO2GSession *session = CO2GTransport::createSession(); session->useTableManager(Yes, 0); SessionStatusListener *sessionListener = new SessionStatusListener(session, false, loginParams->getSessionID(), loginParams->getPin()); session->subscribeSessionStatus(sessionListener); bool bConnected = login(session, sessionListener, loginParams); bool bWasError = false; if (bConnected) { bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0; ResponseListener *responseListener = new ResponseListener(); TableListener *tableListener = new TableListener(responseListener); session->subscribeResponse(responseListener); O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager(); O2GTableManagerStatus managerStatus = tableManager->getStatus(); while (managerStatus == TablesLoading) { Sleep(50); managerStatus = tableManager->getStatus(); } if (managerStatus == TablesLoadFailed) { std::cout << "Cannot refresh all tables of table manager" << std::endl; } O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount()); if (account) { if (bIsAccountEmpty) { sampleParams->setAccount(account->getAccountID()); std::cout << "Account: " << sampleParams->getAccount() << std::endl; } O2G2Ptr<IO2GOfferRow> offer = getOffer(tableManager, sampleParams->getInstrument()); if (offer) { O2G2Ptr<IO2GTradeRow> trade = getTrade(tableManager, sampleParams->getAccount(), offer->getOfferID()); if (trade) { const char *sBuySell = strcmp(trade->getBuySell(), O2G2::Buy) == 0 ? O2G2::Sell : O2G2::Buy; O2G2Ptr<IO2GRequest> requestStop = createNetEntryOrderRequest(session, offer->getOfferID(), account->getAccountID(), sampleParams->getRateStop(), sBuySell, O2G2::Orders::StopEntry); if (requestStop) { tableListener->subscribeEvents(tableManager); responseListener->setRequestID(requestStop->getRequestID()); tableListener->setRequestID(requestStop->getRequestID()); session->sendRequest(requestStop); if (responseListener->waitEvents()) { O2G2Ptr<IO2GRequest> requestLimit = createNetEntryOrderRequest(session, offer->getOfferID(), account->getAccountID(), sampleParams->getRateLimit(), sBuySell, O2G2::Orders::LimitEntry); if (requestLimit) { responseListener->setRequestID(requestLimit->getRequestID()); tableListener->setRequestID(requestLimit->getRequestID()); session->sendRequest(requestLimit); if (responseListener->waitEvents()) { std::cout << "Done!" << std::endl; } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } tableListener->unsubscribeEvents(tableManager); tableListener->release(); } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } else { std::cout << "There are no opened positions for instrument '" << sampleParams->getInstrument() << "'" << std::endl; } } else { std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl; bWasError = true; } } else { std::cout << "No valid accounts" << std::endl; bWasError = true; } session->unsubscribeResponse(responseListener); responseListener->release(); logout(session, sessionListener); } else { bWasError = true; } session->unsubscribeSessionStatus(sessionListener); sessionListener->release(); session->release(); if (bWasError) return -1; return 0; }
int main(int argc, char *argv[]) { std::string procName = "GetLastOrderUpdate"; if (argc == 1) { printHelp(procName); return -1; } bool bWasError = false; LoginParams *loginParams = new LoginParams(argc, argv); SampleParams *sampleParams = new SampleParams(argc, argv); printSampleParams(procName, loginParams, sampleParams); if (!checkObligatoryParams(loginParams, sampleParams)) { delete loginParams; delete sampleParams; return -1; } IO2GSession *session = CO2GTransport::createSession(); SessionStatusListener *sessionListener = new SessionStatusListener(session, true, loginParams->getSessionID(), loginParams->getPin()); session->subscribeSessionStatus(sessionListener); bool bConnected = login(session, sessionListener, loginParams); if (bConnected) { bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0; O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount()); ResponseListener *responseListener = new ResponseListener(session); session->subscribeResponse(responseListener); if (account) { if (bIsAccountEmpty) { sampleParams->setAccount(account->getAccountID()); std::cout << "Account: " << sampleParams->getAccount() << std::endl; } O2G2Ptr<IO2GOfferRow> offer = getOffer(session, sampleParams->getInstrument()); if (offer) { O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules(); if (loginRules) { O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider(); int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account); int iAmount = iBaseUnitSize * sampleParams->getLots(); O2G2Ptr<IO2GRequest> request = createTrueMarketOrderRequest(session, offer->getOfferID(), account->getAccountID(), iAmount, sampleParams->getBuySell()); if (request) { responseListener->setRequestID(request->getRequestID()); session->sendRequest(request); if (responseListener->waitEvents()) { std::string sOrderID = responseListener->getOrderID(); if (!sOrderID.empty()) { O2G2Ptr<IO2GRequest> updateRequest = getLastOrderUpdateRequest(session, sOrderID.c_str(), account->getAccountName()); if (updateRequest) { responseListener->setRequestID(updateRequest->getRequestID()); session->sendRequest(updateRequest); if (responseListener->waitEvents()) { O2G2Ptr<IO2GResponse> response = responseListener->getResponse(); if (response && response->getType() == GetLastOrderUpdate) { O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory(); if (readerFactory) { O2G2Ptr<IO2GLastOrderUpdateResponseReader> reader = readerFactory->createLastOrderUpdateResponseReader(response); char sTime[20]; formatDate(reader->getOrder()->getStatusTime(), sTime); std::cout << "Last order update: UpdateType='" << reader->getUpdateType() << "', " << "OrderID='" << reader->getOrder()->getOrderID() << "', " << "Status='" << reader->getOrder()->getStatus() << "', " << "StatusTime='" << sTime << "'" << std::endl; } } std::cout << "Done!" << std::endl; } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } } else { std::cout << "Response waiting timeout expired" << std::endl; bWasError = true; } } else { std::cout << "Cannot create request" << std::endl; bWasError = true; } } else { std::cout << "Cannot get login rules" << std::endl; bWasError = true; } } else { std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl; bWasError = true; } } else { std::cout << "No valid accounts" << std::endl; bWasError = true; } session->unsubscribeResponse(responseListener); responseListener->release(); logout(session, sessionListener); } else { bWasError = true; } session->unsubscribeSessionStatus(sessionListener); sessionListener->release(); session->release(); delete loginParams; delete sampleParams; if (bWasError) return -1; return 0; }
void TableListener::unsubscribeEvents(IO2GTableManager *manager) { O2G2Ptr<IO2GOrdersTable> ordersTable = (IO2GOrdersTable *)manager->getTable(Orders); ordersTable->unsubscribeUpdate(Insert, this); }
IO2GRequest *createTrueMarketOrderRequest(IO2GSession *session, const char *sOfferID, const char *sAccountID, int iAmount, const char *sBuySell) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return NULL; } O2G2Ptr<IO2GValueMap> valuemap = requestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::CreateOrder); valuemap->setString(OrderType, O2G2::Orders::TrueMarketOpen); valuemap->setString(AccountID, sAccountID); valuemap->setString(OfferID, sOfferID); valuemap->setString(BuySell, sBuySell); valuemap->setInt(Amount, iAmount); valuemap->setString(CustomID, "TrueMarketOrder"); O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); }
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; }
// Create GetLastOrderUpdate request IO2GRequest *getLastOrderUpdateRequest(IO2GSession *session, const char *sOrderID, const char *sAccountName) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (!requestFactory) { std::cout << "Cannot create request factory" << std::endl; return NULL; } O2G2Ptr<IO2GValueMap> valuemap = requestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::GetLastOrderUpdate); valuemap->setString(Key, O2G2::KeyType::OrderID); valuemap->setString(Id, sOrderID); // value of Key valuemap->setString(AccountName, sAccountName); // Account name, not Account ID O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); }
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; } }
IO2GRequest *createOTOCORequest(IO2GSession *session, const char *sOfferID, const char *sAccountID, int iAmount, double dRatePrimary, double dRateOcoFirst, double dRateOcoSecond) { O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory(); if (requestFactory) { // Create OTO command O2G2Ptr<IO2GValueMap> valuemapMain = requestFactory->createValueMap(); valuemapMain->setString(Command, O2G2::Commands::CreateOTO); // Create Entry order O2G2Ptr<IO2GValueMap> valuemapPrimary = requestFactory->createValueMap(); valuemapPrimary->setString(Command, O2G2::Commands::CreateOrder); valuemapPrimary->setString(OrderType, O2G2::Orders::StopEntry); valuemapPrimary->setString(AccountID, sAccountID); valuemapPrimary->setString(OfferID, sOfferID); valuemapPrimary->setString(BuySell, O2G2::Sell); valuemapPrimary->setInt(Amount, iAmount); valuemapPrimary->setDouble(Rate, dRatePrimary); // Create OCO group of orders O2G2Ptr<IO2GValueMap> valuemapOCO = requestFactory->createValueMap(); valuemapOCO->setString(Command, O2G2::Commands::CreateOCO); // Create Entry orders to OCO O2G2Ptr<IO2GValueMap> valuemapOCOFirst = requestFactory->createValueMap(); valuemapOCOFirst->setString(Command, O2G2::Commands::CreateOrder); valuemapOCOFirst->setString(OrderType, O2G2::Orders::StopEntry); valuemapOCOFirst->setString(AccountID, sAccountID); valuemapOCOFirst->setString(OfferID, sOfferID); valuemapOCOFirst->setString(BuySell, O2G2::Buy); valuemapOCOFirst->setInt(Amount, iAmount); valuemapOCOFirst->setDouble(Rate, dRateOcoFirst); O2G2Ptr<IO2GValueMap> valuemapOCOSecond = requestFactory->createValueMap(); valuemapOCOSecond->setString(Command, O2G2::Commands::CreateOrder); valuemapOCOSecond->setString(OrderType, O2G2::Orders::StopEntry); valuemapOCOSecond->setString(AccountID, sAccountID); valuemapOCOSecond->setString(OfferID, sOfferID); valuemapOCOSecond->setString(BuySell, O2G2::Buy); valuemapOCOSecond->setInt(Amount, iAmount); valuemapOCOSecond->setDouble(Rate, dRateOcoSecond); // Fill the created groups. Please note, first you should add an entry order to OTO order and then OCO group of orders valuemapMain->appendChild(valuemapPrimary);; valuemapOCO->appendChild(valuemapOCOFirst); valuemapOCO->appendChild(valuemapOCOSecond); valuemapMain->appendChild(valuemapOCO); O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemapMain); if (!request) { std::cout << requestFactory->getLastError() << std::endl; return NULL; } return request.Detach(); } else { std::cout << "Cannot create request factory" << std::endl; return NULL; } }