GroupsTool.py

   1 # -*- coding: utf-8 -*-
   2 #######################################################################################
   3 #   Plinn - http://plinn.org                                                          #
   4 #   Copyright (C) 2005-2007  Benoît PIN <benoit.pin@ensmp.fr>                         #
   5 #                                                                                     #
   6 #   This program is free software; you can redistribute it and/or                     #
   7 #   modify it under the terms of the GNU General Public License                       #
   8 #   as published by the Free Software Foundation; either version 2                    #
   9 #   of the License, or (at your option) any later version.                            #
  10 #                                                                                     #
  11 #   This program is distributed in the hope that it will be useful,                   #
  12 #   but WITHOUT ANY WARRANTY; without even the implied warranty of                    #
  13 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                     #
  14 #   GNU General Public License for more details.                                      #
  15 #                                                                                     #
  16 #   You should have received a copy of the GNU General Public License                 #
  17 #   along with this program; if not, write to the Free Software                       #
  18 #   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   #
  19 #######################################################################################
  20 """
  21 $Id: GroupsTool.py 1332 2008-07-31 12:09:28Z pin $
  22 $URL: http://svn.cri.ensmp.fr/svn/Plinn/branches/CMF-2.1/GroupsTool.py $
  23 """
  24
  25 from Globals import InitializeClass
  26 from AccessControl import ClassSecurityInfo
  27 from Products.CMFCore.permissions import View, AccessContentsInformation
  28 from Products.CMFCore.utils import getToolByName
  29 from Products.GroupUserFolder.GroupsToolPermissions import ViewGroups, AddGroups, DeleteGroups
  30 from Products.GroupUserFolder.GroupsTool import GroupsTool as BaseTool
  31 from sets import Set
  32 from OFS.SimpleItem import SimpleItem
  33 from OFS.Cache import Cacheable
  34
  35 #Cache view names
  36 CACHE_ROOT_GROUPS = 'getRootGroups'
  37 CACHE_GROUPS_OF_GROUP = 'getGroupsOfGroup'
  38 CACHE_USER_NAMES_OF_GROUP= 'getUserNamesOfGroup'
  39
  40
  41 class GroupsTool(BaseTool, Cacheable) :
  42         """ Groups tool that behave like Membership tool """
  43
  44         meta_type = 'Plinn Groups Tool'
  45
  46         security = ClassSecurityInfo()
  47
  48         manage_options = BaseTool.manage_options + Cacheable.manage_options
  49
  50         security.declareProtected(AddGroups, 'getGroupWorkspacesCreationFlag')
  51
  52
  53         def _getUserNamesOfGroup(self, prefixed_group, no_recurse = 1) :
  54                 aclu = self.aq_inner.acl_users
  55                 allUsers = aclu.getPureUsers()
  56                 usersDict = {}
  57
  58                 # make a dictionary of users indexed by group
  59                 for user in allUsers :
  60                         for group in user.getGroups(no_recurse = no_recurse) :
  61                                 if not usersDict.has_key(group) :
  62                                         usersDict[group] = [user.id, ]
  63                                 else :
  64                                         usersDict[group].append(user.id)
  65                 return usersDict
  66
  67
  68
  69         security.declareProtected(ViewGroups, 'getUserNamesOfGroup')
  70         def getUserNamesOfGroup(self, prefixed_group, no_recurse = 1) :
  71                 """ Return users of groups"""
  72
  73                 if self.ZCacheable_isCachingEnabled() :
  74                         usersDict = self.ZCacheable_get(view_name=CACHE_USER_NAMES_OF_GROUP,
  75                                                                                         keywords={'no_recurse' : no_recurse},
  76                                                                                         default=None)
  77                         if usersDict is None :
  78                                 # load cache
  79                                 usersDict = self._getUserNamesOfGroup(prefixed_group, no_recurse = no_recurse)
  80                                 self.ZCacheable_set(usersDict,
  81                                                                         view_name=CACHE_USER_NAMES_OF_GROUP,
  82                                                                         keywords={'no_recurse' : no_recurse})
  83                 else :
  84                         usersDict = self._getUserNamesOfGroup(prefixed_group, no_recurse = no_recurse)
  85
  86                 return usersDict.get(prefixed_group, [])
  87
  88
  89         def _getGroupsOfGroup(self, prefixed_group) :
  90                 aclu = self.aq_inner.acl_users
  91
  92                 allGroups = aclu.getGroups()
  93                 groupsDict = {}
  94
  95                 # make a dictionary of users indexed by group
  96                 for group in allGroups :
  97                         for superGroup in group.getGroups(no_recurse=1) :
  98                                 if not groupsDict.has_key(superGroup) :
  99                                         groupsDict[superGroup] = [group.id, ]
 100                                 else :
 101                                         groupsDict[superGroup].append(group.id)
 102
 103                 return groupsDict
 104
 105
 106
 107         security.declareProtected(ViewGroups, 'getGroupsOfGroup')
 108         def getGroupsOfGroup(self, prefixed_group) :
 109                 """ Return groups of group """
 110                 if self.ZCacheable_isCachingEnabled() :
 111                         groupsDict = self.ZCacheable_get(view_name=CACHE_GROUPS_OF_GROUP, default=None)
 112
 113                         if groupsDict is None :
 114                                 # load cache
 115                                 groupsDict = self._getGroupsOfGroup(prefixed_group)
 116                                 self.ZCacheable_set(groupsDict, view_name=CACHE_GROUPS_OF_GROUP)
 117                 else :
 118                         groupsDict = self._getGroupsOfGroup(prefixed_group)
 119
 120                 return groupsDict.get(prefixed_group, [])
 121
 122         security.declareProtected(ViewGroups, 'getGroups')
 123         def getGroups(self, groups) :
 124                 """ Return wrapped groups """
 125                 wGroups = [ self.getGroupById(group) for group in groups ]
 126                 wGroups = filter(None, wGroups)
 127
 128                 wGroups.sort(_sortGroup)
 129                 return wGroups
 130
 131         security.declareProtected(ViewGroups, 'getOtherGroups')
 132         def getOtherGroups(self, groups) :
 133                 """ Return other wrapped groups """
 134                 aclu = self.aq_inner.acl_users
 135                 prefix = aclu.getGroupPrefix()
 136                 allGroupIds = aclu.getGroupNames()
 137
 138
 139                 prefixed = 0
 140                 wGroups = []
 141                 if groups :
 142                         if groups[0].startswith(prefix) :
 143                                 prefixed = 1
 144
 145
 146                         if prefixed :
 147                                 prefixLength = len(prefix)
 148                                 groups = [ group[prefixLength:] for group in groups ]
 149
 150                         for groupId in allGroupIds :
 151                                 if groupId not in groups :
 152                                         wGroups.append(self.getGroupById(groupId))
 153
 154                 else :
 155                         for groupId in allGroupIds :
 156                                 wGroups.append(self.getGroupById(groupId))
 157
 158
 159                 wGroups.sort(_sortGroup)
 160                 return wGroups
 161
 162
 163         def _getRootGroups(self) :
 164                 top_level_list = []
 165                 aclu = self.acl_users
 166                 allGroups = aclu.getGroups()
 167                 groupPrefix = aclu.getGroupPrefix()
 168
 169                 for group in allGroups :
 170                         if not group.getGroups(no_recurse = 1) :
 171                                 top_level_list.append(groupPrefix+group.id)
 172                 return top_level_list
 173
 174         security.declareProtected(ViewGroups, 'getRootGroups')
 175         def getRootGroups(self) :
 176                 """ return top level groups """
 177                 if self.ZCacheable_isCachingEnabled() :
 178                         rootGroups = self.ZCacheable_get(view_name=CACHE_ROOT_GROUPS, default=None)
 179
 180                         if rootGroups is None :
 181                                 rootGroups = self._getRootGroups()
 182                                 self.ZCacheable_set(rootGroups, view_name=CACHE_ROOT_GROUPS)
 183                 else :
 184                         rootGroups = self._getRootGroups()
 185
 186                 return rootGroups
 187
 188
 189         security.declareProtected(ViewGroups, 'getGroupsWithLocalRole')
 190         def getGroupsWithLocalRole(self, object, role) :
 191                 """ Return Groups with local role """
 192
 193                 aclu = self.aq_inner.acl_users
 194                 prefix = aclu.getGroupPrefix()
 195                 allGroupNames = aclu.getGroupNames()
 196                 usersAndGroupsWithLocalRole = object.users_with_local_role(role)
 197
 198                 return [ gn for gn in usersAndGroupsWithLocalRole if gn.startswith(prefix) ]
 199
 200
 201         security.declareProtected(AddGroups, 'addGroup')
 202         def addGroup(self, groupName, **mapping):
 203                 """ Create a group, and a group workspace if the toggle is on,
 204                         with the supplied id, roles, and domains.
 205                 """
 206                 self.acl_users.changeOrCreateGroups(new_groups = [groupName, ])
 207
 208                 group = self.getGroupById(groupName)
 209                 group.setGroupProperties(mapping)
 210
 211                 if mapping.get('createArea', None) :
 212                         self.createGrouparea(self.acl_users.getGroupPrefix()+groupName)
 213
 214                 if self.ZCacheable_isCachingEnabled() :
 215                         self.ZCacheable_set(None, view_name=CACHE_ROOT_GROUPS)
 216
 217
 218         security.declareProtected(AddGroups, 'createGrouparea')
 219         def createGrouparea(self, id):
 220                 """Create a space in the portal for the given group, much like member home
 221                 folders."""
 222
 223                 ttool = getToolByName(self, 'portal_types')
 224                 ti = ttool.getTypeInfo(self.getGroupWorkspaceContainerType())
 225
 226                 utool = getToolByName(self, 'portal_url')
 227                 portal = utool.getPortalObject()
 228                 workspaces = self.getGroupWorkspacesFolder()
 229                 if workspaces is None :
 230                         portalOwner = portal.getOwner()
 231                         aclu = self.aq_inner.acl_users
 232                         portalOwner = portalOwner.__of__(aclu)
 233                         workspaces = ti._constructInstance(portal,
 234                                                                                            self.getGroupWorkspacesFolderId(),
 235                                                                                            title=self.getGroupWorkspacesFolderTitle())
 236                         workspaces.manage_delLocalRoles(workspaces.users_with_local_role('Owner'))
 237                         workspaces.changeOwnership(portalOwner)
 238                         ti._finishConstruction(workspaces)
 239
 240
 241
 242                 # construct without security check
 243                 group = self.getGroupById(id)
 244                 area = ti._constructInstance(workspaces, id, title=group.getProperty('title', ''))
 245
 246                 area.manage_delLocalRoles(area.users_with_local_role('Owner'))
 247                 self.setGroupOwnership(group, area)
 248
 249                 ti._finishConstruction(area)
 250
 251
 252         security.declareProtected(DeleteGroups, 'removeGroups')
 253         def removeGroups(self, ids, keep_workspaces=0) :
 254                 """ remove the groups and invalidate cache """
 255                 BaseTool.removeGroups(self, ids, keep_workspaces=keep_workspaces)
 256                 if self.ZCacheable_isCachingEnabled() :
 257                         self.ZCacheable_set(None, view_name=CACHE_ROOT_GROUPS)
 258                         self.ZCacheable_set(None, view_name=CACHE_GROUPS_OF_GROUP)
 259
 260         security.declareProtected(ViewGroups, 'getExplAndImplGroupsByUserId')
 261         def getExplAndImplGroupsByUserId(self, userid) :
 262                 """ Return a dictionary with implicit and explicit wrapped groups """
 263                 aclu = self.aq_inner.acl_users
 264                 user = aclu.getUser(userid)
 265                 if user :
 266                         expl = Set(self.aq_inner.acl_users.getUser(userid).getGroups(no_recurse = 1) or [])
 267                         implDbl = Set(self.aq_inner.acl_users.getUser(userid).getGroups(no_recurse = 0) or [])
 268                         impl = implDbl.difference(expl)
 269                 # wrap
 270                 expl = [self.getGroupById(gid) for gid in expl]
 271                 impl = [self.getGroupById(gid) for gid in impl]
 272                 expl.sort(_sortGroup)
 273                 impl.sort(_sortGroup)
 274                 return {'explicit' : expl,
 275                                 'implicit' : impl}
 276
 277 InitializeClass(GroupsTool)
 278
 279
 280 def _sortGroup(a, b) :
 281         return cmp(a.id.lower(), b.id.lower())