+++ /dev/null
-# -*- coding: utf-8 -*-
-#######################################################################################
-# Plinn - http://plinn.org #
-# Copyright (C) 2005-2007 Benoît PIN <benoit.pin@ensmp.fr> #
-# #
-# This program is free software; you can redistribute it and/or #
-# modify it under the terms of the GNU General Public License #
-# as published by the Free Software Foundation; either version 2 #
-# of the License, or (at your option) any later version. #
-# #
-# This program is distributed in the hope that it will be useful, #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
-# GNU General Public License for more details. #
-# #
-# You should have received a copy of the GNU General Public License #
-# along with this program; if not, write to the Free Software #
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
-#######################################################################################
-"""
-
-
-"""
-
-from Globals import InitializeClass
-from AccessControl import ClassSecurityInfo
-from Products.CMFCore.permissions import View, AccessContentsInformation
-from Products.CMFCore.utils import getToolByName
-from Products.GroupUserFolder.GroupsToolPermissions import ViewGroups, AddGroups, DeleteGroups
-from Products.GroupUserFolder.GroupsTool import GroupsTool as BaseTool
-from sets import Set
-from OFS.SimpleItem import SimpleItem
-from OFS.Cache import Cacheable
-
-#Cache view names
-CACHE_ROOT_GROUPS = 'getRootGroups'
-CACHE_GROUPS_OF_GROUP = 'getGroupsOfGroup'
-CACHE_USER_NAMES_OF_GROUP= 'getUserNamesOfGroup'
-
-
-class GroupsTool(BaseTool, Cacheable) :
- """ Groups tool that behave like Membership tool """
-
- meta_type = 'Plinn Groups Tool'
-
- security = ClassSecurityInfo()
-
- manage_options = BaseTool.manage_options + Cacheable.manage_options
-
- security.declareProtected(AddGroups, 'getGroupWorkspacesCreationFlag')
-
-
- def _getUserNamesOfGroup(self, prefixed_group, no_recurse = 1) :
- aclu = self.aq_inner.acl_users
- allUsers = aclu.getPureUsers()
- usersDict = {}
-
- # make a dictionary of users indexed by group
- for user in allUsers :
- for group in user.getGroups(no_recurse = no_recurse) :
- if not usersDict.has_key(group) :
- usersDict[group] = [user.id, ]
- else :
- usersDict[group].append(user.id)
- return usersDict
-
-
-
- security.declareProtected(ViewGroups, 'getUserNamesOfGroup')
- def getUserNamesOfGroup(self, prefixed_group, no_recurse = 1) :
- """ Return users of groups"""
-
- if self.ZCacheable_isCachingEnabled() :
- usersDict = self.ZCacheable_get(view_name=CACHE_USER_NAMES_OF_GROUP,
- keywords={'no_recurse' : no_recurse},
- default=None)
- if usersDict is None :
- # load cache
- usersDict = self._getUserNamesOfGroup(prefixed_group, no_recurse = no_recurse)
- self.ZCacheable_set(usersDict,
- view_name=CACHE_USER_NAMES_OF_GROUP,
- keywords={'no_recurse' : no_recurse})
- else :
- usersDict = self._getUserNamesOfGroup(prefixed_group, no_recurse = no_recurse)
-
- return usersDict.get(prefixed_group, [])
-
-
- def _getGroupsOfGroup(self, prefixed_group) :
- aclu = self.aq_inner.acl_users
-
- allGroups = aclu.getGroups()
- groupsDict = {}
-
- # make a dictionary of users indexed by group
- for group in allGroups :
- for superGroup in group.getGroups(no_recurse=1) :
- if not groupsDict.has_key(superGroup) :
- groupsDict[superGroup] = [group.id, ]
- else :
- groupsDict[superGroup].append(group.id)
-
- return groupsDict
-
-
-
- security.declareProtected(ViewGroups, 'getGroupsOfGroup')
- def getGroupsOfGroup(self, prefixed_group) :
- """ Return groups of group """
- if self.ZCacheable_isCachingEnabled() :
- groupsDict = self.ZCacheable_get(view_name=CACHE_GROUPS_OF_GROUP, default=None)
-
- if groupsDict is None :
- # load cache
- groupsDict = self._getGroupsOfGroup(prefixed_group)
- self.ZCacheable_set(groupsDict, view_name=CACHE_GROUPS_OF_GROUP)
- else :
- groupsDict = self._getGroupsOfGroup(prefixed_group)
-
- return groupsDict.get(prefixed_group, [])
-
- security.declareProtected(ViewGroups, 'getGroups')
- def getGroups(self, groups) :
- """ Return wrapped groups """
- wGroups = [ self.getGroupById(group) for group in groups ]
- wGroups = filter(None, wGroups)
-
- wGroups.sort(_sortGroup)
- return wGroups
-
- security.declareProtected(ViewGroups, 'getOtherGroups')
- def getOtherGroups(self, groups) :
- """ Return other wrapped groups """
- aclu = self.aq_inner.acl_users
- prefix = aclu.getGroupPrefix()
- allGroupIds = aclu.getGroupNames()
-
-
- prefixed = 0
- wGroups = []
- if groups :
- if groups[0].startswith(prefix) :
- prefixed = 1
-
-
- if prefixed :
- prefixLength = len(prefix)
- groups = [ group[prefixLength:] for group in groups ]
-
- for groupId in allGroupIds :
- if groupId not in groups :
- wGroups.append(self.getGroupById(groupId))
-
- else :
- for groupId in allGroupIds :
- wGroups.append(self.getGroupById(groupId))
-
-
- wGroups.sort(_sortGroup)
- return wGroups
-
-
- def _getRootGroups(self) :
- top_level_list = []
- aclu = self.acl_users
- allGroups = aclu.getGroups()
- groupPrefix = aclu.getGroupPrefix()
-
- for group in allGroups :
- if not group.getGroups(no_recurse = 1) :
- top_level_list.append(groupPrefix+group.id)
- return top_level_list
-
- security.declareProtected(ViewGroups, 'getRootGroups')
- def getRootGroups(self) :
- """ return top level groups """
- if self.ZCacheable_isCachingEnabled() :
- rootGroups = self.ZCacheable_get(view_name=CACHE_ROOT_GROUPS, default=None)
-
- if rootGroups is None :
- rootGroups = self._getRootGroups()
- self.ZCacheable_set(rootGroups, view_name=CACHE_ROOT_GROUPS)
- else :
- rootGroups = self._getRootGroups()
-
- return rootGroups
-
-
- security.declareProtected(ViewGroups, 'getGroupsWithLocalRole')
- def getGroupsWithLocalRole(self, object, role) :
- """ Return Groups with local role """
-
- aclu = self.aq_inner.acl_users
- prefix = aclu.getGroupPrefix()
- allGroupNames = aclu.getGroupNames()
- usersAndGroupsWithLocalRole = object.users_with_local_role(role)
-
- return [ gn for gn in usersAndGroupsWithLocalRole if gn.startswith(prefix) ]
-
-
- security.declareProtected(AddGroups, 'addGroup')
- def addGroup(self, groupName, **mapping):
- """ Create a group, and a group workspace if the toggle is on,
- with the supplied id, roles, and domains.
- """
- self.acl_users.changeOrCreateGroups(new_groups = [groupName, ])
-
- group = self.getGroupById(groupName)
- group.setGroupProperties(mapping)
-
- if mapping.get('createArea', None) :
- self.createGrouparea(self.acl_users.getGroupPrefix()+groupName)
-
- if self.ZCacheable_isCachingEnabled() :
- self.ZCacheable_set(None, view_name=CACHE_ROOT_GROUPS)
-
-
- security.declareProtected(AddGroups, 'createGrouparea')
- def createGrouparea(self, id):
- """Create a space in the portal for the given group, much like member home
- folders."""
-
- ttool = getToolByName(self, 'portal_types')
- ti = ttool.getTypeInfo(self.getGroupWorkspaceContainerType())
-
- utool = getToolByName(self, 'portal_url')
- portal = utool.getPortalObject()
- workspaces = self.getGroupWorkspacesFolder()
- if workspaces is None :
- portalOwner = portal.getOwner()
- aclu = self.aq_inner.acl_users
- portalOwner = portalOwner.__of__(aclu)
- workspaces = ti._constructInstance(portal,
- self.getGroupWorkspacesFolderId(),
- title=self.getGroupWorkspacesFolderTitle())
- workspaces.manage_delLocalRoles(workspaces.users_with_local_role('Owner'))
- workspaces.changeOwnership(portalOwner)
- ti._finishConstruction(workspaces)
-
-
-
- # construct without security check
- group = self.getGroupById(id)
- area = ti._constructInstance(workspaces, id, title=group.getProperty('title', ''))
-
- area.manage_delLocalRoles(area.users_with_local_role('Owner'))
- self.setGroupOwnership(group, area)
-
- ti._finishConstruction(area)
-
-
- security.declareProtected(DeleteGroups, 'removeGroups')
- def removeGroups(self, ids, keep_workspaces=0) :
- """ remove the groups and invalidate cache """
- BaseTool.removeGroups(self, ids, keep_workspaces=keep_workspaces)
- if self.ZCacheable_isCachingEnabled() :
- self.ZCacheable_set(None, view_name=CACHE_ROOT_GROUPS)
- self.ZCacheable_set(None, view_name=CACHE_GROUPS_OF_GROUP)
-
- security.declareProtected(ViewGroups, 'getExplAndImplGroupsByUserId')
- def getExplAndImplGroupsByUserId(self, userid) :
- """ Return a dictionary with implicit and explicit wrapped groups """
- aclu = self.aq_inner.acl_users
- user = aclu.getUser(userid)
- if user :
- expl = Set(self.aq_inner.acl_users.getUser(userid).getGroups(no_recurse = 1) or [])
- implDbl = Set(self.aq_inner.acl_users.getUser(userid).getGroups(no_recurse = 0) or [])
- impl = implDbl.difference(expl)
- # wrap
- expl = [self.getGroupById(gid) for gid in expl]
- impl = [self.getGroupById(gid) for gid in impl]
- expl.sort(_sortGroup)
- impl.sort(_sortGroup)
- return {'explicit' : expl,
- 'implicit' : impl}
-
-InitializeClass(GroupsTool)
-
-
-def _sortGroup(a, b) :
- return cmp(a.id.lower(), b.id.lower())
projects / Plinn.git / blobdiff