code.grnet.gr Git - astakos/blob - snf-astakos-app/astakos/im/forms.py

   1 # Copyright 2011-2012 GRNET S.A. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or
   4 # without modification, are permitted provided that the following
   5 # conditions are met:
   6 #
   7 #   1. Redistributions of source code must retain the above
   8 #      copyright notice, this list of conditions and the following
   9 #      disclaimer.
  10 #
  11 #   2. Redistributions in binary form must reproduce the above
  12 #      copyright notice, this list of conditions and the following
  13 #      disclaimer in the documentation and/or other materials
  14 #      provided with the distribution.
  15 #
  16 # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  17 # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  20 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  23 # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  24 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  26 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 # POSSIBILITY OF SUCH DAMAGE.
  28 #
  29 # The views and conclusions contained in the software and
  30 # documentation are those of the authors and should not be
  31 # interpreted as representing official policies, either expressed
  32 # or implied, of GRNET S.A.
  33 from urlparse import urljoin
  34 from datetime import datetime
  35
  36 from django import forms
  37 from django.utils.translation import ugettext as _
  38 from django.contrib.auth.forms import UserCreationForm, AuthenticationForm, PasswordResetForm
  39 from django.core.mail import send_mail
  40 from django.contrib.auth.tokens import default_token_generator
  41 from django.template import Context, loader
  42 from django.utils.http import int_to_base36
  43 from django.core.urlresolvers import reverse
  44 from django.utils.functional import lazy
  45 from django.utils.safestring import mark_safe
  46 from django.contrib import messages
  47
  48 from astakos.im.models import AstakosUser, Invitation, get_latest_terms
  49 from astakos.im.settings import INVITATIONS_PER_LEVEL, DEFAULT_FROM_EMAIL, SITENAME, RECAPTCHA_PRIVATE_KEY, DEFAULT_CONTACT_EMAIL, RECAPTCHA_ENABLED
  50 from astakos.im.widgets import DummyWidget, RecaptchaWidget
  51
  52 # since Django 1.4 use django.core.urlresolvers.reverse_lazy instead
  53 from astakos.im.util import reverse_lazy, reserved_email, get_query
  54
  55 import logging
  56 import recaptcha.client.captcha as captcha
  57
  58 logger = logging.getLogger(__name__)
  59
  60 class LocalUserCreationForm(UserCreationForm):
  61     """
  62     Extends the built in UserCreationForm in several ways:
  63
  64     * Adds email, first_name, last_name, recaptcha_challenge_field, recaptcha_response_field field.
  65     * The username field isn't visible and it is assigned a generated id.
  66     * User created is not active.
  67     """
  68     recaptcha_challenge_field = forms.CharField(widget=DummyWidget)
  69     recaptcha_response_field = forms.CharField(widget=RecaptchaWidget, label='')
  70
  71     class Meta:
  72         model = AstakosUser
  73         fields = ("email", "first_name", "last_name", "has_signed_terms", "has_signed_terms")
  74
  75     def __init__(self, *args, **kwargs):
  76         """
  77         Changes the order of fields, and removes the username field.
  78         """
  79         request = kwargs.get('request', None)
  80         if request:
  81             kwargs.pop('request')
  82             self.ip = request.META.get('REMOTE_ADDR',
  83                                        request.META.get('HTTP_X_REAL_IP', None))
  84
  85         super(LocalUserCreationForm, self).__init__(*args, **kwargs)
  86         self.fields.keyOrder = ['email', 'first_name', 'last_name',
  87                                 'password1', 'password2']
  88         if get_latest_terms():
  89             self.fields.keyOrder.append('has_signed_terms')
  90         if RECAPTCHA_ENABLED:
  91             self.fields.keyOrder.extend(['recaptcha_challenge_field',
  92                                          'recaptcha_response_field',])
  93
  94         if 'has_signed_terms' in self.fields:
  95             # Overriding field label since we need to apply a link
  96             # to the terms within the label
  97             terms_link_html = '<a href="%s" target="_blank">%s</a>' \
  98                     % (reverse('latest_terms'), _("the terms"))
  99             self.fields['has_signed_terms'].label = \
 100                     mark_safe("I agree with %s" % terms_link_html)
 101
 102     def clean_email(self):
 103         email = self.cleaned_data['email']
 104         if not email:
 105             raise forms.ValidationError(_("This field is required"))
 106         if reserved_email(email):
 107             raise forms.ValidationError(_("This email is already used"))
 108         return email
 109
 110     def clean_has_signed_terms(self):
 111         has_signed_terms = self.cleaned_data['has_signed_terms']
 112         if not has_signed_terms:
 113             raise forms.ValidationError(_('You have to agree with the terms'))
 114         return has_signed_terms
 115
 116     def clean_recaptcha_response_field(self):
 117         if 'recaptcha_challenge_field' in self.cleaned_data:
 118             self.validate_captcha()
 119         return self.cleaned_data['recaptcha_response_field']
 120
 121     def clean_recaptcha_challenge_field(self):
 122         if 'recaptcha_response_field' in self.cleaned_data:
 123             self.validate_captcha()
 124         return self.cleaned_data['recaptcha_challenge_field']
 125
 126     def validate_captcha(self):
 127         rcf = self.cleaned_data['recaptcha_challenge_field']
 128         rrf = self.cleaned_data['recaptcha_response_field']
 129         check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)
 130         if not check.is_valid:
 131             raise forms.ValidationError(_('You have not entered the correct words'))
 132
 133     def save(self, commit=True):
 134         """
 135         Saves the email, first_name and last_name properties, after the normal
 136         save behavior is complete.
 137         """
 138         user = super(LocalUserCreationForm, self).save(commit=False)
 139         user.renew_token()
 140         if commit:
 141             user.save()
 142         logger.info('Created user %s', user)
 143         return user
 144
 145 class InvitedLocalUserCreationForm(LocalUserCreationForm):
 146     """
 147     Extends the LocalUserCreationForm: email is readonly.
 148     """
 149     class Meta:
 150         model = AstakosUser
 151         fields = ("email", "first_name", "last_name", "has_signed_terms")
 152
 153     def __init__(self, *args, **kwargs):
 154         """
 155         Changes the order of fields, and removes the username field.
 156         """
 157         super(InvitedLocalUserCreationForm, self).__init__(*args, **kwargs)
 158
 159         #set readonly form fields
 160         ro = ('email', 'username',)
 161         for f in ro:
 162             self.fields[f].widget.attrs['readonly'] = True
 163
 164
 165     def save(self, commit=True):
 166         user = super(InvitedLocalUserCreationForm, self).save(commit=False)
 167         level = user.invitation.inviter.level + 1
 168         user.level = level
 169         user.invitations = INVITATIONS_PER_LEVEL.get(level, 0)
 170         user.email_verified = True
 171         if commit:
 172             user.save()
 173         return user
 174
 175 class ThirdPartyUserCreationForm(forms.ModelForm):
 176     class Meta:
 177         model = AstakosUser
 178         fields = ("email", "first_name", "last_name", "third_party_identifier", "has_signed_terms")
 179
 180     def __init__(self, *args, **kwargs):
 181         """
 182         Changes the order of fields, and removes the username field.
 183         """
 184         self.request = kwargs.get('request', None)
 185         if self.request:
 186             kwargs.pop('request')
 187         super(ThirdPartyUserCreationForm, self).__init__(*args, **kwargs)
 188         self.fields.keyOrder = ['email', 'first_name', 'last_name', 'third_party_identifier']
 189         if get_latest_terms():
 190             self.fields.keyOrder.append('has_signed_terms')
 191         #set readonly form fields
 192         ro = ["third_party_identifier", "first_name", "last_name"]
 193         for f in ro:
 194             self.fields[f].widget.attrs['readonly'] = True
 195
 196         if 'has_signed_terms' in self.fields:
 197             # Overriding field label since we need to apply a link
 198             # to the terms within the label
 199             terms_link_html = '<a href="%s" target="_blank">%s</a>' \
 200                     % (reverse('latest_terms'), _("the terms"))
 201             self.fields['has_signed_terms'].label = \
 202                     mark_safe("I agree with %s" % terms_link_html)
 203
 204     def clean_email(self):
 205         email = self.cleaned_data['email']
 206         if not email:
 207             raise forms.ValidationError(_("This field is required"))
 208         return email
 209
 210     def clean_has_signed_terms(self):
 211         has_signed_terms = self.cleaned_data['has_signed_terms']
 212         if not has_signed_terms:
 213             raise forms.ValidationError(_('You have to agree with the terms'))
 214         return has_signed_terms
 215
 216     def save(self, commit=True):
 217         user = super(ThirdPartyUserCreationForm, self).save(commit=False)
 218         user.set_unusable_password()
 219         user.renew_token()
 220         user.provider = get_query(self.request).get('provider')
 221         if commit:
 222             user.save()
 223         logger.info('Created user %s', user)
 224         return user
 225
 226 class InvitedThirdPartyUserCreationForm(ThirdPartyUserCreationForm):
 227     """
 228     Extends the ThirdPartyUserCreationForm: email is readonly.
 229     """
 230     def __init__(self, *args, **kwargs):
 231         """
 232         Changes the order of fields, and removes the username field.
 233         """
 234         super(InvitedThirdPartyUserCreationForm, self).__init__(*args, **kwargs)
 235
 236         #set readonly form fields
 237         ro = ('email',)
 238         for f in ro:
 239             self.fields[f].widget.attrs['readonly'] = True
 240
 241     def save(self, commit=True):
 242         user = super(InvitedThirdPartyUserCreationForm, self).save(commit=False)
 243         level = user.invitation.inviter.level + 1
 244         user.level = level
 245         user.invitations = INVITATIONS_PER_LEVEL.get(level, 0)
 246         user.email_verified = True
 247         if commit:
 248             user.save()
 249         return user
 250
 251 class ShibbolethUserCreationForm(ThirdPartyUserCreationForm):
 252     def clean_email(self):
 253         email = self.cleaned_data['email']
 254         for user in AstakosUser.objects.filter(email = email):
 255             if user.provider == 'shibboleth':
 256                 raise forms.ValidationError(_("This email is already associated with another shibboleth account."))
 257         super(ShibbolethUserCreationForm, self).clean_email()
 258         return email
 259
 260 class InvitedShibbolethUserCreationForm(ShibbolethUserCreationForm, InvitedThirdPartyUserCreationForm):
 261     pass
 262
 263 class LoginForm(AuthenticationForm):
 264     username = forms.EmailField(label=_("Email"))
 265     recaptcha_challenge_field = forms.CharField(widget=DummyWidget)
 266     recaptcha_response_field = forms.CharField(widget=RecaptchaWidget, label='')
 267
 268     def __init__(self, *args, **kwargs):
 269         was_limited = kwargs.get('was_limited', False)
 270         request = kwargs.get('request', None)
 271         if request:
 272             self.ip = request.META.get('REMOTE_ADDR',
 273                                        request.META.get('HTTP_X_REAL_IP', None))
 274
 275         t = ('request', 'was_limited')
 276         for elem in t:
 277             if elem in kwargs.keys():
 278                 kwargs.pop(elem)
 279         super(LoginForm, self).__init__(*args, **kwargs)
 280
 281         self.fields.keyOrder = ['username', 'password']
 282         if was_limited and RECAPTCHA_ENABLED:
 283             self.fields.keyOrder.extend(['recaptcha_challenge_field',
 284                                          'recaptcha_response_field',])
 285
 286     def clean_recaptcha_response_field(self):
 287         if 'recaptcha_challenge_field' in self.cleaned_data:
 288             self.validate_captcha()
 289         return self.cleaned_data['recaptcha_response_field']
 290
 291     def clean_recaptcha_challenge_field(self):
 292         if 'recaptcha_response_field' in self.cleaned_data:
 293             self.validate_captcha()
 294         return self.cleaned_data['recaptcha_challenge_field']
 295
 296     def validate_captcha(self):
 297         rcf = self.cleaned_data['recaptcha_challenge_field']
 298         rrf = self.cleaned_data['recaptcha_response_field']
 299         check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)
 300         if not check.is_valid:
 301             raise forms.ValidationError(_('You have not entered the correct words'))
 302
 303 class ProfileForm(forms.ModelForm):
 304     """
 305     Subclass of ``ModelForm`` for permiting user to edit his/her profile.
 306     Most of the fields are readonly since the user is not allowed to change them.
 307
 308     The class defines a save method which sets ``is_verified`` to True so as the user
 309     during the next login will not to be redirected to profile page.
 310     """
 311     renew = forms.BooleanField(label='Renew token', required=False)
 312
 313     class Meta:
 314         model = AstakosUser
 315         fields = ('email', 'first_name', 'last_name', 'auth_token', 'auth_token_expires')
 316
 317     def __init__(self, *args, **kwargs):
 318         super(ProfileForm, self).__init__(*args, **kwargs)
 319         instance = getattr(self, 'instance', None)
 320         ro_fields = ('email', 'auth_token', 'auth_token_expires')
 321         if instance and instance.id:
 322             for field in ro_fields:
 323                 self.fields[field].widget.attrs['readonly'] = True
 324
 325     def save(self, commit=True):
 326         user = super(ProfileForm, self).save(commit=False)
 327         user.is_verified = True
 328         if self.cleaned_data.get('renew'):
 329             user.renew_token()
 330         if commit:
 331             user.save()
 332         return user
 333
 334 class FeedbackForm(forms.Form):
 335     """
 336     Form for writing feedback.
 337     """
 338     feedback_msg = forms.CharField(widget=forms.Textarea, label=u'Message')
 339     feedback_data = forms.CharField(widget=forms.HiddenInput(), label='',
 340                                     required=False)
 341
 342 class SendInvitationForm(forms.Form):
 343     """
 344     Form for sending an invitations
 345     """
 346
 347     email = forms.EmailField(required = True, label = 'Email address')
 348     first_name = forms.EmailField(label = 'First name')
 349     last_name = forms.EmailField(label = 'Last name')
 350
 351 class ExtendedPasswordResetForm(PasswordResetForm):
 352     """
 353     Extends PasswordResetForm by overriding save method:
 354     passes a custom from_email in send_mail.
 355
 356     Since Django 1.3 this is useless since ``django.contrib.auth.views.reset_password``
 357     accepts a from_email argument.
 358     """
 359     def clean_email(self):
 360         email = super(ExtendedPasswordResetForm, self).clean_email()
 361         try:
 362             user = AstakosUser.objects.get(email=email, is_active=True)
 363             if not user.has_usable_password():
 364                 raise forms.ValidationError(_("This account has not a usable password."))
 365         except AstakosUser.DoesNotExist, e:
 366             raise forms.ValidationError(_('That e-mail address doesn\'t have an associated user account. Are you sure you\'ve registered?'))
 367         return email
 368
 369     def save(self, domain_override=None, email_template_name='registration/password_reset_email.html',
 370              use_https=False, token_generator=default_token_generator, request=None):
 371         """
 372         Generates a one-use only link for resetting password and sends to the user.
 373         """
 374         for user in self.users_cache:
 375             url = reverse('django.contrib.auth.views.password_reset_confirm',
 376                           kwargs={'uidb36':int_to_base36(user.id),
 377                                   'token':token_generator.make_token(user)})
 378             url = request.build_absolute_uri(url)
 379             t = loader.get_template(email_template_name)
 380             c = {
 381                 'email': user.email,
 382                 'url': url,
 383                 'site_name': SITENAME,
 384                 'user': user,
 385                 'baseurl': request.build_absolute_uri(),
 386                 'support': DEFAULT_CONTACT_EMAIL
 387             }
 388             from_email = DEFAULT_FROM_EMAIL
 389             send_mail(_("Password reset on %s alpha2 testing") % SITENAME,
 390                 t.render(Context(c)), from_email, [user.email])
 391
 392 class SignApprovalTermsForm(forms.ModelForm):
 393     class Meta:
 394         model = AstakosUser
 395         fields = ("has_signed_terms",)
 396
 397     def __init__(self, *args, **kwargs):
 398         super(SignApprovalTermsForm, self).__init__(*args, **kwargs)
 399
 400     def clean_has_signed_terms(self):
 401         has_signed_terms = self.cleaned_data['has_signed_terms']
 402         if not has_signed_terms:
 403             raise forms.ValidationError(_('You have to agree with the terms'))
 404         return has_signed_terms
 405
 406 class InvitationForm(forms.ModelForm):
 407     username = forms.EmailField(label=_("Email"))
 408
 409     def __init__(self, *args, **kwargs):
 410         super(InvitationForm, self).__init__(*args, **kwargs)
 411
 412     class Meta:
 413         model = Invitation
 414         fields = ('username', 'realname')
 415
 416     def clean_username(self):
 417         username = self.cleaned_data['username']
 418         try:
 419             Invitation.objects.get(username = username)
 420             raise forms.ValidationError(_('There is already invitation for this email.'))
 421         except Invitation.DoesNotExist:
 422             pass
 423         return username