0001-booking-calendar-cell-display-first-available-slot-i.patch

Josué Kouka, 03 novembre 2017 14:57

Voir les différences: en ligne côte à côte

Subject: [PATCH] booking calendar cell: display first available slot if any
 (#19460)

 combo/apps/calendar/static/css/calendar.css        |  5 +++
 .../templates/calendar/booking_calendar_cell.html  |  7 +++-
 combo/apps/calendar/utils.py                       | 47 +++++++++++++++-------
 tests/test_calendar.py                             | 23 +++++++++--
 4 files changed, 62 insertions(+), 20 deletions(-)

     div.cell.bookingcalendar a {
         cursor: pointer;
+    }
     div.cell.bookingcalendar h2 > span.calinfo {
         font-style: italic;
         font-size: 13px;
+    }

     {% load i18n calendar %}
     {% if cell.title %}
     <h2>{{cell.title}}</h2>
     <h2>
         <span>{{cell.title}}</span>
         {% if calendar %}
         <span class="calinfo">{{ calendar.get_info }}</span>
         {% endif %}
     </h2>
     {% endif %}
     <div>
     {% include 'calendar/booking_calendar_content.html' %}

     import math
     import urllib
     from django.conf import settings
     from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
     from django.utils.dateformat import DateFormat
     from django.utils.dateparse import parse_datetime
     from django.utils.timezone import now
     from django.utils.formats import get_format
     from django.utils.timezone import localtime, make_aware, now
     from django.utils.translation import ugettext_lazy as _
     from combo.utils import requests
-...
         request = context['request']
         cell = context['cell']
         page = request.GET.get('chunk_%s' % cell.pk, 1)
         calendar = get_calendar(cell.agenda_reference, cell.slot_duration, cell.chunk_size)
         calendar = get_calendar(cell.agenda_reference, cell.slot_duration, cell.chunk_size, cell.minimal_booking_duration)
         paginator = Paginator(list(calendar.get_days()), cell.chunk_size)
         try:
             cal_page = paginator.page(page)
-...
         return context
     <<<<<<< HEAD
     def get_calendar(agenda_reference, offset, chunk_size):
     def get_calendar(agenda_reference, offset, chunk_size, min_duration):
         if not agenda_reference:
             return []
         events = get_chrono_events(agenda_reference)
         calendar = Calendar(offset, chunk_size)
     =======
     def get_calendar(agenda_reference, offset):
         if not agenda_reference:
             return []
         events = get_chrono_events(agenda_reference)
         calendar = Calendar(offset)
     >>>>>>> booking calendar: display availablilities in rolling days (#19368)
         calendar = Calendar(offset, chunk_size, min_duration)
         for event in events:
             event_datetime = parse_datetime(event['datetime'])
             if not calendar.has_day(event_datetime.date()):
-...
     class DaySlot(object):
         def __init__(self, date_time, available, exist=True):
             self.date_time = date_time
             self.date_time = localtime(make_aware(date_time))
             self.available = available
             self.exist = exist
         def __repr__(self):
             return '<DaySlot date_time=%s - available=%s>' % (self.date_time.isoformat(), self.available)
         def __str__(self):
             date = DateFormat(self.date_time).format(get_format('DATE_FORMAT'))
             return _('%s at %s') % (date, self.date_time.strftime('%H:%M'))
         @property
         def label(self):
             return '%s' % self.date_time.isoformat()
-...
         def get_maximum_slot(self):
             return max(self.slots, key=lambda x: x.date_time.time())
         def get_first_available_slot(self, offset, min_duration):
             step = min_duration.seconds / offset.seconds
             for idx in range(len(self.slots)):
                 tmp = self.slots[idx:idx + step]
                 if (tmp[-1].date_time - tmp[0].date_time) != ((step - 1) * offset):
                     continue
                 if not all(map(lambda x: x.available, tmp)):
                     continue
                 return tmp[0]
             return None
     class Calendar(object):
         def __init__(self, offset, chunk_size):
         def __init__(self, offset, chunk_size, min_duration):
             self.offset = offset
             self.chunk_size = chunk_size
             self.days = []
             self.min_duration = min_duration
         def __repr__(self):
             return '<Calendar>'
         def get_info(self):
             for day in self.days:
                 first_available_slot = day.get_first_available_slot(self.offset, self.min_duration)
                 if first_available_slot:
                     return _('(Next available slot: %s)') % first_available_slot
             return _('(No slot available)')
         def get_slots(self):
             start = self.get_minimum_slot()
             end = self.get_maximum_slot()

     import pytest
     import mock
     from django.utils.dateparse import parse_time
     from django.utils.timezone import now
     from django.contrib.auth.models import User
-...
         assert parsed.path == '/test/'
         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']
         assert qs['session_var_booking_start'] == ['2017-06-13T08:00:00+00:00']
         assert qs['session_var_booking_end'] == ['2017-06-13T09:30:00+00:00']
     @mock.patch('combo.apps.calendar.utils.now', mocked_now)
     @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, 7)
         cal = get_calendar('default:whatever', cell.slot_duration, 7, cell.minimal_booking_duration)
         assert len(cal.days) == 3
         for day in cal.get_days():
             assert day in [
-...
         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
     @mock.patch('combo.apps.calendar.utils.requests.get', side_effect=mocked_requests_get)
     def test_cell_rendering_cal_info(mocked_get, client, cell):
         page = client.get('/booking/')
         assert '(Next available slot: June 13' in page.content
         # test when no slot is available
         with mock.patch('combo.utils.requests.get') as request_get:
             def side_effect(*args, **kwargs):
                 if 'chrono' in kwargs['remote_service']['url']:
                     return MockedRequestResponse(content=json.dumps({"data": []}))
                 return MockedRequestResponse(content=json.dumps(WCS_FORMDEFS))
             request_get.side_effect = side_effect
             page = client.get('/booking/')
             assert '(No slot available)' in page.content
+    -

Projet

Général

Profil

Produits Entr'ouvert » Combo

0001-booking-calendar-cell-display-first-available-slot-i.patch