Produits Entr'ouvert » Chrono

    label = models.CharField(_('Label'), max_length=150)

    slug = models.SlugField(_('Identifier'), max_length=160, unique=True)

    kind = models.CharField(_('Kind'), max_length=20, choices=AGENDA_KINDS, default='events')

    maximal_booking_delay = models.PositiveIntegerField(

    class Meta:

        ordering = ['label']

            'permissions': {

                'view': self.view_role.name if self.view_role else None,

                'edit': self.edit_role.name if self.edit_role else None,

        }

        if self.kind == 'events':

            agenda['events'] = [x.export_json() for x in self.event_set.all()]

                Desk.import_json(desk).save()

        return created

WEEKDAYS_LIST = sorted(WEEKDAYS.items(), key=lambda x: x[0])

    def __str__(self):

        return u'%s / %s → %s' % (

    @property

    def weekday_str(self):

    def export_json(self):

        return {

        }

    def get_time_slots(self, min_datetime, max_datetime, meeting_type):

        min_datetime = make_naive(min_datetime)

        max_datetime = make_naive(max_datetime)

        if real_min_datetime < min_datetime:

            real_min_datetime += datetime.timedelta(days=7)

        while event_datetime < max_datetime:

            end_time = event_datetime + meeting_duration

            next_time = event_datetime + duration

            if end_time.time() > self.end_time or event_datetime.date() != next_time.date():

                # back to morning

                # but next week

                event_datetime += datetime.timedelta(days=7)

                next_time = event_datetime + duration

            if event_datetime > max_datetime:

                break

            event_datetime = next_time

    @classmethod

    def import_json(cls, data):

        meeting_type, created = cls.objects.get_or_create(

        if not created:

            for k, v in data.items():

                setattr(meeting_type, k, v)

    def export_json(self):

        return {

        }

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

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

    places = models.PositiveIntegerField(_('Places'))

    slug = models.SlugField(_('Identifier'), max_length=160, null=True, blank=True, default=None)

    full = models.BooleanField(default=False)

    meeting_type = models.ForeignKey(MeetingType, null=True, on_delete=models.CASCADE)

    desk = models.ForeignKey('Desk', null=True, on_delete=models.CASCADE)

    def check_full(self):

        self.full = bool(

    def in_bookable_period(self):

            return False

        if self.agenda.maximal_booking_delay and (

            return False

        if self.start_datetime < now():

            # past the event date, we may want in the future to allow for some

    @property

    def booked_places(self):

    @property

    def waiting_list(self):

    @property

    def end_datetime(self):

    @classmethod

    def import_json(cls, data):

        if data.get('slug'):

            event, created = cls.objects.get_or_create(slug=data['slug'], defaults=data)

            if not created:

    in_waiting_list = models.BooleanField(default=False)

    creation_datetime = models.DateTimeField(auto_now_add=True)

    # primary booking is used to group multiple bookings together

    label = models.CharField(max_length=250, blank=True)

    user_name = models.CharField(max_length=250, blank=True)

    backoffice_url = models.URLField(blank=True)

        ics = vobject.iCalendar()

        ics.add('prodid').value = '-//Entr\'ouvert//NON SGML Publik'

        vevent = vobject.newFromBehavior('vevent')

        vevent.add('summary').value = self.user_display_label or self.label

        vevent.add('dtstart').value = self.event.start_datetime

        if self.user_name:

            vevent.add('attendee').value = self.user_name

        if self.event.meeting_type:

        for field in ('description', 'location', 'comment', 'url'):

            field_value = request and request.GET.get(field) or self.extra_data.get(field)

        return ics.serialize()

@python_2_unicode_compatible

class Desk(models.Model):

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

    label = models.CharField(_('Label'), max_length=150)

    slug = models.SlugField(_('Identifier'), max_length=160)

    timeperiod_exceptions_remote_url = models.URLField(

    def __str__(self):

        return self.label

    def import_json(cls, data):

        timeperiods = data.pop('timeperiods')

        exceptions = data.pop('exceptions')

        if not created:

            for k, v in data.items():

                setattr(instance, k, v)

        return instance

    def export_json(self):

    def get_exceptions_within_two_weeks(self):

        in_two_weeks = make_aware(datetime.datetime.today() + datetime.timedelta(days=14))

        exceptions = self.timeperiodexception_set.filter(end_datetime__gte=now()).filter(

        if exceptions.exists():

            return exceptions

        # if none found within the 2 coming weeks, return the next one

        if next_exception:

            return [next_exception]

        return []

            response.raise_for_status()

        except requests.HTTPError as e:

            raise ICSError(

        except requests.RequestException as e:

            raise ICSError(

        return self.create_timeperiod_exceptions_from_ics(response.text, keep_synced_by_uid=True)

                        if end_dt < update_datetime:

                            TimePeriodException.objects.filter(**kwargs).update(**event)

                        else:

                            if created:

                                total_created += 1

                    # delete unseen occurrences

            if keep_synced_by_uid:

                # delete all outdated exceptions from remote calendar

        return total_created

        aware_date = make_aware(datetime.datetime(date.year, date.month, date.day))

        aware_next_date = aware_date + datetime.timedelta(days=1)

        for exception in self.timeperiodexception_set.filter(

            openslots.remove(exception.start_datetime, exception.end_datetime)

        return openslots.search(aware_date, aware_next_date)

                exc_repr = u'%s' % date_format(localtime(self.start_datetime), 'SHORT_DATE_FORMAT')

            else:

                exc_repr = u'%s → %s' % (

        else:

            if localtime(self.start_datetime).date() == localtime(self.end_datetime).date():

                # same day

                exc_repr = u'%s → %s' % (

            else:

                exc_repr = u'%s → %s' % (

        if self.label:

            exc_repr = u'%s (%s)' % (self.label, exc_repr)

            # incomplete time period, can't tell

            return False

        for event in Event.objects.filter(

            if self.start_datetime <= event.start_datetime < self.end_datetime:

                return True

        return False

from django.core.management import call_command

from django.core.management.base import CommandError

pytestmark = pytest.mark.django_db

    booking.save()

    assert Event.objects.all()[0].booked_places == 0

def test_event_bookable_period():

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

    agenda.save()

    event.save()

    assert event.in_bookable_period() is False

def test_meeting_type_slugs():

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

    agenda1.save()

    meeting_type3.save()

    assert meeting_type3.slug == 'baz'

def test_timeperiodexception_creation_from_ics():

    agenda = Agenda(label=u'Test 1 agenda')

    agenda.save()

    assert exceptions_count == 2

    assert TimePeriodException.objects.filter(desk=desk).count() == 2

def test_timeperiodexception_creation_from_ics_without_startdt():

    agenda = Agenda(label=u'Test 2 agenda')

    agenda.save()

        exceptions_count = desk.create_timeperiod_exceptions_from_ics(ics_sample)

    assert 'Event "Event 1" has no start date.' == str(e.value)

def test_timeperiodexception_creation_from_ics_without_enddt():

    agenda = Agenda(label=u'Test 3 agenda')

    agenda.save()

    desk.save()

    assert desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_RECURRENT_EVENT) == 3

    assert TimePeriodException.objects.filter(desk=desk).count() == 3

    assert desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_RECURRENT_EVENT) == 0

    # verify occurences are cleaned when count changed

    assert desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_RECURRENT_EVENT_2) == 0

    assert TimePeriodException.objects.filter(desk=desk).count() == 2

def test_timeexception_creation_from_ics_with_dates():

    agenda = Agenda(label=u'Test 5 agenda')

        assert localtime(exception.start_datetime) == make_aware(datetime.datetime(2018, 1, 1, 0, 0))

        assert localtime(exception.end_datetime) == make_aware(datetime.datetime(2018, 1, 1, 0, 0))

def test_timeexception_create_from_invalid_ics():

    agenda = Agenda(label=u'Test 6 agenda')

    agenda.save()

        exceptions_count = desk.create_timeperiod_exceptions_from_ics(INVALID_ICS_SAMPLE)

    assert str(e.value) == 'File format is invalid.'

def test_timeexception_create_from_ics_with_no_events():

    agenda = Agenda(label=u'Test 7 agenda')

    agenda.save()

        exceptions_count = desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_NO_EVENTS)

    assert str(e.value) == "The file doesn't contain any events."

@mock.patch('chrono.agendas.models.requests.get')

def test_timeperiodexception_creation_from_remote_ics(mocked_get):

    agenda = Agenda(label=u'Test 8 agenda')

    assert exceptions_count == 0

    TimePeriodException.objects.filter(external_id='desk-%s:' % desk.id).count() == 0

@mock.patch('chrono.agendas.models.requests.get')

def test_timeperiodexception_creation_from_unreachable_remote_ics(mocked_get):

    agenda = Agenda(label=u'Test 9 agenda')

    mocked_response = mock.Mock()

    mocked_response.text = ICS_SAMPLE

    mocked_get.return_value = mocked_response

    def mocked_requests_connection_error(*args, **kwargs):

        raise requests.ConnectionError('unreachable')

    mocked_get.side_effect = mocked_requests_connection_error

    with pytest.raises(ICSError) as e:

        exceptions_count = desk.create_timeperiod_exceptions_from_remote_ics('http://example.com/sample.ics')

    assert str(e.value) == "Failed to retrieve remote calendar (http://example.com/sample.ics, unreachable)."

@mock.patch('chrono.agendas.models.requests.get')

def test_timeperiodexception_creation_from_forbidden_remote_ics(mocked_get):

    agenda = Agenda(label=u'Test 10 agenda')

    mocked_response = mock.Mock()

    mocked_response.status_code = 403

    mocked_get.return_value = mocked_response

    def mocked_requests_http_forbidden_error(*args, **kwargs):

        raise requests.HTTPError(response=mocked_response)

    mocked_get.side_effect = mocked_requests_http_forbidden_error

    with pytest.raises(ICSError) as e:

        exceptions_count = desk.create_timeperiod_exceptions_from_remote_ics('http://example.com/sample.ics')

@mock.patch('chrono.agendas.models.requests.get')

def test_sync_desks_timeperiod_exceptions_from_ics(mocked_get, capsys):

    agenda = Agenda(label=u'Test 11 agenda')

    agenda.save()

    desk.save()

    mocked_response = mock.Mock()

    mocked_response.status_code = 403

    mocked_get.return_value = mocked_response

    def mocked_requests_http_forbidden_error(*args, **kwargs):

        raise requests.HTTPError(response=mocked_response)

    mocked_get.side_effect = mocked_requests_http_forbidden_error

    call_command('sync_desks_timeperiod_exceptions')

    out, err = capsys.readouterr()

@mock.patch('chrono.agendas.models.requests.get')

def test_sync_desks_timeperiod_exceptions_from_changing_ics(mocked_get, caplog):

    agenda = Agenda(label=u'Test 11 agenda')

    agenda.save()

    desk.save()

    mocked_response = mock.Mock()

    mocked_response.text = ICS_SAMPLE

    call_command('sync_desks_timeperiod_exceptions')

    assert not TimePeriodException.objects.filter(desk=desk).exists()

def test_base_meeting_duration():

    agenda = Agenda(label='Meeting', kind='meetings')

    agenda.save()

    exceptions_count = desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_DURATION)

    assert exceptions_count == 2

    assert TimePeriodException.objects.filter(desk=desk).count() == 2

@pytest.mark.freeze_time('2017-12-01')

    desk.save()

    assert desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_RECURRENT_EVENT_IN_THE_PAST) == 2

    assert TimePeriodException.objects.filter(desk=desk).count() == 2

    assert desk.create_timeperiod_exceptions_from_ics(ICS_SAMPLE_WITH_RECURRENT_EVENT_IN_THE_PAST) == 0

from chrono.wsgi import application

from chrono.manager.utils import export_site

pytestmark = pytest.mark.django_db

@pytest.fixture

def simple_user():

    try:

        user = User.objects.create_user('user', password='user')

    return user

@pytest.fixture

def manager_user():

    try:

    user.groups.set([group])

    return user

@pytest.fixture

def admin_user():

    try:

        user = User.objects.create_superuser('admin', email=None, password='admin')

    return user

@pytest.fixture

def api_user():

    try:

        user = User.objects.get(username='api-user')

    except User.DoesNotExist:

        user.set_password('password')

        user.save()

    return user

def login(app, username='admin', password='admin'):

    login_page = app.get('/login/')

    login_form = login_page.forms[0]

    assert resp.status_int == 302

    return app

def test_unlogged_access(app):

    # connect while not being logged in

    assert app.get('/manage/', status=302).location.endswith('/login/?next=/manage/')

def test_simple_user_access(app, simple_user):

    # connect while being logged as a simple user, access should be forbidden

    app = login(app, username='user', password='user')

    assert app.get('/manage/', status=403)

def test_manager_user_access(app, manager_user):

    # connect while being logged as a manager user, access should be granted if

    # there's at least an agenda that is viewable or editable.

    agenda.save()

    assert app.get('/manage/', status=200)

def test_home_redirect(app):

    assert app.get('/', status=302).location.endswith('/manage/')

def test_access(app, admin_user):

    app = login(app)

    resp = app.get('/manage/', status=200)

    assert '<h2>Agendas</h2>' in resp.text

    assert "This site doesn't have any agenda yet." in resp.text

def test_logout(app, admin_user):

    app = login(app)

    app.get('/logout/')

    assert app.get('/manage/', status=302).location.endswith('/login/?next=/manage/')

def test_menu_json(app, admin_user):

    app = login(app)

    resp = app.get('/manage/menu.json', status=200)

    assert resp2.text == 'Q(%s);' % resp.text

    assert resp2.content_type == 'application/javascript'

def test_view_agendas_as_manager(app, manager_user):

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

    agenda.view_role = manager_user.groups.all()[0]

    # check it gives a 404 on unknown agendas

    resp = app.get('/manage/agendas/%s/settings' % '9999', status=404)

def test_add_agenda(app, admin_user):

    app = login(app)

    resp = app.get('/manage/', status=200)

    assert 'Foo bar' in resp.text

    assert '<h2>Settings' in resp.text

def test_add_agenda_as_manager(app, manager_user):

    # open /manage/ access to manager_user, and check agenda creation is not

    # allowed.

    resp = app.get('/manage/', status=200)

    resp = app.get('/manage/agendas/add/', status=403)

def test_options_agenda(app, admin_user):

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

    agenda.save()

    assert 'Foo baz' in resp.text

    assert '<h2>Settings' in resp.text

def test_options_agenda_as_manager(app, manager_user):

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

    agenda.view_role = manager_user.groups.all()[0]

    assert 'Foo baz' in resp.text

    assert '<h2>Settings' in resp.text

def test_delete_agenda(app, admin_user):

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

    agenda.save()

    resp = resp.follow()

    assert not 'Foo bar' in resp.text

def test_delete_busy_agenda(app, admin_user):

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

    agenda.save()

    event.save()

    app = login(app)

    booking.save()

    resp = resp.form.submit(status=403)

def test_delete_agenda_as_manager(app, manager_user):

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

    agenda.edit_role = manager_user.groups.all()[0]

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

    desk_b = Desk.objects.create(agenda=agenda, label='Desk B')

    event.save()

    app = login(app)

    app = login(app)

    app.get('/manage/agendas/%s/add-event' % '999', status=404)

def test_add_event_as_manager(app, manager_user):

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

    agenda.view_role = manager_user.groups.all()[0]

    assert 'Feb. 15, 2016, 5 p.m.' in resp.text

    assert '10 places' in resp.text

def test_edit_event(app, admin_user):

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

    agenda.save()

    event.save()

    app = login(app)

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

    assert 'Feb. 16, 2016, 5 p.m.' in resp.text

    assert '20 places' in resp.text

def test_edit_missing_event(app, admin_user):

    app = login(app)

    app.get('/manage/agendas/999/', status=404)

def test_edit_event_as_manager(app, manager_user):

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

    agenda.view_role = manager_user.groups.all()[0]

    agenda.save()

    event.save()

    app = login(app, username='manager', password='manager')

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

    assert 'Feb. 16, 2016, 5 p.m.' in resp.text

    assert '20 places' in resp.text

def test_booked_places(app, admin_user):

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

    agenda.save()

    event.save()

    Booking(event=event).save()

    Booking(event=event).save()

    assert '10 places' in resp.text

    assert '2 booked places' in resp.text

def test_event_classes(app, admin_user):

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

    agenda.save()

    event.save()

    for i in range(2):

        Booking(event=event).save()

    assert 'full' in resp.text

    assert 'overbooking' in resp.text

def test_delete_event(app, admin_user):

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

    agenda.save()

    event.save()

    app = login(app)

    assert resp.location.endswith('/manage/agendas/%s/settings' % agenda.id)

    assert Event.objects.count() == 0

def test_delete_busy_event(app, admin_user):

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

    agenda.save()

    event.save()

    app = login(app)

    booking.save()

    resp = resp.form.submit(status=403)

def test_delete_event_as_manager(app, manager_user):

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

    agenda.edit_role = manager_user.groups.all()[0]

    agenda.save()

    event.save()

    app = login(app, username='manager', password='manager')

    assert resp.location.endswith('/manage/agendas/%s/settings' % agenda.id)

    assert Event.objects.count() == 0

def test_import_events(app, admin_user):

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

    agenda.save()

    Event.objects.all().delete()

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

    resp = resp.form.submit(status=302)

    assert Event.objects.count() == 1

    assert Event.objects.all()[0].start_datetime == make_aware(datetime.datetime(2016, 9, 16, 18, 0))

    Event.objects.all().delete()

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

    resp = resp.form.submit(status=302)

    assert Event.objects.count() == 1

    assert Event.objects.all()[0].start_datetime == make_aware(datetime.datetime(2016, 9, 16, 18, 0))

    Event.objects.all().delete()

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

    resp = resp.form.submit(status=302)

    assert Event.objects.count() == 1

    assert Event.objects.all()[0].start_datetime == make_aware(datetime.datetime(2016, 9, 16, 18, 0))

    Event.objects.all().delete()

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

    resp = resp.form.submit(status=302)

    assert Event.objects.count() == 2

    Event.objects.all().delete()

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

    resp = resp.form.submit(status=302)

    assert Event.objects.count() == 2

    Event.objects.all().delete()

    agenda = Agenda.objects.get(label='Foo bar')

    assert agenda.kind == 'meetings'

def test_meetings_agenda_add_meeting_type(app, admin_user):

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

    agenda.save()

    resp = resp.form.submit()

    assert MeetingType.objects.get(agenda=agenda).duration == 30

def test_meetings_agenda_delete_meeting_type(app, admin_user):

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

    agenda.save()

    assert resp.location.endswith('/manage/agendas/%s/settings' % agenda.id)

    assert MeetingType.objects.count() == 0

def test_meetings_agenda_add_time_period(app, admin_user):

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

    agenda.save()

    resp = resp.form.submit()

    assert TimePeriod.objects.filter(desk=desk).count() == 4

def test_meetings_agenda_delete_time_period(app, admin_user):

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

    agenda.save()

    MeetingType(agenda=agenda, label='Blah').save()

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

    time_period.save()

    app = login(app)

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

    MeetingType(agenda=agenda, label='Blah').save()

    app.get('/manage/agendas/%d/desk/%d/add-time-period' % (agenda.id, desk.id), status=403)

    time_period.save()

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

    app.get('/manage/timeperiods/%d/edit' % time_period.id, status=403)

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

    assert TimePeriodException.objects.count() == 1

    time_period_exception = TimePeriodException.objects.first()

    # add an exception beyond 2 weeks and make sure it isn't listed

    resp = resp.click('Add a time period exception', index=1)

    future = tomorrow + datetime.timedelta(days=15)

    assert TimePeriodException.objects.count() == 2

    assert 'Exception 1' in resp.text

    assert 'Exception 2' not in resp.text

    assert 'Exception 1' in resp.text

    assert 'Exception 2' in resp.text

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

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

    MeetingType(agenda=agenda, label='Blah').save()

    Booking.objects.create(event=event)

    login(app)

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp = resp.click('Add a time period exception')

    # fields should be marked with errors

    assert resp.text.count('This field is required.') == 2

    # try again with data in fields

    # check it's possible to add an exception on another desk

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

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp = resp.click('Add a time period exception', href='desk/%s/' % desk.id)

    resp = resp.form.submit()

    assert TimePeriodException.objects.count() == 1

def test_meetings_agenda_add_time_period_exception_when_cancelled_booking_exists(app, admin_user):

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

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

    MeetingType(agenda=agenda, label='Blah').save()

    login(app)

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    assert 'One or several bookings exists within this time slot.' not in resp.text

    assert TimePeriodException.objects.count() == 1

def test_meetings_agenda_add_invalid_time_period_exception(app, admin_user):

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

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

    MeetingType(agenda=agenda, label='Blah').save()

    login(app)

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

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

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

    MeetingType(agenda=agenda, label='Blah').save()

    login(app)

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

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

    assert TimePeriodException.objects.count() == 1

    time_period_exception = TimePeriodException.objects.first()

    resp = resp.click(href='/manage/time-period-exceptions/%d/edit' % time_period_exception.id)

    resp = resp.click('Delete')

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

        label='Future Exception',

        desk=desk,

        start_datetime=now() + datetime.timedelta(days=1),

    resp = app.get('/manage/time-period-exceptions/%d/exception-list' % desk.pk)

    resp = resp.click(href='/manage/time-period-exceptions/%d/delete' % time_period_exception.pk)

    resp = resp.form.submit(

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

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

    MeetingType(agenda=agenda, label='Blah').save()

    past_exception = TimePeriodException.objects.create(

        label='Past Exception',

        desk=desk,

        start_datetime=now() - datetime.timedelta(days=2),

    current_exception = TimePeriodException.objects.create(

        label='Current Exception',

        desk=desk,

        start_datetime=now() - datetime.timedelta(days=1),

    future_exception = TimePeriodException.objects.create(

        label='Future Exception',

        desk=desk,

        start_datetime=now() + datetime.timedelta(days=1),

    login(app)

    resp = app.get('/manage/agendas/%d/settings' % agenda.pk)

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

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

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

    MeetingType(agenda=agenda, label='Foo').save()

    login(app)

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    assert 'ics_url' in resp.form.fields

    resp.form['ics_url'] = 'http://example.com/foo.ics'

    mocked_response = mock.Mock()

VERSION:2.0

PRODID:-//foo.bar//EN

BEGIN:VEVENT

    resp = resp.click('upload')

    resp.form['ics_url'] = ''

    resp = resp.form.submit(status=302)

@mock.patch('chrono.agendas.models.requests.get')

def test_agenda_import_time_period_exception_with_remote_ics_no_events(mocked_get, app, admin_user):

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp = resp.click('upload')

    resp.form['ics_url'] = 'http://example.com/foo.ics'

    mocked_response = mock.Mock()

VERSION:2.0

PRODID:-//foo.bar//EN

BEGIN:VEVENT

    resp = resp.click('Settings')

    resp = resp.click('upload')

    resp = resp.form.submit(status=302)

@mock.patch('chrono.agendas.models.requests.get')

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp = resp.click('upload')

    resp.form['ics_url'] = 'http://example.com/foo.ics'

    mocked_response = mock.Mock()

VERSION:2.0

PRODID:-//foo.bar//EN

BEGIN:VEVENT

    resp = resp.form.submit(status=302)

    assert TimePeriodException.objects.filter(desk=desk).count() == 1

@mock.patch('chrono.agendas.models.requests.get')

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

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

    MeetingType(agenda=agenda, label='Bar').save()

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp.form['ics_url'] = 'http://example.com/foo.ics'

    mocked_response = mock.Mock()

    mocked_get.return_value = mocked_response

    def mocked_requests_connection_error(*args, **kwargs):

        raise requests.exceptions.ConnectionError('unreachable')

    mocked_get.side_effect = mocked_requests_connection_error

    resp = resp.form.submit(status=200)

    assert 'Failed to retrieve remote calendar (http://example.com/foo.ics, unreachable).' in resp.text

@mock.patch('chrono.agendas.models.requests.get')

def test_agenda_import_time_period_exception_from_forbidden_remote_ics(mocked_get, app, admin_user):

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

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    mocked_response = mock.Mock()

    mocked_response.status_code = 403

    mocked_get.return_value = mocked_response

    def mocked_requests_http_forbidden_error(*args, **kwargs):

        raise requests.exceptions.HTTPError(response=mocked_response)

    mocked_get.side_effect = mocked_requests_http_forbidden_error

    resp = resp.form.submit(status=200)

    assert 'Failed to retrieve remote calendar (http://example.com/foo.ics, HTTP error 403).' in resp.text

@mock.patch('chrono.agendas.models.requests.get')

def test_agenda_import_time_period_exception_from_remote_ics_with_ssl_error(mocked_get, app, admin_user):

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

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    assert 'Import exceptions from .ics' not in resp.text

    resp = app.get('/manage/agendas/%d/' % agenda.pk).follow()

    resp = resp.click('Settings')

    resp.form['ics_url'] = 'https://example.com/foo.ics'

    mocked_response = mock.Mock()

    mocked_get.return_value = mocked_response

    def mocked_requests_http_ssl_error(*args, **kwargs):

        raise requests.exceptions.SSLError('SSL error')

    mocked_get.side_effect = mocked_requests_http_ssl_error

    resp = resp.form.submit(status=200)

    assert 'Failed to retrieve remote calendar (https://example.com/foo.ics, SSL error).' in resp.text

def test_agenda_day_view(app, admin_user, manager_user, api_user):

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

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

    resp = resp.follow()

    assert 'No opening hours this day.' in resp.text  # no time pediod

    timeperiod.save()

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

    assert not 'No opening hours this day.' in resp.text

    booking_url = resp.json['data'][0]['api']['fillslot_url']

    booking_url2 = resp.json['data'][2]['api']['fillslot_url']

    resp = app.post(booking_url)

    app.reset()

    login(app)

    date = Booking.objects.all()[0].event.start_datetime

    assert resp.text.count('div class="booking') == 2

    assert 'hourspan-2' in resp.text  # table CSS class

    assert 'height: 50%; top: 0%;' in resp.text  # booking cells

    # (and visually this will give more room for events)

    meetingtype = MeetingType(agenda=agenda, label='Baz', duration=15)

    meetingtype.save()

    assert resp.text.count('div class="booking') == 2

    assert 'hourspan-4' in resp.text  # table CSS class

    app.reset()

    login(app)

    assert resp.text.count('div class="booking') == 1

    # wrong type

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

    agenda2.save()

    # not enough permissions

    agenda2.view_role = manager_user.groups.all()[0]

    agenda2.save()

    app.reset()

    app = login(app, username='manager', password='manager')

    # just enough permissions

    agenda.view_role = manager_user.groups.all()[0]

    agenda.save()

def test_agenda_day_view_late_meeting(app, admin_user, manager_user, api_user):

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

    today = datetime.date.today()

    timeperiod.save()

    login(app)

    assert resp.text.count('<tr') == 15

    assert '<th class="hour">11 p.m.</th>' in resp.text

def test_agenda_invalid_day_view(app, admin_user, manager_user, api_user):

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

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

    resp = app.get('/manage/agendas/%s/%d/%d/%d/' % (agenda.id, 2018, 11, 31), status=302)

    assert resp.location.endswith('2018/11/30/')

def test_agenda_month_view(app, admin_user, manager_user, api_user):

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

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

    today = datetime.date.today()

    assert resp.request.url.endswith('%s/%s/' % (today.year, today.month))

    assert 'No opening hours this month.' in resp.text

    today = datetime.date(2018, 11, 10)  # fixed day

    timeperiod_weekday = today.weekday()

    timeperiod.save()

    resp = app.get('/manage/agendas/%s/%s/%s/' % (agenda.id, today.year, today.month))

    assert not 'No opening hours this month.' in resp.text

    assert not '<div class="booking' in resp.text

    first_month_day = today.replace(day=1)

    start_week_number = first_month_day.isocalendar()[1]

    end_week_number = last_month_day.isocalendar()[1]

    weeks_number = end_week_number - start_week_number + 1