repo_bson_role.h

#pragma once
#include "repo_bson.h"

namespace repo {
    namespace core {
        namespace model {
            enum class DBActions {
                INSERT, UPDATE, REMOVE, FIND, CREATE_USER, CREATE_ROLE,
                DROP_ROLE, GRANT_ROLE, REVOKE_ROLE, VIEW_ROLE, UNKNOWN
            };
            enum class AccessRight { READ, WRITE, READ_WRITE };

            struct RepoPrivilege
            {
                std::string database;
                std::string collection;
                std::vector<DBActions> actions;
            };

            struct RepoPermission
            {
                std::string database;
                //Project name (not collection! put "model" instead of "model.{scene,history,stash,...}" in here.)
                std::string project;
                AccessRight permission;
            };

            class REPO_API_EXPORT RepoRole : public RepoBSON
            {
#define REPO_ROLE_LABEL_ROLE            "role"
#define REPO_ROLE_LABEL_DATABASE        "db"
#define REPO_ROLE_LABEL_COLLECTION      "collection"
#define REPO_ROLE_LABEL_RESOURCE        "resource"
#define REPO_ROLE_LABEL_ACTIONS         "actions"
#define REPO_ROLE_LABEL_PRIVILEGES      "privileges"
#define REPO_ROLE_LABEL_INHERITED_ROLES "roles"

            public:

                RepoRole() {}

                RepoRole(RepoBSON bson) : RepoBSON(bson){}

                ~RepoRole() {}

            public:

                static std::string dbActionToString(const DBActions &action);

                static std::vector<std::string> dbActionsToStrings(
                    const std::vector<DBActions> &actions);

                static DBActions stringToDBAction(const std::string &action);

                static std::vector<DBActions> stringsToDBActions(
                    const std::vector<std::string> &strings);

                static std::vector<RepoPrivilege> translatePermissions(
                    const std::vector<RepoPermission> &permissions);

                static std::vector<RepoPermission> translatePrivileges(
                    const std::vector<RepoPrivilege> &permissions);

                static void updateActions(
                    const std::string &collectionType,
                    const AccessRight &permission,
                    std::vector<DBActions> &vec
                    );

                RepoRole cloneAndUpdatePermissions(
                    const std::vector<RepoPermission> &permissions
                    ) const;

                RepoRole cloneAndUpdatePrivileges(
                    const std::vector<RepoPrivilege> &privileges
                    ) const;

                std::string getDatabase() const
                {
                    return getStringField(REPO_ROLE_LABEL_DATABASE);
                }

                std::vector<std::pair<std::string, std::string>> getInheritedRoles() const;

                std::string getName() const
                {
                    return getStringField(REPO_ROLE_LABEL_ROLE);
                }

                std::vector<RepoPrivilege> getPrivileges() const;

                std::unordered_map<std::string, RepoPrivilege> getPrivilegesMapped() const
                {
                    return getPrivilegesMapped(getPrivileges());
                }

                static std::unordered_map<std::string, RepoPrivilege>
                    getPrivilegesMapped(const std::vector<RepoPrivilege> &ps);

                std::vector<RepoPermission> getProjectAccessRights() const
                {
                    return translatePrivileges(getPrivileges());
                }

            private:

                std::vector<DBActions> getActions(RepoBSON actionArr) const;
            };
        }// end namespace model
    } // end namespace core
} // end namespace repo