Synnefo

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

    def save(self, commit=True):

        user.set_invitation_level()

        user.email_verified = True

        if commit:

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

        name = 'email'

        field = self.fields[name]

        self.initial['email'] = None

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

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

        if request:

        t = ('request', 'was_limited')

        for elem in t:

    Most of the fields are readonly since the user is not allowed to change

    them.

    """

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

    class Meta:

        return user

class FeedbackForm(forms.Form):

    """

    Form for writing feedback.

            raise forms.ValidationError(_(astakos_messages.EMAIL_UNKNOWN))

        return email

        """

        """

        for user in self.users_cache:

            url = user.astakosuser.get_password_reset_url(token_generator)

            raise forms.ValidationError(_(astakos_messages.EMAIL_USED))

        return addr

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

        ec.user = request.user

        # delete pending email changes

        username = self.cleaned_data['username']

        try:

            Invitation.objects.get(username=username)

        except Invitation.DoesNotExist:

            pass

        return username

    to optionally renew also the token.

    """

    if not settings.NEWPASSWD_INVALIDATE_TOKEN:

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

        self.session_key = kwargs.pop('session_key', None)

            pass

        return super(ExtendedPasswordChangeForm, self).save(commit=commit)

class ExtendedSetPasswordForm(SetPasswordForm):

    """

    Extends SetPasswordForm by enabling user

        return super(ExtendedSetPasswordForm, self).save(commit=commit)

app_name_placeholder = _("myproject.mylab.ntua.gr")

        The project's name should be in a domain format.

        The domain shouldn't neccessarily exist in the real

        world but is helpful to imply a structure.

        e.g.: myproject.mylab.ntua.gr or

        myservice.myteam.myorganization""")

        URL pointing at your project's site.

        e.g.: myinstitution.org/myproject/.

        Leave blank if there is no website.""")

        Please provide a short but descriptive abstract of your

        project, so that anyone searching can quickly understand

        what this project is about.""")

        Write down any comments you may have for the reviewer

        of this application (e.g. background and rationale to

        support your request).

        The comments are strictly for the review process

        and will not be made public.""")

        Provide a date when your need your project to be created,

        and members to be able to join and get resources.

        This date is only a hint to help prioritize reviews.""")

        At this date, the project will be automatically terminated

        and its resource grants revoked from all members. If you are

        not certain, it is best to start with a conservative estimation.

        You can always re-apply for an extension, if you need.""")

        Select how new members are accepted into the project.""")

        Select how new members can leave the project.""")

        Specify the maximum number of members this project may have,

        including the owner. Beyond this number, no new members

        may join the project and be granted the project resources.

join_policies = presentation.PROJECT_MEMBER_JOIN_POLICIES.items()

leave_policies = presentation.PROJECT_MEMBER_LEAVE_POLICIES.items()

class ProjectApplicationForm(forms.ModelForm):

    name = forms.CharField(

    homepage = forms.URLField(

    description = forms.CharField(

    comments = forms.CharField(

    start_date = forms.DateTimeField(

    end_date = forms.DateTimeField(

    member_leave_policy = forms.TypedChoiceField(

    limit_on_members_number = forms.IntegerField(

    class Meta:

        model = ProjectApplication

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

        instance = kwargs.get('instance')

            today = datetime(today.year, today.month, today.day)

            if start_date and (start_date - today).days < 0:

                raise forms.ValidationError(

        return start_date

    def clean_end_date(self):

                    raise forms.ValidationError("Resource %s does not exist" %

                                                resource.name)

                # keep only resource limits for selected resource groups

                    if not resource.allow_in_projects:

                        raise forms.ValidationError("Invalid resource %s" %

                                                    resource.name)

                    append(d)

        ordered_keys = presentation.RESOURCES['resources_order']

        def resource_order(r):

            if r['str_repr'] in ordered_keys:

                return ordered_keys.index(r['str_repr'])

                 ('issue_date', 'Sort by Issue date'),

                 ('start_date', 'Sort by Start Date'),

                 ('end_date', 'Sort by End Date'),

                 ('state', 'Sort by Status'),

                 ('-name', 'Sort by Name'),

                 ('-issue_date', 'Sort by Issue date'),

                 ('-start_date', 'Sort by Start Date'),

                 ('-end_date', 'Sort by End Date'),

                 ('-state', 'Sort by Status'),

        required=True

    )

class AddProjectMembersForm(forms.Form):

    q = forms.CharField(

        label=_('Add members'),

        help_text=_(astakos_messages.ADD_PROJECT_MEMBERS_Q_HELP),

        required=True,)

        except:

            return ()

class ProjectMembersSortForm(forms.Form):

    sorting = forms.ChoiceField(

        label='Sort by',

        choices=(('person__email', 'User Id'),

                 ('person__first_name', 'Name'),

                 ('acceptance_date', 'Acceptance date')

        required=True

    )

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

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

        self.fields_list = [

        ]

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

        self.success_messages = []

        self.fields.keyOrder = self.fields_list

    def _init_extra_form_fields(self):

        if self.email_change:

            self.fields.update(self.email_change_form.fields)

            self.fields['new_email_address'].required = False

        if self.password_change:

            self.fields.update(self.password_change_form.fields)

    def _init_extra_forms(self):

        self.email_change_form = EmailChangeForm(self.data)

        self._init_extra_form_fields()

    def is_valid(self):

            self.password_change_form.save(*args, **kwargs)

            self.password_changed = True

        return super(ExtendedProfileForm, self).save(*args, **kwargs)