2404 lines
87 KiB
Python
2404 lines
87 KiB
Python
# chrono - agendas system
|
|
# Copyright (C) 2016 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 csv
|
|
import datetime
|
|
import itertools
|
|
import json
|
|
import math
|
|
import requests
|
|
import uuid
|
|
|
|
from django.contrib import messages
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.db.models import Q, Value, BooleanField
|
|
from django.db.models import Min, Max
|
|
from django.http import Http404, HttpResponse, HttpResponseRedirect
|
|
from django.shortcuts import get_object_or_404
|
|
from django.shortcuts import redirect
|
|
from django.template.loader import render_to_string
|
|
from django.urls import reverse, reverse_lazy
|
|
from django.utils.dates import MONTHS
|
|
from django.utils.timezone import now, make_aware, make_naive, localtime
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.utils.translation import ungettext
|
|
from django.utils.encoding import force_text
|
|
from django.views.generic import (
|
|
DetailView,
|
|
CreateView,
|
|
UpdateView,
|
|
ListView,
|
|
DeleteView,
|
|
FormView,
|
|
TemplateView,
|
|
DayArchiveView,
|
|
MonthArchiveView,
|
|
View,
|
|
)
|
|
|
|
from chrono.agendas.models import (
|
|
Agenda,
|
|
Event,
|
|
MeetingType,
|
|
TimePeriod,
|
|
Booking,
|
|
Desk,
|
|
TimePeriodException,
|
|
ICSError,
|
|
AgendaImportError,
|
|
TimePeriodExceptionSource,
|
|
VirtualMember,
|
|
Resource,
|
|
Category,
|
|
EventCancellationReport,
|
|
AgendaNotificationsSettings,
|
|
AgendaReminderSettings,
|
|
UnavailabilityCalendar,
|
|
)
|
|
|
|
from .forms import (
|
|
AgendaAddForm,
|
|
AgendaEditForm,
|
|
NewEventForm,
|
|
EventForm,
|
|
NewMeetingTypeForm,
|
|
MeetingTypeForm,
|
|
TimePeriodForm,
|
|
ImportEventsForm,
|
|
NewDeskForm,
|
|
DeskForm,
|
|
TimePeriodExceptionForm,
|
|
ExceptionsImportForm,
|
|
AgendasImportForm,
|
|
TimePeriodAddForm,
|
|
TimePeriodExceptionSourceReplaceForm,
|
|
VirtualMemberForm,
|
|
ResourceAddForm,
|
|
ResourceEditForm,
|
|
AgendaResourceForm,
|
|
AgendaDuplicateForm,
|
|
CategoryAddForm,
|
|
CategoryEditForm,
|
|
BookingCancelForm,
|
|
EventCancelForm,
|
|
AgendaNotificationsForm,
|
|
AgendaReminderForm,
|
|
UnavailabilityCalendarAddForm,
|
|
UnavailabilityCalendarEditForm,
|
|
)
|
|
from .utils import import_site
|
|
|
|
FUTURE_BOOKING_ERROR_MSG = _('This cannot be removed as there are bookings for a future date.')
|
|
|
|
|
|
class HomepageView(ListView):
|
|
template_name = 'chrono/manager_home.html'
|
|
model = Agenda
|
|
|
|
def get_queryset(self):
|
|
queryset = super(HomepageView, self).get_queryset()
|
|
if not self.request.user.is_staff:
|
|
group_ids = [x.id for x in self.request.user.groups.all()]
|
|
queryset = queryset.filter(Q(view_role_id__in=group_ids) | Q(edit_role_id__in=group_ids))
|
|
return queryset.order_by('category__label', 'label')
|
|
|
|
|
|
homepage = HomepageView.as_view()
|
|
|
|
|
|
class ResourceListView(ListView):
|
|
template_name = 'chrono/manager_resource_list.html'
|
|
model = Resource
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
resource_list = ResourceListView.as_view()
|
|
|
|
|
|
class ResourceDetailView(DetailView):
|
|
template_name = 'chrono/manager_resource_detail.html'
|
|
model = Resource
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['resource'] = self.object
|
|
return context
|
|
|
|
|
|
resource_view = ResourceDetailView.as_view()
|
|
|
|
|
|
class DateMixin(object):
|
|
def get_days(self):
|
|
return [str(x) for x in range(1, 32)]
|
|
|
|
def get_months(self):
|
|
return [(str(x), MONTHS[x]) for x in range(1, 13)]
|
|
|
|
def get_years(self):
|
|
year = now().year
|
|
return [str(x) for x in range(year - 1, year + 5)]
|
|
|
|
|
|
class ResourceDayView(DateMixin, DayArchiveView):
|
|
template_name = 'chrono/manager_resource_day_view.html'
|
|
model = Event
|
|
month_format = '%m'
|
|
date_field = 'start_datetime'
|
|
allow_empty = True
|
|
allow_future = True
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
self.resource = get_object_or_404(Resource, pk=kwargs['pk'])
|
|
# specify 6am time to get the expected timezone on daylight saving time
|
|
# days.
|
|
try:
|
|
self.date = make_aware(
|
|
datetime.datetime.strptime(
|
|
'%s-%s-%s 06:00' % (self.get_year(), self.get_month(), self.get_day()), '%Y-%m-%d %H:%M'
|
|
)
|
|
)
|
|
except ValueError: # day is out of range for month
|
|
# redirect to last day of month
|
|
date = datetime.date(int(self.get_year()), int(self.get_month()), 1)
|
|
date += datetime.timedelta(days=40)
|
|
date = date.replace(day=1)
|
|
date -= datetime.timedelta(days=1)
|
|
return HttpResponseRedirect(
|
|
reverse(
|
|
'chrono-manager-resource-day-view',
|
|
kwargs={'pk': self.resource.pk, 'year': date.year, 'month': date.month, 'day': date.day},
|
|
)
|
|
)
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_queryset(self):
|
|
queryset = (
|
|
self.resource.event_set.all().select_related('meeting_type').prefetch_related('booking_set')
|
|
)
|
|
return queryset
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
context['resource'] = self.resource
|
|
context['hour_span'] = 1
|
|
durations = MeetingType.objects.filter(agenda__resources=self.resource).values_list(
|
|
'duration', flat=True
|
|
)
|
|
if durations:
|
|
gcd = durations[0]
|
|
for duration in durations[1:]:
|
|
gcd = math.gcd(duration, gcd)
|
|
context['hour_span'] = max(60 // gcd, 1)
|
|
|
|
return context
|
|
|
|
def get_previous_day_url(self):
|
|
previous_day = self.date.date() - datetime.timedelta(days=1)
|
|
return reverse(
|
|
'chrono-manager-resource-day-view',
|
|
kwargs={
|
|
'pk': self.resource.pk,
|
|
'year': previous_day.year,
|
|
'month': previous_day.month,
|
|
'day': previous_day.day,
|
|
},
|
|
)
|
|
|
|
def get_next_day_url(self):
|
|
next_day = self.date.date() + datetime.timedelta(days=1)
|
|
return reverse(
|
|
'chrono-manager-resource-day-view',
|
|
kwargs={
|
|
'pk': self.resource.pk,
|
|
'year': next_day.year,
|
|
'month': next_day.month,
|
|
'day': next_day.day,
|
|
},
|
|
)
|
|
|
|
def get_timetable_infos(self):
|
|
interval = datetime.timedelta(minutes=60)
|
|
|
|
min_event = max_event = None
|
|
timeperiods = TimePeriod.objects.filter(desk__agenda__resources=self.resource).aggregate(
|
|
Min('start_time'), Max('end_time')
|
|
)
|
|
min_timeperiod = timeperiods['start_time__min']
|
|
max_timeperiod = timeperiods['end_time__max']
|
|
active_events = [
|
|
x for x in self.object_list if any([y.cancellation_datetime is None for y in x.booking_set.all()])
|
|
]
|
|
if active_events:
|
|
min_event = min([localtime(x.start_datetime).time() for x in active_events])
|
|
max_event = max([localtime(x.start_datetime + interval).time() for x in active_events])
|
|
if min_timeperiod is None and min_event is None:
|
|
return
|
|
min_display = min(min_timeperiod or datetime.time(23), min_event or datetime.time(23))
|
|
max_display = max(max_timeperiod or datetime.time(0), max_event or datetime.time(0))
|
|
|
|
current_date = self.date.replace(hour=min_display.hour, minute=0)
|
|
max_date = self.date.replace(hour=max_display.hour, minute=0)
|
|
if max_display.minute != 0:
|
|
# until the end of the last hour.
|
|
max_date += datetime.timedelta(hours=1)
|
|
|
|
while current_date < max_date:
|
|
info = {}
|
|
info['bookings'] = bookings = [] # bookings for this resource
|
|
finish_datetime = current_date + interval
|
|
for event in [
|
|
x
|
|
for x in self.object_list
|
|
if x.start_datetime >= current_date and x.start_datetime < finish_datetime
|
|
]:
|
|
# don't consider cancelled bookings
|
|
for booking in [x for x in event.booking_set.all() if not x.cancellation_datetime]:
|
|
booking.css_top = int(100 * event.start_datetime.minute / 60)
|
|
booking.css_height = int(100 * event.meeting_type.duration / 60)
|
|
bookings.append(booking)
|
|
yield current_date, info
|
|
current_date += interval
|
|
|
|
|
|
resource_day_view = ResourceDayView.as_view()
|
|
|
|
|
|
class ResourceMonthView(DateMixin, MonthArchiveView):
|
|
template_name = 'chrono/manager_resource_month_view.html'
|
|
model = Event
|
|
month_format = '%m'
|
|
date_field = 'start_datetime'
|
|
allow_empty = True
|
|
allow_future = True
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
self.resource = get_object_or_404(Resource, pk=kwargs['pk'])
|
|
self.date = make_aware(
|
|
datetime.datetime.strptime(
|
|
'%s-%s-%s 06:00' % (self.get_year(), self.get_month(), 1), '%Y-%m-%d %H:%M'
|
|
)
|
|
)
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_queryset(self):
|
|
queryset = (
|
|
self.resource.event_set.all().select_related('meeting_type').prefetch_related('booking_set')
|
|
)
|
|
return queryset
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
context['resource'] = self.resource
|
|
|
|
return context
|
|
|
|
def get_previous_month_url(self):
|
|
previous_month = self.get_previous_month(self.date.date())
|
|
return reverse(
|
|
'chrono-manager-resource-month-view',
|
|
kwargs={'pk': self.resource.pk, 'year': previous_month.year, 'month': previous_month.month},
|
|
)
|
|
|
|
def get_next_month_url(self):
|
|
next_month = self.get_next_month(self.date.date())
|
|
return reverse(
|
|
'chrono-manager-resource-month-view',
|
|
kwargs={'pk': self.resource.pk, 'year': next_month.year, 'month': next_month.month},
|
|
)
|
|
|
|
def get_timetable_infos(self):
|
|
interval = datetime.timedelta(minutes=60)
|
|
|
|
min_event = max_event = None
|
|
timeperiods = TimePeriod.objects.filter(desk__agenda__resources=self.resource).aggregate(
|
|
Min('start_time'), Max('end_time')
|
|
)
|
|
min_timeperiod = timeperiods['start_time__min']
|
|
max_timeperiod = timeperiods['end_time__max']
|
|
hide_sunday_timeperiod = hide_weekend_timeperiod = hide_sunday_event = hide_weekend_event = True
|
|
weekdays = TimePeriod.objects.filter(desk__agenda__resources=self.resource).values_list(
|
|
'weekday', flat=True
|
|
)
|
|
if weekdays:
|
|
hide_sunday_timeperiod = 6 not in weekdays
|
|
hide_weekend_timeperiod = hide_sunday_timeperiod and 5 not in weekdays
|
|
active_events = [
|
|
x for x in self.object_list if any([y.cancellation_datetime is None for y in x.booking_set.all()])
|
|
]
|
|
if active_events:
|
|
min_event = min([localtime(x.start_datetime).time() for x in active_events])
|
|
max_event = max([localtime(x.start_datetime + interval).time() for x in active_events])
|
|
hide_sunday_event = not any([x.start_datetime.weekday() == 6 for x in active_events])
|
|
hide_weekend_event = hide_sunday_event and not any(
|
|
[x.start_datetime.weekday() == 5 for x in active_events]
|
|
)
|
|
if min_timeperiod is None and min_event is None:
|
|
return
|
|
self.min_display = min(min_timeperiod or datetime.time(23), min_event or datetime.time(23))
|
|
self.max_display = max(max_timeperiod or datetime.time(0), max_event or datetime.time(0))
|
|
hide_sunday = hide_sunday_timeperiod and hide_sunday_event
|
|
hide_weekend = hide_weekend_timeperiod and hide_weekend_event
|
|
|
|
# avoid displaying empty first week
|
|
first_week_offset = int(
|
|
(hide_sunday and self.date.weekday() == 6) or (hide_weekend and self.date.weekday() == 5)
|
|
)
|
|
|
|
first_week_number = self.date.isocalendar()[1]
|
|
if first_week_number >= 52:
|
|
first_week_number = 0
|
|
last_month_day = self.get_next_month(self.date.date()) - datetime.timedelta(days=1)
|
|
last_week_number = last_month_day.isocalendar()[1]
|
|
|
|
if last_week_number < first_week_number: # new year
|
|
last_week_number = 53
|
|
|
|
for week_number in range(first_week_number + first_week_offset, last_week_number + 1):
|
|
yield self.get_week_timetable_infos(
|
|
week_number - first_week_number, week_end_offset=int(hide_sunday) + int(hide_weekend),
|
|
)
|
|
|
|
def get_week_timetable_infos(self, week_index, week_end_offset=0):
|
|
date = self.date + datetime.timedelta(week_index * 7)
|
|
year, week_number, dow = date.isocalendar()
|
|
start_date = date - datetime.timedelta(dow)
|
|
|
|
interval = datetime.timedelta(minutes=60)
|
|
period = self.date.replace(hour=self.min_display.hour, minute=0)
|
|
max_date = self.date.replace(hour=self.max_display.hour, minute=0)
|
|
if self.max_display.minute != 0:
|
|
# until the end of the last hour.
|
|
max_date += datetime.timedelta(hours=1)
|
|
|
|
periods = []
|
|
while period < max_date:
|
|
periods.append(period)
|
|
period = period + interval
|
|
|
|
return {
|
|
'days': [
|
|
self.get_day_timetable_infos(start_date + datetime.timedelta(i), interval)
|
|
for i in range(1, 8 - week_end_offset)
|
|
],
|
|
'periods': periods,
|
|
}
|
|
|
|
def get_day_timetable_infos(self, day, interval):
|
|
day = make_aware(make_naive(day)) # give day correct timezone
|
|
period = current_date = day.replace(hour=self.min_display.hour, minute=0)
|
|
timetable = {
|
|
'date': current_date,
|
|
'today': day.date() == datetime.date.today(),
|
|
'other_month': day.month != self.date.month,
|
|
'infos': {'booked_slots': []},
|
|
}
|
|
|
|
max_date = day.replace(hour=self.max_display.hour, minute=0)
|
|
if self.max_display.minute != 0:
|
|
# until the end of the last hour.
|
|
max_date += datetime.timedelta(hours=1)
|
|
|
|
# compute booking and opening hours only for current month
|
|
if self.date.month != day.month:
|
|
return timetable
|
|
|
|
while period <= max_date:
|
|
period_end = period + interval
|
|
for event in [
|
|
x for x in self.object_list if x.start_datetime >= period and x.start_datetime < period_end
|
|
]:
|
|
# don't consider cancelled bookings
|
|
bookings = [x for x in event.booking_set.all() if not x.cancellation_datetime]
|
|
if not bookings:
|
|
continue
|
|
booking = {
|
|
'css_top': 100 * (event.start_datetime - current_date).seconds // 3600,
|
|
'css_height': 100 * event.meeting_type.duration // 60,
|
|
'booking': bookings[0],
|
|
}
|
|
timetable['infos']['booked_slots'].append(booking)
|
|
period += interval
|
|
|
|
return timetable
|
|
|
|
|
|
resource_monthly_view = ResourceMonthView.as_view()
|
|
|
|
|
|
class ResourceAddView(CreateView):
|
|
template_name = 'chrono/manager_resource_form.html'
|
|
model = Resource
|
|
form_class = ResourceAddForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-resource-view', kwargs={'pk': self.object.id})
|
|
|
|
|
|
resource_add = ResourceAddView.as_view()
|
|
|
|
|
|
class ResourceEditView(UpdateView):
|
|
template_name = 'chrono/manager_resource_form.html'
|
|
model = Resource
|
|
form_class = ResourceEditForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-resource-view', kwargs={'pk': self.object.id})
|
|
|
|
|
|
resource_edit = ResourceEditView.as_view()
|
|
|
|
|
|
class ResourceDeleteView(DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = Resource
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-resource-list')
|
|
|
|
|
|
resource_delete = ResourceDeleteView.as_view()
|
|
|
|
|
|
class CategoryListView(ListView):
|
|
template_name = 'chrono/manager_category_list.html'
|
|
model = Category
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
category_list = CategoryListView.as_view()
|
|
|
|
|
|
class CategoryAddView(CreateView):
|
|
template_name = 'chrono/manager_category_form.html'
|
|
model = Category
|
|
form_class = CategoryAddForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-category-list')
|
|
|
|
|
|
category_add = CategoryAddView.as_view()
|
|
|
|
|
|
class CategoryEditView(UpdateView):
|
|
template_name = 'chrono/manager_category_form.html'
|
|
model = Category
|
|
form_class = CategoryEditForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-category-list')
|
|
|
|
|
|
category_edit = CategoryEditView.as_view()
|
|
|
|
|
|
class CategoryDeleteView(DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = Category
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-category-list')
|
|
|
|
|
|
category_delete = CategoryDeleteView.as_view()
|
|
|
|
|
|
class AgendaAddView(CreateView):
|
|
template_name = 'chrono/manager_agenda_form.html'
|
|
model = Agenda
|
|
form_class = AgendaAddForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super(AgendaAddView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
model_form = super(AgendaAddView, self).form_valid(form)
|
|
if self.object.kind == 'meetings':
|
|
default_desk = Desk(agenda=self.object, label=_('Desk 1'))
|
|
default_desk.save()
|
|
return model_form
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.object.id})
|
|
|
|
|
|
agenda_add = AgendaAddView.as_view()
|
|
|
|
|
|
class AgendasImportView(FormView):
|
|
form_class = AgendasImportForm
|
|
template_name = 'chrono/agendas_import.html'
|
|
success_url = reverse_lazy('chrono-manager-homepage')
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super(AgendasImportView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
try:
|
|
agendas_json = json.loads(force_text(self.request.FILES['agendas_json'].read()))
|
|
except ValueError:
|
|
form.add_error('agendas_json', _('File is not in the expected JSON format.'))
|
|
return self.form_invalid(form)
|
|
|
|
try:
|
|
results = import_site(agendas_json, overwrite=False)
|
|
except AgendaImportError as exc:
|
|
form.add_error('agendas_json', u'%s' % exc)
|
|
return self.form_invalid(form)
|
|
except KeyError as exc:
|
|
form.add_error('agendas_json', _('Key "%s" is missing.') % exc.args[0])
|
|
return self.form_invalid(form)
|
|
|
|
if results.get('created') == 0 and results.get('updated') == 0:
|
|
messages.info(self.request, _('No agendas were found.'))
|
|
else:
|
|
if results.get('created') == 0:
|
|
message1 = _('No agenda created.')
|
|
else:
|
|
message1 = ungettext(
|
|
'An agenda has been created.', '%(count)d agendas have been created.', results['created']
|
|
) % {'count': results['created']}
|
|
|
|
if results.get('updated') == 0:
|
|
message2 = _('No agenda updated.')
|
|
else:
|
|
message2 = ungettext(
|
|
'An agenda has been updated.', '%(count)d agendas have been updated.', results['updated']
|
|
) % {'count': results['updated']}
|
|
messages.info(self.request, u'%s %s' % (message1, message2))
|
|
|
|
return super(AgendasImportView, self).form_valid(form)
|
|
|
|
|
|
agendas_import = AgendasImportView.as_view()
|
|
|
|
|
|
class ViewableAgendaMixin(object):
|
|
agenda = None
|
|
|
|
def set_agenda(self, **kwargs):
|
|
self.agenda = get_object_or_404(Agenda, id=kwargs.get('pk'))
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.set_agenda(**kwargs)
|
|
if not self.check_permissions(request.user):
|
|
raise PermissionDenied()
|
|
return super(ViewableAgendaMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
def check_permissions(self, user):
|
|
return self.agenda.can_be_viewed(user)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ViewableAgendaMixin, self).get_context_data(**kwargs)
|
|
context['agenda'] = self.agenda
|
|
return context
|
|
|
|
|
|
class ManagedAgendaMixin(ViewableAgendaMixin):
|
|
def check_permissions(self, user):
|
|
return self.agenda.can_be_managed(user)
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
if not kwargs.get('instance'):
|
|
kwargs['instance'] = self.model()
|
|
kwargs['instance'].agenda = self.agenda
|
|
return kwargs
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.id})
|
|
|
|
|
|
class AgendaEditView(ManagedAgendaMixin, UpdateView):
|
|
template_name = 'chrono/manager_agenda_form.html'
|
|
model = Agenda
|
|
form_class = AgendaEditForm
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.object.id})
|
|
|
|
|
|
agenda_edit = AgendaEditView.as_view()
|
|
|
|
|
|
class AgendaDeleteView(DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = Agenda
|
|
success_url = reverse_lazy('chrono-manager-homepage')
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super(AgendaDeleteView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AgendaDeleteView, self).get_context_data(**kwargs)
|
|
context['cannot_delete'] = Booking.objects.filter(
|
|
event__agenda=self.get_object(),
|
|
event__start_datetime__gt=now(),
|
|
cancellation_datetime__isnull=True,
|
|
).exists()
|
|
context['cannot_delete_msg'] = FUTURE_BOOKING_ERROR_MSG
|
|
return context
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
context = self.get_context_data()
|
|
if context['cannot_delete']:
|
|
raise PermissionDenied()
|
|
return super(AgendaDeleteView, self).delete(request, *args, **kwargs)
|
|
|
|
|
|
agenda_delete = AgendaDeleteView.as_view()
|
|
|
|
|
|
class AgendaView(ViewableAgendaMixin, View):
|
|
def get(self, request, *args, **kwargs):
|
|
if self.agenda.kind != 'events':
|
|
# meetings or virtual - redirect to today view
|
|
today = datetime.date.today()
|
|
return redirect(
|
|
'chrono-manager-agenda-day-view',
|
|
pk=self.agenda.id,
|
|
year=today.year,
|
|
month=today.month,
|
|
day=today.day,
|
|
)
|
|
|
|
# events agenda - redirect to month or open events view
|
|
if self.agenda.default_view == 'month':
|
|
return redirect('chrono-manager-agenda-month-redirect-view', pk=self.agenda.pk)
|
|
return redirect('chrono-manager-agenda-open-events-view', pk=self.agenda.pk)
|
|
|
|
|
|
agenda_view = AgendaView.as_view()
|
|
|
|
|
|
class AgendaMonthRedirectView(ViewableAgendaMixin, View):
|
|
def get(self, request, *args, **kwargs):
|
|
if self.agenda.kind != 'events':
|
|
return redirect('chrono-manager-agenda-view', pk=self.agenda.pk)
|
|
|
|
# redirect to monthly view, to first month where there are events,
|
|
# otherwise to latest month with events, otherwise to this month.
|
|
today = datetime.date.today()
|
|
event = self.agenda.event_set.filter(
|
|
start_datetime__gte=datetime.date(today.year, today.month, 1)
|
|
).first()
|
|
if not event:
|
|
event = self.agenda.event_set.filter(
|
|
start_datetime__lte=datetime.date(today.year, today.month, 1)
|
|
).last()
|
|
if event:
|
|
day = event.start_datetime
|
|
else:
|
|
day = today
|
|
return redirect('chrono-manager-agenda-month-view', pk=self.agenda.pk, year=day.year, month=day.month)
|
|
|
|
|
|
agenda_month_redirect_view = AgendaMonthRedirectView.as_view()
|
|
|
|
|
|
class AgendaDateView(DateMixin, ViewableAgendaMixin):
|
|
model = Event
|
|
month_format = '%m'
|
|
date_field = 'start_datetime'
|
|
allow_empty = True
|
|
allow_future = True
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# specify 6am time to get the expected timezone on daylight saving time
|
|
# days.
|
|
try:
|
|
self.date = make_aware(
|
|
datetime.datetime.strptime(
|
|
'%s-%s-%s 06:00' % (self.get_year(), self.get_month(), self.get_day()), '%Y-%m-%d %H:%M'
|
|
)
|
|
)
|
|
except ValueError: # day is out of range for month
|
|
# redirect to last day of month
|
|
date = datetime.date(int(self.get_year()), int(self.get_month()), 1)
|
|
date += datetime.timedelta(days=40)
|
|
date = date.replace(day=1)
|
|
date -= datetime.timedelta(days=1)
|
|
return HttpResponseRedirect(
|
|
reverse(
|
|
'chrono-manager-agenda-day-view',
|
|
kwargs={'pk': kwargs['pk'], 'year': date.year, 'month': date.month, 'day': date.day},
|
|
)
|
|
)
|
|
return super(AgendaDateView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AgendaDateView, self).get_context_data(**kwargs)
|
|
context['agenda'] = self.agenda
|
|
if self.agenda.kind != 'events':
|
|
try:
|
|
context['hour_span'] = max(60 // self.agenda.get_base_meeting_duration(), 1)
|
|
except ValueError: # no meeting types defined
|
|
context['hour_span'] = 1
|
|
context['user_can_manage'] = self.agenda.can_be_managed(self.request.user)
|
|
return context
|
|
|
|
def get_queryset(self):
|
|
if self.agenda.kind == 'events':
|
|
queryset = self.agenda.event_set.all()
|
|
elif self.agenda.kind == 'meetings':
|
|
self.agenda.prefetched_desks = self.agenda.desk_set.all().prefetch_related(
|
|
'timeperiod_set', 'timeperiodexception_set'
|
|
)
|
|
queryset = self.agenda.event_set.select_related('meeting_type').prefetch_related('booking_set')
|
|
else:
|
|
self.agenda.prefetched_desks = (
|
|
Desk.objects.filter(agenda__virtual_agendas=self.agenda)
|
|
.prefetch_related('timeperiod_set', 'timeperiodexception_set')
|
|
.select_related('agenda')
|
|
.order_by('agenda', 'label')
|
|
)
|
|
queryset = (
|
|
Event.objects.filter(agenda__virtual_agendas=self.agenda)
|
|
.select_related('meeting_type')
|
|
.prefetch_related('booking_set')
|
|
)
|
|
return queryset
|
|
|
|
|
|
class AgendaDayView(AgendaDateView, DayArchiveView):
|
|
template_name = 'chrono/manager_agenda_day_view.html'
|
|
|
|
def set_agenda(self, **kwargs):
|
|
# day view should only exist for meetings kind.
|
|
self.agenda = get_object_or_404(Agenda.objects.exclude(kind='events'), pk=kwargs.get('pk'))
|
|
|
|
def get_previous_day_url(self):
|
|
previous_day = self.date.date() - datetime.timedelta(days=1)
|
|
return reverse(
|
|
'chrono-manager-agenda-day-view',
|
|
kwargs={
|
|
'pk': self.agenda.id,
|
|
'year': previous_day.year,
|
|
'month': previous_day.month,
|
|
'day': previous_day.day,
|
|
},
|
|
)
|
|
|
|
def get_next_day_url(self):
|
|
next_day = self.date.date() + datetime.timedelta(days=1)
|
|
return reverse(
|
|
'chrono-manager-agenda-day-view',
|
|
kwargs={
|
|
'pk': self.agenda.id,
|
|
'year': next_day.year,
|
|
'month': next_day.month,
|
|
'day': next_day.day,
|
|
},
|
|
)
|
|
|
|
def get_timetable_infos(self):
|
|
timeperiods = itertools.chain(*[d.timeperiod_set.all() for d in self.agenda.prefetched_desks])
|
|
timeperiods = [t for t in timeperiods if t.weekday == self.date.weekday()]
|
|
timeperiods = sorted(timeperiods, key=lambda t: t.start_time)
|
|
|
|
interval = datetime.timedelta(minutes=60)
|
|
|
|
min_timeperiod = max_timeperiod = min_event = max_event = None
|
|
if timeperiods:
|
|
min_timeperiod = min([x.start_time for x in timeperiods])
|
|
max_timeperiod = max([x.end_time for x in timeperiods])
|
|
active_events = [
|
|
x for x in self.object_list if any([y.cancellation_datetime is None for y in x.booking_set.all()])
|
|
]
|
|
if active_events:
|
|
min_event = min([localtime(x.start_datetime).time() for x in active_events])
|
|
max_event = max([localtime(x.start_datetime + interval).time() for x in active_events])
|
|
if min_timeperiod is None and min_event is None:
|
|
return
|
|
min_display = min(min_timeperiod or datetime.time(23), min_event or datetime.time(23))
|
|
max_display = max(max_timeperiod or datetime.time(0), max_event or datetime.time(0))
|
|
|
|
current_date = self.date.replace(hour=min_display.hour, minute=0)
|
|
start_date = current_date
|
|
max_date = self.date.replace(hour=max_display.hour, minute=0)
|
|
if max_display.minute != 0:
|
|
# until the end of the last hour.
|
|
max_date += datetime.timedelta(hours=1)
|
|
|
|
first = True
|
|
while current_date < max_date:
|
|
# for each timeslot return the timeslot date and a list of per-desk
|
|
# bookings
|
|
infos = [] # various infos, for each desk
|
|
for desk in self.agenda.prefetched_desks:
|
|
info = {'desk': desk}
|
|
if first:
|
|
# use first row to include opening hours
|
|
info['opening_hours'] = opening_hours = []
|
|
for opening_hour in desk.get_opening_hours(current_date.date()):
|
|
opening_hours.append(
|
|
{
|
|
'css_top': 100 * (opening_hour.begin - start_date).seconds // 3600,
|
|
'css_height': 100 * (opening_hour.end - opening_hour.begin).seconds // 3600,
|
|
}
|
|
)
|
|
|
|
# and exceptions for this desk
|
|
info['exceptions'] = []
|
|
for exception in desk.timeperiodexception_set.all():
|
|
if exception.end_datetime < start_date:
|
|
continue
|
|
if exception.start_datetime > max_date:
|
|
continue
|
|
start_max = max(start_date, exception.start_datetime)
|
|
end_min = min(max_date, exception.end_datetime)
|
|
exception.css_top = int(100 * (start_max - start_date).seconds // 3600)
|
|
exception.css_height = int(100 * (end_min - start_max).seconds // 3600)
|
|
info['exceptions'].append(exception)
|
|
|
|
infos.append(info)
|
|
info['bookings'] = bookings = [] # bookings for this desk
|
|
finish_datetime = current_date + interval
|
|
for event in [
|
|
x
|
|
for x in self.object_list
|
|
if x.desk_id == desk.id
|
|
and x.start_datetime >= current_date
|
|
and x.start_datetime < finish_datetime
|
|
]:
|
|
# don't consider cancelled bookings
|
|
for booking in [x for x in event.booking_set.all() if not x.cancellation_datetime]:
|
|
booking.css_top = int(100 * event.start_datetime.minute / 60)
|
|
booking.css_height = int(100 * event.meeting_type.duration / 60)
|
|
bookings.append(booking)
|
|
|
|
yield current_date, infos
|
|
current_date += interval
|
|
first = False
|
|
|
|
|
|
agenda_day_view = AgendaDayView.as_view()
|
|
|
|
|
|
class AgendaMonthView(AgendaDateView, MonthArchiveView):
|
|
def get_queryset(self):
|
|
qs = super(AgendaMonthView, self).get_queryset()
|
|
if self.agenda.kind != 'events':
|
|
return qs
|
|
return Event.annotate_queryset(qs).order_by('start_datetime', 'label')
|
|
|
|
def get_template_names(self):
|
|
if self.agenda.kind == 'virtual':
|
|
return ['chrono/manager_meetings_agenda_month_view.html']
|
|
return ['chrono/manager_%s_agenda_month_view.html' % self.agenda.kind]
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AgendaMonthView, self).get_context_data(**kwargs)
|
|
if self.agenda.kind == 'events':
|
|
context['cancellation_reports'] = EventCancellationReport.objects.filter(
|
|
event__agenda=self.agenda, seen=False,
|
|
).all()
|
|
else:
|
|
context['single_desk'] = bool(self.agenda.prefetched_desks)
|
|
return context
|
|
|
|
def get_previous_month_url(self):
|
|
previous_month = self.get_previous_month(self.date.date())
|
|
return reverse(
|
|
'chrono-manager-agenda-month-view',
|
|
kwargs={'pk': self.agenda.id, 'year': previous_month.year, 'month': previous_month.month},
|
|
)
|
|
|
|
def get_next_month_url(self):
|
|
next_month = self.get_next_month(self.date.date())
|
|
return reverse(
|
|
'chrono-manager-agenda-month-view',
|
|
kwargs={'pk': self.agenda.id, 'year': next_month.year, 'month': next_month.month},
|
|
)
|
|
|
|
def get_day(self):
|
|
return '1'
|
|
|
|
def get_timetable_infos(self):
|
|
timeperiods = itertools.chain(*[d.timeperiod_set.all() for d in self.agenda.prefetched_desks])
|
|
timeperiods = sorted(timeperiods, key=lambda t: (t.weekday, t.start_time))
|
|
|
|
interval = datetime.timedelta(minutes=60)
|
|
|
|
min_timeperiod = max_timeperiod = min_event = max_event = None
|
|
hide_sunday_timeperiod = hide_weekend_timeperiod = hide_sunday_event = hide_weekend_event = True
|
|
if timeperiods:
|
|
min_timeperiod = min([x.start_time for x in timeperiods])
|
|
max_timeperiod = max([x.end_time for x in timeperiods])
|
|
hide_sunday_timeperiod = not any([e.weekday == 6 for e in timeperiods])
|
|
hide_weekend_timeperiod = hide_sunday_timeperiod and not any(
|
|
[e.weekday == 5 for e in timeperiods]
|
|
)
|
|
active_events = [
|
|
x for x in self.object_list if any([y.cancellation_datetime is None for y in x.booking_set.all()])
|
|
]
|
|
if active_events:
|
|
min_event = min([localtime(x.start_datetime).time() for x in active_events])
|
|
max_event = max([localtime(x.start_datetime + interval).time() for x in active_events])
|
|
hide_sunday_event = not any([x.start_datetime.weekday() == 6 for x in active_events])
|
|
hide_weekend_event = hide_sunday_event and not any(
|
|
[x.start_datetime.weekday() == 5 for x in active_events]
|
|
)
|
|
if min_timeperiod is None and min_event is None:
|
|
return
|
|
self.min_display = min(min_timeperiod or datetime.time(23), min_event or datetime.time(23))
|
|
self.max_display = max(max_timeperiod or datetime.time(0), max_event or datetime.time(0))
|
|
hide_sunday = hide_sunday_timeperiod and hide_sunday_event
|
|
hide_weekend = hide_weekend_timeperiod and hide_weekend_event
|
|
|
|
# avoid displaying empty first week
|
|
first_week_offset = int(
|
|
(hide_sunday and self.date.weekday() == 6) or (hide_weekend and self.date.weekday() == 5)
|
|
)
|
|
|
|
first_week_number = self.date.isocalendar()[1]
|
|
if first_week_number >= 52:
|
|
first_week_number = 0
|
|
last_month_day = self.get_next_month(self.date.date()) - datetime.timedelta(days=1)
|
|
last_week_number = last_month_day.isocalendar()[1]
|
|
|
|
if last_week_number < first_week_number: # new year
|
|
last_week_number = 53
|
|
|
|
for week_number in range(first_week_number + first_week_offset, last_week_number + 1):
|
|
yield self.get_week_timetable_infos(
|
|
week_number - first_week_number, week_end_offset=int(hide_sunday) + int(hide_weekend),
|
|
)
|
|
|
|
def get_week_timetable_infos(self, week_index, week_end_offset=0):
|
|
date = self.date + datetime.timedelta(week_index * 7)
|
|
year, week_number, dow = date.isocalendar()
|
|
start_date = date - datetime.timedelta(dow)
|
|
|
|
interval = datetime.timedelta(minutes=60)
|
|
period = self.date.replace(hour=self.min_display.hour, minute=0)
|
|
max_date = self.date.replace(hour=self.max_display.hour, minute=0)
|
|
|
|
periods = []
|
|
while period < max_date:
|
|
periods.append(period)
|
|
period = period + interval
|
|
|
|
return {
|
|
'days': [
|
|
self.get_day_timetable_infos(start_date + datetime.timedelta(i), interval)
|
|
for i in range(1, 8 - week_end_offset)
|
|
],
|
|
'periods': periods,
|
|
}
|
|
|
|
def get_day_timetable_infos(self, day, interval):
|
|
day = make_aware(make_naive(day)) # give day correct timezone
|
|
period = current_date = day.replace(hour=self.min_display.hour, minute=0)
|
|
timetable = {
|
|
'date': current_date,
|
|
'today': day.date() == datetime.date.today(),
|
|
'other_month': day.month != self.date.month,
|
|
'infos': {'opening_hours': [], 'exceptions': [], 'booked_slots': []},
|
|
}
|
|
|
|
desks = self.agenda.prefetched_desks
|
|
desks_len = len(desks)
|
|
max_date = day.replace(hour=self.max_display.hour, minute=0)
|
|
|
|
# compute booking and opening hours only for current month
|
|
if self.date.month != day.month:
|
|
return timetable
|
|
|
|
while period <= max_date:
|
|
left = 1
|
|
period_end = period + interval
|
|
for desk_index, desk in enumerate(desks):
|
|
width = (98.0 / desks_len) - 1
|
|
for event in [
|
|
x
|
|
for x in self.object_list
|
|
if x.desk_id == desk.id and x.start_datetime >= period and x.start_datetime < period_end
|
|
]:
|
|
# don't consider cancelled bookings
|
|
bookings = [x for x in event.booking_set.all() if not x.cancellation_datetime]
|
|
if not bookings:
|
|
continue
|
|
booking = {
|
|
'css_top': 100 * (event.start_datetime - current_date).seconds // 3600,
|
|
'css_height': 100 * event.meeting_type.duration // 60,
|
|
'css_width': width,
|
|
'css_left': left,
|
|
'desk': desk,
|
|
'booking': bookings[0],
|
|
}
|
|
timetable['infos']['booked_slots'].append(booking)
|
|
|
|
# get desks opening hours on last period iteration
|
|
if period == max_date:
|
|
for opening_hour in desk.get_opening_hours(current_date):
|
|
timetable['infos']['opening_hours'].append(
|
|
{
|
|
'css_top': 100 * (opening_hour.begin - current_date).seconds // 3600,
|
|
'css_height': 100 * (opening_hour.end - opening_hour.begin).seconds // 3600,
|
|
'css_width': width,
|
|
'css_left': left,
|
|
}
|
|
)
|
|
for exception in desk.timeperiodexception_set.all():
|
|
if exception.end_datetime < current_date:
|
|
continue
|
|
if exception.start_datetime > max_date:
|
|
continue
|
|
start_max = max(current_date, exception.start_datetime)
|
|
end_min = min(max_date, exception.end_datetime)
|
|
exception.css_top = int(100 * (start_max - current_date).seconds // 3600)
|
|
exception.css_height = int(100 * (end_min - start_max).seconds // 3600)
|
|
exception.css_width = width
|
|
exception.css_left = left
|
|
timetable['infos']['exceptions'].append(exception)
|
|
|
|
left += width + 1
|
|
period += interval
|
|
|
|
return timetable
|
|
|
|
|
|
agenda_monthly_view = AgendaMonthView.as_view()
|
|
|
|
|
|
class AgendaOpenEventsView(ViewableAgendaMixin, DetailView):
|
|
model = Agenda
|
|
template_name = 'chrono/manager_agenda_open_events.html'
|
|
|
|
def set_agenda(self, **kwargs):
|
|
self.agenda = get_object_or_404(Agenda, pk=kwargs.get('pk'), kind='events')
|
|
|
|
def get_object(self, **kwargs):
|
|
return self.agenda
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['user_can_manage'] = self.agenda.can_be_managed(self.request.user)
|
|
context['open_events'] = Event.annotate_queryset(self.agenda.get_open_events())
|
|
return context
|
|
|
|
|
|
agenda_open_events_view = AgendaOpenEventsView.as_view()
|
|
|
|
|
|
class ManagedAgendaSubobjectMixin(object):
|
|
agenda = None
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.agenda = self.get_object().agenda
|
|
if not self.agenda.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
return super(ManagedAgendaSubobjectMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ManagedAgendaSubobjectMixin, self).get_context_data(**kwargs)
|
|
context['agenda'] = self.object.agenda
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.id})
|
|
|
|
|
|
class ManagedDeskMixin(object):
|
|
desk = None
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
try:
|
|
self.desk = Desk.objects.get(id=kwargs.get('pk'))
|
|
except Desk.DoesNotExist:
|
|
raise Http404()
|
|
if not self.desk.agenda.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
return super(ManagedDeskMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
if not kwargs.get('instance'):
|
|
kwargs['instance'] = self.model()
|
|
kwargs['instance'].desk = self.desk
|
|
return kwargs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ManagedDeskMixin, self).get_context_data(**kwargs)
|
|
context['desk'] = self.desk
|
|
context['agenda'] = self.desk.agenda
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda.id})
|
|
|
|
|
|
class ManagedDeskSubobjectMixin(object):
|
|
desk = None
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.desk = self.get_object().desk
|
|
if not self.desk.agenda.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
return super(ManagedDeskSubobjectMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ManagedDeskSubobjectMixin, self).get_context_data(**kwargs)
|
|
context['desk'] = self.object.desk
|
|
context['agenda'] = self.object.desk.agenda
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda.id})
|
|
|
|
|
|
class ManagedTimePeriodMixin(object):
|
|
agenda = None
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.time_period = self.get_object()
|
|
self.agenda = self.time_period.agenda
|
|
if self.time_period.desk:
|
|
self.agenda = self.time_period.desk.agenda
|
|
|
|
if not self.agenda.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
return super(ManagedTimePeriodMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ManagedTimePeriodMixin, self).get_context_data(**kwargs)
|
|
context['agenda'] = self.agenda
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.id})
|
|
|
|
|
|
class ManagedTimePeriodExceptionMixin(object):
|
|
|
|
desk = None
|
|
unavailability_calendar = None
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
object_ = self.get_object()
|
|
if object_.desk:
|
|
self.desk = self.get_object().desk
|
|
if not self.desk.agenda.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
elif object_.unavailability_calendar:
|
|
self.unavailability_calendar = object_.unavailability_calendar
|
|
if not self.unavailability_calendar.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
if self.desk:
|
|
context['desk'] = self.object.desk
|
|
context['agenda'] = self.object.desk.agenda
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
if self.desk:
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda.id})
|
|
elif self.unavailability_calendar:
|
|
return reverse(
|
|
'chrono-manager-unavailability-calendar-settings',
|
|
kwargs={'pk': self.unavailability_calendar.pk},
|
|
)
|
|
|
|
|
|
class AgendaSettings(ManagedAgendaMixin, DetailView):
|
|
model = Agenda
|
|
|
|
def get_object(self, *args, **kwargs):
|
|
if self.agenda.kind == 'meetings':
|
|
self.agenda.prefetched_desks = self.agenda.desk_set.all().prefetch_related(
|
|
'timeperiod_set', 'timeperiodexception_set',
|
|
)
|
|
return self.agenda
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AgendaSettings, self).get_context_data(**kwargs)
|
|
if self.agenda.accept_meetings():
|
|
context['meeting_types'] = self.object.iter_meetingtypes()
|
|
if self.agenda.kind == 'virtual':
|
|
context['virtual_members'] = [
|
|
(virtual_member, virtual_member.real_agenda.can_be_managed(self.request.user))
|
|
for virtual_member in self.object.get_virtual_members()
|
|
]
|
|
if self.agenda.kind == 'meetings':
|
|
context['has_resources'] = Resource.objects.exists()
|
|
context['has_unavailability_calendars'] = UnavailabilityCalendar.objects.exists()
|
|
return context
|
|
|
|
def get_events(self):
|
|
qs = self.agenda.event_set.all()
|
|
return Event.annotate_queryset(qs)
|
|
|
|
def get_template_names(self):
|
|
return ['chrono/manager_%s_agenda_settings.html' % self.agenda.kind]
|
|
|
|
|
|
agenda_settings = AgendaSettings.as_view()
|
|
|
|
|
|
class AgendaExport(ManagedAgendaMixin, DetailView):
|
|
model = Agenda
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
response = HttpResponse(content_type='application/json')
|
|
today = datetime.date.today()
|
|
response['Content-Disposition'] = 'attachment; filename="export_agenda_{}_{}.json"'.format(
|
|
self.get_object().slug, today.strftime('%Y%m%d')
|
|
)
|
|
json.dump({'agendas': [self.get_object().export_json()]}, response, indent=2)
|
|
return response
|
|
|
|
|
|
agenda_export = AgendaExport.as_view()
|
|
|
|
|
|
class AgendaDuplicate(ManagedAgendaMixin, FormView):
|
|
form_class = AgendaDuplicateForm
|
|
template_name = 'chrono/manager_agenda_duplicate_form.html'
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.new_agenda.pk})
|
|
|
|
def get_form_kwargs(self):
|
|
return super(FormView, self).get_form_kwargs()
|
|
|
|
def form_valid(self, form):
|
|
self.new_agenda = self.agenda.duplicate(label=form.cleaned_data['label'])
|
|
return super().form_valid(form)
|
|
|
|
|
|
agenda_duplicate = AgendaDuplicate.as_view()
|
|
|
|
|
|
class AgendaAddEventView(ManagedAgendaMixin, CreateView):
|
|
template_name = 'chrono/manager_event_form.html'
|
|
model = Event
|
|
form_class = NewEventForm
|
|
|
|
|
|
agenda_add_event = AgendaAddEventView.as_view()
|
|
|
|
|
|
class AgendaImportEventsSampleView(TemplateView):
|
|
template_name = 'chrono/manager_sample_events.txt'
|
|
content_type = 'text/csv'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AgendaImportEventsSampleView, self).get_context_data(**kwargs)
|
|
some_future_date = datetime.datetime.now() + datetime.timedelta(days=10)
|
|
some_future_date = some_future_date.replace(hour=14, minute=0, second=0)
|
|
context['some_future_date'] = some_future_date
|
|
return context
|
|
|
|
|
|
agenda_import_events_sample_csv = AgendaImportEventsSampleView.as_view()
|
|
|
|
|
|
class AgendaImportEventsView(ManagedAgendaMixin, FormView):
|
|
form_class = ImportEventsForm
|
|
template_name = 'chrono/manager_import_events.html'
|
|
agenda = None
|
|
|
|
def set_agenda(self, **kwargs):
|
|
self.agenda = get_object_or_404(Agenda, pk=kwargs.get('pk'), kind='events')
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(FormView, self).get_form_kwargs()
|
|
kwargs['agenda_pk'] = self.kwargs['pk']
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
if form.events:
|
|
# existing event slugs for this agenda
|
|
for event in form.events:
|
|
event.agenda = self.agenda
|
|
event.save()
|
|
messages.info(self.request, _('%d events have been imported.') % len(form.events))
|
|
for event in form.warnings.values():
|
|
messages.warning(
|
|
self.request,
|
|
_('Event "%s" start date has changed. Do not forget to notify the registrants.')
|
|
% (event.label or event.slug),
|
|
)
|
|
return super(AgendaImportEventsView, self).form_valid(form)
|
|
|
|
|
|
agenda_import_events = AgendaImportEventsView.as_view()
|
|
|
|
|
|
class AgendaExportEventsView(ManagedAgendaMixin, View):
|
|
template_name = 'chrono/manager_export_events.html'
|
|
agenda = None
|
|
|
|
def set_agenda(self, **kwargs):
|
|
self.agenda = get_object_or_404(Agenda, pk=kwargs.get('pk'), kind='events')
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
response = HttpResponse(content_type='text/csv')
|
|
today = datetime.date.today()
|
|
response['Content-Disposition'] = 'attachment; filename="export_agenda_events_{}_{}.csv"'.format(
|
|
self.agenda.slug, today.strftime('%Y%m%d')
|
|
)
|
|
writer = csv.writer(response)
|
|
# headers
|
|
writer.writerow(
|
|
[
|
|
_('date'),
|
|
_('time'),
|
|
_('number of places'),
|
|
_('number of places in waiting list'),
|
|
_('label'),
|
|
_('identifier'),
|
|
_('description'),
|
|
_('pricing'),
|
|
_('URL'),
|
|
_('publication date'),
|
|
_('duration'),
|
|
]
|
|
)
|
|
for event in self.agenda.event_set.all():
|
|
start_datetime = localtime(event.start_datetime)
|
|
writer.writerow(
|
|
[
|
|
start_datetime.strftime('%Y-%m-%d'),
|
|
start_datetime.strftime('%H:%M'),
|
|
event.places,
|
|
event.waiting_list_places,
|
|
event.label,
|
|
event.slug,
|
|
event.description,
|
|
event.pricing,
|
|
event.url,
|
|
event.publication_date.strftime('%Y-%m-%d') if event.publication_date else '',
|
|
event.duration,
|
|
]
|
|
)
|
|
return response
|
|
|
|
|
|
agenda_export_events = AgendaExportEventsView.as_view()
|
|
|
|
|
|
class AgendaNotificationsSettingsView(ManagedAgendaMixin, UpdateView):
|
|
template_name = 'chrono/manager_agenda_notifications_form.html'
|
|
model = AgendaNotificationsSettings
|
|
form_class = AgendaNotificationsForm
|
|
|
|
def get_object(self):
|
|
try:
|
|
return self.agenda.notifications_settings
|
|
except AgendaNotificationsSettings.DoesNotExist:
|
|
# prevent old events from sending notifications
|
|
statuses = ('almost_full', 'full', 'cancelled')
|
|
timestamp = now()
|
|
for status in statuses:
|
|
filter_kwargs = {status: True}
|
|
update_kwargs = {status + '_notification_timestamp': timestamp}
|
|
self.agenda.event_set.filter(**filter_kwargs).update(**update_kwargs)
|
|
return AgendaNotificationsSettings.objects.create(agenda=self.agenda)
|
|
|
|
|
|
agenda_notifications_settings = AgendaNotificationsSettingsView.as_view()
|
|
|
|
|
|
class AgendaReminderSettingsView(ManagedAgendaMixin, UpdateView):
|
|
template_name = 'chrono/manager_agenda_reminder_form.html'
|
|
model = AgendaReminderSettings
|
|
form_class = AgendaReminderForm
|
|
|
|
def get_object(self):
|
|
try:
|
|
return self.agenda.reminder_settings
|
|
except AgendaReminderSettings.DoesNotExist:
|
|
return AgendaReminderSettings.objects.create(agenda=self.agenda)
|
|
|
|
|
|
agenda_reminder_settings = AgendaReminderSettingsView.as_view()
|
|
|
|
|
|
class AgendaReminderPreviewView(ManagedAgendaMixin, TemplateView):
|
|
template_name = 'chrono/manager_agenda_reminder_preview.html'
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.type_ = kwargs['type']
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
ctx = super().get_context_data(**kwargs)
|
|
kind = self.agenda.kind
|
|
days = self.agenda.reminder_settings.days
|
|
|
|
event = Event(
|
|
label='{{ event_label }}',
|
|
start_datetime=datetime.datetime(year=2020, month=6, day=2, hour=14, minute=30),
|
|
)
|
|
booking = Booking(user_display_label='{{ user_display_label }}', form_url='#')
|
|
booking.event = event
|
|
reminder_ctx = {
|
|
'booking': booking,
|
|
'in_x_days': _('tomorrow') if days == 1 else _('in %s days') % days,
|
|
'date': booking.event.start_datetime,
|
|
'email_extra_info': self.agenda.reminder_settings.email_extra_info,
|
|
'sms_extra_info': self.agenda.reminder_settings.sms_extra_info,
|
|
}
|
|
|
|
if self.type_ == 'email':
|
|
ctx['subject'] = render_to_string('agendas/%s_reminder_subject.txt' % kind, reminder_ctx).strip()
|
|
ctx['message'] = render_to_string('agendas/%s_reminder_body.html' % kind, reminder_ctx)
|
|
elif self.type_ == 'sms':
|
|
ctx['message'] = render_to_string('agendas/%s_reminder_message.txt' % kind, reminder_ctx)
|
|
|
|
return ctx
|
|
|
|
|
|
agenda_reminder_preview = AgendaReminderPreviewView.as_view()
|
|
|
|
|
|
class EventDetailView(ViewableAgendaMixin, DetailView):
|
|
model = Event
|
|
pk_url_kwarg = 'event_pk'
|
|
|
|
def get_template_names(self):
|
|
if self.request.is_ajax():
|
|
return ['chrono/manager_event_detail_fragment.html']
|
|
return ['chrono/manager_event_detail.html']
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(EventDetailView, self).get_context_data(**kwargs)
|
|
context['user_can_manage'] = self.agenda.can_be_managed(self.request.user)
|
|
event = self.get_object()
|
|
context['booked'] = event.booking_set.filter(
|
|
cancellation_datetime__isnull=True, in_waiting_list=False
|
|
).order_by('creation_datetime')
|
|
context['waiting'] = event.booking_set.filter(
|
|
cancellation_datetime__isnull=True, in_waiting_list=True
|
|
).order_by('creation_datetime')
|
|
return context
|
|
|
|
|
|
event_view = EventDetailView.as_view()
|
|
|
|
|
|
class EventEditView(ManagedAgendaMixin, UpdateView):
|
|
template_name = 'chrono/manager_event_form.html'
|
|
model = Event
|
|
form_class = EventForm
|
|
pk_url_kwarg = 'event_pk'
|
|
|
|
def get_success_url(self):
|
|
if self.request.GET.get('next') == 'settings' or self.request.POST.get('next') == 'settings':
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.id})
|
|
return reverse('chrono-manager-event-view', kwargs={'pk': self.agenda.id, 'event_pk': self.object.id})
|
|
|
|
|
|
event_edit = EventEditView.as_view()
|
|
|
|
|
|
class EventDeleteView(ManagedAgendaMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_event_delete.html'
|
|
model = Event
|
|
pk_url_kwarg = 'event_pk'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(EventDeleteView, self).get_context_data(**kwargs)
|
|
context['cannot_delete'] = bool(
|
|
self.object.booking_set.filter(cancellation_datetime__isnull=True).exists()
|
|
and self.object.start_datetime > now()
|
|
)
|
|
return context
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
context = self.get_context_data()
|
|
if context['cannot_delete']:
|
|
raise PermissionDenied()
|
|
return super(EventDeleteView, self).delete(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
if self.request.GET.get('next') == 'settings' or self.request.POST.get('next') == 'settings':
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.id})
|
|
day = self.object.start_datetime
|
|
return reverse(
|
|
'chrono-manager-agenda-month-view',
|
|
kwargs={'pk': self.agenda.id, 'year': day.year, 'month': day.month},
|
|
)
|
|
|
|
|
|
event_delete = EventDeleteView.as_view()
|
|
|
|
|
|
class AgendaAddResourceView(ManagedAgendaMixin, FormView):
|
|
template_name = 'chrono/manager_agenda_resource_form.html'
|
|
form_class = AgendaResourceForm
|
|
|
|
def set_agenda(self, **kwargs):
|
|
self.agenda = get_object_or_404(Agenda, id=kwargs.get('pk'), kind='meetings')
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(FormView, self).get_form_kwargs()
|
|
kwargs['agenda'] = self.agenda
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
self.agenda.resources.add(form.cleaned_data['resource'])
|
|
return super().form_valid(form)
|
|
|
|
|
|
agenda_add_resource = AgendaAddResourceView.as_view()
|
|
|
|
|
|
class AgendaResourceDeleteView(ManagedAgendaMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = Resource
|
|
pk_url_kwarg = 'resource_pk'
|
|
|
|
def set_agenda(self, **kwargs):
|
|
self.agenda = get_object_or_404(Agenda, id=kwargs.get('pk'), kind='meetings')
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
self.agenda.resources.remove(self.object)
|
|
return HttpResponseRedirect(self.get_success_url())
|
|
|
|
|
|
agenda_delete_resource = AgendaResourceDeleteView.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarToggleView(ManagedDeskMixin, DetailView):
|
|
model = UnavailabilityCalendar
|
|
pk_url_kwarg = 'unavailability_calendar_pk'
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
unavailability_calendar = self.get_object()
|
|
try:
|
|
self.desk.unavailability_calendars.get(pk=unavailability_calendar.pk)
|
|
self.desk.unavailability_calendars.remove(unavailability_calendar)
|
|
message = _(
|
|
'Unavailability calendar %(unavailability_calendar)s has been disabled on desk %(desk)s.'
|
|
)
|
|
|
|
except UnavailabilityCalendar.DoesNotExist:
|
|
self.desk.unavailability_calendars.add(unavailability_calendar)
|
|
message = _(
|
|
'Unavailability calendar %(unavailability_calendar)s has been enabled on desk %(desk)s.'
|
|
)
|
|
messages.info(
|
|
self.request, message % {'unavailability_calendar': unavailability_calendar, 'desk': self.desk}
|
|
)
|
|
return HttpResponseRedirect(
|
|
reverse('chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda_id})
|
|
)
|
|
|
|
|
|
unavailability_calendar_toggle_view = UnavailabilityCalendarToggleView.as_view()
|
|
|
|
|
|
class AgendaAddMeetingTypeView(ManagedAgendaMixin, CreateView):
|
|
template_name = 'chrono/manager_meeting_type_form.html'
|
|
model = MeetingType
|
|
form_class = NewMeetingTypeForm
|
|
|
|
|
|
agenda_add_meeting_type = AgendaAddMeetingTypeView.as_view()
|
|
|
|
|
|
class MeetingTypeEditView(ManagedAgendaSubobjectMixin, UpdateView):
|
|
template_name = 'chrono/manager_meeting_type_form.html'
|
|
model = MeetingType
|
|
form_class = MeetingTypeForm
|
|
|
|
|
|
meeting_type_edit = MeetingTypeEditView.as_view()
|
|
|
|
|
|
class MeetingTypeDeleteView(ManagedAgendaSubobjectMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = MeetingType
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(MeetingTypeDeleteView, self).get_context_data(**kwargs)
|
|
meeting_type = self.get_object()
|
|
context['cannot_delete'] = False
|
|
|
|
for virtual_agenda in self.get_object().agenda.virtual_agendas.all():
|
|
if virtual_agenda.real_agendas.count() == 1:
|
|
continue
|
|
for mt in virtual_agenda.iter_meetingtypes():
|
|
if (
|
|
meeting_type.slug == mt.slug
|
|
and meeting_type.label == mt.label
|
|
and meeting_type.duration == mt.duration
|
|
):
|
|
context['cannot_delete'] = True
|
|
context['cannot_delete_msg'] = _(
|
|
'This cannot be removed as it used by a virtual agenda: %(agenda)s'
|
|
% {'agenda': virtual_agenda}
|
|
)
|
|
break
|
|
|
|
return context
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
context = self.get_context_data()
|
|
if context['cannot_delete']:
|
|
raise PermissionDenied()
|
|
|
|
# rewrite django/views/generic/edit.py::DeletionMixin.delete
|
|
# to mark for deletion instead of actually delete
|
|
success_url = self.get_success_url()
|
|
self.object.deleted = True
|
|
self.object.slug += '__deleted__' + str(uuid.uuid4())
|
|
self.object.save()
|
|
return HttpResponseRedirect(success_url)
|
|
|
|
|
|
meeting_type_delete = MeetingTypeDeleteView.as_view()
|
|
|
|
|
|
def process_time_period_add_form(form, desk=None, agenda=None):
|
|
assert desk or agenda, "a time period requires a desk or a agenda"
|
|
for weekday in form.cleaned_data.get('weekdays'):
|
|
period = TimePeriod(
|
|
weekday=weekday,
|
|
start_time=form.cleaned_data['start_time'],
|
|
end_time=form.cleaned_data['end_time'],
|
|
)
|
|
if desk:
|
|
period.desk = desk
|
|
elif agenda:
|
|
period.agenda = agenda
|
|
period.save()
|
|
|
|
|
|
class AgendaAddTimePeriodView(ManagedDeskMixin, FormView):
|
|
template_name = 'chrono/manager_time_period_form.html'
|
|
form_class = TimePeriodAddForm
|
|
|
|
def get_form_kwargs(self):
|
|
return super(FormView, self).get_form_kwargs()
|
|
|
|
def form_valid(self, form):
|
|
process_time_period_add_form(form, desk=self.desk)
|
|
return super(AgendaAddTimePeriodView, self).form_valid(form)
|
|
|
|
|
|
agenda_add_time_period = AgendaAddTimePeriodView.as_view()
|
|
|
|
|
|
class VirtualAgendaAddTimePeriodView(ManagedAgendaMixin, FormView):
|
|
template_name = 'chrono/manager_time_period_form.html'
|
|
form_class = TimePeriodAddForm
|
|
|
|
def get_form_kwargs(self):
|
|
return super(FormView, self).get_form_kwargs()
|
|
|
|
def form_valid(self, form):
|
|
process_time_period_add_form(form, agenda=self.agenda)
|
|
return super(VirtualAgendaAddTimePeriodView, self).form_valid(form)
|
|
|
|
|
|
virtual_agenda_add_time_period = VirtualAgendaAddTimePeriodView.as_view()
|
|
|
|
|
|
class TimePeriodEditView(ManagedTimePeriodMixin, UpdateView):
|
|
template_name = 'chrono/manager_time_period_form.html'
|
|
model = TimePeriod
|
|
form_class = TimePeriodForm
|
|
|
|
|
|
time_period_edit = TimePeriodEditView.as_view()
|
|
|
|
|
|
class TimePeriodDeleteView(ManagedTimePeriodMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = TimePeriod
|
|
|
|
|
|
time_period_delete = TimePeriodDeleteView.as_view()
|
|
|
|
|
|
class AgendaAddDesk(ManagedAgendaMixin, CreateView):
|
|
template_name = 'chrono/manager_desk_form.html'
|
|
model = Desk
|
|
form_class = NewDeskForm
|
|
|
|
|
|
agenda_add_desk = AgendaAddDesk.as_view()
|
|
|
|
|
|
class DeskEditView(ManagedAgendaSubobjectMixin, UpdateView):
|
|
template_name = 'chrono/manager_desk_form.html'
|
|
model = Desk
|
|
form_class = DeskForm
|
|
|
|
|
|
desk_edit = DeskEditView.as_view()
|
|
|
|
|
|
class DeskDeleteView(ManagedAgendaSubobjectMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = Desk
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(DeskDeleteView, self).get_context_data(**kwargs)
|
|
context['cannot_delete'] = Booking.objects.filter(
|
|
event__desk=self.get_object(), event__start_datetime__gt=now(), cancellation_datetime__isnull=True
|
|
).exists()
|
|
context['cannot_delete_msg'] = FUTURE_BOOKING_ERROR_MSG
|
|
return context
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
context = self.get_context_data()
|
|
if context['cannot_delete']:
|
|
raise PermissionDenied()
|
|
return super(DeskDeleteView, self).delete(request, *args, **kwargs)
|
|
|
|
|
|
desk_delete = DeskDeleteView.as_view()
|
|
|
|
|
|
class VirtualMemberAddView(ManagedAgendaMixin, CreateView):
|
|
template_name = 'chrono/manager_virtual_member_form.html'
|
|
form_class = VirtualMemberForm
|
|
model = VirtualMember
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(CreateView, self).get_form_kwargs()
|
|
kwargs['instance'] = VirtualMember(virtual_agenda=self.agenda)
|
|
return kwargs
|
|
|
|
|
|
agenda_add_virtual_member = VirtualMemberAddView.as_view()
|
|
|
|
|
|
class VirtualMemberDeleteView(DeleteView):
|
|
template_name = 'chrono/manager_confirm_virtual_member_delete.html'
|
|
model = VirtualMember
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.agenda = self.get_object().virtual_agenda
|
|
if not self.agenda.can_be_managed(request.user):
|
|
raise PermissionDenied()
|
|
return super(VirtualMemberDeleteView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(VirtualMemberDeleteView, self).get_context_data(**kwargs)
|
|
context['agenda'] = self.agenda
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.agenda.pk})
|
|
|
|
|
|
virtual_member_delete = VirtualMemberDeleteView.as_view()
|
|
|
|
|
|
class AgendaAddTimePeriodExceptionView(ManagedDeskMixin, CreateView):
|
|
template_name = 'chrono/manager_time_period_exception_form.html'
|
|
model = TimePeriodException
|
|
form_class = TimePeriodExceptionForm
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['cancel_url'] = reverse('chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda.pk})
|
|
return context
|
|
|
|
def form_valid(self, form):
|
|
result = super().form_valid(form)
|
|
exceptions = [self.object]
|
|
if form.cleaned_data.get('all_desks'):
|
|
for desk in Desk.objects.filter(agenda=self.object.desk.agenda_id):
|
|
if desk == self.object.desk:
|
|
continue
|
|
exceptions.append(
|
|
TimePeriodException.objects.create(
|
|
desk=desk,
|
|
label=self.object.label,
|
|
start_datetime=self.object.start_datetime,
|
|
end_datetime=self.object.end_datetime,
|
|
)
|
|
)
|
|
for exception in exceptions:
|
|
if exception.has_booking_within_time_slot():
|
|
message = ungettext(
|
|
'Exception added. Note: one or several bookings exists within this time slot.',
|
|
'Exceptions added. Note: one or several bookings exists within this time slot.',
|
|
len(exceptions),
|
|
)
|
|
messages.info(self.request, message)
|
|
break
|
|
return result
|
|
|
|
|
|
agenda_add_time_period_exception = AgendaAddTimePeriodExceptionView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionEditView(ManagedTimePeriodExceptionMixin, UpdateView):
|
|
template_name = 'chrono/manager_time_period_exception_form.html'
|
|
model = TimePeriodException
|
|
form_class = TimePeriodExceptionForm
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
if self.desk:
|
|
context['cancel_url'] = reverse(
|
|
'chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda.pk}
|
|
)
|
|
elif self.unavailability_calendar:
|
|
context['cancel_url'] = reverse(
|
|
'chrono-manager-unavailability-calendar-settings',
|
|
kwargs={'pk': self.unavailability_calendar.pk},
|
|
)
|
|
return context
|
|
|
|
|
|
time_period_exception_edit = TimePeriodExceptionEditView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionListView(ManagedDeskMixin, ListView):
|
|
template_name = 'chrono/manager_time_period_exception_list.html'
|
|
model = TimePeriodException
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
return self.model.objects.filter(desk=self.desk, end_datetime__gte=now()).select_related('source')
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(TimePeriodExceptionListView, self).get_context_data(**kwargs)
|
|
context['user_can_manage'] = self.desk.agenda.can_be_managed(self.request.user)
|
|
return context
|
|
|
|
|
|
time_period_exception_list = TimePeriodExceptionListView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionExtractListView(TimePeriodExceptionListView):
|
|
paginate_by = None # no pagination
|
|
|
|
def get_queryset(self):
|
|
# but limit queryset
|
|
return super(TimePeriodExceptionExtractListView, self).get_queryset()[:10]
|
|
|
|
|
|
time_period_exception_extract_list = TimePeriodExceptionExtractListView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionDeleteView(ManagedTimePeriodExceptionMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_exception_delete.html'
|
|
model = TimePeriodException
|
|
|
|
def get_success_url(self):
|
|
if self.desk:
|
|
referer = self.request.META.get('HTTP_REFERER')
|
|
success_url = reverse('chrono-manager-time-period-exception-list', kwargs={'pk': self.desk.pk})
|
|
if success_url in referer:
|
|
return success_url
|
|
|
|
success_url = super(TimePeriodExceptionDeleteView, self).get_success_url()
|
|
if self.desk and 'from_popup' in self.request.GET:
|
|
success_url = '{}?display_exceptions={}'.format(success_url, self.desk.pk)
|
|
return success_url
|
|
|
|
def get_queryset(self):
|
|
return super().get_queryset().filter(source__settings_slug__isnull=True)
|
|
|
|
|
|
time_period_exception_delete = TimePeriodExceptionDeleteView.as_view()
|
|
|
|
|
|
class DeskImportTimePeriodExceptionsView(ManagedAgendaSubobjectMixin, UpdateView):
|
|
model = Desk
|
|
form_class = ExceptionsImportForm
|
|
template_name = 'chrono/manager_import_exceptions.html'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(DeskImportTimePeriodExceptionsView, self).get_context_data(**kwargs)
|
|
desk = self.get_object()
|
|
context['exception_sources'] = desk.timeperiodexceptionsource_set.all()
|
|
context['desk'] = desk
|
|
context['unavailability_calendars'] = (
|
|
UnavailabilityCalendar.objects.filter(desks=desk)
|
|
.annotate(enabled=Value(True, BooleanField()))
|
|
.union(
|
|
UnavailabilityCalendar.objects.exclude(desks=desk).annotate(
|
|
enabled=Value(False, BooleanField())
|
|
)
|
|
)
|
|
)
|
|
return context
|
|
|
|
def form_valid(self, form):
|
|
exceptions = None
|
|
try:
|
|
if form.cleaned_data['ics_file']:
|
|
exceptions = form.instance.import_timeperiod_exceptions_from_ics_file(
|
|
form.cleaned_data['ics_file']
|
|
)
|
|
elif form.cleaned_data['ics_url']:
|
|
exceptions = form.instance.import_timeperiod_exceptions_from_remote_ics(
|
|
form.cleaned_data['ics_url']
|
|
)
|
|
except ICSError as e:
|
|
form.add_error(None, force_text(e))
|
|
return self.form_invalid(form)
|
|
|
|
if exceptions is not None:
|
|
message = ungettext(
|
|
'An exception has been imported.', '%(count)d exceptions have been imported.', exceptions
|
|
)
|
|
message = message % {'count': exceptions}
|
|
messages.info(self.request, message)
|
|
return super(DeskImportTimePeriodExceptionsView, self).form_valid(form)
|
|
|
|
|
|
desk_import_time_period_exceptions = DeskImportTimePeriodExceptionsView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionSourceDeleteView(ManagedDeskSubobjectMixin, DeleteView):
|
|
template_name = 'chrono/manager_confirm_source_delete.html'
|
|
model = TimePeriodExceptionSource
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.desk.agenda_id})
|
|
|
|
|
|
time_period_exception_source_delete = TimePeriodExceptionSourceDeleteView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionSourceReplaceView(ManagedDeskSubobjectMixin, UpdateView):
|
|
model = TimePeriodExceptionSource
|
|
form_class = TimePeriodExceptionSourceReplaceForm
|
|
template_name = 'chrono/manager_replace_exceptions.html'
|
|
|
|
def get_queryset(self):
|
|
queryset = super(TimePeriodExceptionSourceReplaceView, self).get_queryset()
|
|
return queryset.filter(ics_filename__isnull=False)
|
|
|
|
def form_valid(self, form):
|
|
exceptions = None
|
|
try:
|
|
exceptions = form.instance.desk.import_timeperiod_exceptions_from_ics_file(
|
|
form.cleaned_data['ics_newfile'], source=form.instance
|
|
)
|
|
except ICSError as e:
|
|
form.add_error(None, force_text(e))
|
|
return self.form_invalid(form)
|
|
|
|
if exceptions is not None:
|
|
message = ungettext(
|
|
'An exception has been imported.', '%(count)d exceptions have been imported.', exceptions
|
|
)
|
|
message = message % {'count': exceptions}
|
|
messages.info(self.request, message)
|
|
return super(TimePeriodExceptionSourceReplaceView, self).form_valid(form)
|
|
|
|
|
|
time_period_exception_source_replace = TimePeriodExceptionSourceReplaceView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionSourceRefreshView(ManagedDeskSubobjectMixin, DetailView):
|
|
model = TimePeriodExceptionSource
|
|
|
|
def get_queryset(self):
|
|
queryset = super(TimePeriodExceptionSourceRefreshView, self).get_queryset()
|
|
return queryset.filter(ics_url__isnull=False)
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
try:
|
|
source = self.get_object()
|
|
exceptions = source.desk.import_timeperiod_exceptions_from_remote_ics(
|
|
source.ics_url, source=source
|
|
)
|
|
except ICSError as e:
|
|
messages.error(self.request, force_text(e))
|
|
else:
|
|
message = ungettext(
|
|
'An exception has been imported.', '%(count)d exceptions have been imported.', exceptions
|
|
)
|
|
message = message % {'count': exceptions}
|
|
messages.info(self.request, message)
|
|
# redirect to settings
|
|
return HttpResponseRedirect(
|
|
reverse('chrono-manager-agenda-settings', kwargs={'pk': source.desk.agenda_id})
|
|
)
|
|
|
|
|
|
time_period_exception_source_refresh = TimePeriodExceptionSourceRefreshView.as_view()
|
|
|
|
|
|
class BookingCancelView(ViewableAgendaMixin, UpdateView):
|
|
template_name = 'chrono/manager_confirm_booking_cancellation.html'
|
|
model = Booking
|
|
pk_url_kwarg = 'booking_pk'
|
|
form_class = BookingCancelForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.booking = self.get_object()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
trigger_callback = not form.cleaned_data['disable_trigger']
|
|
try:
|
|
self.booking.cancel(trigger_callback)
|
|
except requests.RequestException as e:
|
|
form.add_error(None, _('There has been an error sending cancellation notification to form.'))
|
|
form.add_error(None, _('Check this box if you are sure you want to proceed anyway.'))
|
|
form.show_trigger_checkbox()
|
|
return self.form_invalid(form)
|
|
return HttpResponseRedirect(self.get_success_url())
|
|
|
|
def get_success_url(self):
|
|
next_url = self.request.POST.get('next')
|
|
if next_url:
|
|
return next_url
|
|
event = self.booking.event
|
|
day = event.start_datetime
|
|
return reverse(
|
|
'chrono-manager-agenda-month-view',
|
|
kwargs={'pk': event.agenda.pk, 'year': day.year, 'month': day.month},
|
|
)
|
|
|
|
|
|
booking_cancel = BookingCancelView.as_view()
|
|
|
|
|
|
class EventCancelView(ViewableAgendaMixin, UpdateView):
|
|
template_name = 'chrono/manager_confirm_event_cancellation.html'
|
|
model = Event
|
|
pk_url_kwarg = 'event_pk'
|
|
form_class = EventCancelForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.event = self.get_object()
|
|
if self.event.cancellation_status:
|
|
raise PermissionDenied()
|
|
self.cancel_bookings = False if self.request.GET.get('force_cancellation') else True
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
self.event.cancel(self.cancel_bookings)
|
|
return HttpResponseRedirect(self.get_success_url())
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['cancel_bookings'] = self.cancel_bookings
|
|
context['bookings_count'] = self.event.booking_set.filter(cancellation_datetime__isnull=True).count()
|
|
context['cancellation_forbidden'] = (
|
|
self.event.booking_set.filter(cancel_callback_url='').exclude(backoffice_url='').exists()
|
|
)
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
self.event.refresh_from_db()
|
|
if self.event.cancellation_scheduled:
|
|
messages.info(self.request, _('Event "%s" will be cancelled in a few minutes.') % self.event)
|
|
next_url = self.request.POST.get('next')
|
|
if next_url:
|
|
return next_url
|
|
day = self.event.start_datetime
|
|
return reverse(
|
|
'chrono-manager-agenda-month-view',
|
|
kwargs={'pk': self.event.agenda.pk, 'year': day.year, 'month': day.month},
|
|
)
|
|
|
|
|
|
event_cancel = EventCancelView.as_view()
|
|
|
|
|
|
class EventCancellationReportView(ViewableAgendaMixin, DetailView):
|
|
model = EventCancellationReport
|
|
template_name = 'chrono/manager_event_cancellation_report.html'
|
|
context_object_name = 'report'
|
|
pk_url_kwarg = 'report_pk'
|
|
|
|
def get(self, *args, **kwargs):
|
|
self.report = self.get_object()
|
|
self.report.seen = True
|
|
self.report.save()
|
|
return super().get(*args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
bookings = self.report.bookings.all()
|
|
errors = self.report.booking_errors
|
|
context['errors'] = {
|
|
booking: errors[str(booking.pk)] for booking in bookings if str(booking.pk) in errors
|
|
}
|
|
return context
|
|
|
|
|
|
event_cancellation_report = EventCancellationReportView.as_view()
|
|
|
|
|
|
class EventCancellationReportListView(ViewableAgendaMixin, ListView):
|
|
model = EventCancellationReport
|
|
context_object_name = 'cancellation_reports'
|
|
template_name = 'chrono/manager_event_cancellation_reports.html'
|
|
|
|
|
|
event_cancellation_report_list = EventCancellationReportListView.as_view()
|
|
|
|
|
|
class TimePeriodExceptionSourceToggleView(ManagedDeskSubobjectMixin, DetailView):
|
|
model = TimePeriodExceptionSource
|
|
|
|
def get_object(self, queryset=None):
|
|
source = super().get_object(queryset)
|
|
if source.settings_slug is None:
|
|
raise Http404('This source cannot be enabled nor disabled')
|
|
return source
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
source = self.get_object()
|
|
if source.enabled:
|
|
source.disable()
|
|
message = _('Exception source %(source)s has been disabled on desk %(desk)s.')
|
|
else:
|
|
source.enable()
|
|
message = _('Exception source %(source)s has been enabled on desk %(desk)s.')
|
|
messages.info(self.request, message % {'source': source, 'desk': source.desk})
|
|
return HttpResponseRedirect(
|
|
reverse('chrono-manager-agenda-settings', kwargs={'pk': source.desk.agenda_id})
|
|
)
|
|
|
|
|
|
time_period_exception_source_toggle = TimePeriodExceptionSourceToggleView.as_view()
|
|
|
|
|
|
class ViewableUnavailabilityCalendarMixin(object):
|
|
unavailability_calendar = None
|
|
|
|
def set_unavailability_calendar(self, **kwargs):
|
|
self.unavailability_calendar = get_object_or_404(UnavailabilityCalendar, id=kwargs.get('pk'))
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.set_unavailability_calendar(**kwargs)
|
|
if not self.check_permissions(request.user):
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def check_permissions(self, user):
|
|
return self.unavailability_calendar.can_be_viewed(user)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['unavailability_calendar'] = self.unavailability_calendar
|
|
context['user_can_manage'] = self.unavailability_calendar.can_be_managed(self.request.user)
|
|
return context
|
|
|
|
|
|
class ManagedUnavailabilityCalendarMixin(ViewableUnavailabilityCalendarMixin):
|
|
def check_permissions(self, user):
|
|
return self.unavailability_calendar.can_be_managed(user)
|
|
|
|
def get_success_url(self):
|
|
return reverse(
|
|
'chrono-manager-unavailability-calendar-settings', kwargs={'pk': self.unavailability_calendar.id}
|
|
)
|
|
|
|
|
|
class UnavailabilityCalendarListView(ListView):
|
|
template_name = 'chrono/manager_unavailability_calendar_list.html'
|
|
model = UnavailabilityCalendar
|
|
|
|
def get_queryset(self):
|
|
queryset = super().get_queryset()
|
|
if not self.request.user.is_staff:
|
|
group_ids = [x.id for x in self.request.user.groups.all()]
|
|
queryset = queryset.filter(Q(view_role_id__in=group_ids) | Q(edit_role_id__in=group_ids))
|
|
return queryset.order_by('label')
|
|
|
|
|
|
unavailability_calendar_list = UnavailabilityCalendarListView.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarAddView(CreateView):
|
|
template_name = 'chrono/manager_unavailability_calendar_form.html'
|
|
model = UnavailabilityCalendar
|
|
form_class = UnavailabilityCalendarAddForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-unavailability-calendar-view', kwargs={'pk': self.object.id})
|
|
|
|
|
|
unavailability_calendar_add = UnavailabilityCalendarAddView.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarDetailView(ViewableUnavailabilityCalendarMixin, DetailView):
|
|
template_name = 'chrono/manager_unavailability_calendar_detail.html'
|
|
model = UnavailabilityCalendar
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['agendas'] = Agenda.objects.filter(
|
|
desk__unavailability_calendars__pk=self.unavailability_calendar.pk
|
|
).distinct()
|
|
return context
|
|
|
|
|
|
unavailability_calendar_view = UnavailabilityCalendarDetailView.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarEditView(ManagedUnavailabilityCalendarMixin, UpdateView):
|
|
template_name = 'chrono/manager_unavailability_calendar_form.html'
|
|
model = UnavailabilityCalendar
|
|
form_class = UnavailabilityCalendarEditForm
|
|
|
|
|
|
unavailability_calendar_edit = UnavailabilityCalendarEditView.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarDeleteView(DeleteView):
|
|
template_name = 'chrono/manager_confirm_delete.html'
|
|
model = UnavailabilityCalendar
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
raise PermissionDenied()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
return reverse('chrono-manager-unavailability-calendar-list')
|
|
|
|
|
|
unavailability_calendar_delete = UnavailabilityCalendarDeleteView.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarSettings(ManagedUnavailabilityCalendarMixin, DetailView):
|
|
template_name = 'chrono/manager_unavailability_calendar_settings.html'
|
|
model = UnavailabilityCalendar
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(UnavailabilityCalendarSettings, self).get_context_data(**kwargs)
|
|
context['unavailability_calendar'] = self.object
|
|
return context
|
|
|
|
|
|
unavailability_calendar_settings = UnavailabilityCalendarSettings.as_view()
|
|
|
|
|
|
class UnavailabilityCalendarAddUnavailabilityView(ManagedUnavailabilityCalendarMixin, CreateView):
|
|
template_name = 'chrono/manager_time_period_exception_form.html'
|
|
form_class = TimePeriodExceptionForm
|
|
model = TimePeriodException
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
if not kwargs.get('instance'):
|
|
kwargs['instance'] = self.model()
|
|
kwargs['instance'].unavailability_calendar = self.unavailability_calendar
|
|
return kwargs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(UnavailabilityCalendarAddUnavailabilityView, self).get_context_data(**kwargs)
|
|
context['cancel_url'] = reverse(
|
|
'chrono-manager-unavailability-calendar-settings', kwargs={'pk': self.unavailability_calendar.pk,}
|
|
)
|
|
return context
|
|
|
|
|
|
unavailability_calendar_add_unavailability = UnavailabilityCalendarAddUnavailabilityView.as_view()
|
|
|
|
|
|
def menu_json(request):
|
|
label = _('Agendas')
|
|
json_str = json.dumps(
|
|
[
|
|
{
|
|
'label': force_text(label),
|
|
'slug': 'calendar',
|
|
'url': request.build_absolute_uri(reverse('chrono-manager-homepage')),
|
|
}
|
|
]
|
|
)
|
|
content_type = 'application/json'
|
|
for variable in ('jsonpCallback', 'callback'):
|
|
if variable in request.GET:
|
|
json_str = '%s(%s);' % (request.GET[variable], json_str)
|
|
content_type = 'application/javascript'
|
|
break
|
|
response = HttpResponse(content_type=content_type)
|
|
response.write(json_str)
|
|
return response
|