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 _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))
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
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.')