Produits Entr'ouvert » Chrono

    help = 'Update event recurrences to reflect exceptions'

    def handle(self, **options):

        for agenda in agendas:

            agenda.update_event_recurrences()

            entries = self.prefetched_events

        else:

            # recurring events are never opened

            # exclude canceled events except for event recurrences

            entries = entries.filter(Q(cancelled=False) | Q(primary_event__isnull=False))

            # we never want to allow booking for past events.

        else:

            recurring_events = self.event_set.filter(

                Q(publication_date__isnull=True) | Q(publication_date__lte=localtime(now()).date()),

            )

            exceptions = self.get_recurrence_exceptions(min_start, max_start)

    @transaction.atomic

    def update_event_recurrences(self):

        recurrences = self.event_set.filter(primary_event__isnull=False)

        # remove recurrences

class Event(models.Model):

    ]

    agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE)

    start_datetime = models.DateTimeField(_('Date/time'))

    recurrence_end_date = models.DateField(_('Recurrence end date'), null=True, blank=True)

    primary_event = models.ForeignKey('self', null=True, on_delete=models.CASCADE, related_name='recurrences')

    duration = models.PositiveIntegerField(_('Duration (in minutes)'), default=None, null=True, blank=True)

        self.check_full()

        if not self.slug:

            self.slug = generate_slug(self, seen_slugs=seen_slugs, agenda=self.agenda)

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

    @property

            return False

        if self.agenda.maximal_booking_delay and self.start_datetime > self.agenda.max_booking_datetime:

            return False

            # bookable recurrences probably exist

            return True

        if self.agenda.minimal_booking_delay and self.start_datetime < self.agenda.min_booking_datetime:

        else:

            event = cls(**data)

            event.save()

            event.refresh_from_db()

            event.recurrences.filter(start_datetime__gt=event.recurrence_end_date).delete()

            update_fields = {

        return {

            'start_datetime': make_naive(self.start_datetime).strftime('%Y-%m-%d %H:%M:%S'),

            'publication_date': self.publication_date.strftime('%Y-%m-%d') if self.publication_date else None,

            'recurrence_end_date': recurrence_end_date,

            'places': self.places,

            'waiting_list_places': self.waiting_list_places,

            url=self.url,

        )

        # remove pytz info because dateutil doesn't support DST changes

        min_datetime = make_naive(min_datetime)

        max_datetime = make_naive(max_datetime)

        return recurrences

    def get_recurrence_display(self):

        time = date_format(localtime(self.start_datetime), 'TIME_FORMAT')

            }

        else:

    def has_recurrences_booked(self, after=None):

        return Booking.objects.filter(

            ).order_by()

            recurring_event_queryset = Event.objects.filter(

                Q(publication_date__isnull=True) | Q(publication_date__lte=localtime(now()).date()),

            )

            exceptions_desk = Desk.objects.filter(slug='_exceptions_holder').prefetch_related(

                'unavailability_calendars'

)

from . import widgets

class AbsenceReasonForm(forms.ModelForm):

class NewEventForm(forms.ModelForm):

    class Meta:

        model = Event

        fields = [

            'label',

            'start_datetime',

            'duration',

            'places',

        ]

        field_classes = {

            'start_datetime': SplitDateTimeField,

        }

    class Meta:

        model = Event

            'label',

            'slug',

            'start_datetime',

            'recurrence_end_date',

            'duration',

            'publication_date',

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

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

            for field in self.protected_fields:

                self.fields[field].disabled = True

                self.fields[field].help_text = _(

                    'This field cannot be modified because some recurrences have bookings attached to them.'

                )

        if self.instance.primary_event:

                del self.fields[field]

    def clean(self):

            after=self.cleaned_data['recurrence_end_date']

        ):

            raise ValidationError(_('Bookings exist after this date.'))

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

        with transaction.atomic():

            if any(field for field in self.changed_data if field in self.protected_fields):

                self.instance.recurrences.all().delete()

                update_fields = {

                    field: value

                    for field, value in self.cleaned_data.items()

                }

                self.instance.recurrences.update(**update_fields)

		background-color: $color;

	}

}

    {% else %}

      {% if event.label %}{{ event.label }} / {% endif %}

    {% endif %}

      {% if view_mode == 'day_view' %}{{ event.start_datetime|time }}{% else %}{{ event.start_datetime }}{% endif %}

    {% else %}

      {{ event.get_recurrence_display }}

{% extends "chrono/manager_agenda_view.html" %}

{% block extrascripts %}

{{ block.super }}

<form method="post" enctype="multipart/form-data">

  {% csrf_token %}

  <input type="hidden" name="next" value="{% firstof request.POST.next request.GET.next %}">

  <div class="buttons">

    <button class="submit-button">{% trans "Save" %}</button>

    <a class="cancel" href="{{ view.get_success_url }}">{% trans 'Cancel' %}</a>

  </div>

</form>

{% endblock %}

    def get_queryset(self):

        if self.agenda.kind == 'events':

        else:

            self.agenda.prefetch_desks_and_exceptions()

            if self.agenda.kind == 'meetings':

        if self.agenda.kind == 'events':

            context['has_absence_reasons'] = AbsenceReasonGroup.objects.exists()

            context['has_recurring_events'] = self.agenda.event_set.filter(

            ).exists()

            desk = Desk.objects.get(agenda=self.agenda, slug='_exceptions_holder')

            context['exceptions'] = TimePeriodException.objects.filter(

    pk_url_kwarg = 'event_pk'

    def dispatch(self, request, *args, **kwargs):

            raise Http404('this view makes no sense for recurring events')

        return super().dispatch(request, *args, **kwargs)

        if (

            self.request.GET.get('next') == 'settings'

            or self.request.POST.get('next') == 'settings'

        ):

            return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.id})

        return reverse('chrono-manager-event-view', kwargs={'pk': self.agenda.id, 'event_pk': self.object.id})

from django.forms.fields import SplitDateTimeField

from django.utils.safestring import mark_safe

        super(TimeWidget, self).__init__(**kwargs)

        self.attrs['step'] = '300'  # 5 minutes

        self.attrs['pattern'] = '[0-9]{2}:[0-9]{2}'

        start_datetime=now(),

        places=10,

        agenda=event_agenda,

    )

    assert len(event_agenda.get_open_events()) == 2

    resp = app.get('/api/agenda/', params={'with_open_events': '1'})

    for i in range(10):

        event_agenda = Agenda.objects.create(label='Foo bar', category=category_a)

        TimePeriodException.objects.create(

            desk=event_agenda.desk_set.get(),

            start_datetime=now(),

    event.delete()

    # recurrent event

    event = Event.objects.create(

        slug='recurrent',

        places=2,

        agenda=agenda,

    )

    # recurring event

    Event.objects.all().delete()

    Event.objects.create(

    )

    resp = app.get(api_url)

    assert resp.json['meta']['first_bookable_slot']['text'] == 'Test (May 27, 2017, 1:12 a.m.)'

        label='Foo bar', kind='events', minimal_booking_delay=1, maximal_booking_delay=30

    )

    base_event = Event.objects.create(

    )

    resp = app.get('/api/agenda/%s/datetimes/' % agenda.slug)

        label='Foo bar', kind='events', minimal_booking_delay=0, maximal_booking_delay=30

    )

    event = Event.objects.create(

    )

    event.refresh_from_db()

    agenda = Agenda.objects.create(

        label='Foo bar', kind='events', minimal_booking_delay=1, maximal_booking_delay=30

    )

    resp = app.get('/api/agenda/%s/datetimes/' % agenda.slug)

    data = resp.json['data']

    event.delete()

    # recurrent event

    event = Event.objects.create(

        slug='recurrent',

        places=2,

        agenda=agenda,

    )

    Event.objects.create(

        label='xyz', start_datetime=localtime().replace(day=11, month=11, year=2020), places=10, agenda=agenda

    )

    event = Event.objects.create(

        label='abc',

        places=10,

        agenda=agenda,

    )

    with CaptureQueriesContext(connection) as ctx:

    # create another event with recurrence, the same day/time

    start_datetime = localtime().replace(day=4, month=11, year=2020)

    event = Event.objects.create(

    )

    resp = app.get('/manage/agendas/%s/2020/11/11/' % agenda.pk)

    # the event occurence in DB does not hide recurrence of the second recurrent event

    # add recurring event on every Wednesday

    start_datetime = localtime().replace(day=4, month=11, year=2020)

    event = Event.objects.create(

    )

    with CaptureQueriesContext(connection) as ctx:

    # create another event with recurrence, the same day/time

    start_datetime = localtime().replace(day=4, month=11, year=2020)

    event = Event.objects.create(

    )

    resp = app.get('/manage/agendas/%s/%s/%s/' % (agenda.id, 2020, 12))

    # the event occurence in DB does not hide recurrence of the second recurrent event

        places=42,

    )

    # weekly recurring event, first recurrence is in the past but second is in range

    event = Event.objects.create(

        label='event G',

        places=10,

        agenda=agenda,

    )

    resp = app.get('/manage/agendas/%s/events/open/' % agenda.pk)

    assert 'event A' not in resp.text

    resp = app.get('/manage/agendas/%s/settings' % agenda.id)

    assert not 'Recurrence exceptions' in resp.text

    event.save()

    resp = app.get('/manage/agendas/%s/%s/%s/' % (agenda.id, 2021, 7))

    event = Event.objects.create(

        start_datetime=now(),

        places=10,

        recurrence_end_date=now() + datetime.timedelta(days=30),

        agenda=agenda,

    )

        assert (

            resp.text.count('Enter a valid date')

            or resp.text.count('Enter a valid time') == 1

        )

    app = login(app)

    resp = app.get('/manage/agendas/%s/events/%s/edit' % (agenda.id, event.id))

    resp = resp.form.submit()

    # detail page doesn't exist

    resp = app.get('/manage/agendas/%s/events/%s/' % (agenda.id, event.id), status=404)

    resp = app.get('/manage/agendas/%s/settings' % agenda.id, status=200)

    # event is bookable regardless of minimal_booking_delay, since it has bookable recurrences

    assert len(resp.pyquery.find('.bookable')) == 1

    # but some fields should not be updated

    assert event_recurrence.slug != event.slug

    # changing recurrence attribute removes event recurrences

    resp = app.get('/manage/agendas/%s/events/%s/edit' % (agenda.id, event.id))

    resp = resp.form.submit().follow()

    assert not Event.objects.filter(primary_event=event).exists()

    event_recurrence = event.get_or_create_event_recurrence(event.start_datetime + datetime.timedelta(days=7))

    Booking.objects.create(event=event_recurrence)

    resp = app.get('/manage/agendas/%s/events/%s/edit' % (agenda.id, event.id))

    assert 'disabled' in resp.form['slug'].attrs

    assert 'disabled' in resp.form['start_datetime_0'].attrs

    assert 'disabled' in resp.form['start_datetime_1'].attrs

    assert 'Delete' not in resp.text

    resp = resp.click('Options')

def test_edit_recurring_event_with_end_date(settings, app, admin_user, freezer):

    freezer.move_to('2021-01-12 12:10')

    agenda = Agenda.objects.create(label='Foo bar', kind='events')

    app = login(app)

    resp = app.get('/manage/agendas/%s/events/%s/edit' % (agenda.id, event.id))

    resp = resp.form.submit()

    # recurrences are created automatically

    assert Event.objects.filter(primary_event=event).count() == 5

    assert Event.objects.filter(primary_event=event, start_datetime=now()).exists()

    assert Event.objects.filter(primary_event=event).count() == 4

    assert 'Bookings exist after this date' in resp.text

def test_booked_places(app, admin_user):

    agenda = Agenda(label=u'Foo bar')

def test_delete_recurring_event(app, admin_user, freezer):

    agenda = Agenda.objects.create(label='Foo bar', kind='events')

    start_datetime = now() + datetime.timedelta(days=10)

    app = login(app)

    resp = app.get('/manage/agendas/%s/settings' % agenda.id, status=200)

    event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        label='Event',

        places=10,

        waiting_list_places=10,

    event_json = event.export_json()

    first_event_json = first_event.export_json()

    assert all(first_event_json[k] == event_json[k] for k in event_json if k not in different_fields)

    second_event = recurrences[1]

    freezer.move_to('2020-10-24 12:00')

    settings.TIME_ZONE = 'Europe/Brussels'

    agenda = Agenda.objects.create(label='Agenda', kind='events')

    event.refresh_from_db()

    dt = localtime()

    recurrences = event.get_recurrences(dt, dt + datetime.timedelta(days=8))

    assert event_after_dst.slug == new_event_after_dst.slug

    freezer.move_to('2021-01-06 12:00')  # Wednesday

    agenda = Agenda.objects.create(label='Agenda', kind='events')

    event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        places=5,

    )

    event.refresh_from_db()

    for i in range(len(recurrences) - 1):

        assert recurrences[i].start_datetime + datetime.timedelta(days=1) == recurrences[i + 1].start_datetime

    event.save()

    recurrences = event.get_recurrences(

        localtime() + datetime.timedelta(days=1), localtime() + datetime.timedelta(days=7)

    assert recurrences[1].start_datetime == start_datetime + datetime.timedelta(days=5)

    assert recurrences[-1].start_datetime == start_datetime + datetime.timedelta(days=7)

    event.save()

    recurrences = event.get_recurrences(

        localtime() + datetime.timedelta(days=3), localtime() + datetime.timedelta(days=45)

            recurrences[i].start_datetime + datetime.timedelta(days=14) == recurrences[i + 1].start_datetime

        )

@pytest.mark.freeze_time('2021-01-06')

def test_recurring_events_with_end_date():

    event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        places=5,

        recurrence_end_date=(now() + datetime.timedelta(days=5)).date(),

    )

def test_recurring_events_sort(freezer):

    freezer.move_to('2021-01-06 12:00')  # Wednesday

    agenda = Agenda.objects.create(label='Agenda', kind='events')

    Event.objects.create(

    )

    events = agenda.get_open_events()[:8]

    event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        places=5,

    )

    event.refresh_from_db()

    daily_event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        places=5,

        recurrence_end_date=datetime.date(year=2021, month=5, day=8),

    )

    weekly_event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        places=5,

        recurrence_end_date=datetime.date(year=2021, month=6, day=1),

    )

    daily_event_no_end_date = Event.objects.create(

        agenda=agenda,

        start_datetime=now() + datetime.timedelta(hours=2),

        places=5,

    )

    daily_event_no_end_date.refresh_from_db()

    assert Booking.objects.count() == 1

    assert Event.objects.filter(primary_event=daily_event_no_end_date).count() == 1

    assert agenda.recurrence_exceptions_report.events.get() == event

    json_fields = (

        'extra_data',

        'booking_errors',

    )

    with connection.cursor() as cursor:

            '''ALTER TABLE agendas_eventcancellationreport

              ALTER COLUMN booking_errors TYPE text USING booking_errors::text'''

        )

    call_command('ensure_jsonb')

    event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

        places=10,

        slug='test',

    )

    assert Event.objects.count() == 1

    event = Agenda.objects.get(label='Foo Bar').event_set.first()

    assert event.primary_event is None

    # importing event with end recurrence date creates recurrences

    event.recurrence_end_date = now() + datetime.timedelta(days=7)

    event.save()

    output = get_output_of_command('export_site')

    import_site(data={}, clean=True)