/snf-astakos-app/astakos/im/forms.py - Diff - Synnefo - Greek Research and Technology Network's projects

Revision d2633501 snf-astakos-app/astakos/im/forms.py

     from django.contrib import messages
     from django.utils.encoding import smart_str
     from django.forms.models import fields_for_model
     from django.db import transaction
     from astakos.im.models import (
         AstakosUser, Invitation, get_latest_terms,
-...
     from astakos.im.settings import (INVITATIONS_PER_LEVEL, DEFAULT_FROM_EMAIL,
         BASEURL, SITENAME, RECAPTCHA_PRIVATE_KEY, DEFAULT_CONTACT_EMAIL,
         RECAPTCHA_ENABLED, LOGGING_LEVEL, PASSWORD_RESET_EMAIL_SUBJECT,
         NEWPASSWD_INVALIDATE_TOKEN
         NEWPASSWD_INVALIDATE_TOKEN, MODERATION_ENABLED
+    )
     from astakos.im import settings
     from astakos.im.widgets import DummyWidget, RecaptchaWidget
     from astakos.im.functions import send_change_email
-...
     logger = logging.getLogger(__name__)
     class LocalUserCreationForm(UserCreationForm):
     class StoreUserMixin(object):
         @transaction.commit_on_success
         def store_user(self, user, request):
             user.save()
             self.post_store_user(user, request)
             return user
         def post_store_user(self, user, request):
             """
             Interface method for descendant backends to be able to do stuff within
             the transaction enabled by store_user.
             """
             pass
     class LocalUserCreationForm(UserCreationForm, StoreUserMixin):
         """
         Extends the built in UserCreationForm in several ways:
-...
                         mark_safe("I agree with %s" % terms_link_html)
         def clean_email(self):
             email = self.cleaned_data['email']
             email = self.cleaned_data['email'].lower()
             if not email:
                 raise forms.ValidationError(_("This field is required"))
             if reserved_email(email):
-...
             if not check.is_valid:
                 raise forms.ValidationError(_('You have not entered the correct words'))
         def post_store_user(self, user, request):
             """
             Interface method for descendant backends to be able to do stuff within
             the transaction enabled by store_user.
             """
             user.add_auth_provider('local', auth_backend='astakos')
             user.set_password(self.cleaned_data['password1'])
         def save(self, commit=True):
             """
             Saves the email, first_name and last_name properties, after the normal
             save behavior is complete.
             """
             user = super(LocalUserCreationForm, self).save(commit=False)
             user.renew_token()
             if commit:
                 user.save()
                 logger._log(LOGGING_LEVEL, 'Created user %s' % user.email, [])
-...
         def save(self, commit=True):
             user = super(InvitedLocalUserCreationForm, self).save(commit=False)
             level = user.invitation.inviter.level + 1
             user.level = level
             user.invitations = INVITATIONS_PER_LEVEL.get(level, 0)
             user.update_invitations_level()
             user.email_verified = True
             if commit:
                 user.save()
             return user
     class ThirdPartyUserCreationForm(forms.ModelForm):
     class ThirdPartyUserCreationForm(forms.ModelForm, StoreUserMixin):
         id = forms.CharField(
             widget=forms.HiddenInput(),
             label='',
-...
                         mark_safe("I agree with %s" % terms_link_html)
         def clean_email(self):
             email = self.cleaned_data['email']
             email = self.cleaned_data['email'].lower()
             if not email:
                 raise forms.ValidationError(_("This field is required"))
             return email
-...
                 raise forms.ValidationError(_('You have to agree with the terms'))
             return has_signed_terms
         def post_store_user(self, user, request):
             pending = PendingThirdPartyUser.objects.get(
                                     token=request.POST.get('third_party_token'),
                                     third_party_identifier= \
                 self.cleaned_data.get('third_party_identifier'))
             return user.add_pending_auth_provider(pending)
         def save(self, commit=True):
             user = super(ThirdPartyUserCreationForm, self).save(commit=False)
             user.set_unusable_password()
             user.provider = get_query(self.request).get('provider')
             user.is_local = False
             user.renew_token()
             if commit:
                 user.save()
                 logger._log(LOGGING_LEVEL, 'Created user %s' % user.email, [])
-...
         def save(self, commit=True):
             user = super(InvitedThirdPartyUserCreationForm, self).save(commit=False)
             level = user.invitation.inviter.level + 1
             user.level = level
             user.invitations = INVITATIONS_PER_LEVEL.get(level, 0)
             user.set_invitation_level()
             user.email_verified = True
             if commit:
                 user.save()
-...
             field = self.fields[name]
             self.initial['additional_email'] = self.initial.get(name, field.initial)
             self.initial['email'] = None
         def clean_email(self):
             email = self.cleaned_data['email']
             email = self.cleaned_data['email'].lower()
             if self.instance:
                 if self.instance.email == email:
                     raise forms.ValidationError(_("This is your current email."))
-...
                     raise forms.ValidationError(_("This email is already used"))
             super(ShibbolethUserCreationForm, self).clean_email()
             return email
         def save(self, commit=True):
             user = super(ShibbolethUserCreationForm, self).save(commit=False)
             try:
                 p = PendingThirdPartyUser.objects.get(
                     provider=user.provider,
                     third_party_identifier=user.third_party_identifier
+                )
             except:
                 pass
             else:
                 p.delete()
             return user
     class InvitedShibbolethUserCreationForm(ShibbolethUserCreationForm, InvitedThirdPartyUserCreationForm):
         pass
-...
                 user = AstakosUser.objects.get(email=email, is_active=True)
                 if not user.has_usable_password():
                     raise forms.ValidationError(_("This account has not a usable password."))
                 if not user.can_change_password():
                     raise forms.ValidationError(_('Password change for this account'
                                                   ' is not supported.'))
             except AstakosUser.DoesNotExist, e:
                 raise forms.ValidationError(_('That e-mail address doesn\'t have an associated user account. Are you sure you\'ve registered?'))
                 raise forms.ValidationError(_('That e-mail address doesn\'t have an'
                                               ' associated user account. Are you sure'
                                               ' you\'ve registered?'))
             return email
         def save(self, domain_override=None, email_template_name='registration/password_reset_email.html',
-...
             Generates a one-use only link for resetting password and sends to the user.
             """
             for user in self.users_cache:
                 url = reverse('django.contrib.auth.views.password_reset_confirm',
                               kwargs={'uidb36':int_to_base36(user.id),
                                       'token':token_generator.make_token(user)})
                 url = user.astakosuser.get_password_reset_url(token_generator)
                 url = urljoin(BASEURL, url)
                 t = loader.get_template(email_template_name)
                 c = {
-...
         def clean_new_email_address(self):
             addr = self.cleaned_data['new_email_address']
             if AstakosUser.objects.filter(email__iexact=addr):
                 raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))
                 raise forms.ValidationError(_(u"This email address is already "
                                                "in use. Please supply a "
                                                "different email address."))
             return addr
         def save(self, email_template_name, request, commit=True):
-...
         def __init__(self, user, *args, **kwargs):
             super(ExtendedSetPasswordForm, self).__init__(user, *args, **kwargs)
         @transaction.commit_on_success()
         def save(self, commit=True):
             try:
                 self.user = AstakosUser.objects.get(id=self.user.id)
                 if NEWPASSWD_INVALIDATE_TOKEN or self.cleaned_data.get('renew'):
                     self.user.renew_token()
                 self.user.flush_sessions()
                 #self.user.flush_sessions()
                 if not self.user.has_auth_provider('local'):
                     self.user.add_auth_provider('local', auth_backend='astakos')
             except BaseException, e:
                 logger.exception(e)
                 pass

Also available in: Unified diff