bittrexconnection.h

// <copyright file="bittrexconnection.h" company="FinSec Systems">
// Copyright (c) 2018 finsec.systems. All rights reserved.
// </copyright>
// <author>Viknash</author>
// <date>12/5/2018</date>
// <summary>Declares the API class</summary>

#pragma once

#include "api.h"
#include "app.h"
#include "bittrexapi.h"
#include "bittrexdatabase.h"
#include "db.h"
#include "interface.h"
#include "interfacehelper.h"
#include "bittrex.h"

namespace trader
{

    class BittrexProcessingConnection : public Interface::MessageReceivingConnection
    {
      public:
        BittrexProcessingConnection() {}

        void SecurityListRequest(Poco::AutoPtr< Interface::SecurityListRequestData > securityListRequestData) override;

        void MarketDataRequest(Poco::AutoPtr< Interface::MarketDataRequestData > marketDataRequestData) override;

        void NewOrderSingle(Poco::AutoPtr< Interface::NewOrderSingleData > newOrderSingleData) override;

        void OrderCancelRequest(Poco::AutoPtr< Interface::OrderCancelRequestData > orderCancelRequestData) override;

        void TradeCaptureReportRequest(
            Poco::AutoPtr< Interface::TradeCaptureReportRequestData > tradeCaptureReportRequestData) override;

        void SetConnectionId(const std::string &_connectionId) { connectionId = _connectionId; }

        void SetExchange(Bittrex *_exchange) { exchange = _exchange; }

        void RunMore();

        Bittrex *exchange;

        std::string connectionId;

        struct BittrexMarketData
        {
            BittrexMarketData()
                : lastCachedId(0)
            {
            }
            typedef std::unordered_map< Poco::Int32, BittrexApi::History::DataObject::ResultArray > MarketDataMap;
            MarketDataMap marketDataMap;    
            Poco::Int32 lastCachedId;   
        };

        typedef std::unordered_map< std::string, BittrexMarketData > SymIDMap;
        SymIDMap marketToTradeHistoryMap;   

        struct MarketDataRequestRetrievalData
        {
            Poco::AutoPtr< Interface::MarketDataRequestData > marketRequestData;    

            typedef std::unordered_map< std::string, Poco::Int32 > LastCacheIdMap;
            LastCacheIdMap lastCacheIdMap;  
        };

        typedef std::unordered_map< std::string, MarketDataRequestRetrievalData > MarketDataUpdateMap;
        MarketDataUpdateMap marketDataUpdateMap;    
    };

    class BittrexConnection : public Interface::CallConnection, public Poco::Runnable
    {
    public:
        BittrexConnection(const std::string &_connectionid, Bittrex *_exchange)
            : processingConnection(10)
            , stop(false)
        {
            processingConnection.SetConnectionId(_connectionid);
            processingConnection.SetExchange(_exchange);
        }

        void ProcessMessage(Poco::AutoPtr< Interface::IMessageData > _messageData) override
        {
            processingConnection.ProcessMessage(_messageData);
        }

        void SetReceivingConnection(Poco::AutoPtr< Interface::Connection > _connection) override
        {
            processingConnection.SetReceivingConnection(_connection);
        }

        void run() override;

        void DoOperation(Poco::Int32 operation) override;

        BufferedConnection< BittrexProcessingConnection > processingConnection;

        bool stop;
        static AutoPtr< Interface::Connection > getConnection(const std::string &connectionId);
    };

} // namespace trader