IO2GOfferRow *getOfferAndPrint(IO2GSession *session, const char *sInstrument)
{
if (!session || !sInstrument)
return NULL;
IO2GOfferRow *resultOffer = NULL;
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (loginRules)
{
O2G2Ptr<IO2GResponse> response = loginRules->getTableRefreshResponse(Offers);
if (response)
{
O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory();
if (readerFactory)
{
O2G2Ptr<IO2GOffersTableResponseReader> reader = readerFactory->createOffersTableReader(response);
for (int i = 0; i < reader->size(); ++i)
{
O2G2Ptr<IO2GOfferRow> offer = reader->getRow(i);
if (offer)
{
if (strcmp(offer->getSubscriptionStatus(), O2G2::SubscriptionStatuses::ViewOnly) == 0)
printf("%s : [V]iew only\n", offer->getInstrument());
else if (strcmp(offer->getSubscriptionStatus(), O2G2::SubscriptionStatuses::Disable) == 0)
printf("%s : [D]isabled\n", offer->getInstrument());
else if (strcmp(offer->getSubscriptionStatus(), O2G2::SubscriptionStatuses::Tradable) == 0)
printf("%s : Available for [T]rade\n", offer->getInstrument());
else
printf("%s : %s\n", offer->getInstrument(), offer->getSubscriptionStatus());
if (strcmp(offer->getInstrument(), sInstrument) == 0)
resultOffer = offer.Detach();
}
}
}
}
}
return resultOffer;
}
// Print trading settings of the first account
bool printTradingSettings(IO2GSession *session)
{
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (!loginRules)
{
std::cout << "Cannot get login rules" << std::endl;
return false;
}
O2G2Ptr<IO2GResponse> accountsResponse = loginRules->getTableRefreshResponse(Accounts);
if (!accountsResponse)
{
std::cout << "Cannot get response" << std::endl;
return false;
}
O2G2Ptr<IO2GResponse> offersResponse = loginRules->getTableRefreshResponse(Offers);
if (!offersResponse)
{
std::cout << "Cannot get response" << std::endl;
return false;
}
O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider();
O2G2Ptr<IO2GResponseReaderFactory> factory = session->getResponseReaderFactory();
if (!factory)
{
std::cout << "Cannot create response reader factory" << std::endl;
return false;
}
O2G2Ptr<IO2GAccountsTableResponseReader> accountsReader = factory->createAccountsTableReader(accountsResponse);
O2G2Ptr<IO2GOffersTableResponseReader> instrumentsReader = factory->createOffersTableReader(offersResponse);
O2G2Ptr<IO2GAccountRow> account = accountsReader->getRow(0);
for (int i = 0; i < instrumentsReader->size(); ++i)
{
O2G2Ptr<IO2GOfferRow> instrumentRow = instrumentsReader->getRow(i);
const char *sInstrument = instrumentRow->getInstrument();
int condDistStopForTrade = tradingSettingsProvider->getCondDistStopForTrade(sInstrument);
int condDistLimitForTrade = tradingSettingsProvider->getCondDistLimitForTrade(sInstrument);
int condDistEntryStop = tradingSettingsProvider->getCondDistEntryStop(sInstrument);
int condDistEntryLimit = tradingSettingsProvider->getCondDistEntryLimit(sInstrument);
int minQuantity = tradingSettingsProvider->getMinQuantity(sInstrument, account);
int maxQuantity = tradingSettingsProvider->getMaxQuantity(sInstrument, account);
int baseUnitSize = tradingSettingsProvider->getBaseUnitSize(sInstrument, account);
O2GMarketStatus marketStatus = tradingSettingsProvider->getMarketStatus(sInstrument);
int minTrailingStep = tradingSettingsProvider->getMinTrailingStep();
int maxTrailingStep = tradingSettingsProvider->getMaxTrailingStep();
double mmr = tradingSettingsProvider->getMMR(sInstrument, account);
std::string sMarketStatus = "unknown";
switch (marketStatus)
{
case MarketStatusOpen:
sMarketStatus = "Market Open";
break;
case MarketStatusClosed:
sMarketStatus = "Market Close";
break;
}
std::cout << "Instrument: " << sInstrument << ", Status: " << sMarketStatus << std::endl;
std::cout << "Cond.Dist: ST=" << condDistStopForTrade << "; LT=" << condDistLimitForTrade << std::endl;
std::cout << "Cond.Dist entry stop=" << condDistEntryStop << "; entry limit=" << condDistEntryLimit << std::endl;
std::cout << "Quantity: Min=" << minQuantity << "; Max=" << maxQuantity
<< "; Base unit size=" << baseUnitSize << "; MMR=" << mmr << std::endl;
double mmr2=0, emr=0, lmr=0;
if (tradingSettingsProvider->getMargins(sInstrument, account, mmr2, emr, lmr))
{
std::cout << "Three level margin: MMR=" << mmr2 << "; EMR=" << emr
<< "; LMR=" << lmr << std::endl;
}
else
{
std::cout << "Single level margin: MMR=" << mmr2 << "; EMR=" << emr
<< "; LMR=" << lmr << std::endl;
}
std::cout << "Trailing step: " << minTrailingStep << "-" << maxTrailingStep << std::endl;
}
return true;
}
int main(int argc, char *argv[])
{
std::string procName = "GetOffers";
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)
{
ResponseListener *responseListener = new ResponseListener(session);
responseListener->setInstrument(sampleParams->getInstrument());
session->subscribeResponse(responseListener);
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (loginRules)
{
O2G2Ptr<IO2GResponse> response = NULL;
if (loginRules->isTableLoadedByDefault(Offers))
{
response = loginRules->getTableRefreshResponse(Offers);
if (response)
responseListener->printOffers(session, response, "");
}
else
{
O2G2Ptr<IO2GRequestFactory> requestFactory = session->getRequestFactory();
if (requestFactory)
{
O2G2Ptr<IO2GRequest> offersRequest = requestFactory->createRefreshTableRequest(Offers);
responseListener->setRequestID(offersRequest->getRequestID());
session->sendRequest(offersRequest);
if (responseListener->waitEvents())
{
response = responseListener->getResponse();
if (response)
responseListener->printOffers(session, response, "");
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
}
// Do nothing 10 seconds, let offers print
Sleep(10000);
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Cannot get login rules" << 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;
}
