repo_database_handler_mongo.h

#pragma once

#include <string>
#include <iostream>
#include <sstream>

#if defined(_WIN32) || defined(_WIN64)
#include <WinSock2.h>
#include <Windows.h>

#define strcasecmp _stricmp
#endif

#include <mongo/client/dbclient.h>

#include "repo_database_handler_abstract.h"
#include "connectionpool/repo_connection_pool_mongo.h"
#include "../model/repo_node_utils.h"
#include "../model/bson/repo_bson.h"
#include "../model/bson/repo_bson_builder.h"
#include "../model/bson/repo_bson_role.h"
#include "../model/bson/repo_bson_user.h"
#include "../../lib/repo_stack.h"

namespace repo{
    namespace core{
        namespace handler {
            class MongoDatabaseHandler : public AbstractDatabaseHandler{
                enum class OPERATION { DROP, INSERT, UPDATE };
            public:
                /*
                *   =================================== Public Fields ========================================
                */
                static const std::string ID; 
                static const std::string UUID;
                static const std::string ADMIN_DATABASE;
                static const std::string SYSTEM_ROLES_COLLECTION;
                static const std::string AUTH_MECH;
                static const std::list<std::string> ANY_DATABASE_ROLES;
                static const std::list<std::string> ADMIN_ONLY_DATABASE_ROLES;

                /*
                 *  =============================================================================================
                 */

                /*
                 *  =================================== Public Functions ========================================
                 */

                ~MongoDatabaseHandler();

                static void disconnectHandler();

                static MongoDatabaseHandler* getHandler(
                    std::string &errMsg,
                    const std::string &host,
                    const int         &port,
                    const uint32_t    &maxConnections = 1,
                    const std::string &dbName = std::string(),
                    const std::string &username = std::string(),
                    const std::string &password = std::string(),
                    const bool        &pwDigested = false);

                static MongoDatabaseHandler* getHandler(
                    std::string           &errMsg,
                    const std::string     &host,
                    const int             &port,
                    const uint32_t        &maxConnections,
                    const std::string     &dbName = std::string(),
                    const model::RepoBSON *credentials = nullptr);

                static MongoDatabaseHandler* getHandler(
                    const std::string &host)
                {
                    return handler;
                }

                static repo::core::model::RepoBSON* createBSONCredentials(
                    const std::string &dbName,
                    const std::string &username,
                    const std::string &password,
                    const bool        &pwDigested = false)
                {
                    mongo::BSONObj *mongoBSON = createAuthBSON(dbName, username, password, pwDigested);
                    return mongoBSON ? new repo::core::model::RepoBSON(*mongoBSON) : nullptr;
                }

                /*
                *   ------------- Database info lookup --------------
                */

                uint64_t countItemsInCollection(
                    const std::string &database,
                    const std::string &collection,
                    std::string &errMsg);

                std::vector<repo::core::model::RepoBSON>
                    getAllFromCollectionTailable(
                    const std::string                             &database,
                    const std::string                             &collection,
                    const uint64_t                                &skip = 0,
                    const uint32_t                                &limit = 0,
                    const std::list<std::string>                  &fields = std::list<std::string>(),
                    const std::string                             &sortField = std::string(),
                    const int                                     &sortOrder = -1);

                std::list<std::string> getCollections(const std::string &database);

                repo::core::model::CollectionStats getCollectionStats(
                    const std::string    &database,
                    const std::string    &collection,
                    std::string          &errMsg);

                std::list<std::string> getDatabases(const bool &sorted = true);

                std::map<std::string, std::list<std::string> > getDatabasesWithProjects(
                    const std::list<std::string> &databases,
                    const std::string &projectExt = "history");

                std::list<std::string> getProjects(const std::string &database, const std::string &projectExt);

                std::list<std::string> getAdminDatabaseRoles()
                {
                    return ADMIN_ONLY_DATABASE_ROLES;
                }

                static std::string getAdminDatabaseName()
                {
                    return ADMIN_DATABASE;
                }

                std::list<std::string> getStandardDatabaseRoles()
                {
                    return ANY_DATABASE_ROLES;
                }
                /*
                *   ------------- Database operations (insert/delete/update) --------------
                */

                virtual void createCollection(const std::string &database, const std::string &name);

                bool dropCollection(
                    const std::string &database,
                    const std::string &collection,
                    std::string &errMsg);

                bool dropDatabase(
                    const std::string &database,
                    std::string &errMsg);

                bool dropDocument(
                    const repo::core::model::RepoBSON bson,
                    const std::string &database,
                    const std::string &collection,
                    std::string &errMsg);

                bool dropDocuments(
                    const repo::core::model::RepoBSON criteria,
                    const std::string &database,
                    const std::string &collection,
                    std::string &errMsg);

                bool dropRawFile(
                    const std::string &database,
                    const std::string &collection,
                    const std::string &fileName,
                    std::string &errMsg);

                bool dropRole(
                    const repo::core::model::RepoRole &role,
                    std::string                             &errmsg)
                {
                    return performRoleCmd(OPERATION::DROP, role, errmsg);
                }

                bool dropUser(
                    const repo::core::model::RepoUser &user,
                    std::string                             &errmsg)
                {
                    return performUserCmd(OPERATION::DROP, user, errmsg);
                }

                bool insertDocument(
                    const std::string &database,
                    const std::string &collection,
                    const repo::core::model::RepoBSON &obj,
                    std::string &errMsg);

                bool insertRawFile(
                    const std::string          &database,
                    const std::string          &collection,
                    const std::string          &fileName,
                    const std::vector<uint8_t> &bin,
                    std::string          &errMsg,
                    const std::string          &contentType = "binary/octet-stream"
                    );

                bool insertRole(
                    const repo::core::model::RepoRole       &role,
                    std::string                             &errmsg)
                {
                    return performRoleCmd(OPERATION::INSERT, role, errmsg);
                }

                bool insertUser(
                    const repo::core::model::RepoUser &user,
                    std::string                             &errmsg)
                {
                    return performUserCmd(OPERATION::INSERT, user, errmsg);
                }

                bool upsertDocument(
                    const std::string &database,
                    const std::string &collection,
                    const repo::core::model::RepoBSON &obj,
                    const bool        &overwrite,
                    std::string &errMsg);

                bool updateRole(
                    const repo::core::model::RepoRole       &role,
                    std::string                             &errmsg)
                {
                    return performRoleCmd(OPERATION::UPDATE, role, errmsg);
                }

                bool updateUser(
                    const repo::core::model::RepoUser &user,
                    std::string                             &errmsg)
                {
                    return performUserCmd(OPERATION::UPDATE, user, errmsg);
                }

                /*
                *   ------------- Query operations --------------
                */

                std::vector<repo::core::model::RepoBSON> findAllByUniqueIDs(
                    const std::string& database,
                    const std::string& collection,
                    const repo::core::model::RepoBSON& uuids);

                std::vector<repo::core::model::RepoBSON> findAllByCriteria(
                    const std::string& database,
                    const std::string& collection,
                    const repo::core::model::RepoBSON& criteria);

                repo::core::model::RepoBSON findOneByCriteria(
                    const std::string& database,
                    const std::string& collection,
                    const repo::core::model::RepoBSON& criteria,
                    const std::string& sortField = ""
                    );

                repo::core::model::RepoBSON findOneBySharedID(
                    const std::string& database,
                    const std::string& collection,
                    const repoUUID& uuid,
                    const std::string& sortField);

                repo::core::model::RepoBSON findOneByUniqueID(
                    const std::string& database,
                    const std::string& collection,
                    const repoUUID& uuid);

                std::vector<uint8_t> getRawFile(
                    const std::string& database,
                    const std::string& collection,
                    const std::string& fname
                    );

                /*
                 *  =============================================================================================
                 */

            protected:
                /*
                *   =================================== Protected Fields ========================================
                */
                static MongoDatabaseHandler *handler; /* !the single instance of this class*/
                /*
                *   =============================================================================================
                */

            private:
                /*
                 *  =================================== Private Fields ========================================
                 */

                connectionPool::MongoConnectionPool *workerPool;

                std::map<std::string, std::pair<std::string, std::string> > databasesAuthentication;

                mongo::ConnectionString dbAddress; /* !address of the database (host:port)*/

                /*
                 *  =============================================================================================
                 */

                /*
                 *  =================================== Private Functions ========================================
                 */

                MongoDatabaseHandler(
                    const mongo::ConnectionString &dbAddress,
                    const uint32_t                &maxConnections,
                    const std::string             &dbName,
                    const std::string             &username = std::string(),
                    const std::string             &password = std::string(),
                    const bool                    &pwDigested = false);

                MongoDatabaseHandler(
                    const mongo::ConnectionString &dbAddress,
                    const uint32_t                &maxConnections,
                    const std::string             &dbName,
                    const model::RepoBSON         *cred);

                repo::core::model::RepoBSON createRepoBSON(
                    mongo::DBClientBase *worker,
                    const std::string &database,
                    const std::string &collection,
                    const mongo::BSONObj &obj);

                static mongo::BSONObj* createAuthBSON(
                    const std::string &database,
                    const std::string &username,
                    const std::string &password,
                    const bool        &pwDigested);
                mongo::BSONObj fieldsToReturn(
                    const std::list<std::string>& fields,
                    bool excludeIdField = false);

                std::string getCollectionFromNamespace(const std::string &ns);

                std::vector<uint8_t> getBigFile(
                    mongo::DBClientBase *worker,
                    const std::string &database,
                    const std::string &collection,
                    const std::string &fileName);

                std::string getNamespace(
                    const std::string &database,
                    const std::string &collection);

                std::string getProjectFromCollection(const std::string &ns, const std::string &projectExt);

                bool performRoleCmd(
                    const OPERATION                         &op,
                    const repo::core::model::RepoRole       &role,
                    std::string                             &errMsg);

                bool performUserCmd(
                    const OPERATION                         &op,
                    const repo::core::model::RepoUser &user,
                    std::string                       &errMsg);

                bool storeBigFiles(
                    mongo::DBClientBase *worker,
                    const std::string &database,
                    const std::string &collection,
                    const repo::core::model::RepoBSON &obj,
                    std::string &errMsg);

                static bool caseInsensitiveStringCompare(const std::string& s1, const std::string& s2);

                /*
                *   =========================================================================================
                */
            };
        } /* namespace handler */
    }
}