Return to groups.py CVS log

Up to [Repository] / basket

major changes users and groups introduced

"""gruppenverwaltung fuer baskets, benutzer koennen verschiedenen gruppen zugeordnet werden"""

from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Globals import package_home
import os.path
from types import *

from AccessControl import SecurityManagement

class GroupFolder(Folder):
    """Folder which contains groups"""
    
    meta_type="GroupFolder"

    def registerNewUser(self,user,password,email,forward_to=None,RESPONSE=None):
        """register a new user to the system, username and password, will be stored in the acl_users folder,
        additional information are added here."""
        
        #TODO: check if user already exists in LDAP
        #print [x for x in repr(self.acl_users.getUserNames())]
        if user in repr(self.acl_users.getUserNames()):
            return "ERROR: username already exists"
        self.acl_users.addUser(user,password,email)

        add="user=%s"%user
        if forward_to.find("?")>-1:
            #already parameters
            add="&"+add
        else:
            add="?"+add
        
        if RESPONSE and forward_to:
            RESPONSE.redirect(forward_to+add)
            
    def isMemberOf(self,group):
        user=SecurityManagement.getSecurityManager().getUser()
        
        if user and not (str(user)=='Anonymous User'):
            return self.checkMembership(str(user), group)
        return False
    
    def addUsersToGroups(self,users,groups):
        """add users to groups
        @param users: list of usernames
        @param groups: list of groupnames
        """
        for user in users:
            self.addUserToGroups(user,groups)
        
        
    def addUserToGroups(self,user,groups):
        '''
        Add a user to a group
        @param user: username
        @param groups: list of groupnames
        '''
        
        #make sure that list of groups
        
        if type(groups) is not ListType:
            groups=[groups]
            
        groupObjects=self.ZopeFind(self,obj_ids=groups)
        #group doesn't exist, return with false
        if len(groupObjects)<1:
            return False
        
        #otherwise add user to group
        for groupObject in groupObjects:
            groupObject[1].addUser(user)
        
        return True
    
    def addGroupsToGroups(self,newGroups,groups):
        """
        add Groups to groups
        @param unewGroups: list of groups to be added
        @param groups: list of groupnames
        """
        
        for group in newGroups:
            self.addGroupToGroups(group,groups)
        
        
    def addGroupToGroups(self,group,groups):
        '''
        Add a user to a group
        @param user: username
        @param groups: list of groupnames
        '''
        
        #make sure that list of groups
        
        if type(groups) is not ListType:
            groups=[groups]
            
        groupObjects=self.ZopeFind(self,obj_ids=groups)
        #group doesn't exist, return with false
        if len(groupObjects)<1:
            return False
        
        #otherwise add user to group
        for groupObject in groupObjects:
            groupObject[1].addGroup(group)
        
        return True
    
    def checkMembership(self,user,group):
        '''Check if user is member of group
        
        @param user:
        @param group:
        '''
        
        groups=self.ZopeFind(self,obj_metatypes=['Group'],obj_ids=[group])
        #group doesn't exist
        
        if len(groups)<1:
            return False
        else:
            print "check",groups[0][0],user,groups[0][1].aq_parent.aq_parent.getId()
            return groups[0][1].isInGroup(user)
        
    def returnUsers(self):
        """return all users of groups"""
        
        users={}
        for group in self.ZopeFind(self,obj_metatypes=['Group']):
            for user in group[1].getUsers():
                if users.has_key(user):
                    users[user].append(group[0])
                else:
                    users[user]=[group[0]]
        
        return users
    
def manage_addGroupFolderForm(self):
    """form for adding a groupFolder"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addGroupFolder.zpt')).__of__(self)
    return pt()

def manage_addGroupFolder(self,id,RESPONSE=None):
    """add a group folder object"""

  
    newObj=GroupFolder(id)
    
    self._setObject(id,newObj)
    ob=self._getOb(id)
    
    
    #group folder always contains admin,editor,user
     
    manage_addGroup(ob,'admin') 
    manage_addGroup(ob,'editor') 
    manage_addGroup(ob,'user') 
    
    #actual user is always editor and admin
    user=str(self.REQUEST['AUTHENTICATED_USER'])
    
    ob.addUsersToGroups([user],['admin','editor'])
    
    #admin of supergrous are always admins of subgroups
    
    ob.addGroupsToGroups(['admin'],['admin'])
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
     

class Group(SimpleItem):
    """Group"""

    meta_type="Group"
    
    def __init__(self,id,description):
        """init group"""
        self.id=id
        self.description=description
        self.userList=[]
        self.groupList=[]
        
    def addUser(self,username):
        '''
        add an username to the group        
        @param username:username
        '''
        #make sure that entry is persistent
        list=self.userList
        list.append(username)
        self.userList=list[0:]
        
    def addGroup(self,group):
        '''
        add a group to the group
        @param group: group to be added
        '''
        #make sure that entry is persistent
        list=self.groupList
        list.append(group)
        self.groupList=list[0:]
        
        
    def getGroups(self):
        """get groups, whose members are automatically members of this group"""
        return self.groupList
    
    def getUsers(self):
        """ get Userlist """
        return self.userList
    
    def isInGroup(self,username):
        '''
        check if username is in group
        @param username: username
        '''
        
        #special handling of group 'user' all users are in user
        
        #TODO: only user which can log in are in 'user'
        if self.id=="user":
            return True
        
        #check first if user is in userList of this group
        print self.userList, username
        if username in self.userList:
            return True
        
        #check now if user is member of one of the groups in grouplist
        
        groupFolders=self.ZopeFind(self.aq_parent,obj_metatypes=['GroupFolder'])
        #no groupFolder im parent
        
        if len(groupFolders)<1:
            return False
        
        #checke all groups in grouplist
        for group in self.ZopeFind(groupFolders[0][1],obj_metatype=['Group'],obj_ids=[self.groupList]):
            if group[1].isInGroup(username):
                return True
        
        return False
        

        
def manage_addGroupForm(self):
    """form for adding a groupFolder"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addGroup.zpt')).__of__(self)
    return pt()

def manage_addGroup(self,id,description='',RESPONSE=None):
    """add a group folder object"""

    
    newObj=Group(id,description)
    
    self._setObject(id,newObj)
    ob=self._getOb(id)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')