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

Josué Kouka, 30 octobre 2017 15:49

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/models.py                      |  2 +-
 .../templates/calendar/booking_calendar_cell.html  |  7 +++-
 combo/apps/calendar/utils.py                       | 38 ++++++++++++++++++----
 tests/test_calendar.py                             | 22 +++++++++++--
 4 files changed, 58 insertions(+), 11 deletions(-)

combo/apps/calendar/models.py
54	54
55	55	def render(self, context):
56	56	calendar = get_calendar(self.agenda_reference, self.slot_duration,
57		self.displayed_days)
	57	self.displayed_days, self.minimal_booking_duration)
58	58	context['calendar'] = calendar
59	59	return super(BookingCalendar, self).render(context)

     <div id="cal-{{cell.id}}">
         {% if cell.title %}
         <h2>{{cell.title}}</h2>
         <h2>
             <span>{{cell.title}}</span>
             {% if calendar %}
             <span>{{ calendar.get_info }}</span>
             {% endif %}
         </h2>
         {% endif %}
         <div>
             {% if calendar.days %}

     # 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
     import urllib
     from django.conf import settings
     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
-...
         return result.get('data', [])
     def get_calendar(agenda_reference, offset, size):
     def get_calendar(agenda_reference, offset, size, min_duration):
         if not agenda_reference:
             return []
         events = get_chrono_events(agenda_reference)
         weekcal = Calendar(offset, size)
         weekcal = Calendar(offset, size, min_duration)
         for event in events:
             event_datetime = parse_datetime(event['datetime'])
             event_date = 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, size):
         def __init__(self, offset, size, min_duration):
             self.offset = offset
             self.days = []
             self.size = size
             self.min_duration = min_duration
         def __repr__(self):
             if self.days:
                 return '<Calendar: %s -> %s >' % (self.days[0], self.days[-1])
             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()

         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.requests.get', side_effect=mocked_requests_get)
     def test_calendar(mocked_get, cell):
         cal = get_calendar('default:whatever', cell.slot_duration)
         cal = get_calendar('default:whatever', cell.slot_duration, 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