Synnefo

from django import forms

from django.utils.translation import ugettext as _

from django.contrib.auth.forms import (UserCreationForm, AuthenticationForm,

from django.core.mail import send_mail

from django.contrib.auth.tokens import default_token_generator

from django.template import Context, loader

from django.forms.extras.widgets import SelectDateWidget

from django.conf import settings

    Membership, GroupKind, get_latest_terms

)

from astakos.im.settings import (INVITATIONS_PER_LEVEL, BASEURL, SITENAME,

from astakos.im.widgets import DummyWidget, RecaptchaWidget

from astakos.im.functions import send_change_email

logger = logging.getLogger(__name__)

class LocalUserCreationForm(UserCreationForm):

    """

    Extends the built in UserCreationForm in several ways:

    * User created is not active.

    """

    recaptcha_challenge_field = forms.CharField(widget=DummyWidget)

    class Meta:

        model = AstakosUser

    def __init__(self, *args, **kwargs):

        """

            kwargs.pop('request')

            self.ip = request.META.get('REMOTE_ADDR',

                                       request.META.get('HTTP_X_REAL_IP', None))

        super(LocalUserCreationForm, self).__init__(*args, **kwargs)

        self.fields.keyOrder = ['email', 'first_name', 'last_name',

                                'password1', 'password2']

        if RECAPTCHA_ENABLED:

            self.fields.keyOrder.extend(['recaptcha_challenge_field',

        if get_latest_terms():

            self.fields.keyOrder.append('has_signed_terms')

        if 'has_signed_terms' in self.fields:

            # Overriding field label since we need to apply a link

            # to the terms within the label

            terms_link_html = '<a href="%s" target="_blank">%s</a>' \

            self.fields['has_signed_terms'].label = \

    def clean_email(self):

        email = self.cleaned_data['email']

        rrf = self.cleaned_data['recaptcha_response_field']

        check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)

        if not check.is_valid:

    def save(self, commit=True):

        """

            logger.log(LOGGING_LEVEL, 'Created user %s' % user.email)

        return user

class InvitedLocalUserCreationForm(LocalUserCreationForm):

    """

    Extends the LocalUserCreationForm: email is readonly.

        ro = ('email', 'username',)

        for f in ro:

            self.fields[f].widget.attrs['readonly'] = True

    def save(self, commit=True):

        user = super(InvitedLocalUserCreationForm, self).save(commit=False)

            user.save()

        return user

class ThirdPartyUserCreationForm(forms.ModelForm):

    class Meta:

        model = AstakosUser

    def __init__(self, *args, **kwargs):

        """

        Changes the order of fields, and removes the username field.

        if self.request:

            kwargs.pop('request')

        super(ThirdPartyUserCreationForm, self).__init__(*args, **kwargs)

        if get_latest_terms():

            self.fields.keyOrder.append('has_signed_terms')

        #set readonly form fields

        ro = ["third_party_identifier"]

        for f in ro:

            self.fields[f].widget.attrs['readonly'] = True

        if 'has_signed_terms' in self.fields:

            # Overriding field label since we need to apply a link

            # to the terms within the label

            terms_link_html = '<a href="%s" target="_blank">%s</a>' \

            self.fields['has_signed_terms'].label = \

    def clean_email(self):

        email = self.cleaned_data['email']

        if not email:

            raise forms.ValidationError(_("This field is required"))

        return email

    def clean_has_signed_terms(self):

        has_signed_terms = self.cleaned_data['has_signed_terms']

        if not has_signed_terms:

            raise forms.ValidationError(_('You have to agree with the terms'))

        return has_signed_terms

    def save(self, commit=True):

        user = super(ThirdPartyUserCreationForm, self).save(commit=False)

        user.set_unusable_password()

            logger.log(LOGGING_LEVEL, 'Created user %s' % user.email)

        return user

class InvitedThirdPartyUserCreationForm(ThirdPartyUserCreationForm):

    """

    Extends the ThirdPartyUserCreationForm: email is readonly.

        """

        Changes the order of fields, and removes the username field.

        """

        #set readonly form fields

        ro = ('email',)

        for f in ro:

            self.fields[f].widget.attrs['readonly'] = True

    def save(self, commit=True):

        level = user.invitation.inviter.level + 1

        user.level = level

        user.invitations = INVITATIONS_PER_LEVEL.get(level, 0)

            user.save()

        return user

class ShibbolethUserCreationForm(ThirdPartyUserCreationForm):

    def __init__(self, *args, **kwargs):

        super(ShibbolethUserCreationForm, self).__init__(*args, **kwargs)

        self.fields.keyOrder.append('additional_email')

        # copy email value to additional_mail in case user will change it

        name = 'email'

        field = self.fields[name]

    def clean_email(self):

        email = self.cleaned_data['email']

            if user.provider == 'shibboleth':

                raise forms.ValidationError(_("This email is already associated with another shibboleth account."))

            elif not user.is_active:

        super(ShibbolethUserCreationForm, self).clean_email()

        return email

class InvitedShibbolethUserCreationForm(ShibbolethUserCreationForm, InvitedThirdPartyUserCreationForm):

    pass

class LoginForm(AuthenticationForm):

    username = forms.EmailField(label=_("Email"))

    recaptcha_challenge_field = forms.CharField(widget=DummyWidget)

    def __init__(self, *args, **kwargs):

        was_limited = kwargs.get('was_limited', False)

        request = kwargs.get('request', None)

        if request:

            self.ip = request.META.get('REMOTE_ADDR',

                                       request.META.get('HTTP_X_REAL_IP', None))

        t = ('request', 'was_limited')

        for elem in t:

            if elem in kwargs.keys():

                kwargs.pop(elem)

        super(LoginForm, self).__init__(*args, **kwargs)

        self.fields.keyOrder = ['username', 'password']

        if was_limited and RECAPTCHA_ENABLED:

            self.fields.keyOrder.extend(['recaptcha_challenge_field',

    def clean_recaptcha_response_field(self):

        if 'recaptcha_challenge_field' in self.cleaned_data:

            self.validate_captcha()

        rrf = self.cleaned_data['recaptcha_response_field']

        check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)

        if not check.is_valid:

    def clean(self):

        super(LoginForm, self).clean()

        if self.user_cache and self.user_cache.provider not in ('local', ''):

            raise forms.ValidationError(_('Local login is not the current authentication method for this account.'))

        return self.cleaned_data

class ProfileForm(forms.ModelForm):

    """

    Subclass of ``ModelForm`` for permiting user to edit his/her profile.

    class Meta:

        model = AstakosUser

    def __init__(self, *args, **kwargs):

        super(ProfileForm, self).__init__(*args, **kwargs)

            user.save()

        return user

class FeedbackForm(forms.Form):

    """

    Form for writing feedback.

    feedback_data = forms.CharField(widget=forms.HiddenInput(), label='',

                                    required=False)

class SendInvitationForm(forms.Form):

    """

    Form for sending an invitations

    """

class ExtendedPasswordResetForm(PasswordResetForm):

    """

        try:

            user = AstakosUser.objects.get(email=email, is_active=True)

            if not user.has_usable_password():

        except AstakosUser.DoesNotExist:

            raise forms.ValidationError(_('That e-mail address doesn\'t have an associated user account. Are you sure you\'ve registered?'))

        return email

        """

        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',

            url = urljoin(BASEURL, url)

            t = loader.get_template(email_template_name)

            c = {

            }

            from_email = settings.SERVER_EMAIL

            send_mail(_("Password reset on %s alpha2 testing") % SITENAME,

class EmailChangeForm(forms.ModelForm):

    class Meta:

        model = EmailChange

        fields = ('new_email_address',)

    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.'))

        return addr

    def save(self, email_template_name, request, commit=True):

        ec = super(EmailChangeForm, self).save(commit=False)

        ec.user = request.user

        if commit:

            ec.save()

        send_change_email(ec, request, email_template_name=email_template_name)

class SignApprovalTermsForm(forms.ModelForm):

    class Meta:

        model = AstakosUser

            raise forms.ValidationError(_('You have to agree with the terms'))

        return has_signed_terms

class InvitationForm(forms.ModelForm):

    username = forms.EmailField(label=_("Email"))

    def __init__(self, *args, **kwargs):

        super(InvitationForm, self).__init__(*args, **kwargs)

    class Meta:

        model = Invitation

        fields = ('username', 'realname')

    def clean_username(self):

        username = self.cleaned_data['username']

        try:

        except Invitation.DoesNotExist:

            pass

        return username

class ExtendedPasswordChangeForm(PasswordChangeForm):

    """

    Extends PasswordChangeForm by enabling user

    to optionally renew also the token.

    """

    renew = forms.BooleanField(label='Renew token', required=False)

    def __init__(self, user, *args, **kwargs):

        super(ExtendedPasswordChangeForm, self).__init__(user, *args, **kwargs)

    def save(self, commit=True):

        user = super(ExtendedPasswordChangeForm, self).save(commit=False)

        if self.cleaned_data.get('renew'):

            user.save()

        return user

class AstakosGroupCreationForm(forms.ModelForm):

#     issue_date = forms.DateField(widget=SelectDateWidget())

#     expiration_date = forms.DateField(widget=SelectDateWidget())

    class Meta:

        model = AstakosGroup

    def __init__(self, *args, **kwargs):

        try:

            resources = kwargs.pop('resources')

                required=False,

                help_text=_('Leave it blank for no additional quota.')

            )

    def resources(self):

        for name, value in self.cleaned_data.items():

            prefix, delimiter, suffix = name.partition('resource_')

                    continue

                yield (suffix, value)

class AstakosGroupSearchForm(forms.Form):