rcUsers.py

#!/usr/local/bin/python
#
#                               Copyright 2002
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "User maintenance classes"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/01/25 03:09:30 $").split(' ')[1]
__version__  = "$Revision: 2.2 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

class rcUser(object):
  """Class that stores security and identification information about users
  """
  def __init__(self, userId, loginId, userName):
    self.__userId = userId
    self.__loginId = loginId
    self.__userName = userName
    self.__roles = []
    self.__permissions = []

  def getId(self):
    """Returns the three digit user id

    \return User Id
    """
    return self.__userId

  def getLoginId(self):
    """Returns the user's login id

    \return Login id
    """
    return self.__loginId

  def getName(self):
    """Returns the user name

    \return User name
    """
    return self.__userName

  def getRoles(self):
    """Returns the list of roles that this user belongs in

    \return List of roles
    """
    return self.__roles

  def getPermissions(self):
    """Returns the list of permissions that this user has

    \return List of permissions
    """
    return self.__permissions

  def addRole(self, role):
    """Adds \a role to this user's roles

    \param role Role name
    """
    self.__roles.append(role)

  def addPermission(self, permission):
    """Adds \a permission to this user's permissions

    \param permission Permission name
    """
    self.__permissions.append(permission)

  def isAdministrator(self):
    """Returns the user's administrator status

    \return 1: If this user is an administrator
            0: Otherwise
    """
    return ('administrator' in self.__roles)

  def __str__(self):
    return self.getName()

class rcUsers(object):
  """A dictionary like class that maintains a list of user objects
  """
  def __init__(self):
    self.__users = {}

  def addUser(self, user):
    """Adds the \a user to the list

    \param user An rcUser object instance
    """
    self.__users[user.getId()] = user

  def deleteUser(self, userId):
    """Deletes the user from the list based on the \a userId

    \param  userId The three digit id of the user

    \return  True: If the user was successfully deleted
            False: If the user does not exist
    """
    if userId in self.__users:
      self.__users.__delitem__(userId)
      return True
    else:
      return False


  def getUserByLoginId(self, loginId):
    """Retrieves the user based on the \a loginId

    \param loginId Login id of the user

    \return rcUser object instance
    """
    for user in self.__users.values():
      if loginId == user.getLoginId():
        return user

  def getUserByName(self, name):
    """Retrieves the user based on the \a name

    \param name Name of the user

    \return rcUser object instance
    """
    for user in self.__users.values():
      if name == user.getName():
        return user

  def getUser(self, userId):
    """Retrieves the user based on \a userid

    \param Three digit of the user

    \return rcUser object instance
    """
    if userId in self.__users:
      return self.__users[userId]

  def getUsers(self):
    """Retrieves all users

    \return A dictionary of all users keyed by the user id
    """
    return self.__users

  def getIdNameDict(self):
    """Retrieves all users in the form of a dictionary
    where values are user names. Provided for backward compatibility
    with the old code.

    \return A dictionary of user names keyed by the user id
    """
    # Provided for backward compatibility to mimick the old list
    userList = {}
    for (userId, user) in self.__users.items():
      userList[userId] = user.getName()
    return userList

---