Sektionen
Benutzerspezifische Werkzeuge
Sie sind hier: Startseite Support Dokumentation docs Plone: (Rechte-) Rollen Management

Plone: (Rechte-) Rollen Management

Ermitteln und setzen von lokalen Rollen in Plone.

Was sind Rollen in Plone

Da es in Plone sehr viele Rechte gibt, mit denen man sehr genau bestimmen kann, was ein Nutzer darf, ist es kaum möglich diese alle direkt zu verwalten. Daher können in Plone zu Rechte in Rechterollen zusammen gefasst werden, um sie so einfach als Set von Rollen, an einen Nutzer oder einer Gruppe verleihen zu können.

Am häufigsten kommen lokale Rollen (local roles) zum Einsatz, die z.B. über den Freigabe-Reiter an Nutzer und Gruppen vergeben werden können.

Im folgenden werden ein paar Methoden zur programmatischen Verwaltung lokaler Rollen aufgezeigt.

 

 

 

 

Lokale Rollen in Plone verwalten

Die folgenden Methoden sind an jedem Plone Objekt verfügbar.

has_local_roles

Gibt die Anzahl der lokalen Rollen, des Objektes zurück.

>>> self.has_local_roles()
2

get_local_roles

Gibt ein geschachteltes Tupel bestehend aus Nutzern und zugeordneten lokalen Rollen zurück.

Info: Es werden nur in diesem Kontext zugewiesene Rollen aufgelistet, nicht aber durch Vererbung erhaltene Rollen.

>>> self.get_local_roles()
( ('max', ('Contributor', 'Reader')), ('anna', ('Owner',) ) )

users_with_local_role

Gibt eine Liste der Nutzer zurück, die eine bestimmte lokale Rolle auf diesem Objekt haben.

Info: Es werden nur in diesem Kontext zugewiesene Rollen aufgelistet, nicht aber durch Vererbung erhaltene Rollen.

>>> self.users_with_local_role('Owner')
['anna']

get_local_roles_for_userid

Gibt ein Tupel der lokalen Rollen eines Nutzers zurück.

Info: Es werden nur in diesem Kontext zugewiesene Rollen aufgelistet, nicht aber durch Vererbung erhaltene Rollen.

>>> self.get_local_roles_for_userid('max')
('Contributor', 'Reader')

manage_addLocalRoles

Fügt einem Nutzer, eine Liste von lokalen Rollen, auf dem Objekt hinzu.
Bereits vorhandene Rollen bleiben erhalten.

Info: Es findet keine Prüfung statt, ob die Rollen wirklich existieren, hierzu können die nachfolgend beschriebene Methoden valid_roles und validate_roles verwenden werden.

>>> self.manage_addLocalRoles('anna', ['Reviewer'])

manage_setLocalRoles

Setzt für einen Nutzer eine Liste von lokalen Rollen, auf dem Objekt.
Bereits existierende Rollen des Nutzers auf dem Objekt werden dabei überschrieben!

Info: Es findet keine Prüfung statt, ob die Rollen wirklich existieren, hierzu können die nachfolgend beschriebene Methoden valid_roles und validate_roles verwenden werden.

>>> self.manage_setLocalRoles('max', ['Reviewer'])

manage_delLocalRoles

Entfernt alle lokalen rollen, für jeden Nutzer in der übergebenen Liste.
Möchte man einzelne lokale Rollen entfernen, so muss man die anderen Rollen vorher auslesen und nach dem löschen neu setzen!

>>> self.manage_delLocalRoles(['max'])

valid_roles

Gibt ein Tupel der verfügbaren Rollen zurück.

>>> self.valid_roles()
('Anonymous', 'Authenticated', 'Contributor', 'Editor', 'Manager', \
'Member', 'Owner', 'Reader', 'Reviewer')

validate_roles

Gibt 1 zurück wenn alle Rollen existieren, sonst wird 0 zurück gegeben.

>>> self.validate_roles(['Contributor','Owner'])
1
>>> self.validate_roles(['Contributor','Owners'])
0

Lokale Rollen, inklusive allen geerbten Rollen ermitteln

Um ebenfalls alle, durch Vererbung erhaltenen Rollen, eines Nutzers zu bekommen, kann die Methode getRolesInContext vom LocalRolesManager von PAS verwenden.

Products/PlonePAS/plugins/local_role.py

>>> max = portal.acl_users.getUserById('max')
>>> portal.acl_users.local_roles.getRolesInContext(max, self)
[u'Contributor', u'Editor', 'Reader']

 

 

RoleManager Interface (Plone3.3.5)

/parts/zope2/lib/python/AccessControl/interfaces.py
/parts/zope2/lib/python/AccessControl/Role.py

class IRoleManager(IPermissionMappingSupport):
"""An object that has configurable permissions"""

permissionMappingPossibleValues = Attribute("""Acquired attribute""")
def ac_inherited_permissions(all=0):
"""Get all permissions not defined in ourself that are inherited.

This will be a sequence of tuples with a name as the first item and an
empty tuple as the second.
"""

def permission_settings(permission=None):
"""Return user-role permission settings.

If 'permission' is passed to the method then only the settings for
'permission' is returned.
"""

manage_roleForm = Attribute(""" """)

def manage_role(role_to_manage, permissions=[], REQUEST=None):
"""Change the permissions given to the given role.
"""

manage_acquiredForm = Attribute(""" """)

def manage_acquiredPermissions(permissions=[], REQUEST=None):
"""Change the permissions that acquire.
"""

manage_permissionForm = Attribute(""" """)

def manage_permission(permission_to_manage,
roles=[], acquire=0, REQUEST=None):
"""Change the settings for the given permission.

If optional arg acquire is true, then the roles for the permission
are acquired, in addition to the ones specified, otherwise the
permissions are restricted to only the designated roles.
"""

def manage_access(REQUEST, **kw):
"""Return an interface for making permissions settings.
"""

def manage_changePermissions(REQUEST):
"""Change all permissions settings, called by management screen.
"""

def permissionsOfRole(role):
"""Used by management screen.
"""

def rolesOfPermission(permission):
"""Used by management screen.
"""


def acquiredRolesAreUsedBy(permission):
"""Used by management screen.
"""


# Local roles support
# -------------------
#
# Local roles allow a user to be given extra roles in the context
# of a particular object (and its children). When a user is given
# extra roles in a particular object, an entry for that user is made
# in the __ac_local_roles__ dict containing the extra roles.

__ac_local_roles__ = Attribute(""" """)

manage_listLocalRoles = Attribute(""" """)

manage_editLocalRoles = Attribute(""" """)

def has_local_roles():
"""
"""

def get_local_roles():
"""
"""

def users_with_local_role(role):
"""
"""

def get_valid_userids():
"""
"""

def get_local_roles_for_userid(userid):
"""
"""

def manage_addLocalRoles(userid, roles, REQUEST=None):
"""Set local roles for a user."""

def manage_setLocalRoles(userid, roles, REQUEST=None):
"""Set local roles for a user."""

def manage_delLocalRoles(userids, REQUEST=None):
"""Remove all local roles for a user."""

#------------------------------------------------------------

def access_debug_info():
"""Return debug info.
"""

def valid_roles():
"""Return list of valid roles.
"""

def validate_roles(roles):
"""Return true if all given roles are valid.
"""

def userdefined_roles():
"""Return list of user-defined roles.
"""

def manage_defined_roles(submit=None, REQUEST=None):
"""Called by management screen.
"""

def _addRole(role, REQUEST=None):
"""
"""

def _delRoles(roles, REQUEST=None):
"""
"""

def _has_user_defined_role(role):
"""
"""

def manage_editRoles(REQUEST, acl_type='A', acl_roles=[]):
"""
"""

def _setRoles(acl_type, acl_roles):
"""
"""

def possible_permissions():
"""
"""


Vererbung von Rollen deaktivieren

ptool = api.portal.get_tool(name='plone_utils')
ptool.acquireLocalRoles(obj, status=0)