ORMFunctionalObject.hpp

Go to the documentation of this file.

#ifndef ORM_FUNCTIONAL_OBJECT_HPP
#define ORM_FUNCTIONAL_OBJECT_HPP


#include "FakeDB.hpp"
#include "BaseDB.hpp"
#include "Response.hpp"
#include "DataBaseDriverConfig.hpp"
#include "Logger.hpp"

#include <functional>


namespace HCE
{

class ORMFunctionalObject
{
public:
    explicit ORMFunctionalObject(const DataBaseDriverConfig& db_config);
    virtual ~ORMFunctionalObject() throw();
public:
    std::string processJSON(const std::string& input_message);
    //Documents processObj(const std::string& input_message);
    Poco::SharedPtr<Response> processObj(const Request&);
public:
    inline unsigned int getErrorCode() const { return _errorCode; }
    inline std::string getErrorMsg() const { return _errorMsg; }
private:
    void init();
private:
    void createDriverByName();
    void setDriverUrl();
    void setDatabaseName();
private:
    void put( const std::string & key, const std::string & value ) {
        this->_dbDriver->put(key,value);
        this->_status = this->_dbDriver->getLastError();
    }
    std::string get ( const std::string & key ) {
        std::string value(this->_dbDriver->get(key));
        this->_status = this->_dbDriver->getLastError();
        return value;
    }
    std::vector<std::string> get_all () {
        std::vector<std::string> value (this->_dbDriver->get_all());
        this->_status = this->_dbDriver->getLastError();
        return value;
    }
    void del (const std::string& key) {
        this->_dbDriver->del(key);
        this->_status = _dbDriver->getLastError();
    }
private:
    Poco::SharedPtr<Response> putData(const std::string&);
    Poco::SharedPtr<Response> getData(const std::string&);
    Poco::SharedPtr<Response> delData(const std::string&);
    Poco::SharedPtr<Response> checkData(const std::string&);
    Poco::SharedPtr<Response> adminData(const std::string&);
    inline int getLastError() { return _dbDriver->getLastError(); }
private:
//public:
    //template<typename T>
    //STATUS loadResourceFromJSON(const std::string&, T&);
    STATUS loadResourcesFromJSON(const std::string&, std::map<std::string, std::string>&);
    STATUS loadDocIdsFromJSON(const std::string&, std::vector<std::string>&);
    void init_command();
    const std::string getDBEngine() const { return this->_dbConfig.getDriverName(); }
private:
    unsigned int _errorCode;
    std::string _errorMsg;
    STATUS _status;
    //typedef Poco::SharedPtr<Response> (HCE::ORMFunctionalObject::*FP)(const std::string&);
    typedef std::function<Poco::SharedPtr<HCE::Response>(ORMFunctionalObject*,const std::string&)> FP;
    std::vector<FP> command;
private:
    Poco::SharedPtr<HCE::BaseDB> _dbDriver;
    HCE::DataBaseDriverConfig _dbConfig;
    Poco::DynamicFactory<HCE::BaseDB> _factory;
};

inline void ORMFunctionalObject::createDriverByName() {
        this->_status = ACTION_GENERAL_FAILURE;
        this->_dbDriver = this->_factory.createInstance( this->_dbConfig.getDriverName() );
        this->_status = ACTION_SUCCESS;
}

inline void ORMFunctionalObject::setDriverUrl() {
        this->_status = ACTION_GENERAL_FAILURE;
        if (this->_dbDriver) {
                this->_dbDriver->setDriverUrl( this->_dbConfig.getDataBaseUrl() );
                this->_status = ACTION_SUCCESS;
        }
}

inline void ORMFunctionalObject::setDatabaseName() {
        this->_status = ACTION_GENERAL_FAILURE;
        if (this->_dbDriver) {
                this->_dbDriver->setDatabaseName( this->_dbConfig.getDataBaseName() );
                this->_status = ACTION_SUCCESS;
        }
}

}

#endif