Produits Entr'ouvert » Combo

Combo calendar cell

===================

To be visible, this cell needs a 'chrono' entry in settings.KNOWN_SERVICES

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import django.apps

class AppConfig(django.apps.AppConfig):

    name = 'combo.apps.calendar'

    def get_before_urls(self):

        from . import urls

        return urls.urlpatterns

default_app_config = 'combo.apps.calendar.AppConfig'

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import datetime

from django import forms

from django.utils.translation import ugettext_lazy as _

from django.utils.dateparse import parse_datetime

from .models import BookingCalendar

from .utils import get_agendas, get_formdefs

class BookingCalendarForm(forms.ModelForm):

    class Meta:

        model = BookingCalendar

        fields = (

            'title', 'agenda_reference', 'formdef_reference',

            'slot_duration', 'minimal_event_duration')

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

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

        agenda_references = get_agendas()

        formdef_references = get_formdefs()

        self.fields['agenda_reference'].widget = forms.Select(choices=agenda_references)

        self.fields['formdef_reference'].widget = forms.Select(choices=formdef_references)

class BookingForm(forms.Form):

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

        self.cell = kwargs.pop('cell')

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

        self.cleaned_data = {}

    def is_valid(self):

        slots = getattr(self.data, 'getlist', lambda x: [])('slots')

        # check that at least one slot if selected

        if not slots:

            raise ValueError(_('Please select slots'))

        offset = self.cell.slot_duration.hour * 60 + self.cell.slot_duration.minute

        start_dt = parse_datetime(slots[0])

        end_dt = parse_datetime(slots[-1]) + datetime.timedelta(minutes=offset)

        slots.append(end_dt.isoformat())

        # check that all slots are part of the same day

        for slot in slots:

            if parse_datetime(slot).date() != start_dt.date():

                raise ValueError(_('Please select slots of the same day'))

        # check that slots datetime are contiguous

        start = start_dt

        while start <= end_dt:

            if start.isoformat() not in slots:

                raise ValueError(_('Please select contiguous slots'))

            start = start + datetime.timedelta(minutes=offset)

        # check that event booking duration >= minimal booking duration

        min_duration = self.cell.minimal_event_duration.hour * 60 + self.cell.minimal_event_duration.minute

        if not (end_dt - start_dt) >= datetime.timedelta(minutes=min_duration):

            raise ValueError(_(

                'Minimal booking duration is %s' % self.cell.minimal_event_duration.strftime('%H:%M')))

        self.cleaned_data['start'] = start_dt

        self.cleaned_data['end'] = end_dt

        return True

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

from django.db import migrations, models

import datetime

class Migration(migrations.Migration):

    dependencies = [

        ('data', '0027_page_picture'),

        ('auth', '0006_require_contenttypes_0002'),

    ]

    operations = [

        migrations.CreateModel(

            name='BookingCalendar',

            fields=[

                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),

                ('placeholder', models.CharField(max_length=20)),

                ('order', models.PositiveIntegerField()),

                ('slug', models.SlugField(verbose_name='Slug', blank=True)),

                ('extra_css_class', models.CharField(max_length=100, verbose_name='Extra classes for CSS styling', blank=True)),

                ('public', models.BooleanField(default=True, verbose_name='Public')),

                ('restricted_to_unlogged', models.BooleanField(default=False, verbose_name='Restrict to unlogged users')),

                ('last_update_timestamp', models.DateTimeField(auto_now=True)),

                ('title', models.CharField(max_length=128, null=True, verbose_name='Title', blank=True)),

                ('agenda_reference', models.CharField(max_length=128, verbose_name='Agenda')),

                ('formdef_reference', models.CharField(max_length=128, verbose_name='Form')),

                ('slot_duration', models.TimeField(default=datetime.time(0, 30), verbose_name='Slot duration')),

                ('minimal_event_duration', models.TimeField(default=datetime.time(1, 0), verbose_name='Minimal event duration')),

                ('groups', models.ManyToManyField(to='auth.Group', verbose_name='Groups', blank=True)),

                ('page', models.ForeignKey(to='data.Page')),

            ],

            options={

                'verbose_name': 'Booking Calendar',

            },

        ),

    ]

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.utils.dateparse import parse_time

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

from combo.data.models import CellBase

from combo.data.library import register_cell_class

from .utils import is_chrono_enabled, is_wcs_enabled, get_calendar

@register_cell_class

class BookingCalendar(CellBase):

    title = models.CharField(_('Title'), max_length=128, blank=True, null=True)

    agenda_reference = models.CharField(_('Agenda'), max_length=128)

    formdef_reference = models.CharField(_('Form'), max_length=128)

    slot_duration = models.TimeField(

        _('Slot duration'), default=parse_time('00:30'))

    minimal_event_duration = models.TimeField(

        _('Minimal event duration'), default=parse_time('01:00'))

    template_name = 'calendar/booking_calendar_cell.html'

    class Meta:

        verbose_name = _('Booking Calendar')

    def get_default_form_class(self):

        from .forms import BookingCalendarForm

        return BookingCalendarForm

    @classmethod

    def is_enabled(cls):

        return is_chrono_enabled() and is_wcs_enabled()

    def get_calendar(self):

        return get_calendar(self.agenda_reference, self.slot_duration)

    def render(self, context):

        request = context['request']

        page = request.GET.get('week_%s' % self.pk, 1)

        # get calendar

        calendar = self.get_calendar()

        paginator = Paginator(calendar, 1)

        try:

            cal_page = paginator.page(page)

        except PageNotAnInteger:

            cal_page = paginator.page(1)

        except (EmptyPage,):

            cal_page = paginator.page(paginator.num_pages)

        context['calendar'] = cal_page

        return super(BookingCalendar, self).render(context)

{% load i18n calendar %}

<div id="cal-{{cell.pk}}">

    {% if cell.title %}

    <h2>{{cell.title}}</h2>

    {% endif %}

    <div>

        {% if calendar.has_other_pages %}

        <p class="paginator">

        {% if calendar.has_previous %}

        <a href="?week_{{cell.pk}}={{ calendar.previous_page_number }}#cal-{{cell.pk}}">{% trans "previous week" %}</a>

        {% else %}

        <span>&lt;&lt;</span>

        {% endif %}

         

        <span class="current">

            {{ calendar.number }} / {{ calendar.paginator.num_pages }}

        </span>

         

        {% if calendar.has_next %}

        <a href="?week_{{cell.pk}}={{ calendar.next_page_number }}#cal-{{cell.pk}}">{% trans "next week" %}</a>

        {% else %}

        <span>&gt;&gt;</span>

        {% endif %}

        {% endif %}

        {% if calendar %}

        <form method="POST" action="{% url 'calendar-booking' cell.pk %}">

            {% csrf_token %}

            <table id="cal-table-{{cell.pk}}">

                {% for cal in calendar %}

                <thead>

                    <tr>

                        <th></th>

                        {% for day in cal.get_days %}

                        <th>{{day|date:"SHORT_DATE_FORMAT"}}</th>

                        {% endfor %}

                    </tr>

                </thead>

                <tbody>

                    {% for slot in cal.get_slots %}

                    <tr>

                        <th>{{slot|date:"TIME_FORMAT"}}</th>

                        {% for day in cal.get_days %}

                        <td>

                            {% cal_slot_available cal day=day slot=slot as value %}

                                {% if value.available %}

                                    <input type="checkbox" name="slots" value="{{value.label}}" id="{{value.label}}"/>

                                {% endif %}

                        </td>

                        {% endfor %}

                    </tr>

                    {% endfor %}

                </tbody>

                {% endfor %}

            </table>

            <input type="submit" value="{% trans "Book" context "booking" %}">

        </form>

        {% endif %}

    </div>

</div>

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import datetime

from django import template

register = template.Library()

@register.assignment_tag

def cal_slot_available(cal, *args, **kwargs):

    day = kwargs.get('day')

    slot = kwargs.get('slot')

    time_slot = datetime.datetime.combine(day, slot)

    return cal.get_availability(time_slot)

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.conf.urls import url

from .views import BookingView

urlpatterns = [

    url(r'^calendar/book/(?P<pk>[\w,-]+)/', BookingView.as_view(), name='calendar-booking'),

]

# combo - content management system

# Copyright (C) 2017 Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import urllib

import datetime

from django.conf import settings

from django.utils.dateparse import parse_datetime

from combo.utils import requests

def get_services(service_name, exclude_secondary=False):

    if hasattr(settings, 'KNOWN_SERVICES') and settings.KNOWN_SERVICES.get(service_name):

        services = settings.KNOWN_SERVICES[service_name]

        if exclude_secondary:

            for service, items in services.items():

                if not items.get('secondary', True):

                    return {service: items}

        return services

    return {}

def get_service(service_name, key, exclude_secondary=False):

    service = get_services(service_name, exclude_secondary)

    return service.get(key, {})

def is_chrono_enabled():

    return bool(get_services('chrono', exclude_secondary=True))

def is_wcs_enabled():

    return bool(get_services('wcs'))

def get_agendas():

    chronos = get_services('chrono', exclude_secondary=True)

    references = []

    for chrono_key, chrono_site in chronos.items():

        response = requests.get('api/agenda/', remote_service=chrono_site, without_user=True)

        try:

            result = response.json()

        except ValueError:

            return references

        for agenda in result.get('data'):

            references.append((

                '%s:%s' % (chrono_key, agenda['slug']), agenda['text']))

    return references

def get_formdefs():

    wcs = get_services('wcs')

    references = []

    for wcs_key, wcs_site in wcs.items():

        response = requests.get('api/formdefs/', remote_service=wcs_site, without_user=True)

        try:

            result = response.json()

        except ValueError:

            return references

        if isinstance(result, (dict,)):

            if result.get('err'):

                continue

            result = result.get('data')

        for form in result:

            references.append((

                '%s:%s' % (wcs_key, form['slug']), form['title']))

    return references

def get_chrono_events(agenda_reference, **kwargs):

    chrono_key, chrono_slug = agenda_reference.split(':')

    chrono = get_service('chrono', chrono_key, exclude_secondary=True)

    response = requests.get('api/agenda/%s/datetimes/' % chrono_slug, remote_service=chrono, without_user=True)

    try:

        result = response.json()

    except ValueError:

        return {}

    return result.get('data', [])

def get_calendar(agenda_reference, offset):

    calendar = {}

    events = get_chrono_events(agenda_reference)

    for event in events:

        event_datetime = parse_datetime(event['datetime'])

        week_ref = event_datetime.isocalendar()[1]

        if week_ref not in calendar:

            calendar[week_ref] = WeekCalendar(week_ref, offset)

        week_cal = calendar[week_ref]

        # add day to week calendar

        if not week_cal.has_day(event_datetime.date()):

            day = WeekDay(event_datetime.date())

            week_cal.days.append(day)

        else:

            day = week_cal.get_day(event_datetime.date())

        # add slots to day

        day.add_slots(DaySlot(

            event_datetime, True if not event.get('disabled', True) else False))

    return sorted(calendar.values(), key=lambda x: x.week)

def get_form_url_with_params(cell, data):

    session_vars = {

        "session_var_booking_agenda_slug": cell.agenda_reference.split(':')[1],

        "session_var_booking_start": data['start'].isoformat(),

        "session_var_booking_end": data['end'].isoformat()

    }

    wcs_key, wcs_slug = cell.formdef_reference.split(':')

    wcs = get_service('wcs', key=wcs_key)

    response = requests.get('api/formdefs/', remote_service=wcs, without_user=True)

    for formdef in response.json():

        if formdef['slug'] == wcs_slug:

            break

    url = '%s/?%s' % (formdef['url'], urllib.urlencode(session_vars))

    return url

class DaySlot(object):

    def __init__(self, date_time, available):

        self.date_time = date_time

        self.available = available

    def __repr__(self):

        return '<DaySlot date_time=%s - available=%s>' % (self.date_time.isoformat(), self.available)

    @property

    def label(self):

        return '%s' % self.date_time.isoformat()

class WeekDay(object):

    def __init__(self, date):

        self.date = date

        self.slots = []

    def __repr__(self):

        return '<WeekDay %s >' % self.date.isoformat()

    def add_slots(self, slot):

        if slot not in self.slots:

            self.slots.append(slot)

    def get_slot(self, slot_time):

        for slot in self.slots:

            if slot.date_time.time() == slot_time:

                return slot

        slot_datetime = datetime.datetime.combine(self.date, slot_time)

        return DaySlot(slot_datetime, False)

    def get_minimum_slot(self):

        return min(self.slots, key=lambda x: x.date_time.time())

    def get_maximum_slot(self):

        return max(self.slots, key=lambda x: x.date_time.time())

    def is_available(self, slot_time):

        return self.get_slot(slot_time).available

class WeekCalendar(object):

    def __init__(self, week, offset):

        self.week = week

        self.offset = offset

        self.days = []

    def __repr__(self):

        return '<WeekCalendar - %s>' % self.week

    def get_slots(self):

        start = self.get_minimum_slot()

        end = self.get_maximum_slot()

        offset = self.offset.hour * 60 + self.offset.minute

        while start <= end:

            yield start

            start = datetime.datetime.combine(

                datetime.date.today(), start) + datetime.timedelta(minutes=offset)

            start = start.time()

    def get_days(self):

        if self.days:

            fday = self.days[0].date

        else:

            fday = datetime.datetime.today()

        # only week days

        for index in range(0, 5):

            day = fday + datetime.timedelta(days=index - fday.weekday())

            yield day

    def get_day(self, date):

        for day in self.days:

            if day.date == date:

                return day

        return None

    def has_day(self, date):

        return bool(self.get_day(date))

    def get_availability(self, slot):

        if not self.has_day(slot.date()):

            return DaySlot(slot, False)

        day = self.get_day(slot.date())

        return day.get_slot(slot.time())

    def get_minimum_slot(self):

        return min([day.get_minimum_slot().date_time.time() for day in self.days])

    def get_maximum_slot(self):

        return max([day.get_maximum_slot().date_time.time() for day in self.days])

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.http import HttpResponseRedirect

from django.views.generic import View

from django.views.generic.detail import SingleObjectMixin

from django.contrib import messages

from .models import BookingCalendar

from .utils import get_form_url_with_params

from .forms import BookingForm

class BookingView(SingleObjectMixin, View):

    http_method_names = ['post']

    model = BookingCalendar

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

        cell = self.get_object()

        form = BookingForm(request.POST, cell=cell)

        try:

            form.is_valid()

        except ValueError as exc:

            messages.error(request, exc.message)

            return HttpResponseRedirect(cell.page.get_online_url())

        data = form.cleaned_data

        url = get_form_url_with_params(cell, data)

        return HttpResponseRedirect(url)

    'combo.apps.calendar',

    },

    'chrono': {

        'default': {'title': 'test', 'url': 'http://chrono.example.org',

                    'secret': 'combo', 'orig': 'combo',

                    'backoffice-menu-url': 'http://chrono.example.org/manage/',}

import json

import urlparse

import datetime

import pytest

import mock

from django.utils.dateparse import parse_time

from django.contrib.auth.models import User

from combo.data.models import Page

from combo.apps.calendar.models import BookingCalendar

from combo.apps.calendar.utils import get_calendar

pytestmark = pytest.mark.django_db

CHRONO_EVENTS = {

    "data": [

        {

            "disabled": False,

            "text": "13 juin 2017 08:00",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/86/"

            },

            "id": 86,

            "datetime": "2017-06-13 08:00:00"

        },

        {

            "disabled": False,

            "text": "13 juin 2017 08:30",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/87/"

            },

            "id": 87,

            "datetime": "2017-06-13 08:30:00"

        },

        {

            "disabled": False,

            "text": "13 juin 2017 09:00",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/88/"

            },

            "id": 88,

            "datetime": "2017-06-13 09:00:00"

        },

        {

            "disabled": False,

            "text": "13 juin 2017 09:30",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/89/"

            },

            "id": 89,

            "datetime": "2017-06-13 09:30:00"

        },

        {

            "disabled": False,

            "text": "14 juin 2017 09:30",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/89/"

            },

            "id": 90,

            "datetime": "2017-06-14 09:30:00"

        },

        {

            "disabled": False,

            "text": "14 juin 2017 10:00",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/89/"

            },

            "id": 91,

            "datetime": "2017-06-14 10:00:00"

        },

        {

            "disabled": True,

            "text": "14 juin 2017 15:00",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/89/"

            },

            "id": 91,

            "datetime": "2017-06-14 15:00:00"

        },

        {

            "disabled": True,

            "text": "15 juin 2017 10:00",

            "api": {

                "fillslot_url": "http://example.net/api/agenda/whatever/fillslot/89/"

            },

            "id": 92,

            "datetime": "2017-06-15 10:00:00"

        }

    ]

}

WCS_FORMDEFS = [

    {

        "count": 12,

        "category": "common",

        "functions": {

            "_receiver": {

                "label": "Recipient"

            },

        },

        "authentication_required": False,

        "description": "",

        "title": "Demande de place en creche",

        "url": "http://example.net/demande-de-place-en-creche/",

        "category_slug": "common",

        "redirection": False,

        "keywords": [],

        "slug": "demande-de-place-en-creche"

    }

]

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

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

    login_form = login_page.forms[0]

    login_form['username'] = username

    login_form['password'] = password

    resp = login_form.submit()

    assert resp.status_int == 302

    return app

def str2datetime(sdt):

    return datetime.datetime.strptime(sdt, '%Y-%m-%dT%H:%M:%S')

class MockedRequestResponse(mock.Mock):

    def json(self):

        return json.loads(self.content)

def mocked_requests_get(*args, **kwargs):

    remote_service = kwargs.get('remote_service')

    if 'chrono' in remote_service['url']:

        return MockedRequestResponse(

            content=json.dumps(CHRONO_EVENTS))

    else:

        return MockedRequestResponse(

            content=json.dumps(WCS_FORMDEFS))

@pytest.fixture

def admin(db):

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

@pytest.fixture

def cell(db):

    page = Page.objects.create(title='wjatever', slug='test', template_name='standard')

    cell = BookingCalendar(

        page=page, title='Example Of Calendar',

        agenda_reference='default:test',

        formdef_reference='default:test',

        slot_duration=parse_time('00:30'),

        minimal_event_duration=parse_time('01:00'),

        placeholder='content', order=0

    )

    cell.save()

    return cell

@mock.patch('combo.apps.calendar.utils.requests.get', side_effect=mocked_requests_get)

def test_cell_rendering(mocked_get, app, cell):

    page = app.get('/test/')

    # test without selecting slots

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

    assert 'Please select slots' in resp.content

    # test with slots from different day

    resp.form.set('slots', True, 0)

    resp.form.set('slots', True, 1)

    resp.form.set('slots', True, 4)

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

    # test with non contiguous slots

    assert 'Please select slots of the same day' in resp.content

    resp.form.set('slots', True, 0)

    resp.form.set('slots', True, 2)

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

    assert 'Please select contiguous slots' in resp.content

    # test with invalid booking duration

    resp.form.set('slots', True, 0)

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

    assert 'Minimal booking duration is 01:00' in resp.content

    # test with valid selected slots

    resp.form.set('slots', True, 0)

    resp.form.set('slots', True, 1)

    resp.form.set('slots', True, 2)

    resp = resp.form.submit()

    parsed = urlparse.urlparse(resp.url)

    qs = urlparse.parse_qs(parsed.query)

    assert qs['session_var_booking_agenda_slug'] == ['test']

    assert qs['session_var_booking_start'] == ['2017-06-13T08:00:00']

    assert qs['session_var_booking_end'] == ['2017-06-13T09:30:00']

@mock.patch('combo.apps.calendar.utils.requests.get', side_effect=mocked_requests_get)

def test_cell_rendering_when_authenticated(mocked_get, app, cell, admin):

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

    # test without selecting slots

    page = app.get('/test/')

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

    assert 'Please select slots' in resp.content

    # test with slots from different day

    resp.form.set('slots', True, 0)

    resp.form.set('slots', True, 1)

    resp.form.set('slots', True, 4)

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

    # test with non contiguous slots

    assert 'Please select slots of the same day' in resp.content

    resp.form.set('slots', True, 0)

    resp.form.set('slots', True, 2)

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

    assert 'Please select contiguous slots' in resp.content

    # test with invalid booking duration

    resp.form.set('slots', True, 0)

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

    assert 'Minimal booking duration is 01:00' in resp.content

    # test with valid selected slots

    resp.form.set('slots', True, 0)

    resp.form.set('slots', True, 1)

    resp.form.set('slots', True, 2)

    resp = resp.form.submit()

    parsed = urlparse.urlparse(resp.url)

    qs = urlparse.parse_qs(parsed.query)

    assert qs['session_var_booking_agenda_slug'] == ['test']

    assert qs['session_var_booking_start'] == ['2017-06-13T08:00:00']

    assert qs['session_var_booking_end'] == ['2017-06-13T09:30:00']

@mock.patch('combo.apps.calendar.utils.requests.get', side_effect=mocked_requests_get)

def test_calendar(mocked_get, cell):

    cal = get_calendar('default:whatever', cell.slot_duration)[0]

    assert len(cal.days) == 3

    for day in cal.get_days():

        assert day in [

            str2datetime('2017-06-12T08:00:00').date() + datetime.timedelta(days=i)

            for i in range(0, 5)]

    min_slot = str2datetime('2017-06-13T08:00:00')

    max_slot = str2datetime('2017-06-14T15:00:00')

    for slot in cal.get_slots():

        assert (min_slot.time() <= slot <= max_slot.time()) is True

    assert cal.has_day(min_slot.date()) is True

    assert cal.get_availability(str2datetime('2017-06-14T15:00:00')).available is False

    assert cal.get_minimum_slot() == min_slot.time()

    assert cal.get_maximum_slot() == max_slot.time()

    assert cal.get_day(max_slot.date()).slots[-1].available is False