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();
}
Exemple #2
0
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();
}
Exemple #3
0
IO2GRequest *joinToNewGroupRequest(IO2GSession *session, const char *sAccountID,
        std::vector<std::string> &orderIDs, int iContingencyType)
{
    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::JoinToNewContingencyGroup);
    valuemap->setInt(ContingencyGroupType, iContingencyType);

    for (size_t i=0; i < orderIDs.size(); ++i)
    {
        O2G2Ptr<IO2GValueMap> valuemapChild = requestFactory->createValueMap();
        valuemapChild->setString(OrderID, orderIDs[i].c_str());
        valuemapChild->setString(AccountID, sAccountID);
        valuemap->appendChild(valuemapChild);
    }

    O2G2Ptr<IO2GRequest> request = requestFactory->createOrderRequest(valuemap);
    if (!request)
    {
        std::cout << requestFactory->getLastError() << std::endl;
        return NULL;
    }
    return request.Detach();
}
Exemple #4
0
// 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;
}
Exemple #5
0
// 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();
}
// 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();
}
Exemple #7
0
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();
}
Exemple #8
0
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;
}
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();
}
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;
	}
}