bittrexapi.h

#pragma once 
#include "app.h"
#include "api.h"
#include "bittrexconfig.h"
#include "helper.h"


namespace trader {

    namespace BittrexApi {
    
        class Balance :  public Poco::RefCountedObject {
        public:
            
            Balance();
            
            ~Balance();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultArray {
                    
                    void SetAvailable(double val)
                    {
                        available = val;
                    }
                    
                    bool isSetAvailable() {
                        return (available != std::numeric_limits<double>::max());
                    }
                    
                    double  available;
                    
                    void SetBalance(double val)
                    {
                        balance = val;
                    }
                    
                    bool isSetBalance() {
                        return (balance != std::numeric_limits<double>::max());
                    }
                    
                    double  balance;
                    
                    void SetCryptoAddress(std::string val)
                    {
                        cryptoAddress = val;
                    }
                    
                    bool isSetCryptoAddress() {
                        return (cryptoAddress != "Empty");
                    }
                    
                    std::string cryptoAddress;
                    
                    void SetCurrency(std::string val)
                    {
                        currency = val;
                    }
                    
                    bool isSetCurrency() {
                        return (currency != "Empty");
                    }
                    
                    std::string currency;
                    
                    void SetPending(double val)
                    {
                        pending = val;
                    }
                    
                    bool isSetPending() {
                        return (pending != std::numeric_limits<double>::max());
                    }
                    
                    double  pending;
                    
                    void SetRequested(bool val)
                    {
                        requested = val;
                        requestedSet = true;
                    }
                    
                    bool isSetRequested() {
                        return (requestedSet != false);
                    }
                    
                    bool    requested;
                    bool    requestedSet;
                    
                    void SetUuid(std::string val)
                    {
                        uuid = val;
                    }
                    
                    bool isSetUuid() {
                        return (uuid != "Empty");
                    }
                    
                    std::string uuid;
                    
                    ResultArray()
                    : available(std::numeric_limits<double>::max())
                    , balance(std::numeric_limits<double>::max())
                    , cryptoAddress("Empty")
                    , currency("Empty")
                    , pending(std::numeric_limits<double>::max())
                    , requested(false)
                    , requestedSet(false)
                    , uuid("Empty")
                    {
                    }
                
                };
                
                typedef std::vector<ResultArray> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //Balance
        
        class BalanceParams :  public Poco::RefCountedObject {
        public:
            
            BalanceParams();
            
            ~BalanceParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // a string literal for the market (ex: BTC-LTC)
                void SetCurrency(std::string val)
                {
                    currency = val;
                }
                
                bool isSetCurrency() {
                    return (currency != "Empty");
                }
                
                std::string currency;
                
                DataObject()
                : currency("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //BalanceParams
        
        class History :  public Poco::RefCountedObject {
        public:
            
            History();
            
            ~History();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultArray {
                    
                    void SetFillType(std::string val)
                    {
                        std::regex valRegex("FILL|PARTIAL_FILL");
                        std::string valMatch(val);
                        if (std::regex_match(valMatch, valRegex))
                        {
                            fillType = val;
                        }
                        else
                        {
                            throw Poco::RegularExpressionException("fillType invalid.");
                        }
                    }
                    
                    bool isSetFillType() {
                        return (fillType != "Empty");
                    }
                    
                    std::string fillType;
                    
                    void SetId(Poco::Int32 val)
                    {
                        id = val;
                    }
                    
                    bool isSetId() {
                        return (id != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 id;
                    
                    void SetOrderType(std::string val)
                    {
                        std::regex valRegex("BUY|SELL");
                        std::string valMatch(val);
                        if (std::regex_match(valMatch, valRegex))
                        {
                            orderType = val;
                        }
                        else
                        {
                            throw Poco::RegularExpressionException("orderType invalid.");
                        }
                    }
                    
                    bool isSetOrderType() {
                        return (orderType != "Empty");
                    }
                    
                    std::string orderType;
                    
                    void SetPrice(double val)
                    {
                        price = val;
                    }
                    
                    bool isSetPrice() {
                        return (price != std::numeric_limits<double>::max());
                    }
                    
                    double  price;
                    
                    void SetQuantity(double val)
                    {
                        quantity = val;
                    }
                    
                    bool isSetQuantity() {
                        return (quantity != std::numeric_limits<double>::max());
                    }
                    
                    double  quantity;
                    
                    void SetTimeStamp(FormattedTime val)
                    {
                        timeStamp = val;
                    }
                    
                    void SetTimeStamp(const std::string& val)
                    {
                        FormattedTime fmt("%Y-%m-%dT%H:%M:%S");
                        fmt = val;
                        timeStamp = fmt;
                    }
                    FormattedTime   timeStamp;
                    
                    void SetTotal(double val)
                    {
                        total = val;
                    }
                    
                    bool isSetTotal() {
                        return (total != std::numeric_limits<double>::max());
                    }
                    
                    double  total;
                    
                    ResultArray()
                    : fillType("Empty")
                    , id(std::numeric_limits<Poco::Int32>::max())
                    , orderType("Empty")
                    , price(std::numeric_limits<double>::max())
                    , quantity(std::numeric_limits<double>::max())
                    , timeStamp("%Y-%m-%dT%H:%M:%S")
                    , total(std::numeric_limits<double>::max())
                    {
                    }
                
                };
                
                typedef std::vector<ResultArray> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //History
        
        class HistoryParams :  public Poco::RefCountedObject {
        public:
            
            HistoryParams();
            
            ~HistoryParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // a string literal for the market (ex: BTC-LTC)
                void SetMarket(std::string val)
                {
                    market = val;
                }
                
                bool isSetMarket() {
                    return (market != "Empty");
                }
                
                std::string market;
                
                DataObject()
                : market("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //HistoryParams
        
        class Markets :  public Poco::RefCountedObject {
        public:
            
            Markets();
            
            ~Markets();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultArray {
                    
                    void SetBaseCurrency(std::string val)
                    {
                        baseCurrency = val;
                    }
                    
                    bool isSetBaseCurrency() {
                        return (baseCurrency != "Empty");
                    }
                    
                    std::string baseCurrency;
                    
                    void SetBaseCurrencyLong(std::string val)
                    {
                        baseCurrencyLong = val;
                    }
                    
                    bool isSetBaseCurrencyLong() {
                        return (baseCurrencyLong != "Empty");
                    }
                    
                    std::string baseCurrencyLong;
                    
                    void SetCreated(FormattedTime val)
                    {
                        created = val;
                    }
                    
                    void SetCreated(const std::string& val)
                    {
                        FormattedTime fmt("%Y-%m-%dT%H:%M:%S");
                        fmt = val;
                        created = fmt;
                    }
                    FormattedTime   created;
                    
                    void SetIsActive(bool val)
                    {
                        isActive = val;
                        isActiveSet = true;
                    }
                    
                    bool isSetIsActive() {
                        return (isActiveSet != false);
                    }
                    
                    bool    isActive;
                    bool    isActiveSet;
                    
                    void SetLogoUrl(std::string val)
                    {
                        logoUrl = val;
                    }
                    
                    bool isSetLogoUrl() {
                        return (logoUrl != "Empty");
                    }
                    
                    std::string logoUrl;
                    
                    void SetMarketCurrency(std::string val)
                    {
                        marketCurrency = val;
                    }
                    
                    bool isSetMarketCurrency() {
                        return (marketCurrency != "Empty");
                    }
                    
                    std::string marketCurrency;
                    
                    void SetMarketCurrencyLong(std::string val)
                    {
                        marketCurrencyLong = val;
                    }
                    
                    bool isSetMarketCurrencyLong() {
                        return (marketCurrencyLong != "Empty");
                    }
                    
                    std::string marketCurrencyLong;
                    
                    void SetMarketName(std::string val)
                    {
                        marketName = val;
                    }
                    
                    bool isSetMarketName() {
                        return (marketName != "Empty");
                    }
                    
                    std::string marketName;
                    
                    void SetMinTradeSize(Poco::Int32 val)
                    {
                        minTradeSize = val;
                    }
                    
                    bool isSetMinTradeSize() {
                        return (minTradeSize != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 minTradeSize;
                    
                    void SetNotice(std::string val)
                    {
                        notice = val;
                    }
                    
                    bool isSetNotice() {
                        return (notice != "Empty");
                    }
                    
                    std::string notice;
                    
                    ResultArray()
                    : baseCurrency("Empty")
                    , baseCurrencyLong("Empty")
                    , created("%Y-%m-%dT%H:%M:%S")
                    , isActive(false)
                    , isActiveSet(false)
                    , logoUrl("Empty")
                    , marketCurrency("Empty")
                    , marketCurrencyLong("Empty")
                    , marketName("Empty")
                    , minTradeSize(std::numeric_limits<Poco::Int32>::max())
                    , notice("Empty")
                    {
                    }
                
                };
                
                typedef std::vector<ResultArray> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //Markets
        
        class OrderBook :  public Poco::RefCountedObject {
        public:
            
            OrderBook();
            
            ~OrderBook();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultArray {
                    
                    void SetQuantity(double val)
                    {
                        quantity = val;
                    }
                    
                    bool isSetQuantity() {
                        return (quantity != std::numeric_limits<double>::max());
                    }
                    
                    double  quantity;
                    
                    void SetRate(double val)
                    {
                        rate = val;
                    }
                    
                    bool isSetRate() {
                        return (rate != std::numeric_limits<double>::max());
                    }
                    
                    double  rate;
                    
                    ResultArray()
                    : quantity(std::numeric_limits<double>::max())
                    , rate(std::numeric_limits<double>::max())
                    {
                    }
                
                };
                
                typedef std::vector<ResultArray> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderBook
        
        class OrderBookBoth :  public Poco::RefCountedObject {
        public:
            
            OrderBookBoth();
            
            ~OrderBookBoth();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultObject {
                    
                    struct BuyArray {
                        
                        void SetQuantity(double val)
                        {
                            quantity = val;
                        }
                        
                        bool isSetQuantity() {
                            return (quantity != std::numeric_limits<double>::max());
                        }
                        
                        double  quantity;
                        
                        void SetRate(double val)
                        {
                            rate = val;
                        }
                        
                        bool isSetRate() {
                            return (rate != std::numeric_limits<double>::max());
                        }
                        
                        double  rate;
                        
                        BuyArray()
                        : quantity(std::numeric_limits<double>::max())
                        , rate(std::numeric_limits<double>::max())
                        {
                        }
                    
                    };
                    
                    typedef std::vector<BuyArray> Buy;
                    Buy buy;
                    struct SellArray {
                        
                        void SetQuantity(double val)
                        {
                            quantity = val;
                        }
                        
                        bool isSetQuantity() {
                            return (quantity != std::numeric_limits<double>::max());
                        }
                        
                        double  quantity;
                        
                        void SetRate(double val)
                        {
                            rate = val;
                        }
                        
                        bool isSetRate() {
                            return (rate != std::numeric_limits<double>::max());
                        }
                        
                        double  rate;
                        
                        SellArray()
                        : quantity(std::numeric_limits<double>::max())
                        , rate(std::numeric_limits<double>::max())
                        {
                        }
                    
                    };
                    
                    typedef std::vector<SellArray> Sell;
                    Sell    sell;
                    ResultObject()
                    {
                    }
                
                };
                
                ResultObject    resultObject;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderBookBoth
        
        class OrderBookParams :  public Poco::RefCountedObject {
        public:
            
            OrderBookParams();
            
            ~OrderBookParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // a string literal for the market (ex: BTC-LTC)
                void SetMarket(std::string val)
                {
                    market = val;
                }
                
                bool isSetMarket() {
                    return (market != "Empty");
                }
                
                std::string market;
                
                // buy, sell or both to identify the type of orderbook to return
                void SetType(std::string val)
                {
                    std::regex valRegex("buy|sell|both");
                    std::string valMatch(val);
                    if (std::regex_match(valMatch, valRegex))
                    {
                        type = val;
                    }
                    else
                    {
                        throw Poco::RegularExpressionException("type invalid.");
                    }
                }
                
                bool isSetType() {
                    return (type != "Empty");
                }
                
                std::string type;
                
                DataObject()
                : market("Empty")
                , type("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderBookParams
        
        class ResultIntrospector :  public Poco::RefCountedObject {
        public:
            
            ResultIntrospector();
            
            ~ResultIntrospector();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetMessage(std::string val)
                {
                    message = val;
                }
                
                bool isSetMessage() {
                    return (message != "Empty");
                }
                
                std::string message;
                
                void SetSuccess(bool val)
                {
                    success = val;
                    successSet = true;
                }
                
                bool isSetSuccess() {
                    return (successSet != false);
                }
                
                bool    success;
                bool    successSet;
                
                DataObject()
                : message("Empty")
                , success(false)
                , successSet(false)
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //ResultIntrospector
        
        class EndPoints {
        public:
            
            EndPoints(Poco::AutoPtr<trader::App> app, Api* api);
            
            ~EndPoints();
            
            
            // Used to get the open and available trading markets at Bittrex along with other meta data.
            Poco::AutoPtr<Markets> GetMarkets();
            
            // Used to retrieve all balances from your account
            Poco::AutoPtr<Balance> GetBalance(Poco::AutoPtr<BalanceParams> balanceParams);
            
            // Used to retrieve the latest trades that have occured for a specific market
            Poco::AutoPtr<History> GetMarketHistory(Poco::AutoPtr<HistoryParams> historyParams);
            
            // Used to get retrieve the orderbook for a given market
            Poco::AutoPtr<OrderBook> GetOrderBook(Poco::AutoPtr<OrderBookParams> orderBookParams);
            
            // Used to get retrieve the orderbook for a given market
            Poco::AutoPtr<OrderBookBoth> GetBothOrderBooks(Poco::AutoPtr<OrderBookParams> orderBookParams);
            
            BittrexConfig   config;
            
            Poco::AutoPtr<trader::App>  _app;
            Api*    _api;
            std::string _uri;
        }; //EndPoints
        
    } //BittrexApi
} //trader