def _domainmanageresponder(request, page_num=None, adict={}): ''' This method provides a mechanism for and admin user to manage domains. The decorator ensures that the user is an admin before proceeding. The page lists a paginated view of current domains. add allows the admin to add more domains ''' # Create model instance model = AdminModel() # default mode mode ='add' # Get all the domains in the # system that are not admins domains = list(model.getalldomains()) # Set page based on passed in number or session page = page_num or request.session.get('d_page',1) # Set the page number in the session request.session['d_page'] = page # Get collection and current page dcollection, domains_page = paginatorwrapper(domains, page, per_page=items_per_page, orphans=1) # The template vars info_dict = {'domains':domains_page, 'collection': dcollection, 'page':'dmanage', 'mode':mode, 'thistemplate':thistemplate} # update the template vars info_dict.update(adict) return render_to_response('admin/domainmanage.html', info_dict, context_instance=RequestContext(request))
class GroupAdd(forms.Form): def __init__(self, groupname=None, kargs=None): super(GroupAdd,self).__init__(kargs) self.extras = {} self.model = AdminModel() # Get all available domains domains = self.model.getalldomains() if domains: self.fields['domain'].choices = [domain.domainname for domain in domains] aliases = self.model.getallaliases() if aliases: self.fields['alias'].others = [alias.aliasname for alias in aliases] self.fields['alias'].exclude = groupname alias = UniqueField(label="aliases", required=True, max_length=64, others=[], exclude=None, b_spaces=False) domain = MultipleOptionField(label="Domain", required=True, choices=[], b_spaces=False) notes = forms.CharField(label="notes", required=False) def clean_alias(self): cleaned_data = super(GroupAdd, self).clean() try: alias = cleaned_data['alias'] except KeyError: pass else: if not _validlocalpart (alias): raise forms.ValidationError('Please enter a valid group.' ) return alias
def domainedit(request, domain_name): ''' This method edits an existing domain of the system. it fills the form with the domain details and then awaits posted data from the user, validates said data, and if and error occurs uses the responder to display them to the user. A succesfull post will update the domain using the viewdb function and redirect to avoid post problems ''' # Create model instance model = AdminModel() # Set the mode mode ="edit" # Retrieve the requested user. request_domain = model.getdomain( domain_name) # If there was no user in the db with this name or # the function has thrown an error, we have been # given bogus input data if (request_domain and not request_domain.domainname) or (not request_domain and model.error): # Raise user has not be found raise Http404 # Check we have posted data if request.method =="POST": # copy posted data new_data = request.POST.copy() # remove whitespaces removewhitespace(new_data) # bind form instance form = DomainEdit(request_domain.domainname, kargs=new_data) # Ensure for is valid if form.is_valid(): # Clean the data cleaned_data = form.cleaned_data # create function parameter list params = {'mode': 2, # edit 'domainname': request_domain.domainname, 'newdomainname': cleaned_data['domain']} # call managedomain in edit mode domainedited = model.managedomain(params) # Ensure no errors have occured if not domainedited and model.error: # if we have errors display them errors = {'form':form, 'new_data':new_data, 'requestdomain':request_domain, 'mode':mode, 'dberror':model.error} # Use the responder return _usermanageresponder(request, adict=errors) # Redirect to avoid post problems return HttpResponseRedirect (urlrel + 'admin/domain/manage/') # If not valid call responder with error else: errors = {'form':form, 'new_data':new_data, 'mode':mode, 'requestdomain':request_domain} return _domainmanageresponder(request, adict=errors) return _domainmanageresponder(request, adict={'requestdomain':request_domain, 'mode':mode})
def useradd(request): ''' This method adds a user into the system. It awaits posted data from the user, validates said data, and if and error occurs uses the responder to display them to the user. A succesfull post will create the user using the viewdb function and redirect to avoid post problems ''' # Create model instance model = AdminModel() # Set the mode mode ="add" # Check we have posted data if request.method == "POST": # copy posted data new_data = request.POST.copy() # Strip strings of leading/preceding whitespace removewhitespace(new_data) # bind form instance form = UserAdd(new_data) # Ensure for is valid if form.is_valid(): # Standardized data cleaned_data = form.cleaned_data # Create the parameters params = {'mode': 1, 'userid': cleaned_data['userid'], 'password': cleaned_data['password'], 'home': mailstore_home % cleaned_data['userid'], 'domain': cleaned_data['domain'], 'uid': user_uid, 'gid': user_gid, 'status': 1, 'typer': cleaned_data['typer'].capitalize(), 'role': cleaned_data['role'], 'fullname': cleaned_data['fullname'], 'notes': cleaned_data['notes'] } # add the user useradded = model.manageuser(params) # Ensure there was no error if not useradded or model.error: # If there was an error, display it to the user errors = {'form':form, 'new_data':new_data, 'mode':mode, 'dberror':model.error} # Use the responder to show. return _usermanageresponder(request, adict=errors) # If not valid call responder with error else: # This gets rendered if the form entries were incorrect errors = {'form':form, 'new_data':new_data, 'mode':mode} return _usermanageresponder(request, adict=errors) return HttpResponseRedirect (urlrel + 'admin/user/manage/')
def _gen_pass(length=8, chars=string.letters + string.digits): # Create model instance model = AdminModel() # Assume the password exists exists = True password = None while exists: # Create a 8 alphanumberic code password = ''.join([ choice(chars) for i in range(length) ]) exists = model.checkpass(password) return password
def domainadd(request): ''' This method adds a domain into the system. It awaits posted data from the user, validates said data, and if and error occurs uses the responder to display them to the user. A succesfull post will create the domain using the viewdb function and redirect to avoid post problems ''' # Create model instance model = AdminModel() # Set the mode mode ="add" # Check we have posted data if request.method =="POST": # copy posted data new_data = request.POST.copy() # Remove white space removewhitespace(new_data) # bind form instance form = DomainAdd(new_data) # Ensure for is valid if form.is_valid(): # Get standardized data cleaned_data = form.cleaned_data # Set up for add mode. params = {'mode': 1, 'domainname': cleaned_data['domain'], 'newdomainname': None, } # Add domain domainadded = model.managedomain(params) # Make sure no errors occured. if not domainadded and model.error: errors = {'form':form, 'new_data':new_data, 'mode':mode, 'dberror':model.error } return _domainmanageresponder(request, adict=errors) # If not valid call responder with error else: errors = {'form':form,'new_data':new_data, 'mode':mode} return _domainmanageresponder(request, adict=errors) return HttpResponseRedirect (urlrel + 'admin/domain/manage/')
def userunhide(request, userid, domain): ''' This method un-hides a user from the system by setting said user's status equal to 1. This will ensure that this person can login to the system. ''' # Create model instance model = AdminModel() # Retrieve the requested user. request_user = model.getuser(userid, domain) # If there was no user in the db with this name or the function has thrown # an error, we have been given bogus input data if (request_user and not request_user.userid) or (not request_user and model.error): # Raise user has not be found raise Http404 # Set up for unhide params = {'mode': 5, 'userid': request_user.userid, 'password': None, 'home': None, 'domain': request_user.domain, 'uid': None, 'gid': None, 'status': 1, 'typer': None, 'role': None, 'fullname': None, 'notes':None } #re-enable user userunhidden = model.manageuser(params) # Make sure no errors have occured. if not userunhidden and model.error: errors = {'mode':'add', 'requestuser':request_user } return _usermanageresponder(request, adict=errors) return HttpResponseRedirect (urlrel + 'admin/user/manage/')
def _usermanageresponder(request, page_num=None, adict={}): ''' This method provides a mechanism for and admin user to mange people. The decorator ensures that the user is an admin before proceeding. The page lists a paginated view of current users. add allows the admin to add more users ''' # Create model instance model = AdminModel() # default mode mode ='add' # Get all the users in the # system that are not admins users = list(model.getallusers()) # Set page based on passed in number or session page = page_num or request.session.get('u_page',1) # Set the page number in the session request.session['u_page'] = page # Defaults ucollection, users_page = paginatorwrapper(users, page, per_page=items_per_page, orphans=1) # Get all available domains domains = list(model.getalldomains()) # Generate a password generated_pass = _gen_pass() # The template vars info_dict = {'users':users_page, 'collection': ucollection, 'domains':domains, 'page':'umanage', 'gen_pass':generated_pass, 'mode':mode, 'types':types, 'thistemplate':thistemplate} # update the template vars info_dict.update(adict) return render_to_response('admin/usermanage.html', info_dict, context_instance=RequestContext(request))
def __init__(self, groupname=None, kargs=None): super(GroupAdd,self).__init__(kargs) self.extras = {} self.model = AdminModel() # Get all available domains domains = self.model.getalldomains() if domains: self.fields['domain'].choices = [domain.domainname for domain in domains] aliases = self.model.getallaliases() if aliases: self.fields['alias'].others = [alias.aliasname for alias in aliases] self.fields['alias'].exclude = groupname
def groupdelete(request, alias, domain): ''' This method deletes an existing group of the system. This will cause a cascading effect in the database, where by users of the group will be removed as well. ''' # Create model instance model = AdminModel() # Set the mode mode ="add" # Retrieve the requested alias. request_alias = model.getalias(alias,domain) # Retrieve the requested alias users. request_users = model.getaliasusers(alias,domain) # If there was no alias in the db with this name or # the function has thrown an error, we have been # given bogus input data if (request_alias and not request_alias.aliasname) or (not request_alias and model.error): # Raise domain has not be found raise Http404 else: params = {'mode': 3, 'alias': request_alias.aliasname, 'domain': request_alias.domainname, 'new_alias': None, 'notes':None } aliasdeleted = model.managealias(params) # Ensure no errors have occured if not aliasdeleted and model.error: errors = {'requestalias':request_alias, 'mode':mode, 'requestusers':request_users, 'dberror':model.error } return _groupmanageresponder(request, adict=errors) # Redirect to avoid post problems return HttpResponseRedirect (urlrel + 'admin/group/manage/')
def getaliasusers(request, domain_name): ''' This method gets all the users associated to particular domain. It is used as an ajax call on the group management page. There reason for this is that only users of the domain associated to the alias can be selected. This is is not known ahead of time and is hence done dynamically. ''' # Make model instance model = AdminModel() # Get the domain to see if it is valid domain = model.getdomain(domain_name) # Is it a valid domain is_domain = False # Check valid domain if domain and domain.domainname and not model.error: is_domain = True domain_users = DomainUsers(domain_name, model.getnondisabledusers(domain_name)) # Default new_data values new_data = None if request.method == "POST": new_data = request.POST.copy() try: users_string = new_data['users'] except KeyError: new_data = None else: new_data.update({'users':users_string.split(',')}) return render_to_response('admin/aliasusers.html', {'domain_users':domain_users, 'new_data':new_data, 'is_domain':is_domain}, context_instance=RequestContext(request))
def domaindelete(request, domain_name): ''' This method deletes an existing domain of the system. This can only occur if not people are referencing the domain. If the domain is being referenced the user can not delete the domain ''' # Create model instance model = AdminModel() # Set the mode mode ="add" # Retrieve the requested domain. request_domain = model.getdomain(domain_name) # If there was no domain in the db with this name or the function has # thrown an error, we have been given bogus input data if (request_domain and not request_domain.domainname) or (not request_domain and model.error): # Raise domain has not be found raise Http404 # Set up for delete params = {'mode': 3, 'domainname': request_domain.domainname, 'newdomainname':None, } # Delete domain domaindeleted = model.managedomain(params) # Ensure no errors have occured if not domaindeleted and model.error: errors = {'requestdomain':request_domain, 'mode':mode, 'deleteerror':model.error } return _domainmanageresponder(request, adict=errors) # Redirect to avoid post problems return HttpResponseRedirect (urlrel + 'admin/domain/manage/')
class DomainEdit(forms.Form): def __init__(self, domain_name, kargs=None): super(DomainEdit,self).__init__(kargs) self.model = AdminModel() self.fields['domain'].others = [domain.domainname for domain in self.model.getalldomains()] self.fields['domain'].exclude = domain_name domain = UniqueField(label="Domain", required=True, max_length=128, others=[], b_spaces=False) def clean_domain (self): cleaned_data = super(DomainEdit, self).clean() try: domain = cleaned_data['domain'] except KeyError: pass else: if not _validdomain (domain): raise forms.ValidationError('Please enter a valid domain.' ) return domain
def setUp(self): # Get connection singleton connection = CLWConnection(test_db_host, test_db_name, test_db_user, test_db_pass) # Create a new cursor object. cursor = connection.cursor() params = {'mode': 1, 'domainname': 'example.co.uk', 'newdomainname': None, } self.adminmodel = AdminModel() self.authmodel = AuthModel() self.mailmodel = MailModel() self.eximmodel = EximModel() domainadded = self.adminmodel.managedomain(params) # Create a user params = {'mode': 1, 'userid': 'test.a', 'password': '******', 'home': '/home/mailstore/', 'domain': 'example.co.uk', 'uid': 1001, 'gid': 1001, 'status': 1, 'typer':'Person', 'role':"", 'fullname':'Test User', 'notes':None } # add the user useradded = self.adminmodel.manageuser(params) # Check user added self.assertNotEqual(useradded, False)
class MailTestCase(unittest.TestCase): def setUp(self): # Get connection singleton connection = CLWConnection(test_db_host, test_db_name, test_db_user, test_db_pass) # Create a new cursor object. cursor = connection.cursor() params = {'mode': 1, 'domainname': 'example.co.uk', 'newdomainname': None, } self.adminmodel = AdminModel() self.authmodel = AuthModel() self.mailmodel = MailModel() self.eximmodel = EximModel() domainadded = self.adminmodel.managedomain(params) # Create a user params = {'mode': 1, 'userid': 'test.a', 'password': '******', 'home': '/home/mailstore/', 'domain': 'example.co.uk', 'uid': 1001, 'gid': 1001, 'status': 1, 'typer':'Person', 'role':"", 'fullname':'Test User', 'notes':None } # add the user useradded = self.adminmodel.manageuser(params) # Check user added self.assertNotEqual(useradded, False) def test_auth(self): # Check login user = self.authmodel.login('*****@*****.**', 'password') # check user returned self.assertEqual(user.userid, 'test.a') # Check not working user = self.authmodel.login('*****@*****.**', 'password') self.assertEqual(user.userid, None) def test_usermanage(self): # Create a user params = {'mode': 1, 'userid': 'test.b', 'password': '******', 'home': '/home/mailstore/', 'domain': 'example.co.uk', 'uid': 1001, 'gid': 1001, 'status': 1, 'typer':'Person', 'role':"Architect", 'fullname':'Test User', 'notes':"here are some notes" } # add the user useradded = self.adminmodel.manageuser(params) # Check user added self.assertNotEqual(useradded, False) # add the user useradded = self.adminmodel.manageuser(params) user = self.adminmodel.getuser('test.b', 'example.co.uk') self.assertNotEqual(user, None) self.assertEqual(user.password,'password') self.assertEqual(user.userid,'test.b') self.assertEqual(user.domain,'example.co.uk') self.assertEqual(user.status,1) self.assertEqual(user.typer,'Person') self.assertEqual(user.uid,1001) self.assertEqual(user.gid,1001) self.assertEqual(user.role,'Architect') self.assertEqual(user.notes,'here are some notes') # Edit a user params = {'mode': 2, 'userid': 'test.b', 'password': '******', 'home': '/home/mailstore/', 'domain': 'example.co.uk', 'uid': 1001, 'gid': 1001, 'status': 1, 'typer':'Person', 'role':"Architect", 'fullname':'Test User edited', 'notes':"here are some notes" } # edit the user useredited = self.adminmodel.manageuser(params) # Check user edited self.assertNotEqual(useredited, False) user = self.adminmodel.getuser('test.b', 'example.co.uk') self.assertNotEqual(user, None) self.assertEqual(user.password,'changedpass') self.assertEqual(user.fullname,'Test User edited') #hide a user params = {'mode': 4, 'userid': 'test.b', 'password': None, 'home': None, 'domain':'example.co.uk', 'uid': None, 'gid': None, 'status': 9, 'typer':None, 'role':None, 'fullname':None, 'notes':None } # edit the user userhidden = self.adminmodel.manageuser(params) # Check user edited self.assertNotEqual(userhidden, False) user = self.adminmodel.getuser('test.b', 'example.co.uk') self.assertNotEqual(user, None) self.assertEqual(user.status,9) # delete a user params = {'mode': 3, 'userid': 'test.b', 'password': None, 'home': None, 'domain': 'example.co.uk', 'uid': None, 'gid': None, 'status': 9, 'typer':None, 'role':None, 'fullname':None, 'notes':None } # delete the user userdeleted = self.adminmodel.manageuser(params) self.assertNotEqual(userdeleted, False) user = self.adminmodel.getuser('test.b', 'example.co.uk') self.assertEqual(user.userid, None) def test_goupmanage(self): # Create a group params = {'mode': 1, 'alias': 'agroup', 'domain': 'example.co.uk', 'new_alias': None, 'notes':"test" } # try add the group groupadded = self.adminmodel.managealias(params) # Check group was added self.assertEqual(groupadded, True) params = {'mode':1, # add alias users 'alias':'agroup', 'userid':'test.a', 'domain':'example.co.uk' } # check added user to alias aliasuseradded = self.adminmodel.managealiasuser(params) self.assertEqual(aliasuseradded, True) # Retrieve info alias = self.adminmodel.getalias('agroup', 'example.co.uk') self.assertNotEqual(alias, None) self.assertEqual(alias.aliasname,'agroup') self.assertEqual(alias.notes,'test') users = self.adminmodel.getaliasusers('agroup','example.co.uk') self.assertNotEqual(users, None) users = list(users) self.assertEqual(len(users),1) user = users[0] self.assertEqual(user.username,'*****@*****.**') # create function parameter list params = {'mode': 2, 'alias': 'agroup', 'domain': 'example.co.uk', 'new_alias': 'bgroup', 'notes': None } # edit the group groupedited = self.adminmodel.managealias(params) # Check alias edited self.assertNotEqual(groupedited, False) alias = self.adminmodel.getalias('bgroup', 'example.co.uk') self.assertNotEqual(alias, None) self.assertEqual(alias.aliasname,'bgroup') self.assertEqual(alias.notes,None) users = self.adminmodel.getaliasusers('bgroup','example.co.uk') self.assertNotEqual(users, None) users = list(users) self.assertEqual(len(users),1) user = users[0] self.assertEqual(user.username,'*****@*****.**') # create function parameter list params = {'mode': 3, 'alias': 'bgroup', 'domain': 'example.co.uk', 'new_alias': None, 'notes':None } # delete the group groupdeleted = self.adminmodel.managealias(params) # Check user edited self.assertNotEqual(groupdeleted, False) # Ensure there was a cascding delete of alias users users = self.adminmodel.getaliasusers('bgroup','example.co.uk') self.assertEqual(users, None) def test_domainmanage(self): # Create a domain params = {'mode': 1, 'domainname': 'HOPKINS.CO.UK', 'newdomainname': None, } # try add the domain domainadded = self.adminmodel.managedomain(params) # Check domain was NOT added self.assertEqual(domainadded, False) self.assertEqual(self.adminmodel.error, "This domain already exists\n") # Create a domain params = {'mode': 1, 'domainname': 'otherdomain.com', 'newdomainname': None, } # try add the domain domainadded = self.adminmodel.managedomain(params) # Check domain was added self.assertEqual(domainadded, True) # Get the domain request_domain = self.adminmodel.getdomain('otherdomain.com') self.assertEqual(request_domain.domainname, 'otherdomain.com') params = {'mode': 2, 'domainname': 'example.co.uk', 'newdomainname': 'newexample.co.uk', } # check edited domain domainedited = self.adminmodel.managedomain(params) self.assertEqual(domainedited, True) # Get the domain request_domain = self.adminmodel.getdomain('newexample.co.uk') self.assertEqual(request_domain.domainname, 'newexample.co.uk') # Check changed reflected in users user = self.adminmodel.getuser('test.a', 'newexample.co.uk') self.assertNotEqual(user, None) self.assertEqual(user.domain, 'newexample.co.uk') self.assertEqual(user.userid, 'test.a') # Delete a domain params = {'mode': 3, 'domainname': 'otherdomain.com', 'newdomainname': None, } # try delete the domain domaindeleted = self.adminmodel.managedomain(params) # Check domain was deleted self.assertEqual(domaindeleted, True) # Get the domain request_domain = self.adminmodel.getdomain('otherdomain.com') self.assertEqual(request_domain.domainname, None) # try delete domain with reference to user params = {'mode': 3, 'domainname': 'newexample.co.uk', 'newdomainname': None, } # try delete the domain domaindeleted = self.adminmodel.managedomain(params) # Check domain was Not deleted self.assertEqual(domaindeleted, False) self.assertEqual(self.adminmodel.error, "This domain is referenced by users of the system and cannot be deleted.\n") # Get the domain request_domain = self.adminmodel.getdomain('newexample.co.uk') self.assertNotEqual(request_domain, None) def test_holidaymanage(self): #Add holiday param_dict = {'mode':1, 'username':'******', 'domain':'example.co.uk', 'hstart':'2008-01-01 09:00:00', 'hend':'2008-01-10 09:00:00', 'message':"The holiday message", 'id':-1, 'b_default':False} result = self.mailmodel.manageholiday(**param_dict) self.assertNotEqual(result, None) holidays = self.mailmodel.getuserholidays( 'test.a', 'example.co.uk') self.assertNotEqual(holidays, None) holidays = list(holidays) self.assertEqual(len(holidays), 1) holiday = holidays[0] self.assertEqual(holiday.holstart.year,2008) self.assertEqual(holiday.holstart.month,1) self.assertEqual(holiday.holstart.day,1) self.assertEqual(holiday.holstart.hour,9) self.assertEqual(holiday.holstart.minute,0) self.assertEqual(holiday.holend.year,2008) self.assertEqual(holiday.holend.month,1) self.assertEqual(holiday.holend.day,10) self.assertEqual(holiday.holend.hour,9) self.assertEqual(holiday.holend.minute,0) self.assertEqual(holiday.holmsg,'The holiday message') #Edit holiday param_dict = {'mode':2, 'username':'******', 'domain':'example.co.uk', 'hstart':'2008-01-01 10:00:00', 'hend':'2008-01-10 09:00:00', 'message':"The edit message", 'id':holiday.holid, 'b_default':False} result = self.mailmodel.manageholiday(**param_dict) self.assertNotEqual(result, None) holidays = self.mailmodel.getuserholidays( 'test.a', 'example.co.uk') self.assertNotEqual(holidays, None) holidays = list(holidays) self.assertEqual(len(holidays), 1) holiday = holidays[0] self.assertEqual(holiday.holstart.year,2008) self.assertEqual(holiday.holstart.month,1) self.assertEqual(holiday.holstart.day,1) self.assertEqual(holiday.holstart.hour,10) self.assertEqual(holiday.holstart.minute,0) self.assertEqual(holiday.holmsg,'The edit message') #Delete holiday param_dict = {'mode':3, 'username':'******', 'domain':'example.co.uk', 'hstart':None, 'hend':None, 'message':None, 'id':holiday.holid, 'b_default': None} result = self.mailmodel.manageholiday(**param_dict) self.assertNotEqual(result, None) holidays = self.mailmodel.getuserholidays( 'test.a', 'example.co.uk') self.assertEqual(holidays, None) # Check setting of holdiday to current now = datetime.now() tendays = now + timedelta (days =10) #Add holiday param_dict = {'mode':1, 'username':'******', 'domain':'example.co.uk', 'hstart':now, 'hend':tendays, 'message':"current message", 'id':-1, 'b_default':False} result = self.mailmodel.manageholiday(**param_dict) self.assertNotEqual(result, None) b_holset = self.eximmodel.setholidays() self.assertEqual(b_holset, 1) holmessage = self.mailmodel.getcurrentholiday('test.a','example.co.uk') self.assertNotEqual(holmessage, None) self.assertEqual(holmessage.message, 'current message') # Remove current holiday param_dict = {'mode':2, 'username':'******', 'domain':'example.co.uk', 'hstart':None, 'hend':None, 'message':None, 'id':None} result = self.mailmodel.removeleave(**param_dict) user = self.adminmodel.getuser('test.a', 'example.co.uk') self.assertNotEqual(user, None) self.assertEqual(user.status,1) # Test leaver # Create a user params = {'mode': 1, 'userid': 'leaver', 'password': '******', 'home': '/home/mailstore/', 'domain': 'example.co.uk', 'uid': 1001, 'gid': 1001, 'status': 1, 'typer':'Person', 'role':"", 'fullname':'Leaver', 'notes':None } # add the user useradded = self.adminmodel.manageuser(params) # Check user added self.assertNotEqual(useradded, False) # set user to leaver params = {'mode': 1, 'userid': 'leaver', 'domain': 'example.co.uk', 'leavedate': now, 'message': 'This person has left' } result = self.eximmodel.manageleaver(params) self.assertNotEqual(result, None) message = self.eximmodel.getleavermessage('leaver','example.co.uk') self.assertNotEqual(message,None) self.assertEqual(message,'This person has left') # unset user to leaver params = {'mode': 2, 'userid': 'leaver', 'domain': 'example.co.uk', 'leavedate':None, 'message':None } result = self.eximmodel.manageleaver(params) self.assertNotEqual(result, None) # Check changed reflected in users user = self.adminmodel.getuser('test.a', 'example.co.uk') self.assertNotEqual(result, None) self.assertEqual(user.status,1) def test_exim(self): ''' This test case ensures that the exim functions used are working properly''' active_user = self.eximmodel.getactiveuser('test.a','example.co.uk') self.assertNotEqual(active_user, None) self.assertEqual(active_user.userid,'test.a') holiday_user = self.eximmodel.getactiveuser('test.a','example.co.uk') self.assertNotEqual(holiday_user, None) self.assertEqual(holiday_user.userid,'test.a') now = datetime.now() tendays = now + timedelta (days =10) #Add holiday param_dict = {'mode':1, 'username':'******', 'domain':'example.co.uk', 'hstart':now, 'hend':tendays, 'message':"current message", 'id':-1, 'b_default':False} result = self.mailmodel.manageholiday(**param_dict) self.assertNotEqual(result, None) b_holset = self.eximmodel.setholidays() self.assertEqual(b_holset, 1) # unset user to leaver params = {'mode': 1, 'userid': 'test.a', 'domain': 'example.co.uk', 'leavedate':now, 'message':"leaving" } result = self.eximmodel.manageleaver(params) self.assertNotEqual(result, None) leave_user = self.eximmodel.getleaveruser('test.a','example.co.uk') self.assertNotEqual(leave_user, None) self.assertEqual(leave_user.userid,'test.a') params = {'userid': 'test.a', 'domain': 'example.co.uk'} result = self.eximmodel.manageactiveusers(params) self.assertNotEqual(result, None) active_user = self.adminmodel.getuser('test.a','example.co.uk') self.assertNotEqual(active_user, None) self.assertEqual(active_user.status,1) def tearDown(self): query = "DELETE FROM users;" self.adminmodel.executequery(query) query = "DELETE FROM domains;" self.adminmodel.executequery(query)
class UserAdd(forms.Form): def __init__(self, kargs=None): super(UserAdd,self).__init__(kargs) self.model = AdminModel() self.extras = {} self.fields['domain'].choices = [domain.domainname for domain in self.model.getalldomains()] self.fields['typer'].choices = [typer for typer in types] fullname = forms.CharField(label="fullname", max_length=32, min_length=3, required=True) userid = forms.CharField(label="userid", max_length=64, min_length=1, required=True) password = forms.CharField(label="password", max_length=64, required=True) role = forms.CharField(label="role", max_length=64, required=False) domain = MultipleOptionField(label="Domain", required=True, choices=[], b_spaces = False) typer = MultipleOptionField(label="type", required=True, choices=[]) notes = forms.CharField(label="notes", required=False) def clean_userid (self): cleaned_data = super(UserAdd, self).clean() try: userid = cleaned_data['userid'] except KeyError: pass else: if _hasspaces (userid): raise forms.ValidationError('This field cannot contain spaces.' ) if not _validlocalpart (userid): raise forms.ValidationError('Please enter a valid userid.' ) return userid def clean(self): cleaned_data = super(UserAdd, self).clean() try: value = cleaned_data['userid'] except KeyError: pass else: if _validascii(value): self.checkusername(cleaned_data) # If any errors were picked up raise a validation error so that # the form does not validate. if self.extras: # This error message is generic as the only purpose is to # raise *an* error. raise forms.ValidationError('General Form Errors have occured.') return cleaned_data def _createError(self,key,error_message): errorList = ErrorList() errorList.append(error_message) self.extras[key] = errorList def checkusername(self, cleaned_data): try: userid = cleaned_data['userid'] domain = cleaned_data['domain'] except KeyError: # we dont worry about # key error as it implies and error # has already been caught elsewhere pass else: user = self.model.getuser(userid, domain) if user and user.userid: self._createError('userid','This user already exists.')
def groupedit(request, alias, domain): ''' This method edits an existing alias of the system. it fills the form with the alias details and then awaits posted data from the user, validates said data, and if and error occurs uses the responder to display them to the user. A succesfull post will update the alias using the viewdb function and redirect to avoid post problems ''' # Create model instance model = AdminModel() # Set the mode mode ="edit" # Retrieve the requested alias. request_alias = model.getalias(alias, domain) # If there was no user in the db with this name or # the function has thrown an error, we have been # given bogus input data if ((request_alias and not request_alias.aliasname) or (not request_alias and model.error)): # Raise alias has not be found raise Http404 else: # Retrieve current alias users aliasusers = model.getaliasusers(alias, domain) # a list of users # associated to the domain of the alias domain_users = DomainUsers(domain, model.getnondisabledusers(domain)) request_users =[] if aliasusers: request_users = [user.username for user in model.getaliasusers(alias, domain)] # Check we have posted data if request.method =="POST": # copy posted data new_data = request.POST.copy() # The selected users users = request.POST.getlist('users') # Update post dict new_data.update({'users':users}) # bind form instance form = GroupEdit(groupname=request_alias.aliasname, kargs=new_data) # Ensure for is valid if form.is_valid(): # Clean the data cleaned_data = form.clean() # create function parameter list params = {'mode': 2, 'alias': request_alias.aliasname, 'domain': cleaned_data['domain'], 'new_alias': cleaned_data['alias'], 'notes': cleaned_data['notes'] } # call managealias in edit mode groupedited = model.managealias(params) # Ensure no errors have occured if not groupedited and model.error: errors = {'form':form, 'new_data':new_data, 'requestalias':request_alias, 'mode':mode, 'requestusers':request_users, 'domain_users':domain_users, 'dberror':model.error } return _groupmanageresponder(request, adict=errors) # Once the alias has been edit, # we update the selected users # Start by deleteing the previous alias users if request_users: for user in request_users: # Split the string of usernames # These need to be usernames as that # is the only unique constraint in the db userid, domain = user.split('@') # All previously selected users params = {'mode':3, # add alias users 'alias':cleaned_data['alias'], 'userid':userid, 'domain':domain } aliasuserdeleted = model.managealiasuser(params) if not aliasuserdeleted and model.error: errors = {'form':form, 'new_data':new_data, 'mode':mode, 'dberror':model.error, 'domain_users':domain_users, 'requestusers':request_users} return _groupmanageresponder(request, adict=errors) # Add new users if users: for user in users: # Split the string of usernames # These need to be usernames as that # is the only unique constraint in the db userid, domain = user.split('@') # All previously selected users params = {'mode':1, # add alias users 'alias':cleaned_data['alias'], 'userid':userid, 'domain':domain } aliasuseradded = model.managealiasuser(params) if not aliasuseradded and model.error: errors = {'form':form, 'new_data':new_data, 'mode':mode, 'dberror':model.error, 'domain_users':domain_users, 'requestusers':request_users} return _groupmanageresponder(request, adict=errors) # Redirect to avoid post problems return HttpResponseRedirect (urlrel + 'admin/group/manage/') # If not valid call responder with error else: errors = {'form':form,'new_data':new_data, 'mode':mode, 'requestalias':request_alias, 'domain_users':domain_users, 'requestusers':request_users} return _groupmanageresponder(request, adict=errors) return _groupmanageresponder(request, adict= {'requestalias':request_alias, 'requestusers':request_users, 'domain_users':domain_users, 'mode': mode}) return HttpResponseRedirect(urlrel + 'admin/group/manage/')
def groupadd(request): ''' This method adds a group into the system. It awaits posted data from the user, validates said data, and if and error occurs uses the responder to display them to the user. A succesfull post will create the group using the viewdb function and redirect to avoid post problems ''' # Create model instance model = AdminModel() # Set the mode mode ="add" # Check we have posted data if request.method =="POST": # copy posted data new_data = request.POST.copy() # The selected users users = [str(user) for user in request.POST.getlist('users')] # Update the post dict new_data.update({'users':users}) # remove white spaces removewhitespace(new_data) # bind form instance form = GroupAdd(kargs=new_data) # Ensure for is valid if form.is_valid(): # get standardized data cleaned_data = form.cleaned_data # Set up for add mode params = {'mode': 1, 'alias': cleaned_data['alias'], 'domain': cleaned_data['domain'], 'new_alias': None, 'notes': cleaned_data['notes'] } # Add alias aliasadded = model.managealias(params) # Ensure not errors have occured if not aliasadded and model.error: # Create a new template context errors = {'form':form, 'new_data':new_data, 'mode':mode, 'dberror':model.error } # User responder to show errors return _groupmanageresponder(request, adict=errors) # Once the alias has been created, we add the selected users for user in users: # Split the string of usernames These need to be usernames as # that is the only unique constraint in the db userid, domain = user.split('@') # set up for add alias user params = {'mode':1, # add alias users 'alias':cleaned_data['alias'], 'userid':userid, 'domain':domain } # Add alias user aliasuseradded = model.managealiasuser(params) # Ensure no errors have occured if not aliasuseradded and model.error: # Make a new template context errors = {'form':form, 'new_data':new_data, 'mode':mode, 'dberror':model.error } # User group responder to show errors return _groupmanageresponder(request, adict=errors) # If not valid form call responder with error else: errors = {'form':form,'new_data':new_data, 'mode':mode} return _groupmanageresponder(request, adict=errors) return HttpResponseRedirect (urlrel + 'admin/group/manage/')
def __init__(self, kargs=None): super(UserAdd,self).__init__(kargs) self.model = AdminModel() self.extras = {} self.fields['domain'].choices = [domain.domainname for domain in self.model.getalldomains()] self.fields['typer'].choices = [typer for typer in types]
def __init__(self, kargs=None): super(DomainAdd,self).__init__(kargs) self.model = AdminModel() self.fields['domain'].others = [domain.domainname for domain in self.model.getalldomains()]
def userhide(request, userid, domain): ''' This method hides a user from the system by setting said user's status equal to 9. This will ensure that this person can no longer log in to the system. ''' # Create model instance model = AdminModel() # Retrieve the requested user. request_user = model.getuser(userid, domain) # If there was no user in the db with this name or the function has thrown # an error, we have been given bogus input data if (request_user and not request_user.userid) or (not request_user and model.error): # Raise user has not be found raise Http404 # First remove user from aliases that point to him/her All previously # selected users params = {'mode':4, # remove alias users 'alias':None, 'userid':request_user.userid, 'domain':request_user.domain } # Remove user from aliases aliasuserdeleted = model.managealiasuser(params) # Ensure no errors have occured if not aliasuserdeleted and model.error: # Make new template context errors = {'mode':'add', 'requestuser':request_user, 'hideerror':model.error} # use responder to show errors return _usermanageresponder(request, adict=errors) # Set up for hidding user params = {'mode': 4, 'userid': request_user.userid, 'password': None, 'home': None, 'domain': request_user.domain, 'uid': None, 'gid': None, 'status': 9, 'typer': None, 'role': None, 'fullname': None, 'notes':None } # Hide user userhidden = model.manageuser(params) # Show errors if occured if not userhidden and model.error: # Create new template context errors = {'mode':'add', 'requestuser':request_user, 'hideerror':model.error } # User responder to show errors return _usermanageresponder(request, adict=errors) return HttpResponseRedirect (urlrel + 'admin/user/manage/')
def useredit(request, userid, domain): ''' This method edits an existing user of the system. it fills the form with the users details and then awaits posted data from the user, validates said data, and if and error occurs uses the responder to display them to the user. A succesfull post will update the user using the viewdb function and redirect to avoid post problems ''' # Create model instance model = AdminModel() # Set the mode mode ="edit" # Retrieve the requested user. request_user = model.getuser(userid, domain) # If there was no user in the db with this name or the function has thrown # an error, we have been given bogus input data if (request_user and not request_user.userid) or (not request_user and model.error): # Raise user has not be found raise Http404 # Check we have posted data if request.method =="POST": # copy posted data new_data = request.POST.copy() # Remove white space. removewhitespace(new_data) # bind form instance form = UserEdit(new_data) # Ensure for is valid if form.is_valid(): # Clean the data cleaned_data = form.cleaned_data # create function parameter list params = {'mode': 2, # edit 'userid': cleaned_data['userid'], 'password': cleaned_data['password'], 'home': mailstore_home % cleaned_data['userid'], 'domain': cleaned_data['domain'], 'uid': user_uid, 'gid': user_gid, 'status': 1, 'typer': cleaned_data['typer'].capitalize(), 'role': cleaned_data['role'], 'fullname': cleaned_data['fullname'], 'notes': cleaned_data['notes']} # call manageuser in edit mode useredited = model.manageuser(params) # Ensure no errors have occured if not useredited and model.error: # if we have errors display them errors = {'form':form, 'new_data':new_data, 'requestuser':request_user, 'mode':mode, 'dberror':model.error} # Use the responder return _usermanageresponder(request, adict=errors) # Redirect to avoid post problems return HttpResponseRedirect (urlrel + 'admin/user/manage/') # If not valid call responder with error else: errors = {'form':form, 'new_data':new_data, 'mode':mode, 'requestuser':request_user} return _usermanageresponder(request, adict=errors) return _usermanageresponder(request, adict={'requestuser':request_user, 'mode':mode})
def __init__(self, domain_name, kargs=None): super(DomainEdit,self).__init__(kargs) self.model = AdminModel() self.fields['domain'].others = [domain.domainname for domain in self.model.getalldomains()] self.fields['domain'].exclude = domain_name