Response.hpp

Go to the documentation of this file.

#ifndef RESPONSE_HPP
#define RESPONSE_HPP


#include <string>
#include <map>

#include <Poco/Any.h>
#include <Poco/DynamicFactory.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/PrintHandler.h>
#include <Poco/JSON/JSONException.h>
#include <Poco/Environment.h>

#include "Errors.hpp"
#include "EncodeDecodeBase64.hpp"


namespace HCE
{

enum class CommandId {
    DB_ENGINE_NAME=0 
};


enum {
    PUT=0           
    , GET           
    , DEL         
    , CHECK         
    , MANAGE          
    , LIST
//    , COMMAND_COUNT //!< Keep it at the end of enum
};

class Request {
public:
        Request(const std::string& json) : initialized(false) {
        #ifdef _DEBUG_
        std::cout << "request constructor" << std::endl;
        std::cout << json << std::endl;
        #endif
                try {
                        Poco::JSON::Array::Ptr obj;
                        Poco::JSON::Parser parser;
                        Poco::Dynamic::Var result = parser.parse(json);
                        if ( result.type() == typeid(Poco::JSON::Object::Ptr) ) {
                                type = result.extract<Poco::JSON::Object::Ptr>()->getValue<unsigned int>("type");
                                data = result.extract<Poco::JSON::Object::Ptr>()->getValue<std::string>("data");
                        }
                        initialized = true;
                }
                catch(const Poco::Exception& exc) {
                        std::cout << exc.displayText() << std::endl;
                }
        }
public:
        unsigned int type;
        std::string data;
        bool initialized;
};


//typedef bool STATUS;
struct DataSet
{
        DataSet()
        {
        }
        DataSet(const std::map<std::string, std::string>& docs)
        {
            Poco::JSON::Object items;
            Poco::JSON::Object item;
            for(auto doc : docs)
            {
                std::string base64_decoded = doc.second;
                std::string base64_encoded = HCE::encodeBase64(base64_decoded);
                Poco::Dynamic::Var value(base64_encoded);
                item.set(doc.first,value);
            }
            items.set("documents",item);
            std::ostringstream oss;
            items.stringify(oss);
            data = oss.str();
#ifdef _DEBUG_
            std::cout << "data:\n"
                << data << std::endl;
#endif
        }
        std::string jsonToString() const
        {
            return data;
        }
        bool operator==(const HCE::DataSet& rhs) const
        {
            return (data.compare(rhs.data)) ? false : true;
        }
        std::string data;
        Poco::JSON::Object item;
    };
    struct Documents {
        std::vector<std::pair<const std::string, const std::string> > docs;
    };
    struct Response
    {
        Response(unsigned err_code=ACTION_NOT_SUPPORT)
        : error_code( Poco::NumberFormatter::format(err_code))
        , error_message(error_messages[err_code])
        , data()
        , time() {
            init();
        }
        Response(const std::map<std::string,std::string>& outData, const STATUS& status)
        : error_code(Poco::NumberFormatter::format(status)), error_message(error_messages[status]), data(outData) {
            init();
        }
        void init() {
            item.set("error_code", Poco::Dynamic::Var(error_code));
            item.set("error_message", Poco::Dynamic::Var(error_message));
            item.set("data", Poco::Dynamic::Var(data.jsonToString()));
            item.set("time", Poco::Dynamic::Var(time));
        }
        /*
        Response(const std::string& json)
        {
            try
            {
                Poco::JSON::Array::Ptr obj;
                Poco::JSON::Parser parser;
                Poco::JSON::DefaultHandler defaultHandler;
                parser.setHandler( &defaultHandler );
                parser.parse(json);
                Poco::DynamicAny result = defaultHandler.result();
                if ( result.type() == typeid(Poco::JSON::Object::Ptr) )
                {
                    if(result.extract<Poco::JSON::Object::Ptr>()->getObject("error_code"))
                    {
                        error_code = result.extract<Poco::JSON::Object::Ptr>()->getValue<std::string>("error_code");
                    }
                    if(result.extract<Poco::JSON::Object::Ptr>()->getObject("error_message"))
                    {
                        error_message = result.extract<Poco::JSON::Object::Ptr>()->getValue<std::string>("error_message");
                    }
                }
            }
            catch(Poco::JSON::JSONException& jsone)
            {
                std::cout << jsone.message() << std::endl;
            }
        }
        */
        /*
        Response(const std::string& errCode, const std::string& errMsg, const DataSet& outData, const std::string& elapsedTime)
        : error_code(errCode), error_message(errMsg), data(outData), time(elapsedTime), item()
        {
            item.set("error_code", Poco::Dynamic::Var(error_code));
            item.set("error_message", Poco::Dynamic::Var(error_message));
            item.set("data", Poco::Dynamic::Var(data.jsonToString()));
            item.set("time", Poco::Dynamic::Var(time));
        }
        */
        static Documents docs() {
            Documents doc;
            return doc;
        }
        inline void setTime(const std::string& _time) {
            item.set("time", Poco::Dynamic::Var(_time));
        }
        std::string json()
        {
            std::ostringstream oss;
            item.stringify(oss);
            return oss.str();
        }
        bool operator==(const HCE::Response& rhs) const
        {
            return (
                    this->error_code==rhs.error_code
                    && this->error_message==rhs.error_message
                    && this->data==rhs.data
                    );
        }
        std::string error_code;
        std::string error_message;
        DataSet data;
        std::string time;
        Poco::JSON::Object item;
    };

} 


#endif