Added django default forms

[skip ci]

Added django default forms
[skip ci]
Sergio Oliveira
1 parent 0816569e
Showing 2 changed files with 327 additions and 10 deletions Show diff stats
colab/accounts/admin.py
colab/accounts/forms.py
  
 from django import forms
 from django.contrib import admin
+from django.contrib.auth import get_user_model
 from django.contrib.auth.admin import UserAdmin
+from django.contrib.auth.forms import UserCreationForm
 from django.utils.translation import ugettext_lazy as _
  
-from .models import User
+User = get_user_model()
  
  
-class UserCreationForm(forms.ModelForm):
+class CustomUserCreationForm(UserCreationForm):
     class Meta:
         model = User
-        fields = ('username', 'email')
+        fields = ("username", "email")
  
-    def __init__(self, *args, **kwargs):
-        super(UserCreationForm, self).__init__(*args, **kwargs)
-        self.fields['email'].required = True
+    #def __init__(self, *args, **kwargs):
+    #    super(CustomUserCreationForm, self).__init__(*args, **kwargs)
+    #    self.fields['email'].required = True
  
  
 class UserChangeForm(forms.ModelForm):
@@ -33,10 +35,10 @@ class UserChangeForm(forms.ModelForm):
  
 class MyUserAdmin(UserAdmin):
     form = UserChangeForm
-    add_form = UserCreationForm
+    add_form = CustomUserCreationForm
  
     fieldsets = (
-        (None, {'fields': ('username', 'email')}),
+        (None, {'fields': ('username', 'email', 'password')}),
         (_('Personal info'), {'fields': ('first_name', 'last_name', 'twitter', 
                                          'facebook', 'google_talk', 'webpage',
                              )}),
@@ -48,8 +50,8 @@ class MyUserAdmin(UserAdmin):
     add_fieldsets = (
         (None, {
             'classes': ('wide',),
-            'fields': ('username', 'email')}
-        ),
+            'fields': ('username', 'email', 'password1', 'password2'),
+        }),
     )
  
  
@@ -158,3 +158,318 @@ class ChangeXMPPPasswordForm(forms.ModelForm):
         if commit:
             self.instance.save()
         return self.instance
+
+class UserCreationForm(forms.ModelForm):
+    """
+    A form that creates a user, with no privileges, from the given username and
+    password.
+    """
+    error_messages = {
+        'duplicate_username': _("A user with that username already exists."),
+        'password_mismatch': _("The two password fields didn't match."),
+    }
+    username = forms.RegexField(label=_("Username"), max_length=30,
+        regex=r'^[\w.@+-]+$',
+        help_text=_("Required. 30 characters or fewer. Letters, digits and "
+                    "@/./+/-/_ only."),
+        error_messages={
+            'invalid': _("This value may contain only letters, numbers and "
+                         "@/./+/-/_ characters.")})
+    password1 = forms.CharField(label=_("Password"),
+        widget=forms.PasswordInput)
+    password2 = forms.CharField(label=_("Password confirmation"),
+        widget=forms.PasswordInput,
+        help_text=_("Enter the same password as above, for verification."))
+
+    class Meta:
+        model = User
+        fields = ("username",)
+
+    def clean_username(self):
+        # Since User.username is unique, this check is redundant,
+        # but it sets a nicer error message than the ORM. See #13147.
+        username = self.cleaned_data["username"]
+        try:
+            User._default_manager.get(username=username)
+        except User.DoesNotExist:
+            return username
+        raise forms.ValidationError(
+            self.error_messages['duplicate_username'],
+            code='duplicate_username',
+        )
+
+    def clean_password2(self):
+        password1 = self.cleaned_data.get("password1")
+        password2 = self.cleaned_data.get("password2")
+        if password1 and password2 and password1 != password2:
+            raise forms.ValidationError(
+                self.error_messages['password_mismatch'],
+                code='password_mismatch',
+            )
+        return password2
+
+    def save(self, commit=True):
+        user = super(UserCreationForm, self).save(commit=False)
+        user.set_password(self.cleaned_data["password1"])
+        if commit:
+            user.save()
+        return user
+
+
+class UserChangeForm(forms.ModelForm):
+    username = forms.RegexField(
+        label=_("Username"), max_length=30, regex=r"^[\w.@+-]+$",
+        help_text=_("Required. 30 characters or fewer. Letters, digits and "
+                    "@/./+/-/_ only."),
+        error_messages={
+            'invalid': _("This value may contain only letters, numbers and "
+                         "@/./+/-/_ characters.")})
+    password = ReadOnlyPasswordHashField(label=_("Password"),
+        help_text=_("Raw passwords are not stored, so there is no way to see "
+                    "this user's password, but you can change the password "
+                    "using <a href=\"password/\">this form</a>."))
+
+    class Meta:
+        model = User
+        fields = '__all__'
+
+    def __init__(self, *args, **kwargs):
+        super(UserChangeForm, self).__init__(*args, **kwargs)
+        f = self.fields.get('user_permissions', None)
+        if f is not None:
+            f.queryset = f.queryset.select_related('content_type')
+
+    def clean_password(self):
+        # Regardless of what the user provides, return the initial value.
+        # This is done here, rather than on the field, because the
+        # field does not have access to the initial value
+        return self.initial["password"]
+
+
+class AuthenticationForm(forms.Form):
+    """
+    Base class for authenticating users. Extend this to get a form that accepts
+    username/password logins.
+    """
+    username = forms.CharField(max_length=254)
+    password = forms.CharField(label=_("Password"), widget=forms.PasswordInput)
+
+    error_messages = {
+        'invalid_login': _("Please enter a correct %(username)s and password. "
+                           "Note that both fields may be case-sensitive."),
+        'inactive': _("This account is inactive."),
+    }
+
+    def __init__(self, request=None, *args, **kwargs):
+        """
+        The 'request' parameter is set for custom auth use by subclasses.
+        The form data comes in via the standard 'data' kwarg.
+        """
+        self.request = request
+        self.user_cache = None
+        super(AuthenticationForm, self).__init__(*args, **kwargs)
+
+        # Set the label for the "username" field.
+        UserModel = get_user_model()
+        self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)
+        if self.fields['username'].label is None:
+            self.fields['username'].label = capfirst(self.username_field.verbose_name)
+
+    def clean(self):
+        username = self.cleaned_data.get('username')
+        password = self.cleaned_data.get('password')
+
+        if username and password:
+            self.user_cache = authenticate(username=username,
+                                           password=password)
+            if self.user_cache is None:
+                raise forms.ValidationError(
+                    self.error_messages['invalid_login'],
+                    code='invalid_login',
+                    params={'username': self.username_field.verbose_name},
+                )
+            else:
+                self.confirm_login_allowed(self.user_cache)
+
+        return self.cleaned_data
+
+    def confirm_login_allowed(self, user):
+        """
+        Controls whether the given User may log in. This is a policy setting,
+        independent of end-user authentication. This default behavior is to
+        allow login by active users, and reject login by inactive users.
+        If the given user cannot log in, this method should raise a
+        ``forms.ValidationError``.
+        If the given user may log in, this method should return None.
+        """
+        if not user.is_active:
+            raise forms.ValidationError(
+                self.error_messages['inactive'],
+                code='inactive',
+            )
+
+    def get_user_id(self):
+        if self.user_cache:
+            return self.user_cache.id
+        return None
+
+    def get_user(self):
+        return self.user_cache
+
+
+class PasswordResetForm(forms.Form):
+    email = forms.EmailField(label=_("Email"), max_length=254)
+
+    def save(self, domain_override=None,
+             subject_template_name='registration/password_reset_subject.txt',
+             email_template_name='registration/password_reset_email.html',
+             use_https=False, token_generator=default_token_generator,
+             from_email=None, request=None, html_email_template_name=None):
+        """
+        Generates a one-use only link for resetting password and sends to the
+        user.
+        """
+        from django.core.mail import send_mail
+        UserModel = get_user_model()
+        email = self.cleaned_data["email"]
+        active_users = UserModel._default_manager.filter(
+            email__iexact=email, is_active=True)
+        for user in active_users:
+            # Make sure that no email is sent to a user that actually has
+            # a password marked as unusable
+            if not user.has_usable_password():
+                continue
+            if not domain_override:
+                current_site = get_current_site(request)
+                site_name = current_site.name
+                domain = current_site.domain
+            else:
+                site_name = domain = domain_override
+            c = {
+                'email': user.email,
+                'domain': domain,
+                'site_name': site_name,
+                'uid': urlsafe_base64_encode(force_bytes(user.pk)),
+                'user': user,
+                'token': token_generator.make_token(user),
+                'protocol': 'https' if use_https else 'http',
+            }
+            subject = loader.render_to_string(subject_template_name, c)
+            # Email subject *must not* contain newlines
+            subject = ''.join(subject.splitlines())
+            email = loader.render_to_string(email_template_name, c)
+
+            if html_email_template_name:
+                html_email = loader.render_to_string(html_email_template_name, c)
+            else:
+                html_email = None
+            send_mail(subject, email, from_email, [user.email], html_message=html_email)
+
+
+class SetPasswordForm(forms.Form):
+    """
+    A form that lets a user change set their password without entering the old
+    password
+    """
+    error_messages = {
+        'password_mismatch': _("The two password fields didn't match."),
+    }
+    new_password1 = forms.CharField(label=_("New password"),
+                                    widget=forms.PasswordInput)
+    new_password2 = forms.CharField(label=_("New password confirmation"),
+                                    widget=forms.PasswordInput)
+
+    def __init__(self, user, *args, **kwargs):
+        self.user = user
+        super(SetPasswordForm, self).__init__(*args, **kwargs)
+
+    def clean_new_password2(self):
+        password1 = self.cleaned_data.get('new_password1')
+        password2 = self.cleaned_data.get('new_password2')
+        if password1 and password2:
+            if password1 != password2:
+                raise forms.ValidationError(
+                    self.error_messages['password_mismatch'],
+                    code='password_mismatch',
+                )
+        return password2
+
+    def save(self, commit=True):
+        self.user.set_password(self.cleaned_data['new_password1'])
+        if commit:
+            self.user.save()
+        return self.user
+
+
+class PasswordChangeForm(SetPasswordForm):
+    """
+    A form that lets a user change their password by entering their old
+    password.
+    """
+    error_messages = dict(SetPasswordForm.error_messages, **{
+        'password_incorrect': _("Your old password was entered incorrectly. "
+                                "Please enter it again."),
+    })
+    old_password = forms.CharField(label=_("Old password"),
+                                   widget=forms.PasswordInput)
+
+    def clean_old_password(self):
+        """
+        Validates that the old_password field is correct.
+        """
+        old_password = self.cleaned_data["old_password"]
+        if not self.user.check_password(old_password):
+            raise forms.ValidationError(
+                self.error_messages['password_incorrect'],
+                code='password_incorrect',
+            )
+        return old_password
+
+PasswordChangeForm.base_fields = OrderedDict(
+    (k, PasswordChangeForm.base_fields[k])
+    for k in ['old_password', 'new_password1', 'new_password2']
+)
+
+
+class AdminPasswordChangeForm(forms.Form):
+    """
+    A form used to change the password of a user in the admin interface.
+    """
+    error_messages = {
+        'password_mismatch': _("The two password fields didn't match."),
+    }
+    password1 = forms.CharField(label=_("Password"),
+                                widget=forms.PasswordInput)
+    password2 = forms.CharField(label=_("Password (again)"),
+                                widget=forms.PasswordInput)
+
+    def __init__(self, user, *args, **kwargs):
+        self.user = user
+        super(AdminPasswordChangeForm, self).__init__(*args, **kwargs)
+
+    def clean_password2(self):
+        password1 = self.cleaned_data.get('password1')
+        password2 = self.cleaned_data.get('password2')
+        if password1 and password2:
+            if password1 != password2:
+                raise forms.ValidationError(
+                    self.error_messages['password_mismatch'],
+                    code='password_mismatch',
+                )
+        return password2
+
+    def save(self, commit=True):
+        """
+        Saves the new password.
+        """
+        self.user.set_password(self.cleaned_data["password1"])
+        if commit:
+            self.user.save()
+        return self.user
+
+    def _get_changed_data(self):
+        data = super(AdminPasswordChangeForm, self).changed_data
+        for name in self.fields.keys():
+            if name not in data:
+                return []
+        return ['password']
1	1
2	2	from django import forms
3	3	from django.contrib import admin
	4	+from django.contrib.auth import get_user_model
4	5	from django.contrib.auth.admin import UserAdmin
	6	+from django.contrib.auth.forms import UserCreationForm
5	7	from django.utils.translation import ugettext_lazy as _
6	8
7		-from .models import User
	9	+User = get_user_model()
8	10
9	11
10		-class UserCreationForm(forms.ModelForm):
	12	+class CustomUserCreationForm(UserCreationForm):
11	13	class Meta:
12	14	model = User
13		- fields = ('username', 'email')
	15	+ fields = ("username", "email")
14	16
15		- def __init__(self, args, *kwargs):
16		- super(UserCreationForm, self).__init__(args, *kwargs)
17		- self.fields['email'].required = True
	17	+ #def __init__(self, args, *kwargs):
	18	+ # super(CustomUserCreationForm, self).__init__(args, *kwargs)
	19	+ # self.fields['email'].required = True
18	20
19	21
20	22	class UserChangeForm(forms.ModelForm):
...	...	@@ -33,10 +35,10 @@ class UserChangeForm(forms.ModelForm):
33	35
34	36	class MyUserAdmin(UserAdmin):
35	37	form = UserChangeForm
36		- add_form = UserCreationForm
	38	+ add_form = CustomUserCreationForm
37	39
38	40	fieldsets = (
39		- (None, {'fields': ('username', 'email')}),
	41	+ (None, {'fields': ('username', 'email', 'password')}),
40	42	(_('Personal info'), {'fields': ('first_name', 'last_name', 'twitter',
41	43	'facebook', 'google_talk', 'webpage',
42	44	)}),
...	...	@@ -48,8 +50,8 @@ class MyUserAdmin(UserAdmin):
48	50	add_fieldsets = (
49	51	(None, {
50	52	'classes': ('wide',),
51		- 'fields': ('username', 'email')}
52		- ),
	53	+ 'fields': ('username', 'email', 'password1', 'password2'),
	54	+ }),
53	55	)
54	56
55	57
...	...
...	...	@@ -158,3 +158,318 @@ class ChangeXMPPPasswordForm(forms.ModelForm):
158	158	if commit:
159	159	self.instance.save()
160	160	return self.instance
	161	+
	162	+class UserCreationForm(forms.ModelForm):
	163	+ """
	164	+ A form that creates a user, with no privileges, from the given username and
	165	+ password.
	166	+ """
	167	+ error_messages = {
	168	+ 'duplicate_username': _("A user with that username already exists."),
	169	+ 'password_mismatch': _("The two password fields didn't match."),
	170	+ }
	171	+ username = forms.RegexField(label=_("Username"), max_length=30,
	172	+ regex=r'^[\w.@+-]+$',
	173	+ help_text=_("Required. 30 characters or fewer. Letters, digits and "
	174	+ "@/./+/-/_ only."),
	175	+ error_messages={
	176	+ 'invalid': _("This value may contain only letters, numbers and "
	177	+ "@/./+/-/_ characters.")})
	178	+ password1 = forms.CharField(label=_("Password"),
	179	+ widget=forms.PasswordInput)
	180	+ password2 = forms.CharField(label=_("Password confirmation"),
	181	+ widget=forms.PasswordInput,
	182	+ help_text=_("Enter the same password as above, for verification."))
	183	+
	184	+ class Meta:
	185	+ model = User
	186	+ fields = ("username",)
	187	+
	188	+ def clean_username(self):
	189	+ # Since User.username is unique, this check is redundant,
	190	+ # but it sets a nicer error message than the ORM. See #13147.
	191	+ username = self.cleaned_data["username"]
	192	+ try:
	193	+ User._default_manager.get(username=username)
	194	+ except User.DoesNotExist:
	195	+ return username
	196	+ raise forms.ValidationError(
	197	+ self.error_messages['duplicate_username'],
	198	+ code='duplicate_username',
	199	+ )
	200	+
	201	+ def clean_password2(self):
	202	+ password1 = self.cleaned_data.get("password1")
	203	+ password2 = self.cleaned_data.get("password2")
	204	+ if password1 and password2 and password1 != password2:
	205	+ raise forms.ValidationError(
	206	+ self.error_messages['password_mismatch'],
	207	+ code='password_mismatch',
	208	+ )
	209	+ return password2
	210	+
	211	+ def save(self, commit=True):
	212	+ user = super(UserCreationForm, self).save(commit=False)
	213	+ user.set_password(self.cleaned_data["password1"])
	214	+ if commit:
	215	+ user.save()
	216	+ return user
	217	+
	218	+
	219	+class UserChangeForm(forms.ModelForm):
	220	+ username = forms.RegexField(
	221	+ label=_("Username"), max_length=30, regex=r"^[\w.@+-]+$",
	222	+ help_text=_("Required. 30 characters or fewer. Letters, digits and "
	223	+ "@/./+/-/_ only."),
	224	+ error_messages={
	225	+ 'invalid': _("This value may contain only letters, numbers and "
	226	+ "@/./+/-/_ characters.")})
	227	+ password = ReadOnlyPasswordHashField(label=_("Password"),
	228	+ help_text=_("Raw passwords are not stored, so there is no way to see "
	229	+ "this user's password, but you can change the password "
	230	+ "using <a href=\"password/\">this form</a>."))
	231	+
	232	+ class Meta:
	233	+ model = User
	234	+ fields = '__all__'
	235	+
	236	+ def __init__(self, args, *kwargs):
	237	+ super(UserChangeForm, self).__init__(args, *kwargs)
	238	+ f = self.fields.get('user_permissions', None)
	239	+ if f is not None:
	240	+ f.queryset = f.queryset.select_related('content_type')
	241	+
	242	+ def clean_password(self):
	243	+ # Regardless of what the user provides, return the initial value.
	244	+ # This is done here, rather than on the field, because the
	245	+ # field does not have access to the initial value
	246	+ return self.initial["password"]
	247	+
	248	+
	249	+class AuthenticationForm(forms.Form):
	250	+ """
	251	+ Base class for authenticating users. Extend this to get a form that accepts
	252	+ username/password logins.
	253	+ """
	254	+ username = forms.CharField(max_length=254)
	255	+ password = forms.CharField(label=_("Password"), widget=forms.PasswordInput)
	256	+
	257	+ error_messages = {
	258	+ 'invalid_login': _("Please enter a correct %(username)s and password. "
	259	+ "Note that both fields may be case-sensitive."),
	260	+ 'inactive': _("This account is inactive."),
	261	+ }
	262	+
	263	+ def __init__(self, request=None, args, *kwargs):
	264	+ """
	265	+ The 'request' parameter is set for custom auth use by subclasses.
	266	+ The form data comes in via the standard 'data' kwarg.
	267	+ """
	268	+ self.request = request
	269	+ self.user_cache = None
	270	+ super(AuthenticationForm, self).__init__(args, *kwargs)
	271	+
	272	+ # Set the label for the "username" field.
	273	+ UserModel = get_user_model()
	274	+ self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)
	275	+ if self.fields['username'].label is None:
	276	+ self.fields['username'].label = capfirst(self.username_field.verbose_name)
	277	+
	278	+ def clean(self):
	279	+ username = self.cleaned_data.get('username')
	280	+ password = self.cleaned_data.get('password')
	281	+
	282	+ if username and password:
	283	+ self.user_cache = authenticate(username=username,
	284	+ password=password)
	285	+ if self.user_cache is None:
	286	+ raise forms.ValidationError(
	287	+ self.error_messages['invalid_login'],
	288	+ code='invalid_login',
	289	+ params={'username': self.username_field.verbose_name},
	290	+ )
	291	+ else:
	292	+ self.confirm_login_allowed(self.user_cache)
	293	+
	294	+ return self.cleaned_data
	295	+
	296	+ def confirm_login_allowed(self, user):
	297	+ """
	298	+ Controls whether the given User may log in. This is a policy setting,
	299	+ independent of end-user authentication. This default behavior is to
	300	+ allow login by active users, and reject login by inactive users.
	301	+ If the given user cannot log in, this method should raise a
	302	+ ``forms.ValidationError``.
	303	+ If the given user may log in, this method should return None.
	304	+ """
	305	+ if not user.is_active:
	306	+ raise forms.ValidationError(
	307	+ self.error_messages['inactive'],
	308	+ code='inactive',
	309	+ )
	310	+
	311	+ def get_user_id(self):
	312	+ if self.user_cache:
	313	+ return self.user_cache.id
	314	+ return None
	315	+
	316	+ def get_user(self):
	317	+ return self.user_cache
	318	+
	319	+
	320	+class PasswordResetForm(forms.Form):
	321	+ email = forms.EmailField(label=_("Email"), max_length=254)
	322	+
	323	+ def save(self, domain_override=None,
	324	+ subject_template_name='registration/password_reset_subject.txt',
	325	+ email_template_name='registration/password_reset_email.html',
	326	+ use_https=False, token_generator=default_token_generator,
	327	+ from_email=None, request=None, html_email_template_name=None):
	328	+ """
	329	+ Generates a one-use only link for resetting password and sends to the
	330	+ user.
	331	+ """
	332	+ from django.core.mail import send_mail
	333	+ UserModel = get_user_model()
	334	+ email = self.cleaned_data["email"]
	335	+ active_users = UserModel._default_manager.filter(
	336	+ email__iexact=email, is_active=True)
	337	+ for user in active_users:
	338	+ # Make sure that no email is sent to a user that actually has
	339	+ # a password marked as unusable
	340	+ if not user.has_usable_password():
	341	+ continue
	342	+ if not domain_override:
	343	+ current_site = get_current_site(request)
	344	+ site_name = current_site.name
	345	+ domain = current_site.domain
	346	+ else:
	347	+ site_name = domain = domain_override
	348	+ c = {
	349	+ 'email': user.email,
	350	+ 'domain': domain,
	351	+ 'site_name': site_name,
	352	+ 'uid': urlsafe_base64_encode(force_bytes(user.pk)),
	353	+ 'user': user,
	354	+ 'token': token_generator.make_token(user),
	355	+ 'protocol': 'https' if use_https else 'http',
	356	+ }
	357	+ subject = loader.render_to_string(subject_template_name, c)
	358	+ # Email subject must not contain newlines
	359	+ subject = ''.join(subject.splitlines())
	360	+ email = loader.render_to_string(email_template_name, c)
	361	+
	362	+ if html_email_template_name:
	363	+ html_email = loader.render_to_string(html_email_template_name, c)
	364	+ else:
	365	+ html_email = None
	366	+ send_mail(subject, email, from_email, [user.email], html_message=html_email)
	367	+
	368	+
	369	+class SetPasswordForm(forms.Form):
	370	+ """
	371	+ A form that lets a user change set their password without entering the old
	372	+ password
	373	+ """
	374	+ error_messages = {
	375	+ 'password_mismatch': _("The two password fields didn't match."),
	376	+ }
	377	+ new_password1 = forms.CharField(label=_("New password"),
	378	+ widget=forms.PasswordInput)
	379	+ new_password2 = forms.CharField(label=_("New password confirmation"),
	380	+ widget=forms.PasswordInput)
	381	+
	382	+ def __init__(self, user, args, *kwargs):
	383	+ self.user = user
	384	+ super(SetPasswordForm, self).__init__(args, *kwargs)
	385	+
	386	+ def clean_new_password2(self):
	387	+ password1 = self.cleaned_data.get('new_password1')
	388	+ password2 = self.cleaned_data.get('new_password2')
	389	+ if password1 and password2:
	390	+ if password1 != password2:
	391	+ raise forms.ValidationError(
	392	+ self.error_messages['password_mismatch'],
	393	+ code='password_mismatch',
	394	+ )
	395	+ return password2
	396	+
	397	+ def save(self, commit=True):
	398	+ self.user.set_password(self.cleaned_data['new_password1'])
	399	+ if commit:
	400	+ self.user.save()
	401	+ return self.user
	402	+
	403	+
	404	+class PasswordChangeForm(SetPasswordForm):
	405	+ """
	406	+ A form that lets a user change their password by entering their old
	407	+ password.
	408	+ """
	409	+ error_messages = dict(SetPasswordForm.error_messages, **{
	410	+ 'password_incorrect': _("Your old password was entered incorrectly. "
	411	+ "Please enter it again."),
	412	+ })
	413	+ old_password = forms.CharField(label=_("Old password"),
	414	+ widget=forms.PasswordInput)
	415	+
	416	+ def clean_old_password(self):
	417	+ """
	418	+ Validates that the old_password field is correct.
	419	+ """
	420	+ old_password = self.cleaned_data["old_password"]
	421	+ if not self.user.check_password(old_password):
	422	+ raise forms.ValidationError(
	423	+ self.error_messages['password_incorrect'],
	424	+ code='password_incorrect',
	425	+ )
	426	+ return old_password
	427	+
	428	+PasswordChangeForm.base_fields = OrderedDict(
	429	+ (k, PasswordChangeForm.base_fields[k])
	430	+ for k in ['old_password', 'new_password1', 'new_password2']
	431	+)
	432	+
	433	+
	434	+class AdminPasswordChangeForm(forms.Form):
	435	+ """
	436	+ A form used to change the password of a user in the admin interface.
	437	+ """
	438	+ error_messages = {
	439	+ 'password_mismatch': _("The two password fields didn't match."),
	440	+ }
	441	+ password1 = forms.CharField(label=_("Password"),
	442	+ widget=forms.PasswordInput)
	443	+ password2 = forms.CharField(label=_("Password (again)"),
	444	+ widget=forms.PasswordInput)
	445	+
	446	+ def __init__(self, user, args, *kwargs):
	447	+ self.user = user
	448	+ super(AdminPasswordChangeForm, self).__init__(args, *kwargs)
	449	+
	450	+ def clean_password2(self):
	451	+ password1 = self.cleaned_data.get('password1')
	452	+ password2 = self.cleaned_data.get('password2')
	453	+ if password1 and password2:
	454	+ if password1 != password2:
	455	+ raise forms.ValidationError(
	456	+ self.error_messages['password_mismatch'],
	457	+ code='password_mismatch',
	458	+ )
	459	+ return password2
	460	+
	461	+ def save(self, commit=True):
	462	+ """
	463	+ Saves the new password.
	464	+ """
	465	+ self.user.set_password(self.cleaned_data["password1"])
	466	+ if commit:
	467	+ self.user.save()
	468	+ return self.user
	469	+
	470	+ def _get_changed_data(self):
	471	+ data = super(AdminPasswordChangeForm, self).changed_data
	472	+ for name in self.fields.keys():
	473	+ if name not in data:
	474	+ return []
	475	+ return ['password']
...	...