Produits Entr'ouvert » Calebasse

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

from django import forms

from django.utils.translation import ugettext_lazy as _

from ..personnes.models import Worker

from ..ressources.models import ActType

from ..middleware.request import get_request

            help_text=u'en minutes; vous pouvez utiliser la roulette de votre souris.')

class NewAppointmentForm(BaseForm):

                'time',

                'duration',

                'start_datetime': forms.HiddenInput,

        }

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

            self.service = service

                                                                                | Q(name__iexact='telephone')

                                                                                | Q(name__iexact='téléphone'))]

                    Worker.objects.for_service(service)

                    .order_by('name')

        act_type = self.data.get('act_type')

        # act type is available as raw data from the post request

        if act_type in self.special_types:

            return time(8, 0)

        if self.cleaned_data['time']:

            return self.cleaned_data['time']

        raise forms.ValidationError(_(u'This field is required.'))

        if act_type in self.special_types:

            return 10

        if self.cleaned_data['duration']:

            duration = self.cleaned_data['duration']

            try:

                duration = int(duration)

                if duration <= 0:

                    raise ValueError

                return duration

            except ValueError:

                raise forms.ValidationError(u'Le champ doit contenir uniquement des chiffres')

        raise forms.ValidationError(_(u'This field is required.'))

        patients = self.cleaned_data['patient']

            return [patient for patient in PatientRecord.objects.filter(pk__in=patients)]

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

            cleaned_data['start_datetime'] = datetime.combine(cleaned_data['date'],

                    cleaned_data['time'])

            # nasty trick to store the list of patients and pass the form

            # validation

            cleaned_data['patients'] = cleaned_data['patient']

            cleaned_data['patient'] = cleaned_data['patient'][0]

        patients = self.cleaned_data.pop('patients')

        for patient in patients:

            appointment.start_datetime = datetime.combine(self.cleaned_data['date'],

                                                          self.cleaned_data['time'])

            appointment.end_datetime = appointment.start_datetime + timedelta(

            appointment.clean()

            if commit:

                appointment.patient = patient

                appointment.save()

                                    '{obj_id} created by {user} from {ip}',

                                     obj_id=appointment.id)

                appointment.services = [self.service]

    def clean_patient(self):

        return self.cleaned_data['patient']

    def save(self, commit=True):

        appointment = super(NewAppointmentForm, self).save(commit=False)

        appointment.start_datetime = datetime.combine(self.cleaned_data['date'],

                    self.cleaned_data['time'])

        appointment.end_datetime = appointment.start_datetime + timedelta(

                minutes=self.cleaned_data['duration'])

        appointment.creator = get_request().user

        appointment.clean()

        if commit:

            appointment.save()

                                 '{obj_id} saved by {user} from {ip}',

                                 obj_id=appointment.id)

        return appointment

            choices=Event.PERIODICITIES, required=True)

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

            recurrence_end_date = cleaned_data['recurrence_end_date']

                            u"La date doit être supérieur au dernier acte facturé de la récurrence"])

        return cleaned_data

        if instance and instance.pk:

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

            self.fields['patient'].widget.attrs['disabled'] = 'disabled'

    def clean_patient(self):

        instance = getattr(self, 'instance', None)

        if instance:

            return instance.patient

        else:

            return self.cleaned_data.get('patient', None)

    class Meta:

        model = Event

        fields = (

                'date',

                'time',

                'duration',

                'start_datetime': forms.HiddenInput,

        self.service = service

        self.fields['date'].css = 'datepicker'

    def clean_duration(self):

        duration = self.cleaned_data['duration']

        try:

            return int(duration)

        except:

        event = super(NewEventForm, self).save(commit=False)

        event.start_datetime = datetime.combine(self.cleaned_data['date'],

        event.clean()

        if commit:

            event.save()

                                 obj_id=event.id)

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

            cleaned_data['start_datetime'] = datetime.combine(cleaned_data['date'],

                    cleaned_data['time'])

        if event_type and event_type.id == 4 and not cleaned_data.get('title'): # 'Autre'

            self._errors['title'] = self.error_class([

                            u"Ce champ est obligatoire pour les événements de type « Autre »."])

        return cleaned_data

    recurrence_periodicity = forms.ChoiceField(label=u"Périodicité",

            choices=Event.PERIODICITIES, required=True)

class UpdateEventForm(NewEventForm):

    class Meta(NewEventForm.Meta):

        fields = (

                'start_datetime',

                'title',

                'date',

                'time',

                'duration',

                'event_type',

                'services',

        )

class PeriodicEventsSearchForm(forms.Form):

            choices=(

                (0, 'Rendez-vous patient'),

            initial=[0,1])

    no_end_date = forms.BooleanField(label=u'Sans date de fin', required=False)

        cleaned_data = super(PeriodicEventsSearchForm, 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