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_2_8_1-0-gea32989045 $ #
# $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_)