Produits Entr'ouvert » Chrono

    TimePeriod = apps.get_model('agendas', 'TimePeriod')

    Desk = apps.get_model('agendas', 'Desk')

    for time_period in TimePeriod.objects.all():

        time_period.desk = desk

        time_period.save()

        if not event.agenda.kind == 'meetings':

            continue

        event.desk = desk

        event.save()

def remove_duplicate_sources(apps, schema_editor):

    Desk = apps.get_model('agendas', 'Desk')

    for desk in Desk.objects.all():

        duplicate_source_slugs = (

            desk.timeperiodexceptionsource_set.values('settings_slug')

        events = recurrences.filter(start_datetime__gt=min_start).exclude(start_datetime__in=datetimes)

        events.filter(Q(booking__isnull=True) | Q(booking__cancellation_datetime__isnull=False)).delete()

        # report events that weren't deleted because they have bookings

        report.events.set(events)

        # add recurrences

        sources = data.pop('exception_sources', [])

        unavailability_calendars = data.pop('unavailability_calendars', [])

        data = clean_import_data(cls, data)

        for timeperiod in timeperiods:

            timeperiod['desk'] = desk

            TimePeriod.import_json(timeperiod)

    def increase(self, booking, secondary_bookings, primary_booked_places, primary_wanted_places):

        with transaction.atomic():

            bulk_bookings = []

                bulk_bookings.append(

                    booking.clone(

                        primary_booking=booking,

    def get_week_timetable_infos(self, week_index, week_end_offset=0):

        date = self.date + datetime.timedelta(week_index * 7)

        start_date = date - datetime.timedelta(dow)

        interval = datetime.timedelta(minutes=60)

    def get_week_timetable_infos(self, week_index, week_end_offset=0):

        date = self.date + datetime.timedelta(week_index * 7)

        start_date = date - datetime.timedelta(dow)

        interval = datetime.timedelta(minutes=60)

        while period <= max_date:

            left = 1

            period_end = period + interval

                width = (98.0 / desks_len) - 1

                for event in [

                    x

            for services in settings.KNOWN_SERVICES.values():

                for service in services.values():

                    remote_url = service.get('url')

                    if remote_scheme == scheme and remote_netloc == netloc:

                        remote_service = service

                        break

            query_params['orig'] = remote_service.get('orig')

            remote_service_base_url = remote_service.get('url')

            query = urlencode(query_params)

            if '?' in url:

    test_1st_weekday = (localtime(now()).weekday() + 2) % 7

    test_2nd_weekday = (localtime(now()).weekday() + 3) % 7

    time_period = TimePeriod(

        weekday=test_1st_weekday,

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

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

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

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

            start_datetime=now(), places=10, agenda=event_agenda, recurrence_days=[now().weekday()]

        )

        TimePeriodException.objects.create(

def test_bookings_api_filter_agenda(app, user):

    bookings = []

    for label in ['foobar', 'foobaz']:

        event = Event.objects.create(agenda=agenda, start_datetime=now(), places=10)

        bookings.append(Booking.objects.create(event=event, user_external_id='42'))

    assert len([x for x in resp.json['data'] if not x.get('disabled')]) == 3

    assert event.slug in [x['id'] for x in resp.json['data']]

        Booking(event=event).save()

    # all places are booked but all the dates are still displayed as there is a

    assert len([x for x in resp.json['data'] if not x.get('disabled')]) == 3

    # fill the waiting list

        Booking(event=event, in_waiting_list=True).save()

    # the event datetime should no longer be returned

    }

    def simulate_booking(event, nb_places):

            Booking(event=event, user_external_id='42').save()

    simulate_booking(events[0], 10)

    assert len([x for x in resp.json['data'] if not x.get('disabled')]) == 3

    assert event.slug in [x['id'] for x in resp.json['data']]

        Booking(event=event).save()

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

    event.waiting_list_places = 5

    event.save()

        Booking(event=event).save()

    app.authorization = ('Basic', ('john.doe', 'password'))

    assert resp.json['in_waiting_list'] is True

    # fill the waiting list

        Booking(event=event, in_waiting_list=True).save()

    app.authorization = ('Basic', ('john.doe', 'password'))

    assert resp.json['err_desc'] == 'no more desk available'

    # fill the agenda and make sure big O is O(1)

        booking_url = event_data['api']['fillslot_url']

        with CaptureQueriesContext(connection) as ctx:

            app.post(booking_url)

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

    resp = resp.click('Configure', href='roles')

    resp.form['edit_role'] = manager_user.groups.all()[0].pk

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

    assert 'Edit Role: Managers' in resp.text

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

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

    agenda_meetings = Agenda.objects.create(label=u'Foo bar', kind='meetings')

    app = login(app)

    resp = app.get('/manage/agendas/%s/edit' % agenda_events.pk)

    agenda = Agenda(label=u'Foo bar', kind='meetings')

    agenda.save()

    desk_a = Desk.objects.create(agenda=agenda, label='Desk A')

    event = Event(start_datetime=now() + datetime.timedelta(days=10), places=10, agenda=agenda, desk=desk_a)

    event.save()

    assert 'abc' in resp.pyquery.find('.event-info')[3].text

    assert 'abc' in resp.pyquery.find('.event-info')[4].text

        desk=agenda.desk_set.get(),

        start_datetime=start_datetime + datetime.timedelta(days=6),

        end_datetime=start_datetime + datetime.timedelta(days=8),

    )

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

    start_datetime = now() - datetime.timedelta(days=3)

        label='event G',

        start_datetime=start_datetime,

        places=10,

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

    resp = resp.click('Configure', href='roles')

    resp.form['edit_role'] = manager_user.groups.all()[0].pk

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

    desk = Desk.objects.create(agenda=agenda, label='New Desk')

    meetingtype = MeetingType.objects.create(agenda=agenda, label='Bar', duration=30)

    today = datetime.date.today()

        desk=desk, weekday=today.weekday(), start_time=datetime.time(10, 0), end_time=datetime.time(18, 0)

    )

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

    event = Event(start_datetime=make_aware(datetime.datetime(2016, 2, 15, 17, 0)), places=10, agenda=agenda)

    event.save()

        Booking(event=event).save()

    app = login(app)

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

    assert '<span class="tag">Full</span>' not in resp

        Booking(event=event).save()

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

    def mocked_requests_connection_error(*args, **kwargs):

        raise requests.exceptions.ConnectionError('unreachable')

        Booking.objects.create(event=event, cancel_callback_url='http://example.org/jump/trigger/')

    login(app)

    mocked_get.side_effect = mocked_requests_http_forbidden_error

    call_command('sync_desks_timeperiod_exceptions')

    assert (

        err

        == 'unable to create timeperiod exceptions for "Test 11 desk": Failed to retrieve remote calendar (http://example.com/sample.ics, HTTP error 403).\n'

def test_agenda_get_effective_time_periods(db):

    real_agenda = Agenda.objects.create(label='Real Agenda', kind='meetings')

    desk = Desk.objects.create(label='Real Agenda Desk1', agenda=real_agenda)

    time_period = TimePeriod.objects.create(

        weekday=0, start_time=datetime.time(10, 0), end_time=datetime.time(18, 0), desk=desk

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

    event = Event.objects.create(agenda=agenda, start_datetime=now(), places=10, label='Event')

        Booking.objects.create(event=event, cancel_callback_url='http://example.org/jump/trigger/')

    event.cancellation_scheduled = True

        raise requests.exceptions.ConnectionError('unreachable')

    booking_good_url = Booking.objects.create(event=event, cancel_callback_url='http://good.org/')

        Booking.objects.create(event=event, cancel_callback_url='http://example.org/jump/trigger/')

    event.cancellation_scheduled = True

    settings.save()

    # book 9/10 places to reach almost full state

        Booking.objects.create(event=event)

    event.refresh_from_db()

    assert event.almost_full

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

    settings.save()

        Booking.objects.create(event=event)

    event.refresh_from_db()

    assert event.full

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

    event = Event.objects.create(agenda=agenda, start_datetime=start_datetime, places=10, label='Event')

    # extra booking with no email, should be ignored

    freezer.move_to('2020-01-02 10:00')

    # not time to send reminders yet

    # booking is placed the day of the event, notfication should no be sent

    freezer.move_to('2020-01-03 08:00')

    call_command('send_booking_reminders')

    assert len(mailoutbox) == 0

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

    event = Event.objects.create(agenda=agenda, start_datetime=start_datetime, places=10, label='Event')

    freezer.move_to('2020-01-02 15:00')

    with mock.patch('chrono.utils.requests_wrapper.RequestsSession.send') as mock_send:

def test_agenda_reminders_email_content(mailoutbox, freezer):

    freezer.move_to('2020-01-01 14:00')

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

        agenda=agenda, days=1, send_email=True, email_extra_info='Do no forget ID card.'

    )

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

        pricing='10€',

    )

    freezer.move_to('2020-01-02 15:00')

    call_command('send_booking_reminders')

    mailoutbox.clear()

    freezer.move_to('2020-01-01 14:00')

    freezer.move_to('2020-01-02 15:00')

    call_command('send_booking_reminders')

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

    event = Event.objects.create(agenda=agenda, start_datetime=start_datetime, places=10, label='Pool party')

    freezer.move_to('2020-01-02 15:00')

    with mock.patch('chrono.utils.requests_wrapper.RequestsSession.send') as mock_send:

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

    desk = Desk.objects.create(agenda=agenda, label='Desk')

    meetingtype = MeetingType.objects.create(agenda=agenda, label='Bar', duration=30)

        desk=desk, weekday=now().weekday(), start_time=datetime.time(10, 0), end_time=datetime.time(18, 0)

    )

    AgendaReminderSettings.objects.create(agenda=agenda, days=2, send_email=True)

        agenda=agenda, start_datetime=now() + datetime.timedelta(days=10), places=10, label='Event'

    )

        Booking.objects.create(

            event=event,

            extra_data={'test': True},

        places=5,

    )

    event.refresh_from_db()

    recurrences = event.get_recurrences(now(), now() + datetime.timedelta(days=7))

    assert recurrences[0].start_datetime.strftime('%m-%d') == '05-01'

    event = daily_event_no_end_date.get_or_create_event_recurrence(

        now() + datetime.timedelta(days=6, hours=2)

    )

    time_period_exception.save()

    agenda.update_event_recurrences()

def test_import_export_recurring_event(app, freezer):

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

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

    event = Event.objects.create(

        agenda=agenda,

        start_datetime=now(),

    source_desk = TimePeriodExceptionSource.objects.create(desk=desk, settings_slug='holidays', enabled=True)

    start_datetime = datetime.datetime(year=2020, month=1, day=2)

    end_datetime = datetime.datetime(year=2020, month=1, day=3)

        TimePeriodException.objects.create(

            desk=desk,

            source=source_desk,

    source_new_desk = TimePeriodExceptionSource.objects.create(

        desk=new_desk, settings_slug='holidays', enabled=True

    )

        TimePeriodException.objects.create(

            desk=new_desk,

            source=source_new_desk,

    TimePeriodExceptionSource.objects.create(desk=new_desk, settings_slug='holidays', enabled=True)

    # wrong duplicate of exceptions, referencing original desk source

        TimePeriodException.objects.create(

            desk=new_desk,

            source=source_desk,

        requests.get('/foo/bar/', remote_service=remote_service)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert query['orig'][0] == 'myself'

        assert query['email'][0] == ''

        requests.get('/foo/bar/', remote_service=remote_service, without_user=True)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert query['orig'][0] == 'myself'

        assert 'email' not in query

        requests.get('http://example.org/foo/bar/', remote_service='auto')

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert query['orig'][0] == 'chrono'

        assert check_query(querystring, 'chrono') == True

        requests.get('/foo/bar/', remote_service=remote_service, user=user)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert query['NameID'][0] == 'r2d2'

        assert 'email' not in query

        requests.get('/foo/bar/', remote_service=remote_service, user=user, federation_key='email')

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert query['email'][0] == 'foo@example.net'

        assert 'NameID' not in query

        requests.get('/foo/bar/', remote_service=remote_service, user=user)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert 'NameID' not in query

        assert query['email'][0] == 'foo@example.net'

        requests.get('/foo/bar/', remote_service=remote_service, user=user)

        url = send.call_args[0][0].url

        assert url.startswith('http://example.org/foo/bar/?')

        query = urlparse.parse_qs(querystring, keep_blank_values=True)

        assert query['NameID'][0] == ''

        assert query['email'][0] == ''