Produits Entr'ouvert » Calebasse

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

from copy import copy

from django.utils.translation import ugettext_lazy as _

from ..middleware.request import get_request

__all__ = (

    'EventType',

    'Event',

class EventType(models.Model):

    '''

    Simple ``Event`` classifcation.

    '''

    class Meta:

        verbose_name_plural = u'Types d\'événement'

    def __unicode__(self):

        return self.label

    create_date = models.DateTimeField(_(u'Date de création'), auto_now_add=True)

            null=True, blank=True, default=None)

            null=True, blank=True, default=None)

                                  verbose_name=u'Ressource')

    old_rr_id = models.CharField(max_length=8, blank=True, null=True)

    # an exception cannot be periodic

    exception_to = models.ForeignKey('self', related_name='exceptions',

            blank=True, null=True,

            verbose_name=u'Exception à')

    exception_date = models.DateField(blank=True, null=True,

    PERIODS = (

            (1, u'Toutes les semaines'),

            (2, u'Une semaine sur deux'),

            (3, u'Une semaine sur trois'),

            (4, 'Une semaine sur quatre'),

            (5, 'Une semaine sur cinq')

    )

            (1, u'Toutes les semaines'),

            (2, u'Une semaine sur deux'),

            (3, u'Une semaine sur trois'),

            (4, u'Une semaine sur quatre'),

            (5, u'Une semaine sur cinq'),

            (6, u'La première semaine du mois'),

            (7, u'La deuxième semaine du mois'),

            (8, u'La troisième semaine du mois'),

            (9, u'La quatrième semaine du mois'),

            (11, u'Les semaines paires'),

            (12, u'Les semaines impaires')

    )

    WEEK_RANKS = (

            (0, u'La première semaine du mois'),

            (1, u'La deuxième semaine du mois'),

            (2, u'La troisième semaine du mois'),

            (3, u'La quatrième semaine du mois'),

            (-1, u'La dernière semaine du mois'),

#            (-2, u'L\'avant dernière semaine du mois'),

#            (-3, u'L\'antépénultième semaine du mois'),

#            (-4, u'L\'anté-antépénultième semaine du mois'),

#            (-5, u'L\'anté-anté-antépénultième semaine du mois')

    PARITIES = (

            (0, u'Les semaines paires'),

            (1, u'Les semaines impaires')

    )

    recurrence_periodicity = models.PositiveIntegerField(

            choices=PERIODICITIES,

            verbose_name=u"Périodicité",

            default=None,

            blank=True,

            db_index=True)

    recurrence_week_day = models.PositiveIntegerField(default=0, db_index=True)

            choices=zip(OFFSET, OFFSET),

            verbose_name=u"Décalage en semaines par rapport au 1/1/1970 pour le calcul de période",

            default=0,

            db_index=True)

    recurrence_week_period = models.PositiveIntegerField(

            choices=PERIODS,

            verbose_name=u"Période en semaines",

            default=None,

            blank=True,

            null=True,

            db_index=True)

            choices=WEEK_RANKS,

            choices=PARITIES,

            verbose_name=u"Parité des semaines",

            blank=True,

            db_index=True)

            verbose_name=_(u'Fin de la récurrence'),

            blank=True, null=True,

            db_index=True)

        (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),

        verbose_name_plural = u'Evénements'

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

        if kwargs.get('start_datetime') and not kwargs.has_key('recurrence_end_date'):

            kwargs['recurrence_end_date'] = kwargs.get('start_datetime').date()

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

    def clean(self):

        '''Initialize recurrence fields if they are not.'''

        if self.recurrence_week_parity is not None:

            if self.start_datetime:

                week = self.start_datetime.date().isocalendar()[1]

                start_week_parity = week % 2

                if start_week_parity != self.recurrence_week_parity:

            start_week_ranks = weekday_ranks(self.start_datetime.date())

            if self.recurrence_week_rank not in start_week_ranks:

                raise forms.ValidationError('La date de début de périodicité doit faire partie de la bonne semaine dans le mois.')

        if self.recurrence_periodicity:

            l = self.PERIOD_LIST_TO_FIELDS[self.recurrence_periodicity-1]

        else:

            l = None, None, None

        self.recurrence_week_period = l[0]

        self.recurrence_week_rank = l[1]

        self.recurrence_week_parity = l[2]

        if self.start_datetime:

            if self.recurrence_periodicity:

                self.recurrence_week_day = self.start_datetime.weekday()

            if self.recurrence_week_period is not None:

                self.recurrence_week_offset = weeks_since_epoch(self.start_datetime) % self.recurrence_week_period

        '''Distance between start and end of the event'''

        return self.end_datetime - self.start_datetime

    def time(self):

        return self.start_datetime.time()

    @property

    def date(self):

        return self.start_datetime.date()

    @property

    def duration(self):

        if self.timedelta():

            return self.timedelta().seconds / 60

        return 0

        if self.is_recurring():

            # consider exceptions

            exception = self.get_exceptions_dict().get(date)

            if exception is not None:

                return exception if exception.match_date(date) else None

            if self.canceled:

                return None

            if date.weekday() != self.recurrence_week_day:

                return None

            if self.start_datetime.date() > date:

                return None

            if self.recurrence_end_date and self.recurrence_end_date < date:

                return None

            if self.recurrence_week_period is not None:

                if weeks_since_epoch(date) % self.recurrence_week_period != self.recurrence_week_offset:

                    return None

            elif self.recurrence_week_parity is not None:

                if date.isocalendar()[1] % 2 != self.recurrence_week_parity:

                    return None

            elif self.recurrence_week_rank is not None:

                if self.recurrence_week_rank not in weekday_ranks(date):

                    return None

            else:

                raise NotImplemented

            return self

        else:

           The computed event is the fake one that you cannot save to the database.

            exception = self.get_exceptions_dict().get(today)

                if exception.start_datetime.date() == today:

                    return exception.today_occurrence(today)

                else:

                    return None

            if exception_or_self is None:

                return None

            if exception_or_self != self:

           self = self.eventwithact

            return self

        end_datetime = start_datetime + self.timedelta()

        event = copy(self)

        event.exception_date = today

        event.end_datetime = end_datetime

        event.recurrence_week_offset = 0

        event.recurrence_week_rank = None

        event.recurrence_end_date = None

        old_participants = list(self.participants.all())

                self.exceptions_dict[event.start_datetime.date()] = event

        return event

    def next_occurence(self, today=None):

        '''Returns the next occurence after today.'''

        today = today or date.today()

        for occurence in self.all_occurences():

            if occurence.start_datetime.date() > today:

                return occurence

    def is_recurring(self):

        '''Is this event multiple ?'''

        if not hasattr(self, 'exceptions_dict'):

            self.exceptions_dict = dict()

           limit - compute occurrences until limit days in the future

           Default is to limit to 90 days.

            max_end_date = max(date.today(), self.start_datetime.date()) + timedelta(days=limit)

            end_date = min(self.recurrence_end_date or max_end_date, max_end_date)

                delta = timedelta(days=self.recurrence_week_period*7)

                while day <= end_date:

                        occurrences.append(occurrence)

            elif self.recurrence_week_parity is not None:

                delta = timedelta(days=7)

                while day <= end_date:

                    if day.isocalendar()[1] % 2 == self.recurrence_week_parity:

                            occurrences.append(occurrence)

            elif self.recurrence_week_rank is not None:

                delta = timedelta(days=7)

                while day <= end_date:

                    if self.recurrence_week_rank in weekday_ranks(day):

                            occurrences.append(occurrence)

                    if exception.exception_date != exception.start_datetime.date() or exception.exception_date > end_date:

                        occurrences.append(exception.eventwithact if exception.event_type_id == 1 else exception)

        assert self.start_datetime is not None

            for exception in self.exceptions.all():

                exception.delete()

            self.canceled = True

            if hasattr(self, 'eventwithact'):

                # Needed

                self.eventwithact.canceled = True

            # save will clean acts

            self.save(*args, **kwargs)

    @property

    def acts(self):

        from ..actes.models import Act

        return Act.objects.filter(

                models.Q(parent_event=self) | \

                models.Q(parent_event__exception_to=self))

        '''

            Return True if at least one act of the present event or an act

            of one of its exceptions is not new.

        '''

        return True if [a for a in self.acts if not a.is_new()] else False

    def last_act_not_new(self):

        '''

            Return True if at least one act of the present event or an act

            of one of its exceptions is not new.

        '''

        act = None

        for a in self.acts:

            if not a.is_new():

                if not act or a.date > act.date:

                    act = a

        return act

        '''

            Return True if at least one act of the present event or an act

            of one of its exceptions is already billed.

        '''

        return self.acts.filter(already_billed=True).exists()

    def one_act_is_billed(self):

        '''

            Return True if at least one act of the present event or an act

            of one of its exceptions is billed.

        '''

        return self.acts.filter(is_billed=True).exists()

    def events_cleaning(self):

        """

            Delete exceptions out of bounds if not with an associated act

            already billed.

        """

        events = None

        if self.recurrence_end_date:

            events = Event.objects.filter(

                models.Q(exception_to=self,

                    exception_date__lt=self.start_datetime.date()) | \

                models.Q(exception_to=self,

                    exception_date__gt=self.recurrence_end_date))

        else:

            events = Event.objects.filter(exception_to=self,

                    exception_date__lt=self.start_datetime.date())

        for event in events:

            if hasattr(event, 'eventwithact'):

                if not event.eventwithact.act.already_billed:

                    event.delete()

            else:

                event.delete()

    def acts_cleaning(self):

        # list of occurences may have changed

        from ..actes.models import Act

        if self.exception_to:

            # maybe a new exception, so look for parent acts with same date

            # as exception date

            acts = Act.objects.filter(models.Q(parent_event=self)

                    |models.Q(parent_event=self.exception_to,

                        date=self.exception_date))

        else:

            acts = Act.objects.filter(parent_event=self)

        acts = acts.prefetch_related('actvalidationstate_set')

        if acts:

            eventwithact = self.eventwithact

            for act in acts:

                if occurrence:

                    occurrence.update_act(act)

                else:

                        act.delete()

        return Interval(self.start_datetime, self.end_datetime)

        return False

        return self.participants.filter(worker__enabled=False)

        missing_participants = []

        for participant in self.participants.all():

            holidays = None

            worker = participant.worker

            holidays = Holiday.objects.for_worker(worker) \

                  .for_timed_period(self.start_datetime.date(), self.start_datetime.time(), self.end_datetime.time())

            if holidays:

                missing_participants.append(participant)

        return missing_participants

            u'Tous les %s',      #(1, None, None),

            u'Un %s sur deux',   #(2, None, None),

            u'Un %s sur trois',  #(3, None, None),

            u'Un %s sur quatre', #(4, None, None),

            u'Un %s sur cinq',   #(5, None, None),

            u'Le premier %s du mois',   #(None, 0, None),

            u'Le deuxième %s du mois',  #(None, 1, None),

            u'Le troisième %s du mois', #(None, 2, None),

            u'Le quatrième %s du mois', #(None, 3, None),

            u'Le dernier %s du mois',   #(None, 4, None),

            u'Les %s les semaines paires',    #(None, None, 0),

            u'Les %s les semaines impaires', #(None, None, 1)

    ]

    WEEKDAY_DESRIPTION = [

            u'lundi',

            u'mardi',

            u'mercredi',

            u'jeudi',

            u'vendredi',

            u'samedi',

            u'dimanche'

    ]

    def recurrence_description(self):

        '''Self description of this recurring event'''

        if not self.recurrence_periodicity:

            return None

        parts = []

        if self.recurrence_end_date:

            parts.append(u'du')

        else:

            parts.append(u'à partir du')

        parts.append(self.start_datetime.strftime('%d/%m/%Y'))

        if self.recurrence_end_date:

            parts.append(u'au')

            parts.append(self.recurrence_end_date.strftime('%d/%m/%Y'))

        return u' '.join(parts)

        try:

            return self.eventwithact.is_absent()

        except self.DoesNotExist:

            return False

        return '<Event: on {start_datetime} with {participants}'.format(

                start_datetime=self.start_datetime,

                participants=self.participants.all() if self.id else '<un-saved>')

    def create_patient_appointment(self, creator, title, patient,

            doctors=[], act_type=None, service=None, start_datetime=None, end_datetime=None,

                title=title,

                event_type=EventType(id=1),

                participants=doctors,

                services=[service],

                start_datetime=start_datetime,

                end_datetime=end_datetime,

                until=until,

                act_type=act_type,

                patient=patient)

        return appointment

class EventWithAct(Event):

    '''An event corresponding to an act.'''

    objects = EventWithActManager()

    act_type = models.ForeignKey('ressources.ActType',

        verbose_name=u'Type d\'acte')

    patient = models.ForeignKey('dossiers.PatientRecord')

            if act.date == self.start_datetime.date():

                return act

        act = self.act

        if act.id:

            return act.get_state()

        return None

        act = self.act

        if act.id:

            return act.is_absent()

        return False

        self.init_act(act)

        old_save = act.save

        def save(*args, **kwargs):

                    act=act, state_name='NON_VALIDE',

                    author=self.creator, previous_state=None)

            act.last_validation_state = last_validation_state

    def update_act(self, act):

        '''Update an act to match details of the meeting'''

        act.save()