Added plugin ability to validate colab password

Sergio Oliveira
1 parent e24dc879
Showing 4 changed files with 258 additions and 16 deletions Show diff stats
colab/accounts/forms.py
colab/accounts/models.py
colab/accounts/urls.py
colab/utils/conf.py
 # -*- coding: utf-8 -*-
+from collections import OrderedDict
+from importlib import import_module
+
 from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.contrib.auth.tokens import default_token_generator
 from django.contrib.auth.forms import ReadOnlyPasswordHashField
 from django.core.urlresolvers import reverse
 from django.utils.functional import lazy
@@ -282,3 +286,250 @@ class UserChangeForm(forms.ModelForm):
         # 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_password1(self):
+        password = self.cleaned_data.get('new_password1')
+
+        for app in settings.COLAB_APPS.values():
+            if 'password_validators' in app:
+                for validator_path in app.get('password_validators'):
+                    module_path, func_name = validator_path.rsplit('.', 1)
+                    module = import_module(module_path)
+                    validator_func = getattr(module, func_name, None)
+                    if validator_func:
+                        validator_func(password)
+
+        return password
+
+    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']
@@ -2,9 +2,9 @@
 import urlparse
-from django.db import models
 from django.contrib.auth.models import AbstractUser, UserManager
 from django.core.urlresolvers import reverse
+from django.db import models
 from django.utils.crypto import get_random_string
 from django.utils.translation import ugettext_lazy as _
 from django.conf import settings
 from django.conf.urls import patterns, url
+from django.contrib.auth import views as auth_views
 from .views import (UserProfileDetailView, UserProfileUpdateView,
                     ManageUserSubscriptionsView)
-
-from colab.accounts import views
-from django.contrib.auth import views as auth_views
+from .forms import PasswordChangeForm
 urlpatterns = patterns('',
@@ -30,7 +29,8 @@ urlpatterns = patterns(&#39;&#39;,
         name="password_reset"),
     url(r'^change-password/?$', auth_views.password_change,
-        {'template_name':'registration/password_change_form_custom.html'},
+        {'template_name': 'registration/password_change_form_custom.html',
+         'password_change_form': PasswordChangeForm},
         name='password_change'),
     url(r'^change-password-done/?$',
@@ -49,7 +49,7 @@ def _load_py_file(py_path, path):
         sys.path.remove(path)
     py_setting = {var: getattr(py_settings, var) for var in dir(py_settings)
-                  if not var.startswith('__')}
+                  if not var.startswith('_')}
     return py_setting
@@ -125,16 +125,7 @@ def load_colab_apps():
         app_label = app_name.split('.')[-1]
         COLAB_APPS[app_label] = {}
-        COLAB_APPS[app_label]['menu_title'] = py_settings_d.get('menu_title')
-
-        fields = ['verbose_name', 'upstream', 'urls',
-                  'menu_urls', 'middlewares', 'dependencies',
-                  'context_processors', 'private_token', 'name', 'extra']
-
-        for key in fields:
-            value = py_settings_d.get(key)
-            if value:
-                COLAB_APPS[app_label][key] = value
+        COLAB_APPS[app_label] = py_settings_d
     return {'COLAB_APPS': COLAB_APPS}
1	# -- coding: utf-8 --	1	# -- coding: utf-8 --
2		2
		3	+from collections import OrderedDict
		4	+from importlib import import_module
		5	+
3	from django import forms	6	from django import forms
4	from django.conf import settings	7	from django.conf import settings
5	from django.contrib.auth import get_user_model	8	from django.contrib.auth import get_user_model
		9	+from django.contrib.auth.tokens import default_token_generator
6	from django.contrib.auth.forms import ReadOnlyPasswordHashField	10	from django.contrib.auth.forms import ReadOnlyPasswordHashField
7	from django.core.urlresolvers import reverse	11	from django.core.urlresolvers import reverse
8	from django.utils.functional import lazy	12	from django.utils.functional import lazy
	@@ -282,3 +286,250 @@ class UserChangeForm(forms.ModelForm):		@@ -282,3 +286,250 @@ class UserChangeForm(forms.ModelForm):
282	# This is done here, rather than on the field, because the	286	# This is done here, rather than on the field, because the
283	# field does not have access to the initial value	287	# field does not have access to the initial value
284	return self.initial["password"]	288	return self.initial["password"]
		289	+
		290	+
		291	+class AuthenticationForm(forms.Form):
		292	+ """
		293	+ Base class for authenticating users. Extend this to get a form that accepts
		294	+ username/password logins.
		295	+ """
		296	+ username = forms.CharField(max_length=254)
		297	+ password = forms.CharField(label=_("Password"), widget=forms.PasswordInput)
		298	+
		299	+ error_messages = {
		300	+ 'invalid_login': _("Please enter a correct %(username)s and password. "
		301	+ "Note that both fields may be case-sensitive."),
		302	+ 'inactive': _("This account is inactive."),
		303	+ }
		304	+
		305	+ def __init__(self, request=None, args, *kwargs):
		306	+ """
		307	+ The 'request' parameter is set for custom auth use by subclasses.
		308	+ The form data comes in via the standard 'data' kwarg.
		309	+ """
		310	+ self.request = request
		311	+ self.user_cache = None
		312	+ super(AuthenticationForm, self).__init__(args, *kwargs)
		313	+
		314	+ # Set the label for the "username" field.
		315	+ UserModel = get_user_model()
		316	+ self.username_field = UserModel._meta.get_field(
		317	+ UserModel.USERNAME_FIELD)
		318	+ if self.fields['username'].label is None:
		319	+ self.fields['username'].label = capfirst(
		320	+ self.username_field.verbose_name)
		321	+
		322	+ def clean(self):
		323	+ username = self.cleaned_data.get('username')
		324	+ password = self.cleaned_data.get('password')
		325	+
		326	+ if username and password:
		327	+ self.user_cache = authenticate(username=username,
		328	+ password=password)
		329	+ if self.user_cache is None:
		330	+ raise forms.ValidationError(
		331	+ self.error_messages['invalid_login'],
		332	+ code='invalid_login',
		333	+ params={'username': self.username_field.verbose_name},
		334	+ )
		335	+ else:
		336	+ self.confirm_login_allowed(self.user_cache)
		337	+
		338	+ return self.cleaned_data
		339	+
		340	+ def confirm_login_allowed(self, user):
		341	+ """
		342	+ Controls whether the given User may log in. This is a policy setting,
		343	+ independent of end-user authentication. This default behavior is to
		344	+ allow login by active users, and reject login by inactive users.
		345	+ If the given user cannot log in, this method should raise a
		346	+ ``forms.ValidationError``.
		347	+ If the given user may log in, this method should return None.
		348	+ """
		349	+ if not user.is_active:
		350	+ raise forms.ValidationError(
		351	+ self.error_messages['inactive'],
		352	+ code='inactive',
		353	+ )
		354	+
		355	+ def get_user_id(self):
		356	+ if self.user_cache:
		357	+ return self.user_cache.id
		358	+ return None
		359	+
		360	+ def get_user(self):
		361	+ return self.user_cache
		362	+
		363	+
		364	+class PasswordResetForm(forms.Form):
		365	+ email = forms.EmailField(label=_("Email"), max_length=254)
		366	+
		367	+ def save(self, domain_override=None,
		368	+ subject_template_name='registration/password_reset_subject.txt',
		369	+ email_template_name='registration/password_reset_email.html',
		370	+ use_https=False, token_generator=default_token_generator,
		371	+ from_email=None, request=None, html_email_template_name=None):
		372	+ """
		373	+ Generates a one-use only link for resetting password and sends to the
		374	+ user.
		375	+ """
		376	+ from django.core.mail import send_mail
		377	+ UserModel = get_user_model()
		378	+ email = self.cleaned_data["email"]
		379	+ active_users = UserModel._default_manager.filter(
		380	+ email__iexact=email, is_active=True)
		381	+ for user in active_users:
		382	+ # Make sure that no email is sent to a user that actually has
		383	+ # a password marked as unusable
		384	+ if not user.has_usable_password():
		385	+ continue
		386	+ if not domain_override:
		387	+ current_site = get_current_site(request)
		388	+ site_name = current_site.name
		389	+ domain = current_site.domain
		390	+ else:
		391	+ site_name = domain = domain_override
		392	+ c = {
		393	+ 'email': user.email,
		394	+ 'domain': domain,
		395	+ 'site_name': site_name,
		396	+ 'uid': urlsafe_base64_encode(force_bytes(user.pk)),
		397	+ 'user': user,
		398	+ 'token': token_generator.make_token(user),
		399	+ 'protocol': 'https' if use_https else 'http',
		400	+ }
		401	+ subject = loader.render_to_string(subject_template_name, c)
		402	+ # Email subject must not contain newlines
		403	+ subject = ''.join(subject.splitlines())
		404	+ email = loader.render_to_string(email_template_name, c)
		405	+
		406	+ if html_email_template_name:
		407	+ html_email = loader.render_to_string(html_email_template_name,
		408	+ c)
		409	+ else:
		410	+ html_email = None
		411	+ send_mail(subject, email, from_email, [user.email],
		412	+ html_message=html_email)
		413	+
		414	+
		415	+class SetPasswordForm(forms.Form):
		416	+ """
		417	+ A form that lets a user change set their password without entering the old
		418	+ password
		419	+ """
		420	+ error_messages = {
		421	+ 'password_mismatch': _("The two password fields didn't match."),
		422	+ }
		423	+ new_password1 = forms.CharField(label=_("New password"),
		424	+ widget=forms.PasswordInput)
		425	+ new_password2 = forms.CharField(label=_("New password confirmation"),
		426	+ widget=forms.PasswordInput)
		427	+
		428	+ def __init__(self, user, args, *kwargs):
		429	+ self.user = user
		430	+ super(SetPasswordForm, self).__init__(args, *kwargs)
		431	+
		432	+ def clean_new_password1(self):
		433	+ password = self.cleaned_data.get('new_password1')
		434	+
		435	+ for app in settings.COLAB_APPS.values():
		436	+ if 'password_validators' in app:
		437	+ for validator_path in app.get('password_validators'):
		438	+ module_path, func_name = validator_path.rsplit('.', 1)
		439	+ module = import_module(module_path)
		440	+ validator_func = getattr(module, func_name, None)
		441	+ if validator_func:
		442	+ validator_func(password)
		443	+
		444	+ return password
		445	+
		446	+ def clean_new_password2(self):
		447	+ password1 = self.cleaned_data.get('new_password1')
		448	+ password2 = self.cleaned_data.get('new_password2')
		449	+ if password1 and password2:
		450	+ if password1 != password2:
		451	+ raise forms.ValidationError(
		452	+ self.error_messages['password_mismatch'],
		453	+ code='password_mismatch',
		454	+ )
		455	+ return password2
		456	+
		457	+ def save(self, commit=True):
		458	+ self.user.set_password(self.cleaned_data['new_password1'])
		459	+ if commit:
		460	+ self.user.save()
		461	+ return self.user
		462	+
		463	+
		464	+class PasswordChangeForm(SetPasswordForm):
		465	+ """
		466	+ A form that lets a user change their password by entering their old
		467	+ password.
		468	+ """
		469	+ error_messages = dict(SetPasswordForm.error_messages, **{
		470	+ 'password_incorrect': _("Your old password was entered incorrectly. "
		471	+ "Please enter it again."),
		472	+ })
		473	+ old_password = forms.CharField(label=_("Old password"),
		474	+ widget=forms.PasswordInput)
		475	+
		476	+ def clean_old_password(self):
		477	+ """
		478	+ Validates that the old_password field is correct.
		479	+ """
		480	+ old_password = self.cleaned_data["old_password"]
		481	+ if not self.user.check_password(old_password):
		482	+ raise forms.ValidationError(
		483	+ self.error_messages['password_incorrect'],
		484	+ code='password_incorrect',
		485	+ )
		486	+ return old_password
		487	+
		488	+PasswordChangeForm.base_fields = OrderedDict(
		489	+ (k, PasswordChangeForm.base_fields[k])
		490	+ for k in ['old_password', 'new_password1', 'new_password2']
		491	+)
		492	+
		493	+
		494	+class AdminPasswordChangeForm(forms.Form):
		495	+ """
		496	+ A form used to change the password of a user in the admin interface.
		497	+ """
		498	+ error_messages = {
		499	+ 'password_mismatch': _("The two password fields didn't match."),
		500	+ }
		501	+ password1 = forms.CharField(label=_("Password"),
		502	+ widget=forms.PasswordInput)
		503	+ password2 = forms.CharField(label=_("Password (again)"),
		504	+ widget=forms.PasswordInput)
		505	+
		506	+ def __init__(self, user, args, *kwargs):
		507	+ self.user = user
		508	+ super(AdminPasswordChangeForm, self).__init__(args, *kwargs)
		509	+
		510	+ def clean_password2(self):
		511	+ password1 = self.cleaned_data.get('password1')
		512	+ password2 = self.cleaned_data.get('password2')
		513	+ if password1 and password2:
		514	+ if password1 != password2:
		515	+ raise forms.ValidationError(
		516	+ self.error_messages['password_mismatch'],
		517	+ code='password_mismatch',
		518	+ )
		519	+ return password2
		520	+
		521	+ def save(self, commit=True):
		522	+ """
		523	+ Saves the new password.
		524	+ """
		525	+ self.user.set_password(self.cleaned_data["password1"])
		526	+ if commit:
		527	+ self.user.save()
		528	+ return self.user
		529	+
		530	+ def _get_changed_data(self):
		531	+ data = super(AdminPasswordChangeForm, self).changed_data
		532	+ for name in self.fields.keys():
		533	+ if name not in data:
		534	+ return []
		535	+ return ['password']