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;
}
}
