ms_security.hpp

/*
##############################################################################
# file: ms_security.hpp                                                      #
# 'msparser' toolkit                                                         #
# Encapsulates Mascot security as used in authentication                     #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2004 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /MowseBranches/ms_mascotresfile_1.2/include/ms_mascotresfi $ #
#     $Author: villek@matrixscience.com $ #
#       $Date: 2018-07-30 16:23:53 +0100 $ #
#   $Revision: 1b450440f9c97e1e41d0fc6016a27d68951d4532 | MSPARSER_REL_3_1_0-2025-07-27-0-gea47708fac $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
 
 
#if !defined(ms_security_INCLUDED_)
#define ms_security_INCLUDED_
 
 
// Includes from the standard template library
#include <string>
#include <set>
#include <vector>
#include <map>
 
 
#ifdef _WIN32
#include <io.h>
#endif
 
#include <time.h>
 
namespace matrix_science {
    class ms_security_options;
    class ms_security_task;
    class ms_security_tasks;
 
#ifndef SWIG
    class ms_userSortByID
    {
    public:
        bool operator() (const ms_user * t1, const ms_user * t2) const
        {
            return (t1->getID() < t2->getID());
        }
    };
 
    class ms_userSortByLoginName
    {
    public:
        bool operator() (const ms_user * t1, const ms_user * t2) const
        {
            return (t1->getName() < t2->getName());
        }
    };
 
    class ms_userSortByFullName
    {
    public:
        bool operator() (const ms_user * t1, const ms_user * t2) const
        {
            return (t1->getFullName() < t2->getFullName());
        }
    };
 
    class ms_groupSortByID
    {
    public:
        bool operator() (const ms_group * t1, const ms_group * t2) const
        {
            return (t1->getID() < t2->getID());
        }
    };
 
#endif
 
 
    class MS_MASCOTRESFILE_API ms_security : public ms_errors
    {
 
    public:
        ms_security();
        ~ms_security();
 
    public:
 
        enum USERID_SORTBY
        {
            USERID_SORTBY_ID         = 1,  
            USERID_SORTBY_LOGINNAME  = 2,  
            USERID_SORTBY_FULLNAME   = 3  
        };
 
        bool addNewUser(const std::string       sessionID,
                        const int               userID,
                        const std::string       userName,
                        const std::string       password,
                        const time_t            passwordExpiry,
                        const std::string       fullName,
                        const std::string       emailAddress,
                        const ms_user::usertype userType,
                        const bool              enabled);
 
        ms_user getUser(const std::string userName) const;
 
        ms_user getUserFromID(const int userID) const;
 
        bool isUserExists(const int userID) const;
 
        std::vector<int> sortUsers(std::vector<ms_user*> & vecUsers, const USERID_SORTBY sortby) const;
 
        std::vector<int> getAllUserIDs(const USERID_SORTBY sortby = USERID_SORTBY_ID) const;
 
        bool deleteUser(const std::string sessionID, const std::string userName);
 
        bool updateUser(const std::string sessionID, const ms_user user);
 
        bool updatePassword(const std::string sessionID, 
                            const std::string userName,
                            const std::string oldPassword,
                            const std::string newPassword);
 
        std::vector<std::string> getIntegraUsers() const;
 
        bool addNewGroup(const std::string sessionID,
                         const int groupID,
                         const std::string groupName);
 
        ms_group getGroup(const std::string groupName) const;
 
        ms_group getGroupFromID(const int groupID) const;
 
        std::vector<int> getAllGroupIDs() const;
 
        bool deleteGroup(const std::string sessionID, const std::string groupName);
 
        bool updateGroup(const std::string sessionID, const ms_group & group);
 
        ms_security_tasks getPermittedTasksForUser(const std::string name) const;
 
        ms_user::customParams_t getAllCustomParamsForUser(const ms_user & user) const;
 
        ms_security_options getMascotSecurityOptions() const;
 
        ms_security_tasks getTasks() const;
 
        bool isTaskExists(const int taskID) const;
 
        bool createDefaults(const std::string sessionID = "");
 
        bool updateAllSessionFiles(bool deleteOnly = false);
 
    protected:
        bool loadFromFile();
        bool saveToFile();
 
    private:
        //do not copy this class
        ms_security(const ms_security & src);
        ms_security& operator=(const ms_security & right);
 
        typedef std::set<ms_user  *, ms_userSortByID>  userlist_t;
        typedef std::set<ms_group *, ms_groupSortByID> grouplist_t;
 
        const char * invalidChars_;
 
        userlist_t users_;
        grouplist_t groups_;
        ms_security_tasks * tasks_;
        ms_security_options options_;
        int nextFreeGroupID_;
        int nextFreeUserID_;
 
        void removeAllUsersFromMemory();
        void removeAllGroupsFromMemory();
        bool doUpdateUser(const ms_user user);
 
    }; // end of security_group
}
#endif // !defined(ms_security_INCLUDED_)