Produits Entr'ouvert » Chrono

                for weektime_interval in IntervalSet.simple(*time_period_interval) - closed_hours_by_days:

                    yield SharedTimePeriod.from_weektime_interval(weektime_interval, desks=desks)

    def max_booking_datetime(self):

        if self.maximal_booking_delay is None:

            return None

        t = t.replace(hour=0, minute=0, second=0, microsecond=0)

        return localtime(t)

    def min_booking_datetime(self):

        if self.minimal_booking_delay is None:

            return None

        max_start=None,

        user_external_id=None,

        bypass_delays=False,

    ):

        assert self.kind == 'events'

            if not include_full:

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

            min_start = max(self.min_booking_datetime, min_start) if min_start else self.min_booking_datetime

        if min_start:

    return places

    if disable_booked and getattr(event, 'user_places_count', 0) > 0:

        return True

    if event.start_datetime < now():

            return False

        # we just want to show past events, but they are not bookable

        return True

    if event.remaining_places < min_places and event.remaining_waiting_list_places < min_places:

        return True

    return False

    bookable_events=None,

    multiple_agendas=False,

    disable_booked=True,

):

    agenda = agenda or event.agenda

    details = {

                    min_places=min_places,

                    disable_booked=disable_booked,

                    bookable_events=bookable_events,

                ),

                'api': {

                    'bookings_url': request.build_absolute_uri(

def get_events_meta_detail(

):

    bookable_datetimes_number_total = 0

    bookable_datetimes_number_available = 0

    first_bookable_slot = None

    for event in events:

        bookable_datetimes_number_total += 1

            bookable_datetimes_number_available += 1

            if not first_bookable_slot:

                first_bookable_slot = get_event_detail(

                    min_places=min_places,

                    bookable_events=bookable_events,

                    multiple_agendas=multiple_agendas,

                )

    return {

        'no_bookable_datetimes': bool(bookable_datetimes_number_available == 0),

                e

                for e in entries

                if not is_event_disabled(

                )

            ]

                    booked_user_external_id=payload.get('user_external_id'),

                    bookable_events=bookable_events_raw,

                    disable_booked=disable_booked,

                )

                for x in entries

            ],

                    min_start=payload.get('date_start'),

                    max_start=payload.get('date_end'),

                    bypass_delays=payload.get('bypass_delays'),

                )

            )

                    booked_user_external_id=payload.get('user_external_id'),

                    multiple_agendas=True,

                    disable_booked=disable_booked,

                )

                for x in entries

            ],

    # check delays

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

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

    resp = app.get('/api/agenda/%s/datetimes/' % agenda.slug, params={'bypass_delays': True})

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

    agenda.minimal_booking_delay = 10

    agenda.mmaximal_booking_delay = 20

    agenda.save()

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

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

    resp = app.get('/api/agenda/%s/datetimes/' % agenda.slug, params={'bypass_delays': True})

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

def test_recurring_events_api_various_times(app, user, mock_now):

    date_end = localtime() + datetime.timedelta(days=60)  # with a date end to have recurring events

    resp = app.get('/api/agendas/datetimes/', params={'agendas': agenda_slugs, 'date_end': date_end})

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

    resp = app.get(

        '/api/agendas/datetimes/',

        params={'agendas': agenda_slugs, 'date_end': date_end, 'bypass_delays': True},

    )

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

    Agenda.objects.update(minimal_booking_delay=0, maximal_booking_delay=45)

    # invalid slugs

    assert resp.json['data'][2]['id'] == 'second-agenda@event'

    assert resp.json['data'][3]['id'] == 'first-agenda@recurring:2021-05-13-1700'

    assert resp.json['data'][4]['id'] == 'first-agenda@recurring:2021-05-20-1700'

    Event.objects.create(

        slug='event-in-past',

    assert agenda.min_booking_datetime.date() == datetime.date(2021, 7, 10)

    agenda.minimal_booking_delay_in_working_days = False

    agenda.save()

    assert agenda.min_booking_datetime.date() == datetime.date(2021, 7, 10)

    settings.WORKING_DAY_CALENDAR = 'workalendar.europe.France'

    agenda.minimal_booking_delay_in_working_days = True

    agenda.save()

    assert agenda.min_booking_datetime.date() == datetime.date(2021, 7, 12)

    agenda.minimal_booking_delay_in_working_days = False

    agenda.save()

    assert agenda.min_booking_datetime.date() == datetime.date(2021, 7, 10)