/** 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);
							}
						}
					}
				}
			}
		}
	}
}
예제 #2
0
파일: main.cpp 프로젝트: BryanFletcher/FXCM
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;
}
예제 #3
0
파일: main.cpp 프로젝트: BryanFletcher/FXCM
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;
}