exchangeratelabapi.h

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


namespace trader {

    namespace ExchangeratelabApi {
    
        class SingleExchangeRate :  public Poco::RefCountedObject {
        public:
            
            SingleExchangeRate();
            
            ~SingleExchangeRate();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetBaseCurrency(std::string val)
                {
                    baseCurrency = val;
                }
                
                bool isSetBaseCurrency() {
                    return (baseCurrency != "Empty");
                }
                
                std::string baseCurrency;
                
                void SetExecutionTime(Poco::Int32 val)
                {
                    executionTime = val;
                }
                
                bool isSetExecutionTime() {
                    return (executionTime != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 executionTime;
                
                void SetLicenseMessage(std::string val)
                {
                    licenseMessage = val;
                }
                
                bool isSetLicenseMessage() {
                    return (licenseMessage != "Empty");
                }
                
                std::string licenseMessage;
                
                struct RateObject {
                    
                    void SetRate(double val)
                    {
                        rate = val;
                    }
                    
                    bool isSetRate() {
                        return (rate != std::numeric_limits<double>::max());
                    }
                    
                    double  rate;
                    
                    void SetTo(std::string val)
                    {
                        to = val;
                    }
                    
                    bool isSetTo() {
                        return (to != "Empty");
                    }
                    
                    std::string to;
                    
                    RateObject()
                    : rate(std::numeric_limits<double>::max())
                    , to("Empty")
                    {
                    }
                
                };
                
                RateObject  rateObject;
                // Current Unix timestamp
                void SetTimeStamp(std::time_t val)
                {
                    timeStamp = val;
                }
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<time_t>::max());
                }
                
                std::time_t timeStamp;
                
                DataObject()
                : baseCurrency("Empty")
                , executionTime(std::numeric_limits<Poco::Int32>::max())
                , licenseMessage("Empty")
                , timeStamp(std::numeric_limits<time_t>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //SingleExchangeRate
        
        class EndPoints {
        public:
            
            EndPoints(Poco::AutoPtr<trader::App> app, Api* api);
            
            ~EndPoints();
            
            
            // Get current bid and ask
            Poco::AutoPtr<SingleExchangeRate> GetUSDToSGD();
            
            ExchangeratelabConfig   config;
            
            Poco::AutoPtr<trader::App>  _app;
            Api*    _api;
            std::string _uri;
        }; //EndPoints
        
    } //ExchangeratelabApi
} //trader