repo_database_handler_abstract.h

#pragma once

#include <list>
#include <map>
#include <string>

#include "../model/bson/repo_bson.h"
#include "../model/bson/repo_bson_role.h"
#include "../model/bson/repo_bson_user.h"
#include "../model/bson/repo_bson_collection_stats.h"

namespace repo{
    namespace core{
        namespace handler {
            class AbstractDatabaseHandler {
            public:

                virtual ~AbstractDatabaseHandler(){};

                uint64_t documentSizeLimit() { return maxDocumentSize; };

                //* Generates a BSON object containing user credentials
                //* @param username user name for authentication
                //* @param password password of the user
                //* @param pwDigested true if pw is digested
                //* @return returns the constructed BSON object, or 0 if username is empty
                //*/
                //sta repo::core::model::RepoBSON* createBSONCredentials(
                //  const std::string &dbAddress,
                //  const std::string &username,
                //  const std::string &password,
                //  const bool        &pwDigested = false) = 0;

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

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

                virtual 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) = 0;

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

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

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

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

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

                virtual std::list<std::string> getAdminDatabaseRoles() = 0;

                virtual  std::list<std::string> getStandardDatabaseRoles() = 0;

                /*
                *   ------------- Database operations (insert/delete/update) --------------
                */

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

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

                virtual 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"
                    ) = 0;

                virtual bool insertRole(
                    const repo::core::model::RepoRole       &role,
                    std::string                             &errmsg) = 0;

                virtual bool insertUser(
                    const repo::core::model::RepoUser &user,
                    std::string                             &errmsg) = 0;

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

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

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

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

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

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

                virtual bool dropRole(
                    const repo::core::model::RepoRole &role,
                    std::string                       &errmsg) = 0;

                virtual bool dropUser(
                    const repo::core::model::RepoUser &user,
                    std::string                             &errmsg) = 0;

                virtual bool updateRole(
                    const repo::core::model::RepoRole       &role,
                    std::string                             &errmsg) = 0;

                virtual bool updateUser(
                    const repo::core::model::RepoUser &user,
                    std::string                             &errmsg) = 0;
                /*
                *   ------------- Query operations --------------
                */

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

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

                virtual std::vector<repo::core::model::RepoBSON> findAllByUniqueIDs(
                    const std::string& database,
                    const std::string& collection,
                    const repo::core::model::RepoBSON& uuid) = 0;

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

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

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

            protected:
                AbstractDatabaseHandler(uint64_t size) :maxDocumentSize(size){};

                const uint64_t maxDocumentSize;
            };
        }
    }
}