ORMFunctionalObject.cpp

Go to the documentation of this file.

#include "ORMFunctionalObject.hpp"
#include "HCETimer.hpp"
#include "EncodeDecodeBase64.hpp"

#include <Poco/SharedPtr.h>
#include <Poco/NumberFormatter.h>
#include <Poco/NumberParser.h>


namespace HCE
{

ORMFunctionalObject::ORMFunctionalObject(const DataBaseDriverConfig& dbConfig) :
                _errorCode(int()),_errorMsg(),_status(),command(),_dbDriver(0),_dbConfig(dbConfig),_factory() {
        this->init();
    if(this->_status == ACTION_GENERAL_FAILURE) {
        std::cerr << "ERROR: create ORMFunctionalObject failure" << std::endl;
    }
}

ORMFunctionalObject::~ORMFunctionalObject() throw() {
}

void ORMFunctionalObject::init() {
        this->_status = ACTION_SUCCESS;
        #ifdef _USE_VOLDEMORT_DB_
                if (!_factory.isClass(this->_dbConfig.getDriverName())) _factory.registerClass<HCE::VoldemortDB>(this->_dbConfig.getDriverName());
        #elif _USE_LEVEL_DB_
                if (!_factory.isClass(this->_dbConfig.getDriverName())) _factory.registerClass<HCE::LevelDB>(this->_dbConfig.getDriverName());
        #elif _USE_AEROSPIKE_DB_
                if (!_factory.isClass(this->_dbConfig.getDriverName())) _factory.registerClass<HCE::AerospikeDB>(this->_dbConfig.getDriverName());
        #endif
    this->createDriverByName();
    this->setDriverUrl();
    this->setDatabaseName();
    this->setWritePolicy();
    this->setWriteUnique();
    init_command();
}

Poco::SharedPtr<Response> ORMFunctionalObject::processObj(const Request& request) {
    Poco::SharedPtr<Response> response;
    HCETimer timer;
    try {
        response = (request.initialized) ?
                (this->command.at(request.type))(this,request.data) : Poco::SharedPtr<Response>(new Response(INVALID_MESSAGE_BODY));
    }
    catch(std::exception& ex ) {
        Poco::Message msg ("KVDBManager.cpp",ex.what(),Poco::Message::PRIO_ERROR,__FILE__,__LINE__);
        HCE::Logger::writeLog(msg);
        response = Poco::SharedPtr<Response>(new Response);
    }
    response->setTime(Poco::NumberFormatter::format(timer.elapsed()));
    return response;
}

std::string ORMFunctionalObject::processJSON(const std::string& inputMessage) {
    Request request(inputMessage);
    return this->processObj(request)->json();
}

Poco::SharedPtr<Response> ORMFunctionalObject::putData(const std::string& data) {
    std::map<std::string, std::string> resources;
    std::map<std::string, std::string> statuses;
    STATUS status = loadResourcesFromJSON(data, resources);
    //STATUS status = loadResourceFromJSON<std::map<std::string, std::string> >(data, resources);
    for(auto resource : resources) {
        std::string key = resource.first;
        std::string value = resource.second;
        put(key, value);
        statuses[resource.first] = Poco::NumberFormatter::format(getLastError());
        status |= getLastError();
    }
    Poco::SharedPtr<Response> response(new Response(statuses,status));
    return response;
}

Poco::SharedPtr<Response> ORMFunctionalObject::getData(const std::string& data) {
        std::vector<std::string> document_ids;
        std::map<std::string, std::string> documents;
        STATUS status = loadDocIdsFromJSON(data, document_ids);
        for(auto document_id : document_ids) {
                std::string s = get(document_id);
                documents[document_id] = s;
                status |= getLastError();
        }
        Poco::SharedPtr<Response> response(new Response(documents,status));
        return response;
}

Poco::SharedPtr<Response> ORMFunctionalObject::delData(const std::string& data) {
    std::vector<std::string> document_ids;
    std::map<std::string, std::string> statuses;
    STATUS status = loadDocIdsFromJSON(data, document_ids);
    for(auto document_id : document_ids) {
        del(document_id);
        statuses[document_id] = Poco::NumberFormatter::format(getLastError());
        //status |= getLastError();
        status |= ACTION_SUCCESS;
    }
    Poco::SharedPtr<Response> response(new Response(statuses,status));
    return response;
}


Poco::SharedPtr<Response> ORMFunctionalObject::checkData(const std::string& data) {
    std::vector<std::string> document_ids;
    std::map<std::string, std::string> statuses;
    STATUS status = loadDocIdsFromJSON(data, document_ids);
    for(auto document_id : document_ids) {
        get(document_id);
        statuses[document_id] =  Poco::NumberFormatter::format(getLastError());
        //status |= getLastError();
        status |= DOCUMENT_PRESENT;
    }
    Poco::SharedPtr<Response> response(new Response(statuses,status));
    return response;
}


Poco::SharedPtr<Response> ORMFunctionalObject::adminData(const std::string& data) {
    std::vector<std::string> command_ids;
    std::map<std::string, std::string> statuses;
    STATUS status = loadDocIdsFromJSON(data, command_ids);
    for(auto command_id : command_ids) {
        try {
            switch(static_cast<CommandId>(Poco::NumberParser::parse(command_id))) {
                case CommandId::DB_ENGINE_NAME:
                    statuses[command_id] = getDBEngine();
                    status |= ACTION_SUCCESS;
                    break;
                default: break;
            }
        }
        catch (Poco::SyntaxException& ex) {
            status |= INVALID_ADMIN_COMMAND;
        }
    }
    Poco::SharedPtr<Response> response(new Response(statuses,status));
    return response;
}


Poco::SharedPtr<Response> ORMFunctionalObject::getAllKeys(const std::string&) {
    std::vector<std::string> document_ids;
    std::map<std::string, std::string> doc_ids;
    document_ids = get_all();
    for(auto doc_id : document_ids) {
        doc_ids[doc_id] = Poco::NumberFormatter::format(getLastError());
    }
    STATUS status = DOCUMENT_PRESENT;
    Poco::SharedPtr<Response> response(new Response(doc_ids,status));
    return response;
}


STATUS ORMFunctionalObject::loadResourcesFromJSON(const std::string& json, std::map<std::string, std::string>& resources) {
#ifdef _DEBUG_
        Poco::Message msg ("ORMFunctionalObject",json,Poco::Message::PRIO_INFORMATION,__FILE__,__LINE__);
        HCE::Logger::writeLog(msg);
#endif

        STATUS actionStatus = INVALID_MESSAGE_TYPE;
    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)) {
            std::string documents = result.extract<Poco::JSON::Object::Ptr>()->getValue<std::string>("documents");
            parser.reset();
            Poco::Dynamic::Var docs = parser.parse(documents);
            if (docs.type()==typeid(Poco::JSON::Object::Ptr)) {
                std::vector<std::string> keys;
                Poco::JSON::Object::Ptr pdocs = docs.extract<Poco::JSON::Object::Ptr>();
                pdocs->getNames(keys);
                for(auto key:keys) {
                    std::string base64_encode = pdocs->getValue<std::string>(key);
                    std::string value = HCE::decodeBase64(base64_encode);
                    resources[key] = value;
                }
                actionStatus = ACTION_SUCCESS;
            }
        }
    }
    catch(const Poco::JSON::JSONException& jsone) {
        Poco::Message msg ("ORMFunctionalObject",jsone.displayText(),Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
        HCE::Logger::writeLog(msg);
        actionStatus = ACTION_PARSE_ERROR;
    }
    return actionStatus;
}


STATUS ORMFunctionalObject::loadDocIdsFromJSON(const std::string& json, std::vector<std::string>& resources) {

#ifdef _DEBUG_
        Poco::Message msg ("ORMFunctionalObject",json,Poco::Message::PRIO_INFORMATION,__FILE__,__LINE__);
        HCE::Logger::writeLog(msg);
#endif

        STATUS actionStatus = INVALID_MESSAGE_TYPE;
        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)) {
                        std::string documents = result.extract<Poco::JSON::Object::Ptr>()->getValue<std::string>("documents");
                        parser.reset();
                        Poco::Dynamic::Var docs = parser.parse(documents);
                        if (docs.type()==typeid(Poco::JSON::Array::Ptr)) {
                                Poco::JSON::Array::Ptr pdocs = docs.extract<Poco::JSON::Array::Ptr>();
                                resources.reserve(pdocs->size());
                                for(unsigned i=0; i<pdocs->size(); ++i) {
                                        resources.push_back(pdocs->get(i).extract<std::string>());
                                }
                                actionStatus = ACTION_SUCCESS;
                        }
                }
        }
    catch(Poco::JSON::JSONException& jsone) {
        Poco::Message msg ("Application",jsone.displayText(),Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
        HCE::Logger::writeLog(msg);
        actionStatus = ACTION_PARSE_ERROR;
    }
    return actionStatus;
}

void ORMFunctionalObject::init_command()
{
    this->_status = ACTION_SUCCESS;
    try {
        command.push_back(&HCE::ORMFunctionalObject::putData);
        command.push_back(&HCE::ORMFunctionalObject::getData);
        command.push_back(&HCE::ORMFunctionalObject::delData);
        command.push_back(&HCE::ORMFunctionalObject::checkData);
        command.push_back(&HCE::ORMFunctionalObject::adminData);
        command.push_back(&HCE::ORMFunctionalObject::getAllKeys);
    }
    catch (const std::exception& ex) {
        Poco::Message msg_ex ("ORMFunctionalObject",ex.what(),Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
        HCE::Logger::writeLog(msg_ex);
        this->_status = ACTION_GENERAL_FAILURE;
    }
}

}