Produits Entr'ouvert » Combo

Combo calendar cell

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

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

session_vars are defineed such as:

{

    "my_session_var1_name": "value",

    "my_session_var2_name": "ref_to_received_key",

}

# 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.chrono'

    def get_before_urls(self):

        from . import urls

        return urls.urlpatterns

default_app_config = 'combo.apps.chrono.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 json

from datetime import datetime

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.utils.dateparse import parse_time

from django.core.urlresolvers import reverse

from combo.data.models import CellBase

from combo.data.library import register_cell_class

from .utils import is_chrono_enabled

from jsonfield import JSONField

@register_cell_class

class CalendarCell(CellBase):

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

    events_source = models.URLField(_('Events source URL'))

    form_url = models.URLField(_('Application form URL'))

    session_vars = JSONField(_('Session vars'))

    slot_duration = models.TimeField(

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

    minimal_event_duration = models.TimeField(

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

    business_hours_start = models.TimeField(

        _('Business hour start'), default=parse_time('08:00'))

    business_hours_end = models.TimeField(

        _('Business hour end'), default=parse_time('18:00'))

    event_default_title = models.CharField(

        _('Event default title'), max_length=32)

    template_name = 'chrono/calendar.html'

    class Meta:

        verbose_name = _('Calendar Cell')

    class Media:

        js = (

            'xstatic/lib/moment.min.js',

            'xstatic/fullcalendar.min.js',

            'chrono/js/calendar.js'

        )

        css = {'all': ('xstatic/fullcalendar.min.css',)}

    @classmethod

    def is_enabled(cls):

        return is_chrono_enabled()

    def render(self, context):

        include = ['title', 'slot_duration', 'business_hours_start', 'business_hours_end',

                   'minimal_event_duration', 'event_default_title']

        context['chrono'] = json.dumps({key: str(value) for key, value in vars(self).items()

                                       if key in include})

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

$(function() {

    function renderCal(cal_id){

        $(cal_id).fullCalendar({

            lang: "fr",

            header: {

                left: "prev,next today",

                center: "title",

                right: "agendaWeek,agendaDay"

            },

            defaultView: "agendaWeek",

            weekends: false,

            allDaySlot: false,

            slotDuration: chrono.slot_duration,

            forceEventDuration: true,

            defaultTimedEventDuration: chrono.default_event_duration,

            scrollTime: "08:00",

            businessHours: {

                start: chrono.business_hours_start,

                end: chrono.business_hours_end

            },

            events: events_source_url,

            eventOverlap: function(stillEvent, movingEvent) {

                return true;

            },

            editable: true,

            selectable: true,

            selectHelper: true,

            unselectAuto: false,

            selectConstraint: {

                 start: chrono.business_hours_start,

                 end: chrono.business_hours_end,

                id: 'available'

            },

            select: function(start, end) {

                // can't select in the past

                if (start.isBefore(moment())){

                    $(cal_id).fullCalendar("unselect");

                    return false;

                }

                var title = chrono.event_default_title;

                var eventData;

                if (title && title.trim()) {

                    eventData = {

                        title: title,

                        start: start,

                        end: end

                    };

                    $(cal_id).fullCalendar("renderEvent", eventData);

                }

                $(cal_id).fullCalendar("unselect");

            },

            eventRender: function(event, element) {

                var start = moment(event.start).fromNow();

                element.attr("title", start);

            },

            loading: function() {

            },

            eventClick: function(calEvent, jsEvent, view){

                if (calEvent.source){

                    console.log(calEvent.source);

                    return false;

                }

                params = {

                    start: calEvent.start.format(),

                    end: calEvent.end.format()

                }

                form_url = events_booking_url + "?" + $.param(params)

                $.ajax({

                    type: "POST",

                    url: events_booking_url,

                    data: JSON.stringify({

                        start: calEvent.start.format(),

                        end: calEvent.end.format()

                    }),

                    dataType: "json",

                    success: function(response){

                        console.log(response.url);

                        window.location = response.url;

                    },

                    error: function(xhr, status, error){

                        console.log(JSON.stringify(status));

                    }

                })

            },

        });

    }

    $(".calendar").each(function(i, cal){

        renderCal("#" + cal.id);

    });

});

<h2>{{title}}</h2>

<script type="text/javascript">

    var events_source_url = "{% url 'chrono-events' cell.pk %}";

    var events_booking_url = "{% url 'chrono-booking' cell.pk %}";

    var chrono = JSON.parse(unescape('{{chrono | safe }}'));

</script>

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

</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.conf.urls import url

from .views import EventsView, BookingView

urlpatterns = [

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

    url(r'^chrono/book/(?P<pk>[\w,-]+)/', BookingView.as_view(), name='chrono-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/>.

from django.conf import settings

from combo.utils import requests

def get_chrono_service():

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

        return settings.KNOWN_SERVICES['chrono'].values()[0]

def is_chrono_enabled():

    return get_chrono_service()

def convert_widget_format(events):

    data = []

    for event in events.get('data'):

        data.append({

            'id': 'available',

            'title': event.get('text'),

            'start': event.get('datetime'),

            'editable': False,

            'durationEditable': False,

            'rendering': 'inverse-background'

        })

    return data

def get_chrono_events(chrono_url, **kwargs):

    response = requests.get(

        chrono_url,

        headers={'accept': 'application/json'},

        **kwargs)

    data = convert_widget_format(response.json())

    return data

def build_session_vars(cell, data):

    session_vars = {}

    for key, value in cell.session_vars.items():

        key = 'session_var_%s' % key

        if data.get(value):

            session_vars.update({key: data[value]})

        else:

            session_vars.update({key: value})

    return session_vars

# 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

from django.http import JsonResponse

from django.views.decorators.csrf import csrf_exempt

from django.views.generic import View

from django.views.generic.detail import SingleObjectMixin

from .models import CalendarCell

from .utils import get_chrono_events, build_session_vars

class EventsView(SingleObjectMixin, View):

    http_method_names = ['get']

    model = CalendarCell

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

        cell = self.get_object()

        data = get_chrono_events(cell.events_source)

        return JsonResponse(data, safe=False)

class BookingView(SingleObjectMixin, View):

    http_method_names = ['post']

    model = CalendarCell

    @csrf_exempt

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

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

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

        data = json.loads(request.body)

        cell = self.get_object()

        params = build_session_vars(cell, data)

        params = '&'.join(['%s=%s' % (key, value) for key, value in params.items()])

        url = '%s?%s' % (cell.form_url, params)

        return JsonResponse({'url': url}, safe=False)

    'combo.apps.chrono',

    'xstatic.pkg.fullcalendar',

import json

import urlparse

import pytest

import mock

from django.utils.dateparse import parse_time

from combo.data.models import Page

from combo.apps.chrono.models import CalendarCell

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"

        }

    ]

}

class MockedRequestResponse(mock.Mock):

    def json(self):

        return json.loads(self.content)

@pytest.fixture

def cell(db):

    page = Page.objects.create()

    cell = CalendarCell(

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

        events_source='http://example.net/api/events/',

        form_url='http://example.net/form/whatever/',

        session_vars={

            "start_dt": "start", "end_dt": "end",

            "whatever_slug": "whatever"

        },

        slot_duration=parse_time('00:30'),

        business_hours_start=parse_time('08:00'),

        business_hours_end=parse_time('18:00'),

        event_default_title='Available'

    )

    cell.save()

    return cell

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

def test_get_events(mocked_get, app, cell):

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

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

    assert len(resp.json) == 4

    for datum in resp.json:

        assert datum['id'] == 'available'

        assert datum['rendering'] == 'inverse-background'

def test_redirection_session_vars(app, cell, settings):

    params = {

        'start': '2017-05-19T10:30:23',

        'end': '2017-05-19T12:30:14',

    }

    resp = app.post_json('/chrono/book/%s/' % cell.pk, params=params)

    parsed = urlparse.urlparse(resp.json['url'])

    qs = urlparse.parse_qs(parsed.query)

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

    assert qs['session_var_start_dt'] == [params['start']]

    assert qs['session_var_end_dt'] == [params['end']]