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',

            'formdef_url_params', '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.isoformat()

        self.cleaned_data['end'] = end_dt.isoformat()

        return True

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

from __future__ import unicode_literals

from django.db import migrations, models

import jsonfield.fields

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')),

                ('formdef_url_params', jsonfield.fields.JSONField(default={b'session_var_end': b'{{end}}', b'session_var_start': b'{{start}}'}, help_text='{{start}} will take booking start datetime and {{end}} will take booking end datetime', verbose_name='Session vars')),

                ('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 combo.data.models import CellBase

from combo.data.library import register_cell_class

from .utils import is_chrono_enabled, is_wcs_enabled, get_calendar

from jsonfield import JSONField

@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)

    formdef_url_params = JSONField(

        _('Session vars'),

        help_text=_("{{start}} will take booking start datetime and {{end}} will take booking end datetime"),

        default={"session_var_start": "{{start}}", "session_var_end": "{{end}}"})

    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/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):

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

{% load i18n calendar %}

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

    {% if cell.title %}

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

    {% endif %}

    <div>

        {% block calendar_table %}

        {% calendar_table cell=cell %}

        {% endblock %}

    </div>

</div>

{% load i18n calendar %}

<div>

    {% if calendar.has_other_pages %}

        <p class="paginator">

        {% if calendar.has_previous %}

            <a href="?week_{{cell.slug}}={{ calendar.previous_page_number }}">{% 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.slug}}={{ calendar.next_page_number }}">{% trans "next week" %}</a>

        {% else %}

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

        {% endif %}

    {% endif %}

</div>

<div id="calendar_{{cell.pk}}" data-calendar="{{cell.pk}}">

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

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

            {% for cal in calendar %}

            <thead>

                <tr>

                {% for day in cal.days %}

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

                {% endfor %}

                </tr>

            </thead>

            <tbody>

                {% for slot in cal.get_slots %}

                <tr>

                    {% for day in cal.days %}

                        <td>

                            {% if day|available:slot %}

                            {% with value=day|get_slot:slot %}

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

                            <label for="{{value.label}}">{{slot}}</label>

                            {% endwith %}

                            {% endif %}

                        </td>

                    {% endfor %}

                </tr>

                {% endfor %}

            </tbody>

            {% endfor %}

        </table>

        <input type="submit" value="{% trans 'Validate' %}">

    </form>

</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/>.

from django import template

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

register = template.Library()

@register.inclusion_tag('calendar/includes/calendar_table.html', takes_context=True)

def calendar_table(context, cell):

    request = context['request']

    page = request.GET.get('week_%s' % cell.slug, 1)

    # get calendar

    calendar = cell.get_calendar()

    paginator = Paginator(calendar.values(), 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 context

@register.filter

def available(day, slot):

    return day.is_available(slot)

@register.filter

def get_slot(day, slot):

    return day.get_slot(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 EventsView, BookingView

urlpatterns = [

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

    url(r'^api/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 json

import urllib

import urlparse

import datetime

from django.conf import settings

from django.utils.dateparse import parse_datetime

from django.template import Context, Template

from combo.utils import requests

def get_service(service_name, key=None):

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

        services = settings.KNOWN_SERVICES[service_name]

        if key:

            return services.get(key)

        return services

def is_chrono_enabled():

    return bool(get_service('chrono'))

def is_wcs_enabled():

    return bool(get_service('wcs'))

def get_agendas():

    chronos = get_service('chrono')

    references = []

    for chrono_key, chrono_site in chronos.items():

        url = urlparse.urljoin(chrono_site['url'], 'api/agenda/')

        response = requests.get(url, headers={'accept': 'application/json'})

        for agenda in response.json()['data']:

            references.append((

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

            return references

def get_formdefs():

    wcs = get_service('wcs')

    references = []

    for wcs_key, wcs_site in wcs.items():

        url = urlparse.urljoin(wcs_site['url'], 'api/formdefs/')

        response = requests.get(url, headers={'accept': 'application/json'})

        data = response.json()

        if isinstance(data, (dict,)):

            if data.get('err') == 1:

                continue

            data = data.get('data')

        for form in data:

            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', key=chrono_key)

    url = urlparse.urljoin(chrono['url'], 'api/agenda/%s/datetimes/' % chrono_slug)

    response = requests.get(url, headers={'accept': 'application/json'}, **kwargs)

    return response.json().get('data', [])

def get_slots_range(start, end, offset):

    dstart = start

    # offset in minute

    offset = offset.hour * 60 + offset.minute

    while dstart <= end:

        yield dstart.strftime('%H:%M')

        dstart = datetime.datetime.combine(

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

        dstart = dstart.time()

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=week_ref, offset=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))

    return calendar

def get_form_url_with_params(cell, data):

    tpl = Template(json.dumps(cell.formdef_url_params))

    session_vars = json.loads(tpl.render(Context(data)))

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

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

    wcs_base_url = urlparse.urljoin(wcs['url'], 'api/formdefs/')

    response = requests.get(wcs_base_url, headers={'accept': 'application/json'})

    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 '%s - %s' % (self.date_time.isoformat(), self.available)

    @property

    def label(self):

        return self.date_time.isoformat()

class WeekDay(object):

    def __init__(self, date):

        self.date = date

        self.slots = []

    def __repr__(self):

        return self.date.isoformat()

    def add_slots(self, slot):

        if slot not in self.slots:

            self.slots.append(slot)

    def get_slot(self, slot_time):

        exp = datetime.datetime.strptime(slot_time, '%H:%M')

        for slot in self.slots:

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

                return slot

        return DaySlot(exp, False)

    def get_minimum_slot(self):

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

    def get_maximum_slot(self):

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

    def is_available(self, slot_time):

        return self.get_slot(slot_time).available

class WeekCalendar(object):

    def __init__(self, year=None, week=None, offset=None):

        self.year = year

        self.week = week

        self.days = []

        self.slots = []

        self.offset = offset

    def __repr__(self):

        return 'Cal - %s' % self.week

    def get_slots(self):

        start = self.get_minimum_slot().date_time.time()

        end = self.get_maximum_slot().date_time.time()

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

        while start <= end:

            yield start.strftime('%H:%M')

            start = datetime.datetime.combine(

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

            start = start.time()

    def has_day(self, date):

        return bool([day for day in self.days if day.date == date])

    def get_day(self, date):

        for day in self.days:

            if day.date == date:

                return day

        return None

    def get_days(self):

        return self.days

    def get_minimum_slot(self):

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

    def get_maximum_slot(self):

        return max([day.get_maximum_slot() 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, JsonResponse

from django.views.generic import View

from django.views.generic.detail import SingleObjectMixin

from django.views.decorators.csrf import csrf_exempt

from django.contrib import messages

from .models import BookingCalendar

from .utils import get_chrono_events, get_form_url_with_params

from .forms import BookingForm

class EventsView(SingleObjectMixin, View):

    http_method_names = ['get']

    model = BookingCalendar

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

        cell = self.get_object()

        data = get_chrono_events(cell.agenda_reference)

        return JsonResponse(data, safe=False)

class BookingView(SingleObjectMixin, View):

    http_method_names = ['post']

    model = BookingCalendar

    @csrf_exempt

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

        return super(BookingView, self).dispatch(request, *args, **kwargs)

    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://example.org',

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

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

import json

import urlparse

import pytest

import mock

from django.utils.dateparse import parse_time

from combo.data.models import Page

from combo.apps.calendar.models import BookingCalendar

pytestmark = pytest.mark.django_db

CHRONO_EVENTS = {

    "data": [

        {

            "disabled": True,

            "text": "19 mai 2017 08:00",

            "api": {

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

            },

            "id": 86,

            "datetime": "2017-05-19 08:00:00"

        },

        {

            "disabled": True,

            "text": "19 mai 2017 08:30",

            "api": {

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

            },

            "id": 87,

            "datetime": "2017-05-19 08:30:00"

        },

        {

            "disabled": True,

            "text": "19 mai 2017 09:00",

            "api": {

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

            },

            "id": 88,

            "datetime": "2017-05-19 09:00:00"

        },

        {

            "disabled": True,

            "text": "19 mai 2017 09:30",

            "api": {

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

            },

            "id": 89,

            "datetime": "2017-05-19 09:30: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"

    }

]

class MockedRequestResponse(mock.Mock):

    def json(self):

        return json.loads(self.content)

@pytest.fixture

def cell(db):

    page = Page.objects.create()

    cell = BookingCalendar(

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

        agenda_reference='default:whatever',

        formdef_reference='default:whatever',

        formdef_url_params={

            "session_var_start_dt": "{{start}}", "session_var_end_dt": "{{end}}",

            "session_var_whatever_slug": "whatever"

        },

        slot_duration=parse_time('00:30'),

        minimal_event_duration=parse_time('01:00')

    )

    cell.save()

    return cell

@mock.patch('combo.apps.calendar.utils.requests.get')

def test_get_events(mocked_get, app, cell):

    mocked_get.return_value = MockedRequestResponse(content=json.dumps(CHRONO_EVENTS))

    resp = app.get('/api/calendar/events/%s/' % cell.pk)

    assert len(resp.json) == 4

@mock.patch('combo.apps.calendar.utils.requests.get')

def test_redirection_session_vars(mocked_get, app, cell, settings):

    mocked_get.return_value = MockedRequestResponse(content=json.dumps(WCS_FORMDEFS))

    # test with no slots

    params = {'slots': []}

    resp = app.post('/api/calendar/book/%s/' % cell.pk, params=params, status=302).follow()

    assert 'Please select slots' in resp.content

    # test with slots from different day

    params = {'slots': ['2017-05-19T10:30:00', '2017-05-19T11:00:00',

                        '2017-05-20T09:00:00']}

    resp = app.post('/api/calendar/book/%s/' % cell.pk, params=params, status=302).follow()

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

    # test with non contiguous slots

    params = {'slots': ['2017-05-19T10:30:00', '2017-05-19T11:00:00',

                        '2017-05-19T12:00:00']}

    resp = app.post('/api/calendar/book/%s/' % cell.pk, params=params, status=302).follow()

    assert 'Please select contiguous slots' in resp.content

    # test with invalid booking duration

    params = {'slots': ['2017-05-19T10:30:00']}

    resp = app.post('/api/calendar/book/%s/' % cell.pk, params=params, status=302).follow()

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

    # test with valid selected slots

    params = {'slots': ['2017-05-19T10:30:00', '2017-05-19T11:00:00',

                        '2017-05-19T11:30:00', '2017-05-19T12:00:00']}

    resp = app.post('/api/calendar/book/%s/' % cell.pk, params=params, status=302)

    parsed = urlparse.urlparse(resp.url)

    qs = urlparse.parse_qs(parsed.query)

    assert qs['session_var_whatever_slug'] == ['whatever']

    assert qs['session_var_start_dt'] == ['2017-05-19T10:30:00']

    assert qs['session_var_end_dt'] == ['2017-05-19T12:30:00']