chrono/chrono/manager/views.py

# 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 datetime
import json

from django.contrib import messages
from django.core.exceptions import PermissionDenied
from django.db.models import Q
from django.forms import ValidationError
from django.http import Http404, HttpResponse, HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.urls import reverse, reverse_lazy
from django.utils.dates import MONTHS
from django.utils.timezone import now, make_aware, make_naive
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,
)

from .forms import (
    AgendaAddForm,
    AgendaEditForm,
    NewEventForm,
    EventForm,
    NewMeetingTypeForm,
    MeetingTypeForm,
    TimePeriodForm,
    ImportEventsForm,
    NewDeskForm,
    DeskForm,
    TimePeriodExceptionForm,
    ExceptionsImportForm,
    AgendasImportForm,
    TimePeriodAddForm,
    TimePeriodExceptionSourceReplaceForm,
)
from .utils import import_site


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


homepage = HomepageView.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=True)
        except AgendaImportError as exc:
            form.add_error('agendas_json', u'%s' % exc)
            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 dispatch(self, request, *args, **kwargs):
        self.agenda = get_object_or_404(Agenda, id=kwargs.get('pk'))
        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_initial(self):
        initial = super(ManagedAgendaMixin, self).get_initial()
        initial['agenda'] = self.agenda.id
        return initial

    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()
        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):
        today = datetime.date.today()
        if self.agenda.kind == 'meetings':
            # redirect to today view
            return HttpResponseRedirect(
                reverse(
                    'chrono-manager-agenda-day-view',
                    kwargs={'pk': self.agenda.id, 'year': today.year, 'month': today.month, 'day': today.day},
                )
            )

        if self.agenda.kind == 'events':
            # redirect to monthly view, to first month where there are events,
            # otherwise to latest month with events, otherwise to this month.
            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 HttpResponseRedirect(
                reverse(
                    'chrono-manager-agenda-month-view',
                    kwargs={'pk': self.agenda.id, 'year': day.year, 'month': day.month},
                )
            )


agenda_view = AgendaView.as_view()


class AgendaDateView(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 == 'meetings':
            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):
        queryset = super(AgendaDateView, self).get_queryset()
        queryset = queryset.filter(agenda=self.agenda).prefetch_related('booking_set')
        return queryset

    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 AgendaDayView(AgendaDateView, DayArchiveView):
    template_name = 'chrono/manager_agenda_day_view.html'

    def dispatch(self, request, *args, **kwargs):
        # day view should only exist for meetings kind.
        get_object_or_404(Agenda, id=kwargs.get('pk'), kind='meetings')
        return super(AgendaDayView, self).dispatch(request, *args, **kwargs)

    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 = TimePeriod.objects.filter(desk__agenda=self.agenda, weekday=self.date.weekday(),)
        if not timeperiods:
            return

        min_timeperiod = min([x.start_time for x in timeperiods])
        max_timeperiod = max([x.end_time for x in timeperiods])

        interval = datetime.timedelta(minutes=60)
        current_date = self.date.replace(hour=min_timeperiod.hour, minute=0)
        start_date = current_date
        max_date = self.date.replace(hour=max_timeperiod.hour, minute=0)
        if max_timeperiod.minute != 0:
            # until the end of the last hour.
            max_date += datetime.timedelta(hours=1)

        desks = self.agenda.desk_set.all()

        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 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,
                            }
                        )
                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_template_names(self):
        return ['chrono/manager_%s_agenda_month_view.html' % self.agenda.kind]

    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 = TimePeriod.objects.filter(desk__agenda=self.agenda)
        if not timeperiods:
            return

        hide_sunday = not timeperiods.filter(weekday=6).exists()
        hide_weekend = hide_sunday and not timeperiods.filter(weekday=5).exists()
        # 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]
        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,
                timeperiods,
                week_end_offset=int(hide_sunday) + int(hide_weekend),
            )

    def get_week_timetable_infos(self, week_index, timeperiods, week_end_offset=0):

        date = self.date + datetime.timedelta(week_index * 7)
        year, week_number, dow = date.isocalendar()
        start_date = date - datetime.timedelta(dow)

        self.min_timeperiod = min([x.start_time for x in timeperiods])
        self.max_timeperiod = max([x.end_time for x in timeperiods])
        interval = datetime.timedelta(minutes=60)

        period = self.date.replace(hour=self.min_timeperiod.hour, minute=0)
        max_date = self.date.replace(hour=self.max_timeperiod.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_timeperiod.hour, minute=0)
        timetable = {
            'date': current_date,
            'today': day.date() == datetime.date.today(),
            'other_month': day.month != self.date.month,
            'infos': {'opening_hours': [], 'booked_slots': []},
        }

        desks = self.agenda.desk_set.all()
        desks_len = len(desks)
        max_date = day.replace(hour=self.max_timeperiod.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 hour in desk.get_opening_hours(current_date):
                        timetable['infos']['opening_hours'].append(
                            {
                                'css_top': 100 * (hour.begin - current_date).seconds // 3600,
                                'css_height': 100 * (hour.end - hour.begin).seconds // 3600,
                                'css_width': width,
                                'css_left': left,
                            }
                        )
                left += width + 1
            period += interval

        return timetable


agenda_monthly_view = AgendaMonthView.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_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_initial(self):
        initial = super(ManagedDeskMixin, self).get_initial()
        initial['desk'] = self.desk
        return initial

    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 AgendaSettings(ManagedAgendaMixin, DetailView):
    model = Agenda

    def get_context_data(self, **kwargs):
        context = super(AgendaSettings, self).get_context_data(**kwargs)
        context['user_can_manage'] = True
        return context

    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')
        json.dump({'agendas': [self.get_object().export_json()]}, response, indent=2)
        return response


agenda_export = AgendaExport.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 get_form_kwargs(self):
        kwargs = super(AgendaImportEventsView, self).get_form_kwargs()
        kwargs['agenda_pk'] = self.kwargs['pk']
        return kwargs

    def form_valid(self, form):
        if form.events:
            for event in form.events:
                event.agenda_id = self.kwargs['pk']
                if event.slug and Event.objects.filter(agenda_id=event.agenda_id, slug=event.slug).exists():
                    raise ValidationError(_('Duplicated event identifier'))
                event.save()
            messages.info(self.request, _('%d events have been imported.') % len(form.events))
        return super(AgendaImportEventsView, self).form_valid(form)


agenda_import_events = AgendaImportEventsView.as_view()


class EventDetailView(ViewableAgendaMixin, DetailView):
    template_name = 'chrono/manager_event_detail.html'
    model = Event
    pk_url_kwarg = 'event_pk'

    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
        )
        context['waiting'] = event.booking_set.filter(
            cancellation_datetime__isnull=True, in_waiting_list=True
        )
        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 AgendaAddMeetingTypeView(ManagedAgendaMixin, CreateView):
    template_name = 'chrono/manager_meeting_type_form.html'
    model = Event
    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


meeting_type_delete = MeetingTypeDeleteView.as_view()


class AgendaAddTimePeriodView(ManagedDeskMixin, FormView):
    template_name = 'chrono/manager_time_period_form.html'
    form_class = TimePeriodAddForm

    def form_valid(self, form):
        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'],
                desk=self.desk,
            )
            period.save()
        return super(AgendaAddTimePeriodView, self).form_valid(form)


agenda_add_time_period = AgendaAddTimePeriodView.as_view()


class TimePeriodEditView(ManagedDeskSubobjectMixin, UpdateView):
    template_name = 'chrono/manager_time_period_form.html'
    model = TimePeriod
    form_class = TimePeriodForm


time_period_edit = TimePeriodEditView.as_view()


class TimePeriodDeleteView(ManagedDeskSubobjectMixin, 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()
        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 AgendaAddTimePeriodExceptionView(ManagedDeskMixin, CreateView):
    template_name = 'chrono/manager_time_period_exception_form.html'
    model = TimePeriodException
    form_class = TimePeriodExceptionForm


agenda_add_time_period_exception = AgendaAddTimePeriodExceptionView.as_view()


class TimePeriodExceptionEditView(ManagedDeskSubobjectMixin, UpdateView):
    template_name = 'chrono/manager_time_period_exception_form.html'
    model = TimePeriodException
    form_class = TimePeriodExceptionForm


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

    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(ManagedDeskSubobjectMixin, DeleteView):
    template_name = 'chrono/manager_confirm_exception_delete.html'
    model = TimePeriodException

    def get_success_url(self):
        referer = self.request.META.get('HTTP_REFERER')
        success_url = reverse('chrono-manager-time-period-exception-list', kwargs={'pk': self.desk.agenda_id})
        if success_url in referer:
            return success_url

        return super(TimePeriodExceptionDeleteView, self).get_success_url()


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)
        context['exception_sources'] = self.get_object().timeperiodexceptionsource_set.all()
        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 form_valid(self, form):
        exceptions = None
        try:
            exceptions = form.instance.desk.import_timeperiod_exceptions_from_ics_file(
                form.cleaned_data['ics_file'], 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(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()


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