Produits Entr'ouvert » Calebasse

# -*- coding: utf-8 -*-

        'duplicate_username': _("A user with that username already exists."),

        'password_mismatch': _("The two password fields didn't match."),

    }

    password1 = forms.CharField(label=_("Password"),

        widget=forms.PasswordInput,

        required=False)

        self.service = service

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

        self.fields['worker'].queryset = Worker.objects.for_service(service)

        self.fields['username'].label = _('Identifiant')

        if self.instance:

            try:

                worker = self.instance.userworker.worker

                self.fields['worker'].initial = worker.pk

            except UserWorker.DoesNotExist:

                pass

        # Since User.username is unique, this check is redundant,

        # but it sets a nicer error message than the ORM. See #13147.

        username = self.cleaned_data["username"]

            try:

                User.objects.get(username=username)

                raise forms.ValidationError(self.error_messages['duplicate_username'])

            except User.DoesNotExist:

                pass

        return username

        password1 = self.cleaned_data.get("password1")

        password2 = self.cleaned_data.get("password2")

        if password1 and password2 and password1 != password2:

            raise forms.ValidationError(

                self.error_messages['password_mismatch'])

        return password2

    class Meta:

        widgets = {

                'groups': forms.CheckboxSelectMultiple,

        }

    def save(self, commit=True):

        instance = super(UserForm, self).save(commit=False)

        if self.cleaned_data['password1']:

            instance.set_password(self.cleaned_data['password1'])

        worker = self.cleaned_data.get('worker')

        if worker is not None:

            instance.last_name = worker.last_name

                if qs.exists():

                    qs.update(worker=worker)

            try:

                instance.userworker.delete()

            except UserWorker.DoesNotExist:

                pass

            instance.groups = self.cleaned_data['groups']

            instance.save()

    last_name = forms.CharField(label=u'Nom', required=False)

    first_name = forms.CharField(label=u'Prénom', required=False)

    profession = forms.ModelChoiceField(label=u'Profession',

            queryset=WorkerType.objects.all(), required=False)

    INTERVENE_STATUS_CHOICES = {

    intervene_status = forms.MultipleChoiceField(

        choices=INTERVENE_STATUS_CHOICES.iteritems(),

        widget=forms.CheckboxSelectMultiple,

        initial=INTERVENE_STATUS_CHOICES.keys(),

        required=False)

class WorkerIdForm(forms.ModelForm):

    class Meta:

        model = Worker

        widgets = {

                'initials': forms.TextInput(attrs={'size': 6}),

                }

class WorkerServiceForm(forms.ModelForm):

    class Meta:

        model = Worker

        fields = ('services',)

        widgets = {

                'services': forms.CheckboxSelectMultiple,

        }

(2, None, None),

(3, None, None),

(4, None, None),

(5, None, None),

(None, 0, None),

(None, 1, None),

(None, 2, None),

(None, 3, None),

(None, 4, None),

(None, None, 0),

(None, None, 1)

]

    class Meta:

        model = TimeTable

        widgets = {

                'services': forms.CheckboxSelectMultiple,

                'week_parity': forms.HiddenInput(),

                'week_rank': forms.HiddenInput(),

        cleaned_data = super(BaseTimeTableForm, self).clean()

        msg = None

        if not cleaned_data.get('periodicity'):

            msg = u"Périodicité manquante."

        else:

            try:

                periodicity = int(cleaned_data.get('periodicity'))

                if periodicity:

                    if periodicity < 1 or periodicity > 12:

                        msg = u"Périodicité inconnue."

                    else:

                        cleaned_data['week_period'], \

                        cleaned_data['week_parity'] = PERIOD_LIST_TO_FIELDS[periodicity - 1]

                msg = u"Périodicité invalide."

        if msg:

            self._errors["periodicity"] = self.error_class([msg])

        return cleaned_data

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

        self.fields['holiday_type'].queryset = \

                HolidayType.objects.filter(for_group=False)

        widgets = {

                'comment': forms.Textarea(attrs={'rows': 3}),

        }

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

            HolidayType.objects.filter(for_group=False)

        model = Holiday

        widgets = {

            'comment': forms.Textarea(attrs = {'rows': 3, 'cols': 18}),

                                          attrs = {'size': 10}),

            'end_date': forms.DateInput(format = '%d/%m/%Y',

    def clean(self):

        cleaned_data = super(HolidayForm, self).clean()

        if cleaned_data.get('start_date') and cleaned_data.get('end_date'):

            if cleaned_data['start_date'] > cleaned_data['end_date']:

                raise forms.ValidationError(u'La date de début doit être supérieure à la date de fin')

        return cleaned_data

class HolidaySearchForm(forms.Form):

    end_date = forms.DateField(required=False, localize=True)

    def clean(self):

        cleaned_data = super(HolidaySearchForm, self).clean()

                raise forms.ValidationError(u'La date de début doit être supérieure à la date de fin')

        return cleaned_data

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

        old_form = self.form

        self.form = lambda *args, **kwargs: old_form(*args, service=self.service, **kwargs)

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

        self.fields['holiday_type'].queryset = \

                HolidayType.objects.filter(for_group=True)

        formset=GroupHolidayBaseFormSet,

        fields=('start_date', 'end_date', 'start_time', 'end_time', 'holiday_type', 'comment'))