1. basillistik
  2. django-registration

Source

django-registration / registration / forms.py

ubernostrum 5f3892e 
ubernostrum fa915e4 
ubernostrum 5f3892e 


ubernostrum e5110bb 
James Bennett b8374d5 
ubernostrum e263c55 
ubernostrum 0316a37 
ubernostrum 5f3892e 
ubernostrum e5110bb 
ubernostrum 5f3892e 

ubernostrum de1e97d 

ubernostrum 5f3892e 

ubernostrum e5110bb 
ubernostrum 5f3892e 



ubernostrum 1987d9b 
ubernostrum de1e97d 


James Bennett ad134e2 


ubernostrum 5f3892e 

ubernostrum 339f503 


James Bennett fcfd3b6 
James Bennett b23495f 
ubernostrum 5f3892e 
ubernostrum 9397737 
James Bennett 36ede9e 
ubernostrum 852525a 
James Bennett 36ede9e 
ubernostrum 852525a 
James Bennett 36ede9e 
ubernostrum 09fa25f 
ubernostrum 5f3892e 

ubernostrum 897bf79 
ubernostrum 09fa25f 
ubernostrum 5f3892e 

ubernostrum de1e97d 
ubernostrum 5a18d13 
ubernostrum de1e97d 

James Bennett 36ede9e 
ubernostrum df8b10e 

ubernostrum 3c60993 
ubernostrum 897bf79 
ubernostrum 3c60993 




ubernostrum df8b10e 

James Bennett 36ede9e 
ubernostrum df8b10e 
ubernostrum de1e97d 








James Bennett 8578276 
James Bennett 36ede9e 
ubernostrum fa915e4 









ubernostrum 897bf79 
ubernostrum fa915e4 


ubernostrum e263c55 
James Bennett 36ede9e 
ubernostrum e263c55 
ubernostrum fa915e4 






ubernostrum de1e97d 


ubernostrum fa915e4 



James Bennett 8cfe392 

ubernostrum fa915e4 


ubernostrum 897bf79 
ubernostrum fa915e4 


ubernostrum de1e97d 

James Bennett 36ede9e 
ubernostrum de1e97d 
"""
Forms and validation code for user registration.

"""


from django.contrib.auth.models import User
from django import forms
from django.utils.translation import ugettext_lazy as _


# I put this on all required fields, because it's easier to pick up
# on them with CSS or JavaScript if they have a class of "required"
# in the HTML. Your mileage may vary. If/when Django ticket #3515
# lands in trunk, this will no longer be necessary.
attrs_dict = { 'class': 'required' }


class RegistrationForm(forms.Form):
    """
    Form for registering a new user account.
    
    Validates that the requested username is not already in use, and
    requires the password to be entered twice to catch typos.
    
    Subclasses should feel free to add any additional validation they
    need, but should avoid defining a ``save()`` method -- the actual
    saving of collected user data is delegated to the active
    registration backend.
    
    """
    username = forms.RegexField(regex=r'^\w+$',
                                max_length=30,
                                widget=forms.TextInput(attrs=attrs_dict),
                                label=_("Username"),
                                error_messages={ 'invalid': _("This value must contain only letters, numbers and underscores.") })
    email = forms.EmailField(widget=forms.TextInput(attrs=dict(attrs_dict,
                                                               maxlength=75)),
                             label=_("Email address"))
    password1 = forms.CharField(widget=forms.PasswordInput(attrs=attrs_dict, render_value=False),
                                label=_("Password"))
    password2 = forms.CharField(widget=forms.PasswordInput(attrs=attrs_dict, render_value=False),
                                label=_("Password (again)"))
    
    def clean_username(self):
        """
        Validate that the username is alphanumeric and is not already
        in use.
        
        """
        try:
            user = User.objects.get(username__iexact=self.cleaned_data['username'])
        except User.DoesNotExist:
            return self.cleaned_data['username']
        raise forms.ValidationError(_("A user with that username already exists."))

    def clean(self):
        """
        Verifiy that the values entered into the two password fields
        match. Note that an error here will end up in
        ``non_field_errors()`` because it doesn't apply to a single
        field.
        
        """
        if 'password1' in self.cleaned_data and 'password2' in self.cleaned_data:
            if self.cleaned_data['password1'] != self.cleaned_data['password2']:
                raise forms.ValidationError(_("The two password fields didn't match."))
        return self.cleaned_data


class RegistrationFormTermsOfService(RegistrationForm):
    """
    Subclass of ``RegistrationForm`` which adds a required checkbox
    for agreeing to a site's Terms of Service.
    
    """
    tos = forms.BooleanField(widget=forms.CheckboxInput(attrs=attrs_dict),
                             label=_(u'I have read and agree to the Terms of Service'),
                             error_messages={ 'required': _("You must agree to the terms to register") })


class RegistrationFormUniqueEmail(RegistrationForm):
    """
    Subclass of ``RegistrationForm`` which enforces uniqueness of
    email addresses.
    
    """
    def clean_email(self):
        """
        Validate that the supplied email address is unique for the
        site.
        
        """
        if User.objects.filter(email__iexact=self.cleaned_data['email']):
            raise forms.ValidationError(_("This email address is already in use. Please supply a different email address."))
        return self.cleaned_data['email']


class RegistrationFormNoFreeEmail(RegistrationForm):
    """
    Subclass of ``RegistrationForm`` which disallows registration with
    email addresses from popular free webmail services; moderately
    useful for preventing automated spam registrations.
    
    To change the list of banned domains, subclass this form and
    override the attribute ``bad_domains``.
    
    """
    bad_domains = ['aim.com', 'aol.com', 'email.com', 'gmail.com',
                   'googlemail.com', 'hotmail.com', 'hushmail.com',
                   'msn.com', 'mail.ru', 'mailinator.com', 'live.com',
                   'yahoo.com']
    
    def clean_email(self):
        """
        Check the supplied email address against a list of known free
        webmail domains.
        
        """
        email_domain = self.cleaned_data['email'].split('@')[1]
        if email_domain in self.bad_domains:
            raise forms.ValidationError(_("Registration using free email addresses is prohibited. Please supply a different email address."))
        return self.cleaned_data['email']