fybapi.h

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


namespace trader {

    namespace FybApi {
    
        class AccountInfo :  public Poco::RefCountedObject {
        public:
            
            AccountInfo();
            
            ~AccountInfo();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetAccNo(Poco::Int32 val)
                {
                    accNo = val;
                }
                
                bool isSetAccNo() {
                    return (accNo != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 accNo;
                
                void SetBtcBal(double val)
                {
                    btcBal = val;
                }
                
                bool isSetBtcBal() {
                    return (btcBal != std::numeric_limits<double>::max());
                }
                
                double  btcBal;
                
                void SetBtcDeposit(std::string val)
                {
                    std::regex valRegex("^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$");
                    std::string valMatch(val);
                    if (std::regex_match(valMatch, valRegex))
                    {
                        btcDeposit = val;
                    }
                    else
                    {
                        throw Poco::RegularExpressionException("btcDeposit invalid.");
                    }
                }
                
                bool isSetBtcDeposit() {
                    return (btcDeposit != "Empty");
                }
                
                std::string btcDeposit;
                
                void SetEmail(std::string val)
                {
                    std::regex valRegex("([\\w-\\.]+)@((?:[\\w]+\\.)+)([a-zA-Z]{2,4})");
                    std::string valMatch(val);
                    if (std::regex_match(valMatch, valRegex))
                    {
                        email = val;
                    }
                    else
                    {
                        throw Poco::RegularExpressionException("email invalid.");
                    }
                }
                
                bool isSetEmail() {
                    return (email != "Empty");
                }
                
                std::string email;
                
                void SetError(Poco::Int32 val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 error;
                
                void SetSgdBal(double val)
                {
                    sgdBal = val;
                }
                
                bool isSetSgdBal() {
                    return (sgdBal != std::numeric_limits<double>::max());
                }
                
                double  sgdBal;
                
                DataObject()
                : accNo(std::numeric_limits<Poco::Int32>::max())
                , btcBal(std::numeric_limits<double>::max())
                , btcDeposit("Empty")
                , email("Empty")
                , error(std::numeric_limits<Poco::Int32>::max())
                , sgdBal(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AccountInfo
        
        class CancelOrderParams :  public Poco::RefCountedObject {
        public:
            
            CancelOrderParams();
            
            ~CancelOrderParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // Ticket Number of Pending Order to cancel
                void SetOrderNo(Poco::Int32 val)
                {
                    orderNo = val;
                }
                
                bool isSetOrderNo() {
                    return (orderNo != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 orderNo;
                
                DataObject()
                : orderNo(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //CancelOrderParams
        
        class ErrorMessage :  public Poco::RefCountedObject {
        public:
            
            ErrorMessage();
            
            ~ErrorMessage();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetError(std::string val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != "Empty");
                }
                
                std::string error;
                
                DataObject()
                : error("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //ErrorMessage
        
        class ErrorNumber :  public Poco::RefCountedObject {
        public:
            
            ErrorNumber();
            
            ~ErrorNumber();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetError(Poco::Int32 val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 error;
                
                DataObject()
                : error(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //ErrorNumber
        
        class ErrorNumberAndMessage :  public Poco::RefCountedObject {
        public:
            
            ErrorNumberAndMessage();
            
            ~ErrorNumberAndMessage();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetError(Poco::Int32 val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 error;
                
                void SetMsg(std::string val)
                {
                    msg = val;
                }
                
                bool isSetMsg() {
                    return (msg != "Empty");
                }
                
                std::string msg;
                
                DataObject()
                : error(std::numeric_limits<Poco::Int32>::max())
                , msg("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //ErrorNumberAndMessage
        
        class OrderBook :  public Poco::RefCountedObject {
        public:
            
            OrderBook();
            
            ~OrderBook();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                typedef double  AsksArrayArray;
                
                typedef std::vector<AsksArrayArray> AsksArray;
                typedef std::vector<AsksArray> Asks;
                Asks    asks;
                typedef double  BidsArrayArray;
                
                typedef std::vector<BidsArrayArray> BidsArray;
                typedef std::vector<BidsArray> Bids;
                Bids    bids;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderBook
        
        class OrderHistory :  public Poco::RefCountedObject {
        public:
            
            OrderHistory();
            
            ~OrderHistory();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetError(Poco::Int32 val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 error;
                
                struct OrdersArray {
                    
                    void SetDate_created(std::time_t val)
                    {
                        date_created = val;
                    }
                    
                    bool isSetDate_created() {
                        return (date_created != std::numeric_limits<time_t>::max());
                    }
                    
                    std::time_t date_created;
                    
                    void SetDate_executed(std::time_t val)
                    {
                        date_executed = val;
                    }
                    
                    bool isSetDate_executed() {
                        return (date_executed != std::numeric_limits<time_t>::max());
                    }
                    
                    std::time_t date_executed;
                    
                    void SetPrice(std::string val)
                    {
                        price = val;
                    }
                    
                    bool isSetPrice() {
                        return (price != "Empty");
                    }
                    
                    std::string price;
                    
                    void SetQty(std::string val)
                    {
                        qty = val;
                    }
                    
                    bool isSetQty() {
                        return (qty != "Empty");
                    }
                    
                    std::string qty;
                    
                    void SetStatus(std::string val)
                    {
                        status = val;
                    }
                    
                    bool isSetStatus() {
                        return (status != "Empty");
                    }
                    
                    std::string status;
                    
                    void SetTicket(Poco::Int32 val)
                    {
                        ticket = val;
                    }
                    
                    bool isSetTicket() {
                        return (ticket != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 ticket;
                    
                    // Whether it is a buy or sell order. Must be either 'B' or 'S' only.
                    void SetType(char val)
                    {
                        std::regex valRegex("B|S");
                        std::string valMatch(1, val);
                        if (std::regex_match(valMatch, valRegex))
                        {
                            type = val;
                        }
                        else
                        {
                            throw Poco::RegularExpressionException("type invalid.");
                        }
                    }
                    
                    bool isSetType() {
                        return (type != std::numeric_limits<char>::max());
                    }
                    
                    char    type;
                    
                    OrdersArray()
                    : date_created(std::numeric_limits<time_t>::max())
                    , date_executed(std::numeric_limits<time_t>::max())
                    , price("Empty")
                    , qty("Empty")
                    , status("Empty")
                    , ticket(std::numeric_limits<Poco::Int32>::max())
                    , type(std::numeric_limits<char>::max())
                    {
                    }
                
                };
                
                typedef std::vector<OrdersArray> Orders;
                Orders  orders;
                DataObject()
                : error(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderHistory
        
        class OrderHistoryParams :  public Poco::RefCountedObject {
        public:
            
            OrderHistoryParams();
            
            ~OrderHistoryParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetLimit(Poco::Int32 val)
                {
                    limit = val;
                }
                
                bool isSetLimit() {
                    return (limit != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 limit;
                
                DataObject()
                : limit(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderHistoryParams
        
        class OrderParams :  public Poco::RefCountedObject {
        public:
            
            OrderParams();
            
            ~OrderParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // Price to place order at
                void SetPrice(double val)
                {
                    price = val;
                }
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                double  price;
                
                // Quantity of bitcoins
                void SetQty(double val)
                {
                    qty = val;
                }
                
                bool isSetQty() {
                    return (qty != std::numeric_limits<double>::max());
                }
                
                double  qty;
                
                // Whether it is a buy or sell order. Must be either 'B' or 'S' only.
                void SetType(char val)
                {
                    std::regex valRegex("B|S");
                    std::string valMatch(1, val);
                    if (std::regex_match(valMatch, valRegex))
                    {
                        type = val;
                    }
                    else
                    {
                        throw Poco::RegularExpressionException("type invalid.");
                    }
                }
                
                bool isSetType() {
                    return (type != std::numeric_limits<char>::max());
                }
                
                char    type;
                
                DataObject()
                : price(std::numeric_limits<double>::max())
                , qty(std::numeric_limits<double>::max())
                , type(std::numeric_limits<char>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderParams
        
        class OrderStatus :  public Poco::RefCountedObject {
        public:
            
            OrderStatus();
            
            ~OrderStatus();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetError(Poco::Int32 val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 error;
                
                void SetMsg(std::string val)
                {
                    msg = val;
                }
                
                bool isSetMsg() {
                    return (msg != "Empty");
                }
                
                std::string msg;
                
                void SetPending_oid(std::string val)
                {
                    pending_oid = val;
                }
                
                bool isSetPending_oid() {
                    return (pending_oid != "Empty");
                }
                
                std::string pending_oid;
                
                DataObject()
                : error(std::numeric_limits<Poco::Int32>::max())
                , msg("Empty")
                , pending_oid("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderStatus
        
        class PendingOrders :  public Poco::RefCountedObject {
        public:
            
            PendingOrders();
            
            ~PendingOrders();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetError(Poco::Int32 val)
                {
                    error = val;
                }
                
                bool isSetError() {
                    return (error != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 error;
                
                struct OrdersArray {
                    
                    void SetDate(std::time_t val)
                    {
                        date = val;
                    }
                    
                    bool isSetDate() {
                        return (date != std::numeric_limits<time_t>::max());
                    }
                    
                    std::time_t date;
                    
                    void SetPrice(double val)
                    {
                        price = val;
                    }
                    
                    bool isSetPrice() {
                        return (price != std::numeric_limits<double>::max());
                    }
                    
                    double  price;
                    
                    void SetQty(double val)
                    {
                        qty = val;
                    }
                    
                    bool isSetQty() {
                        return (qty != std::numeric_limits<double>::max());
                    }
                    
                    double  qty;
                    
                    void SetTicket(Poco::Int32 val)
                    {
                        ticket = val;
                    }
                    
                    bool isSetTicket() {
                        return (ticket != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 ticket;
                    
                    // Whether it is a buy or sell order. Must be either 'B' or 'S' only.
                    void SetType(char val)
                    {
                        std::regex valRegex("B|S");
                        std::string valMatch(1, val);
                        if (std::regex_match(valMatch, valRegex))
                        {
                            type = val;
                        }
                        else
                        {
                            throw Poco::RegularExpressionException("type invalid.");
                        }
                    }
                    
                    bool isSetType() {
                        return (type != std::numeric_limits<char>::max());
                    }
                    
                    char    type;
                    
                    OrdersArray()
                    : date(std::numeric_limits<time_t>::max())
                    , price(std::numeric_limits<double>::max())
                    , qty(std::numeric_limits<double>::max())
                    , ticket(std::numeric_limits<Poco::Int32>::max())
                    , type(std::numeric_limits<char>::max())
                    {
                    }
                
                };
                
                typedef std::vector<OrdersArray> Orders;
                Orders  orders;
                DataObject()
                : error(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //PendingOrders
        
        class Ticker :  public Poco::RefCountedObject {
        public:
            
            Ticker();
            
            ~Ticker();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetAsk(double val)
                {
                    ask = val;
                }
                
                bool isSetAsk() {
                    return (ask != std::numeric_limits<double>::max());
                }
                
                double  ask;
                
                void SetBid(double val)
                {
                    bid = val;
                }
                
                bool isSetBid() {
                    return (bid != std::numeric_limits<double>::max());
                }
                
                double  bid;
                
                DataObject()
                : ask(std::numeric_limits<double>::max())
                , bid(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //Ticker
        
        class TickerDetailed :  public Poco::RefCountedObject {
        public:
            
            TickerDetailed();
            
            ~TickerDetailed();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetAsk(double val)
                {
                    ask = val;
                }
                
                bool isSetAsk() {
                    return (ask != std::numeric_limits<double>::max());
                }
                
                double  ask;
                
                void SetBid(double val)
                {
                    bid = val;
                }
                
                bool isSetBid() {
                    return (bid != std::numeric_limits<double>::max());
                }
                
                double  bid;
                
                void SetLast(double val)
                {
                    last = val;
                }
                
                bool isSetLast() {
                    return (last != std::numeric_limits<double>::max());
                }
                
                double  last;
                
                void SetVol(double val)
                {
                    vol = val;
                }
                
                bool isSetVol() {
                    return (vol != std::numeric_limits<double>::max());
                }
                
                double  vol;
                
                DataObject()
                : ask(std::numeric_limits<double>::max())
                , bid(std::numeric_limits<double>::max())
                , last(std::numeric_limits<double>::max())
                , vol(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //TickerDetailed
        
        class Trades :  public Poco::RefCountedObject {
        public:
            
            Trades();
            
            ~Trades();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataArray {
                
                void SetAmount(double val)
                {
                    amount = val;
                }
                
                bool isSetAmount() {
                    return (amount != std::numeric_limits<double>::max());
                }
                
                double  amount;
                
                void SetDate(std::time_t val)
                {
                    date = val;
                }
                
                bool isSetDate() {
                    return (date != std::numeric_limits<time_t>::max());
                }
                
                std::time_t date;
                
                void SetPrice(double val)
                {
                    price = val;
                }
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                double  price;
                
                void SetTid(Poco::Int32 val)
                {
                    tid = val;
                }
                
                bool isSetTid() {
                    return (tid != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 tid;
                
                DataArray()
                : amount(std::numeric_limits<double>::max())
                , date(std::numeric_limits<time_t>::max())
                , price(std::numeric_limits<double>::max())
                , tid(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            typedef std::vector<DataArray> Data;
            Data    data;
        }; //Trades
        
        class TradesParams :  public Poco::RefCountedObject {
        public:
            
            TradesParams();
            
            ~TradesParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // Trade ID to begin trade history from. You should cache trade history and query only new trades by passing in last known trade id
                void SetSince(Poco::Int32 val)
                {
                    since = val;
                }
                
                bool isSetSince() {
                    return (since != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 since;
                
                DataObject()
                : since(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //TradesParams
        
        class WithdrawParams :  public Poco::RefCountedObject {
        public:
            
            WithdrawParams();
            
            ~WithdrawParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // Amount of bitcoins/dollars to withdraw
                void SetAmount(double val)
                {
                    amount = val;
                }
                
                bool isSetAmount() {
                    return (amount != std::numeric_limits<double>::max());
                }
                
                double  amount;
                
                // Bitcoin address to withdraw to, leave blank for XFERS
                void SetDestination(std::string val)
                {
                    std::regex valRegex("^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$");
                    std::string valMatch(val);
                    if (std::regex_match(valMatch, valRegex))
                    {
                        destination = val;
                    }
                    else
                    {
                        throw Poco::RegularExpressionException("destination invalid.");
                    }
                }
                
                bool isSetDestination() {
                    return (destination != "Empty");
                }
                
                std::string destination;
                
                // BTC/XFERS (XFERS only for FYB-SG)
                void SetType(std::string val)
                {
                    std::regex valRegex("BTC|XFERS");
                    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()
                : amount(std::numeric_limits<double>::max())
                , destination("Empty")
                , type("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //WithdrawParams
        
        class EndPoints {
        public:
            
            EndPoints(Poco::AutoPtr<trader::App> app, Api* api);
            
            ~EndPoints();
            
            
            // Get current bid and ask
            Poco::AutoPtr<Ticker> GetTicker();
            
            // Get current bid and ask, last traded price and 24H volume
            Poco::AutoPtr<TickerDetailed> GetTickerDetailed();
            
            // Get list of pending orders
            Poco::AutoPtr<OrderBook> GetOrderBook();
            
            // Get list of executed trades
            Poco::AutoPtr<Trades> GetTrades(Poco::AutoPtr<TradesParams> tradesParams);
            
            // Test whether your signature is valid
            Poco::AutoPtr<ErrorMessage> Test();
            
            // Get account info
            Poco::AutoPtr<AccountInfo> GetAccountInfo();
            
            // Get My Pending Orders
            Poco::AutoPtr<PendingOrders> GetPendingOrders();
            
            // Return my executed order history
            Poco::AutoPtr<OrderHistory> GetOrderHistory(Poco::AutoPtr<OrderHistoryParams> orderHistoryParams);
            
            // Place an order. Works similar to placing an order on Trade Page
            Poco::AutoPtr<OrderStatus> PlaceOrder(Poco::AutoPtr<OrderParams> orderParams);
            
            // Cancel my Pending Order
            Poco::AutoPtr<ErrorNumber> CancelOrder(Poco::AutoPtr<CancelOrderParams> cancelOrderParams);
            
            // Make a withdrawal (Does not require email confirmation)
            Poco::AutoPtr<ErrorNumberAndMessage> Withdraw(Poco::AutoPtr<WithdrawParams> withdrawParams);
            
            FybConfig   config;
            
            Poco::AutoPtr<trader::App>  _app;
            Api*    _api;
            std::string _uri;
        }; //EndPoints
        
    } //FybApi
} //trader