Produits Entr'ouvert » Calebasse

from models import Act, ActValidationState

from datetime import date

class ActManager(models.Manager):

    def create_act(self, author=None, **kwargs):

        act = self.create(**kwargs)

        ActValidationState.objects.create(act=act,state_name='NON_VALIDE',

            author=author, previous_state=None)

        return act

    def next_acts(self, patient_record, today=None):

        today = today or date.today()

        return self.filter(date__gte=today) \

                .filter(patient=patient_record) \

                .order_by('date')

    def last_acts(self, patient_record, today=None):

        today = today or date.today()

        return self.filter(date__lte=today) \

                .filter(patient=patient_record) \

                .order_by('-date')

    objects = ActManager()

    date = models.DateField()

    _duration = models.IntegerField(u'Durée en minutes', default=0)

    parent_event = models.ForeignKey('agenda.Event', 

            verbose_name=u'Rendez-vous lié',

            blank=True, null=True)

    VALIDATION_CODE_CHOICES = (

            ('absent', u'Absent'),

            ('present', u'Présent'),

            )

    attendance = models.CharField(max_length=16,

            choices=VALIDATION_CODE_CHOICES,

            default='absent',

            verbose_name=u'Présence')

    convocation_sent = models.BooleanField(blank=True,

            verbose_name=u'Convoqué')

    @property

    def event(self):

        if self.parent_event:

            return self.parent_event.today_occurence(self.date)

        return None

    @property

    def start_time(self):

        event = self.event

        if event:

            return event.start_datetime.timetz()

        return None

        if self.date < hc.start_date:

            if a.date >= hc.start_date:

# END Specific to cmpp healthcare

    def duration(self):

        '''Return a displayable duration for this field.'''

        hours, remainder = divmod(self._duration, 60)

        return '%02d:%02d' % (hours, remainder)

        <td>{{ act.parent_event.start_time|date:"H:i" }}</td>

from datetime import datetime, date

from calebasse.agenda.models import EventWithAct

        act_event = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M X', patient,

                periodicity=1, until=date(2020, 10, 2))

        act_event2 = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M Y', patient, [therapist3],

                periodicity=1, until=date(2020, 10, 2))

        act_event3 = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M X', patient2,

                periodicity=1, until=date(2020, 10, 2))

        act_event4 = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M Y', patient3, [therapist3],

                periodicity=1, until=date(2020, 10, 2))

        act_event5 = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M Y', patient3, [therapist3],

                periodicity=1, until=date(2020, 10, 2))

        act_event6 = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M Z', patient, [therapist3],

                periodicity=1, until=date(2020, 10, 2))

        act_event7 = EventWithAct.objects.create_patient_appointment(creator, 'RDV avec M Z', patient, [therapist3],

                periodicity=1, until=date(2020, 10, 4))

        act_event3.act.set_state('ABS_EXC', creator)

        act_event6.act.set_state('VALIDE', creator)

        result = automated_validation(date(2020, 10, 2), service, creator, commit=False)

        self.assertTrue(act_event.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event2.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event3.act.is_state('ABS_EXC'))

        self.assertTrue(act_event4.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event5.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event6.act.is_state('VALIDE'))

        result = automated_validation(date(2020, 10, 2), service, creator)

        self.assertTrue(act_event.act.is_state('VALIDE'))

        self.assertTrue(act_event2.act.is_state('ACT_DOUBLE'))

        self.assertTrue(act_event3.act.is_state('ABS_EXC'))

        self.assertTrue(act_event4.act.is_state('VALIDE'))

        self.assertTrue(act_event5.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event6.act.is_state('ACT_DOUBLE'))

            [date(2020, 10, 3), date(2020, 10, 4)])

        self.assertTrue(act_event.act.is_state('VALIDE'))

        self.assertTrue(act_event2.act.is_state('ACT_DOUBLE'))

        self.assertTrue(act_event3.act.is_state('ABS_EXC'))

        self.assertTrue(act_event4.act.is_state('VALIDE'))

        self.assertTrue(act_event5.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event6.act.is_state('ACT_DOUBLE'))

        self.assertTrue(act_event.act.is_state('VALIDE'))

        self.assertTrue(act_event2.act.is_state('ACT_DOUBLE'))

        self.assertTrue(act_event3.act.is_state('ABS_EXC'))

        self.assertTrue(act_event4.act.is_state('VALIDE'))

        self.assertTrue(act_event5.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event6.act.is_state('ACT_DOUBLE'))

        self.assertTrue(act_event.act.is_state('VALIDE'))

        self.assertTrue(act_event2.act.is_state('ACT_DOUBLE'))

        self.assertTrue(act_event3.act.is_state('ABS_EXC'))

        self.assertTrue(act_event4.act.is_state('VALIDE'))

        self.assertTrue(act_event5.act.is_state('NON_VALIDE'))

        self.assertTrue(act_event6.act.is_state('ACT_DOUBLE'))

    model=models.Act

        qs = qs.filter(patient__service=self.service)

from models import Event, EventType, EventWithAct

admin.site.register(EventWithAct, reversion.VersionAdmin)

        self.event_id = None

    def init_from_event(self, event, service):

        delta = event.end_datetime - event.start_datetime

        self.event_id = event.id

        self.title = event.title

        services = event.services.all()

        self.date = event.start_datetime.date()

        self.__set_time(time(event.start_datetime.hour, event.start_datetime.minute))

        self.event_id = event.id

        if event.room:

            self.room = event.room.name

        self.description = event.description

        if event.event_type.id == 1:

            event_act = event.act

            workers = event_act.doctors.all()

            self.event_type = event.event_type

def get_daily_appointments(date, worker, service, time_tables, events, holidays):

    events_set = IntervalSet((o.to_interval() for o in events))

    busy_occurrences_set = IntervalSet((o.to_interval() for o in events_set if not o.is_event_absence()))

    for event in events:

        appointment.init_from_event(event, service)

DEFAULT_EVENT_DURATION = datetime.timedelta(hours=+1)

from ..dossiers.models import PatientRecord

from ..personnes.models import Worker

from ..ressources.models import ActType

from ..middleware.request import get_request

from models import Event, EventWithAct, EventType

    participants = make_ajax_field(EventWithAct, 'participants', 'worker-or-group', True)

    patient = make_ajax_field(EventWithAct, 'patient', 'patientrecord', False)

        model = EventWithAct

        except ValueError:

            return 0

    def save(self, commit=True):

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

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

        appointment.end_datetime = appointment.start_datetime + timedelta(

        appointment.recurrence_end_date = appointment.start_datetime.date()

        appointment.creator = get_request().user

        appointment.title = appointment.patient.display_name

        appointment.service = self.service

        appointment.clean()

        if commit:

            appointment.save()

        return appointment

class UpdateAppointmentForm(NewAppointmentForm):

    pass

    participants = make_ajax_field(Event, 'participants', 'worker-or-group', True)

    def save(self, commit=True):

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

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

        event.end_datetime = event.start_datetime + timedelta(

        event.recurrence_end_date = event.start_datetime.date()

        event.creator = get_request().user

        event.service = self.service

        event.clean()

        if commit:

            event.save()

        return event

from datetime import datetime, timedelta, date, time

from django.db.models import Q

from model_utils.managers import InheritanceManager, PassThroughManager, InheritanceQuerySet

from calebasse.utils import weeks_since_epoch

class EventQuerySet(InheritanceQuerySet):

    def for_today(self, today=None):

        today = today or date.today()

        weeks = weeks_since_epoch(today)

        filters = [Q(start_datetime__gte=datetime.combine(today, time()),

               start_datetime__lte=datetime.combine(today, time(23,59,59))) ]

        base_q = Q(start_datetime__lte=datetime.combine(today, time(23,59,59))) & \

                (Q(recurrence_end_date__gte=today) |

                    Q(recurrence_end_date__isnull=True))

        for period in range(1, 6):

            filters.append(base_q & Q(recurrence_week_offset=weeks % period,

                recurrence_week_period=period, recurrence_week_day=today.weekday()))

        qs = self.filter(reduce(Q.__or__, filters))

    def today_occurences(self, today=None):

        today = today or date.today()

        self = self.for_today(today)

        occurences = ( e.today_occurence(today) for e in self )

        return sorted(occurences, key=lambda e: e.start_datetime)

    def daily_disponibilities(self, date, events, participants, time_tables,

            holidays):

        '''Slice the day into quarters between 8:00 and 19:00, and returns the

           list of particpants with their status amon free, busy and away for each

           hour and quarters.

           date - the date of day we slice

           occurences - a dictionnary of iterable of events indexed by participants

           participants - an iterable of participants

           time_tables - a dictionnaty of timetable applying for this day indexed by participants

           holidays - a dictionnary of holidays applying for this day indexed by participants

        '''

        events_set = {}

            events_set[participant.id] = IntervalSet((o.to_interval() for o in events[participant.id] if not o.is_event_absence()))

                    result[start_datetime.hour] = [[], [], [], []]

                if interval.intersection(events_set[participant.id]):

class EventManager(PassThroughManager.for_queryset_class(EventQuerySet),

        InheritanceManager):

    """ This class allows you to manage events, appointment, ...

    """

    def create_event(self, creator, title, event_type, participants=[], description='',

            services=[], start_datetime=None, end_datetime=None, room=None, note=None, periodicity=1, until=False, **kwargs):

        """

        Convenience function to create an ``Event``, optionally create an

        ``EventType``.

        Args:

            event_type: can be either an ``EventType`` object or the label

            is either created or retrieved.

            participants: List of CalebasseUser

            start_datetime: will default to the current hour if ``None``

            end_datetime: will default to ``start_datetime`` plus

            default.DEFAULT_EVENT_DURATION hour if ``None``

        Returns:

            Event object

        """

        if isinstance(event_type, str):

            event_type, created = agenda.models.EventType.objects.get_or_create(

                label=event_type

            )

        if not start_datetime:

            now = datetime.now()

            start_datetime = datetime.combine(now.date, time(now.hour))

        if not end_datetime:

            end_datetime = start_datetime + default.DEFAULT_EVENT_DURATION

        if until is False:

            until = start_datetime.date()

        event = self.create(creator=creator,

                title=title, start_datetime=start_datetime,

                end_datetime=end_datetime, event_type=event_type,

                room=room, recurrence_week_period=periodicity,

                recurrence_end_date=until,

                recurrence_week_day=start_datetime.weekday(), **kwargs)

        event.services = services

        event.participants = participants

        return event

    def next_appointment(self, patient_record):

        qs = self.next_appointments(patient_record)

    def next_appointments(self, patient_record, today=None):

        from calebasse.actes.models import Act

        acts = Act.objects.next_acts(patient_record, today=today) \

                .filter(parent_event__isnull=False) \

                .select_related()

        return [ a.parent_event.today_occurence(a.date) for a in acts ]

    def last_appointment(self, patient_record):

        qs = self.last_appointments(patient_record)

    def last_appointments(self, patient_record, today=None):

        from calebasse.actes.models import Act

        acts = Act.objects.last_acts(patient_record, today=today) \

                .filter(parent_event__isnull=False) \

                .select_related()

        return [ a.parent_event.today_occurence(a.date) for a in acts ]

from datetime import datetime, date, timedelta

from copy import copy

from django.contrib.auth.models import User

from ..middleware.request import get_request

from calebasse.utils import weeks_since_epoch

    'EventWithAct',

    Container model for general agenda events

    creator = models.ForeignKey(User, verbose_name=_(u'Créateur'), blank=True, null=True)

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

    start_datetime = models.DateTimeField(_('Début'), blank=True, null=True, db_index=True)

    end_datetime = models.DateTimeField(_('Fin'), 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')

    )

    OFFSET = range(0,4)

    recurrence_week_day = models.PositiveIntegerField(default=0)

    recurrence_week_offset = models.PositiveIntegerField(

            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)

    recurrence_end_date = models.DateField(

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

            blank=True, null=True,

            db_index=True)

        ordering = ('start_datetime', 'end_datetime', 'title')

    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.start_datetime:

            if self.recurrence_week_period:

                if self.recurrence_end_date and self.recurrence_end_date < self.start_datetime.date():

                    self.recurrence_end_date = self.start_datetime.date()

                self.recurrence_week_day = self.start_datetime.weekday()

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

    def timedelta(self):

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

        return self.end_datetime - self.start_datetime

    def today_occurence(self, today=None):

        '''For a recurring event compute the today 'Event'.

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

        today = today or date.today()

        if not self.is_recurring():

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

                return self

            else:

                return None

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

            return None

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

            return None

        if not (self.start_datetime.date() <= today <= self.recurrence_end_date):

            return None

        start_datetime = datetime.combine(today, self.start_datetime.timetz())

        end_datetime = start_datetime + self.timedelta()

        event = copy(self)

        event.start_datetime = start_datetime

        event.end_datetime = end_datetime

        event.recurrence_end_date = None

        event.recurrence_week_offset = None

        event.recurrence_week_period = None

        event.parent = self

        def save(*args, **kwarks): 

            raise RuntimeError()

        event.save = save

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

        return self.recurrence_week_period is not None

    def all_occurences(self, limit=90):

        '''Returns all occurences of this event as a list or pair (start_datetime,

           end_datetime).

           limit - compute occurrences until limit days in the future

           Default is to limit to 90 days.

        if self.recurrence_week_period:

            day = self.start_datetime.date()

            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:

                yield self.today_occurence(day)

                day += delta

            yield self

    def to_interval(self):

        return Interval(self.start_datetime, self.end_datetime)

    def is_event_absence(self):

        return False

        return self.title

class EventWithActManager(managers.EventManager):

    def create_patient_appointment(self, creator, title, patient,

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

            room=None, periodicity=1, until=False):

        appointment = self.create_event(creator=creator,

                title=title,

                event_type=EventType(id=1),

                participants=doctors,

                services=[service],

                start_datetime=start_datetime,

                end_datetime=end_datetime,

                room=room,

                periodicity=periodicity,

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

    def act(self):

        return self.get_or_create_act()

    def get_or_create_act(self, today=None):

        from ..actes.models import Act, ActValidationState

        today = today or self.start_datetime.date()

        act, created = Act.objects.get_or_create(patient=self.patient,

                parent_event=getattr(self, 'parent', self),

                date=today,

                act_type=self.act_type)

        self.update_act(act)

        if created:

            ActValidationState.objects.create(act=act, state_name='NON_VALIDE',

                author=self.creator, previous_state=None)

        return act

    def update_act(self, act):

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

        delta = self.timedelta()

        duration = delta.seconds // 60

        act._duration = duration

        act.doctors = self.participants.select_subclasses()

        act.act_type = self.act_type

        act.patient = self.patient

        act.date = self.start_datetime.date()

        act.save()

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

        '''Force event_type to be patient meeting.'''

        self.clean()

        self.event_type = EventType(id=1)

        super(EventWithAct, self).save(*args, **kwargs)

        # list of occurences may have changed

        from ..actes.models import Act

        occurences = list(self.all_occurences())

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

        occurences_by_date = dict((o.start_datetime.date(), o) for o in occurences)

        acts_by_date = dict()

        for a in acts:

            # sanity check

            assert a.date not in acts_by_date

            acts_by_date[a.date] = a

        for a in acts:

            o = occurences_by_date.get(a.date)

            if o:

                o.update_act(a)

            else:

                if len(a.actvalidationstate_set.all()) > 1:

                    a.parent_event = None

                    a.save()

                else:

                    a.delete()

        participants = self.participants.select_subclasses()

        for o in occurences:

            if o.start_datetime.date() in acts_by_date:

                continue

            o.get_or_create_act()

        return self.act.is_absent()

    def __unicode__(self):

        kwargs = {

                'patient': self.patient,

                'start_datetime': self.start_datetime,

                'act_type': self.act_type

        }

        kwargs['doctors'] = ', '.join(map(unicode, self.participants.all())) if self.id else ''

        return u'Rdv le {start_datetime} de {patient} avec {doctors} pour ' \

            '{act_type} ({act_type.id})'.format(**kwargs)

           <button title="Éditer un rendez-vous" class="edit-appointment icon-edit" data-event-id="{{ appointment.event_id }}"></button>

           <button title="Éditer un événement" class="edit-event icon-edit" data-event-id="{{ appointment.event_id }}">

        <button class="remove-appointment icon-remove-sign" title="Supprimer un rendez-vous" data-event-id="{{ appointment.event_id }}" data-rdv="{{ appointment.title }}"></button>

    <a href="#" class="generate-mail-btn" data-dossier-id="{{ appointment.patient_record_id }}" data-date="{{date}}" data-occurence-id="{{ appointment.occurrence_id }}" data-next-url="{{ request.get_full_path }}">Courrier</a>

                    <button title="Éditer un rendez-vous" class="edit-appointment icon-edit" data-event-id="{{ appointment.event_id }}"></button>

                    <button title="Éditer un événement" class="edit-event icon-edit" data-event-id="{{ appointment.event_id }}">

                 <button class="remove-appointment icon-remove-sign" title="Supprimer un rendez-vous" data-event-id="{{ appointment.event_id }}" data-rdv="{{ appointment.title }}"></button>

             <a href="#" class="generate-mail-btn" data-dossier-id="{{ appointment.patient_record_id }}" data-date="{{date}}" data-occurence-id="{{ appointment.occurrence_id }}" data-next-url="{{ request.get_full_path }}">Courrier</a>

from datetime import datetime, date, timedelta

from calebasse.agenda.models import Event, EventType, EventWithAct

from calebasse.actes.models import Act

    def test_recurring_events(self):

        event = Event.objects.create(start_datetime=datetime(2012, 10, 20, 13),

                end_datetime=datetime(2012, 10, 20, 13, 30), event_type=EventType(id=1),

                recurrence_week_period=3, recurrence_end_date=date(2012, 12, 1))

        event.clean()

        event.save()

        # Test model

        self.assertEqual(event.timedelta(), timedelta(minutes=30))

        occurences = list(event.all_occurences())

        self.assertEqual(occurences[0].start_datetime,

                datetime(2012, 10, 20, 13))

        self.assertEqual(occurences[0].end_datetime,

                datetime(2012, 10, 20, 13, 30))

        self.assertEqual(occurences[1].start_datetime,

                datetime(2012, 11, 10, 13))

        self.assertEqual(occurences[1].end_datetime,

                datetime(2012, 11, 10, 13, 30))

        self.assertEqual(occurences[2].start_datetime,

                datetime(2012, 12,  1, 13))

        self.assertEqual(occurences[2].end_datetime,

                datetime(2012, 12,  1, 13, 30))

        self.assertEqual(len(occurences), 3)

        self.assertTrue(event.is_recurring())

        self.assertEqual(event.next_occurence(today=date(2012, 10, 21)).start_datetime,

            datetime(2012, 11, 10, 13))

        self.assertEqual(event.next_occurence(today=date(2012, 11,  30)).start_datetime,

            datetime(2012, 12,  1, 13))

        self.assertEqual(event.next_occurence(today=date(2012, 12,  2)), None)

        # Test manager

        i = datetime(2012, 10, 1)

        while i < datetime(2013, 2, 1):

            d = i.date()

            if d in (date(2012, 10, 20), date(2012, 11, 10), date(2012, 12, 1)):

                self.assertEqual(list(Event.objects.for_today(d)), [event], d)

            else:

                self.assertEqual(list(Event.objects.for_today(d)), [], d)

            i += timedelta(days=1)

        service_camsp = Service.objects.get(name='CAMSP')

        patient = create_patient('Jean', 'LEPOULPE', service_camsp, self.creator, date_selected=datetime(2020, 10, 5))

        appointment1 = EventWithAct.objects.create_patient_appointment(self.creator, 'RDV avec M X', patient,

                periodicity=None, until=None)

        self.assertEqual(unicode(appointment1), u'Rdv le 2020-10-02 07:15:00 de Jean LEPOULPE avec Bob LEPONGE, Jean VALJEAN pour trepanation (1)')

    def test_create_recurring_appointment(self):

        service_camsp = Service.objects.get(name='CAMSP')

        patient = create_patient('Jean', 'LEPOULPE', service_camsp, self.creator, date_selected=datetime(2020, 10, 5))

        wtype = WorkerType.objects.create(name='ElDoctor', intervene=True)

        therapist3 = Worker.objects.create(first_name='Pierre', last_name='PaulJacques', type=wtype)

        act_type = ActType.objects.create(name='trepanation')

        service = Service.objects.create(name='CMPP')

        appointment2 = EventWithAct.objects.create_patient_appointment(self.creator, 'RDV avec M Y', patient, [therapist3],

                periodicity=2, until=date(2020, 10, 16))

        occurences = list(appointment2.all_occurences())

        self.assertEqual(len(occurences), 2)

        self.assertEqual(Act.objects.filter(parent_event=appointment2).count(),

                2)

        self.assertEqual(occurences[0].act.date, occurences[0].start_datetime.date())

        self.assertEqual(occurences[1].act.date, occurences[1].start_datetime.date())

        self.assertEqual(Act.objects.filter(parent_event=appointment2).count(),

                2)

        appointment2.recurrence_week_period = None

        appointment2.save()

        self.assertEqual(Act.objects.filter(parent_event=appointment2).count(),

                1)

        appointment2.recurrence_week_period = 2

        appointment2.recurrence_end_date = date(2020, 10, 16)

        appointment2.save()

        occurences = list(appointment2.all_occurences())

        self.assertEqual(len(occurences), 2)

        self.assertEqual(Act.objects.filter(parent_event=appointment2).count(), 2)

        occurences[1].act.set_state('ANNUL_NOUS', self.creator)

        appointment2.recurrence_week_period = None

        appointment2.save()

        occurences = list(appointment2.all_occurences())

        self.assertEqual(len(occurences), 1)

        self.assertEqual(Act.objects.filter(parent_event=appointment2).count(), 1)

        self.assertEqual(Act.objects.count(), 2)