Produits Entr'ouvert » Chrono

from django.core.exceptions import FieldDoesNotExist, ValidationError

from django.core.validators import MaxValueValidator, MinValueValidator

from django.db import IntegrityError, connection, models, transaction

from django.template import Context, Template, TemplateSyntaxError, VariableDoesNotExist, engines

from django.urls import reverse

from django.utils import functional

    def get_open_events(

        self,

        prefetched_queryset=False,

        include_full=True,

        min_start=None,

        max_start=None,

        if user_external_id and not prefetched_queryset:

            entries = Event.annotate_queryset_for_user(entries, user_external_id)

        if max_start:

            entries = self.add_event_recurrences(

                entries,

    def get_past_events(

        self,

        min_start=None,

        max_start=None,

        user_external_id=None,

        if user_external_id:

            entries = Event.annotate_queryset_for_user(entries, user_external_id)

        if min_start:

            entries = self.add_event_recurrences(

                entries,

    )

    pricing = models.CharField(_('Pricing'), max_length=150, null=True, blank=True)

    url = models.CharField(_('URL'), max_length=200, null=True, blank=True)

    almost_full = models.BooleanField(default=False)

    full = models.BooleanField(default=False)

    cancelled = models.BooleanField(default=False)

        assert self.agenda.kind != 'virtual', "an event can't reference a virtual agenda"

        assert not (self.slug and self.slug.isdigit()), 'slug cannot be a number'

        self.start_datetime = self.start_datetime.replace(second=0, microsecond=0)

        if not self.slug:

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

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

        # label can be empty

        return slugify(self.label or ('%s-event' % self.agenda.label))

    def main_list_full(self):

        return bool(self.booked_places >= self.places)

    def set_is_checked(self):

        if not self.agenda.mark_event_checked_auto:

            return

    def is_day_past(self):

        return self.start_datetime.date() <= now().date()

    @staticmethod

    def annotate_queryset_for_user(qs, user_external_id):

        return qs.annotate(

            ),

        )

    @property

    def remaining_places(self):

        return max(0, self.places - self.booked_places)

    @property

    def remaining_waiting_list_places(self):

    @property

    def end_datetime(self):

    def user_name(self):

        return ('%s %s' % (self.user_first_name, self.user_last_name)).strip()

    def cancel(self, trigger_callback=False):

        timestamp = now()

        with transaction.atomic():

def get_event_places(event):

    places = {

        'total': event.places,

        'reserved': event.booked_places,

    if event.waiting_list_places:

        places['has_waiting_list'] = True

        places['waiting_list_total'] = event.waiting_list_places

        # 'waiting_list_activated' means next booking will go into the waiting list

    return places

        entries = []

        if show_past:

            entries += agenda.get_past_events(

                min_start=start_datetime,

                max_start=end_datetime,

                user_external_id=booked_user_external_id or excluded_user_external_id,

            )

        if show_future:

            entries += agenda.get_open_events(

                min_start=start_datetime,

                max_start=end_datetime,

                user_external_id=booked_user_external_id or excluded_user_external_id,

    def validate(self, attrs):

        super().validate(attrs)

            raise serializers.ValidationError({'slots': _('This field is required.')})

        if not attrs.get('user_external_id'):

            raise serializers.ValidationError({'user_external_id': _('This field is required.')})

                    if (

                        payload.get('force_waiting_list')

                        or (event.booked_places + places_count) > event.places

                    ):

                        # if this is full or there are people waiting, put new bookings

                        # in the waiting list.

                        in_waiting_list = True

                            raise APIError(

                                _('sold out'),

                                err_class='sold out',

        full_events = list(events_to_book.filter(full=True))

        events_to_book = events_to_book.filter(full=False)

        events_to_book = events_to_book.annotate(

            in_waiting_list=ExpressionWrapper(

                output_field=BooleanField(),

            )

        )

        extra_data = {k: v for k, v in request.data.items() if k not in payload}

        bookings = [make_booking(event, payload, extra_data) for event in events_to_book]

        with transaction.atomic():

            deleted_count = Booking.objects.filter(

                user_external_id=user_external_id, event__in=events_to_unbook

            ).delete()[0]

            Booking.objects.bulk_create(bookings)

        response = {

            'err': 0,

        user_external_id = payload['user_external_id']

        events = get_events_from_slots(payload['slots'], request, agenda, payload)

        already_booked_events = agenda.event_set.filter(booking__user_external_id=user_external_id)

        if start_datetime:

        events = events.annotate(

            in_waiting_list=ExpressionWrapper(

                output_field=BooleanField(),

            )

        )

        extra_data = {k: v for k, v in request.data.items() if k not in payload}

        bookings = [make_booking(event, payload, extra_data) for event in events]

        with transaction.atomic():

            deleted_count = Booking.objects.filter(

                user_external_id=user_external_id, event__in=events_to_unbook

            ).delete()[0]

            Booking.objects.bulk_create(bookings)

        response = {

            'err': 0,

        # total places for the event (in waiting or main list, depending on the primary booking location)

        places = event.waiting_list_places if booking.in_waiting_list else event.places

        # total booked places for the event (in waiting or main list, depending on the primary booking location)

        # places to book for this primary booking

        primary_wanted_places = payload['count']

{% load i18n %}

           {% if event.main_list_full %}full{% endif %}

             {% if event.cancellation_status %}cancelled{% endif %}

           {% if not event.in_bookable_period %}not-{% endif %}bookable"

    {% if event.places %}

    {% elif event.waiting_list_places %}

    {% endif %}

    ><a href="{% if view_mode == 'settings_view' %}{% url 'chrono-manager-event-edit' pk=agenda.pk event_pk=event.pk %}?next=settings{% elif event.pk %}{% url 'chrono-manager-event-view' pk=agenda.pk event_pk=event.pk %}{% else %}{% url 'chrono-manager-event-create-recurrence' pk=agenda.pk event_identifier=event.slug %}{% endif %}">

    {% if event.cancellation_status %}

      ({% trans "Waiting list:" %}

      {% blocktrans count remaining_places=event.remaining_waiting_list_places %}{{ remaining_places }} remaining place{% plural %}{{ remaining_places }} remaining places{% endblocktrans %}

      -

    {% endif %}

    {% endif %}

    {% if view_mode == 'settings_view' and event.publication_date %}

{% block content %}

<div class="section">

  <h3>

  </h3>

  <div>

    <form class="check-bookings-filters">

{% if object.waiting_list_places %}

<div class="section">

  <h3>

  </h3>

  <div>

    <table class="main check-bookings">

<div class="section">

  <h3>

      Bookings ({{ booked_places }}/{{ places }}): {{ remaining_places }} remaining place

    {% plural %}

      Bookings ({{ booked_places }}/{{ places }}): {{ remaining_places }} remaining places

  </h3>

<div>

    <div class="errornotice"><p>{% trans "This event is overbooked." %}</p></div>

    <div class="infonotice"><p>{% trans "This event is full." %}</p></div>

  {% endif %}

{% if object.waiting_list_places %}

<div class="section">

  <h3>

      Waiting List ({{ booked_places }}/{{ places }}): {{ remaining_places }} remaining place

    {% plural %}

      Waiting List ({{ booked_places }}/{{ places }}): {{ remaining_places }} remaining places

from django.contrib import messages

from django.core.exceptions import PermissionDenied

from django.db import transaction

from django.http import Http404, HttpResponse, HttpResponseRedirect

from django.shortcuts import get_object_or_404, redirect, render

from django.template.defaultfilters import title

        qs = super().get_queryset()

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

            return qs

    def get_dated_items(self):

        date_list, object_list, extra_context = super().get_dated_items()

        qs = super().get_queryset()

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

            return qs

    def get_dated_items(self):

        date_list, object_list, extra_context = super().get_dated_items()

    def get_context_data(self, **kwargs):

        context = super().get_context_data(**kwargs)

        context['user_can_manage'] = self.agenda.can_be_managed(self.request.user)

        return context

        return context

    def get_events(self):

    def get_template_names(self):

        return ['chrono/manager_%s_agenda_settings.html' % self.agenda.kind]

        # build booking list

        context['booked'] = filterset.qs.order_by('user_last_name', 'user_first_name')

        context['booked_without_status'] = any(e.user_was_present is None for e in context['booked'])

        if context['booked_without_status']:

            context['absence_form'] = BookingAbsenceReasonForm(agenda=self.agenda)

            + Count('secondary_booking_set', filter=Q(cancellation_datetime__isnull=True))

        )

        context['waiting'] = waiting_qs

        return context

    event1 = Event.objects.create(

        start_datetime=(localtime() + datetime.timedelta(days=5)).replace(hour=10, minute=0),

        agenda=event_agenda,

    )

    event2 = Event.objects.create(

        start_datetime=(localtime() + datetime.timedelta(days=10)).replace(hour=10, minute=0),

        agenda=event_agenda,

    )

    event3 = Event.objects.create(

        start_datetime=(localtime() + datetime.timedelta(days=15)).replace(hour=10, minute=0),

        agenda=event_agenda,

    )

    assert len(resp.json['data']) == 1

    # one event is full

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

    assert len(resp.json['data']) == 1

    # all events are full

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

    assert len(resp.json['data']) == 0

    # event1 is not full but too soon

    event_agenda.minimal_booking_delay = 10

    event_agenda.save()

    assert list(event_agenda.get_open_events()) == [event2, event3]

    assert len(resp.json['data']) == 0

    # event3 is not full but too late

    event_agenda.maximal_booking_delay = 12

    event_agenda.save()

    assert list(event_agenda.get_open_events()) == [event2]

    assert len(resp.json['data']) == 0

    # events are not full but not published

    event_agenda.event_set.update(publication_date=now().date() + datetime.timedelta(days=20))

    assert list(event_agenda.get_open_events()) == []

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

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

    event1 = Event.objects.create(

        start_datetime=(localtime() + datetime.timedelta(days=5)).replace(hour=10, minute=0),

        agenda=agenda,

    )

    event2 = Event.objects.create(

        start_datetime=(localtime() + datetime.timedelta(days=10)).replace(hour=10, minute=0),

        agenda=agenda,

    )

    event3 = Event.objects.create(

        start_datetime=(localtime() + datetime.timedelta(days=15)).replace(hour=10, minute=0),

        agenda=agenda,

    )

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

    assert data['api']['datetimes_url'] == 'http://testserver/api/agenda/foo-bar/datetimes/'

    # one event is full

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

    assert resp.json['data']['opened_events_available'] is True

    # all events are full

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

    assert resp.json['data']['opened_events_available'] is False

    # event1 is not full but too soon

    agenda.minimal_booking_delay = 10

    agenda.save()

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

    assert resp.json['data']['opened_events_available'] is False

    # event3 is not full but too late

    agenda.maximal_booking_delay = 12

    agenda.save()

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

    assert resp.json['data']['opened_events_available'] is False

    # events are not full but not published

    agenda.event_set.update(publication_date=now().date() + datetime.timedelta(days=20))

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

    assert list(agenda.get_open_events()) == []

    resp3 = app.post('/api/agenda/%s/fillslot/%s/?count=5' % (agenda.slug, event.id))

    assert Event.objects.get(id=event.id).booked_places == 2

    # check waiting list overflow

    resp = app.post('/api/agenda/%s/fillslot/%s/?count=5' % (agenda.slug, event.id))

    assert resp.json['err_class'] == 'sold out'

    assert resp.json['err_desc'] == 'sold out'

    assert Event.objects.get(id=event.id).booked_places == 2

    # accept the waiting list

    resp = app.post(resp3.json['api']['accept_url'])

    assert Event.objects.get(id=event.id).booked_places == 7

    # check with a short waiting list

    Booking.objects.all().delete()

    resp = app.post('/api/agenda/%s/fillslot/%s/?count=3' % (agenda.slug, event.id))

    assert resp.json['err'] == 0

    assert Event.objects.get(id=event.id).booked_places == 3

    resp = app.post('/api/agenda/%s/fillslot/%s/?count=3' % (agenda.slug, event.id))

    assert resp.json['err'] == 1

    resp = app.post('/api/agenda/%s/fillslot/%s/?count=2' % (agenda.slug, event.id))

    assert resp.json['err'] == 0

    assert Event.objects.get(id=event.id).booked_places == 3

def test_multiple_booking_api_fillslots(app, some_data, user):

    resp = app.post('/api/agenda/%s/fillslots/' % agenda.slug, params={'slots': slots, 'count': 5})

    for event in events:

        assert Event.objects.get(id=event.id).booked_places == 2

    accept_url = resp.json['api']['accept_url']

    resp = app.post('/api/agenda/%s/fillslots/' % agenda.slug, params={'slots': slots, 'count': 5})

    assert resp.json['err_desc'] == 'sold out'

    for event in events:

        assert Event.objects.get(id=event.id).booked_places == 2

    # accept the waiting list

    resp = app.post(accept_url)

    for event in events:

        assert Event.objects.get(id=event.id).booked_places == 7

    # check with a short waiting list

    Booking.objects.all().delete()

    assert resp.json['err'] == 0

    for event in events:

        assert Event.objects.get(id=event.id).booked_places == 3

    resp = app.post('/api/agenda/%s/fillslots/' % agenda.slug, params={'slots': slots, 'count': 3})

    assert resp.json['err'] == 1

    assert resp.json['err'] == 0

    for event in events:

        assert Event.objects.get(id=event.id).booked_places == 3

def test_multiple_booking_move_booking(app, user):

    assert Booking.objects.filter(event__primary_event=event).count() == 104

    assert Booking.objects.filter(event__primary_event=sunday_event).count() == 52

    # one recurrence is booked separately

    event = Event.objects.filter(primary_event__isnull=False).first()

    assert resp.json['booking_count'] == 156

    assert not resp.json['full_events']

    assert Booking.objects.count() == 313

    # one booking has been put in waiting list

    params['user_external_id'] = 'user_id_3'

    resp = app.post_json(fillslots_url, params=params)

    # everything goes in waiting list

    # but an event was full

    assert resp.json['booking_count'] == 155

    assert len(resp.json['full_events']) == 1

    # create bookings in waiting list

    for recurrence in event.recurrences.all():

        Booking.objects.create(event=recurrence, in_waiting_list=True)

    # check that new bookings are put in waiting list despite free slots on main list

    params = {'user_external_id': 'user_id', 'slots': 'event:0'}

    resp = app.post_json('/api/agenda/%s/recurring-events/fillslots/' % agenda.slug, params=params)

    assert resp.json['booking_count'] == 5

def test_recurring_events_api_fillslots_change_bookings(app, user, freezer):

    assert Booking.objects.count() == 208

    assert Booking.objects.filter(event__start_datetime__week_day=2).count() == 104

    assert Booking.objects.filter(event__start_datetime__week_day=5).count() == 52

    params['slots'] = 'event:1,event:4'

    resp = app.post_json(fillslots_url, params=params)

    assert Booking.objects.count() == 208

    assert Booking.objects.filter(event__start_datetime__week_day=3).count() == 104

    assert Booking.objects.filter(event__start_datetime__week_day=6).count() == 52

    # passing empty slots cancels all bookings

    params['slots'] = ''

    assert resp.json['booking_count'] == 2

    assert len(resp.json['waiting_list_events']) == 0

    params['user_external_id'] = 'user_id_2'

    resp = app.post_json(fillslots_url, params=params)

    )

    params = {'user_external_id': 'user_id', 'slots': ','.join((event1.slug, event2.slug))}

    assert resp.json['err'] == 1

    assert resp.json['err_desc'] == 'event not bookable'

    params['events'] = 'future'

    assert resp.json['err'] == 1

    assert resp.json['err_desc'] == 'event not bookable'

    params['events'] = 'past'

    assert resp.json['err'] == 1

    assert resp.json['err_desc'] == 'event not bookable'

    params['events'] = 'all'

    assert resp.json['err'] == 0

    assert Agenda.objects.get(id=agenda.id).edit_role is None

def test_virtual_agenda_init():

    agenda1 = Agenda.objects.create(label='Agenda 1', kind='meetings')

    agenda2 = Agenda.objects.create(label='Agenda 2', kind='meetings')

    )

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

    desk.import_timeperiod_exceptions_from_settings(enable=True)

        desk=desk,

        start_datetime=now(),

        end_datetime=now() + datetime.timedelta(minutes=30),

    )

    assert desk.timeperiodexception_set.count() == 34

        agenda=agenda,

        full_event=AgendaNotificationsSettings.EMAIL_FIELD,

        full_event_emails=['hop@entrouvert.com', 'top@entrouvert.com'],

        assert 'Do no forget ID card.' in body

        assert 'Come !' in body

        assert 'Pricing: 10€' in body

    assert 'More information: https://example.party' in mail_bodies[0]

    assert '<a href="https://example.party">More information</a>' in mail_bodies[1]

    mailoutbox.clear()

        event.get_recurrence_display()

        == 'On Monday at 1:30 p.m., once every three weeks, from Jan. 7, 2021, until Jan. 14, 2021'

    )