lingo/lingo/pricing/views.py

# lingo - payment and billing system
# Copyright (C) 2022  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 collections import defaultdict
from operator import itemgetter

from django import forms
from django.contrib import messages
from django.db.models import Prefetch
from django.http import Http404, HttpResponse, HttpResponseBadRequest, HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.urls import reverse, reverse_lazy
from django.utils.encoding import force_text
from django.utils.translation import ugettext_lazy as _
from django.utils.translation import ungettext
from django.views.generic import (
    CreateView,
    DeleteView,
    DetailView,
    FormView,
    ListView,
    RedirectView,
    UpdateView,
)
from django.views.generic.detail import SingleObjectMixin

from lingo.agendas.chrono import refresh_agendas
from lingo.agendas.models import Agenda, CheckType, CheckTypeGroup
from lingo.agendas.views import AgendaMixin
from lingo.pricing.forms import (
    AgendaPricingForm,
    CheckTypeForm,
    CriteriaForm,
    ExportForm,
    ImportForm,
    NewCheckTypeForm,
    NewCriteriaForm,
    PricingCriteriaCategoryAddForm,
    PricingCriteriaCategoryEditForm,
    PricingDuplicateForm,
    PricingMatrixForm,
    PricingVariableFormSet,
)
from lingo.pricing.models import AgendaPricing, Criteria, CriteriaCategory, Pricing, PricingCriteriaCategory
from lingo.pricing.utils import export_site, import_site
from lingo.utils.misc import AgendaImportError


class ConfigExportView(FormView):
    form_class = ExportForm
    template_name = 'lingo/pricing/export.html'

    def form_valid(self, form):
        response = HttpResponse(content_type='application/json')
        today = datetime.date.today()
        response['Content-Disposition'] = 'attachment; filename="export_pricing_config_{}.json"'.format(
            today.strftime('%Y%m%d')
        )
        json.dump(export_site(**form.cleaned_data), response, indent=2)
        return response


config_export = ConfigExportView.as_view()


class ConfigImportView(FormView):
    form_class = ImportForm
    template_name = 'lingo/pricing/import.html'
    success_url = reverse_lazy('lingo-manager-pricing-list')

    def form_valid(self, form):
        try:
            config_json = json.loads(force_text(self.request.FILES['config_json'].read()))
        except ValueError:
            form.add_error('config_json', _('File is not in the expected JSON format.'))
            return self.form_invalid(form)

        try:
            results = import_site(config_json, overwrite=False)
        except AgendaImportError as exc:
            form.add_error('config_json', '%s' % exc)
            return self.form_invalid(form)
        except KeyError as exc:
            form.add_error('config_json', _('Key "%s" is missing.') % exc.args[0])
            return self.form_invalid(form)

        import_messages = {
            'agendas': {
                'update_noop': _('No agenda updated.'),
                'update': lambda x: ungettext(
                    'An agenda has been updated.',
                    '%(count)d agendas have been updated.',
                    x,
                ),
            },
            'check_type_groups': {
                'create_noop': _('No check type group created.'),
                'create': lambda x: ungettext(
                    'A check type group has been created.',
                    '%(count)d check type groups have been created.',
                    x,
                ),
                'update_noop': _('No check type group updated.'),
                'update': lambda x: ungettext(
                    'A check type group has been updated.',
                    '%(count)d check type groups have been updated.',
                    x,
                ),
            },
            'pricing_categories': {
                'create_noop': _('No pricing criteria category created.'),
                'create': lambda x: ungettext(
                    'A pricing criteria category has been created.',
                    '%(count)d pricing criteria categories have been created.',
                    x,
                ),
                'update_noop': _('No pricing criteria category updated.'),
                'update': lambda x: ungettext(
                    'A pricing criteria category has been updated.',
                    '%(count)d pricing criteria categories have been updated.',
                    x,
                ),
            },
            'pricing_models': {
                'create_noop': _('No pricing model created.'),
                'create': lambda x: ungettext(
                    'A pricing model has been created.',
                    '%(count)d pricing models have been created.',
                    x,
                ),
                'update_noop': _('No pricing model updated.'),
                'update': lambda x: ungettext(
                    'A pricing model has been updated.',
                    '%(count)d pricing models have been updated.',
                    x,
                ),
            },
        }

        global_noop = True
        for obj_name, obj_results in results.items():
            if obj_results['all']:
                global_noop = False
                count = len(obj_results['created'])
                if not count:
                    message1 = import_messages[obj_name].get('create_noop')
                else:
                    message1 = import_messages[obj_name]['create'](count) % {'count': count}

                count = len(obj_results['updated'])
                if not count:
                    message2 = import_messages[obj_name]['update_noop']
                else:
                    message2 = import_messages[obj_name]['update'](count) % {'count': count}

                obj_results['messages'] = "%s %s" % (message1, message2)

        a_count, ct_count, pc_count, pm_count = (
            len(results['agendas']['all']),
            len(results['check_type_groups']['all']),
            len(results['pricing_categories']['all']),
            len(results['pricing_models']['all']),
        )
        if (a_count, ct_count, pc_count, pm_count) == (1, 0, 0, 0):
            # only one agenda imported, redirect to agenda page
            return HttpResponseRedirect(
                reverse(
                    'lingo-manager-agenda-detail',
                    kwargs={'pk': results['agendas']['all'][0].pk},
                )
            )
        if (a_count, ct_count, pc_count, pm_count) == (0, 1, 0, 0):
            # only one check type group imported, redirect to check type page
            return HttpResponseRedirect(reverse('lingo-manager-check-type-list'))
        if (a_count, ct_count, pc_count, pm_count) == (0, 0, 1, 0):
            # only one criteria category imported, redirect to criteria page
            return HttpResponseRedirect(reverse('lingo-manager-pricing-criteria-list'))
        if (a_count, ct_count, pc_count, pm_count) == (0, 0, 0, 1):
            # only one pricing imported, redirect to pricing page
            return HttpResponseRedirect(
                reverse(
                    'lingo-manager-pricing-detail',
                    kwargs={'pk': results['pricing_models']['all'][0].pk},
                )
            )

        if global_noop:
            messages.info(self.request, _('No data found.'))
        else:
            messages.info(self.request, results['agendas']['messages'])
            messages.info(self.request, results['check_type_groups']['messages'])
            messages.info(self.request, results['pricing_categories']['messages'])
            messages.info(self.request, results['pricing_models']['messages'])

        return super().form_valid(form)


config_import = ConfigImportView.as_view()


class PricingListView(ListView):
    template_name = 'lingo/pricing/manager_pricing_list.html'
    model = Pricing


pricing_list = PricingListView.as_view()


class CriteriaListView(ListView):
    template_name = 'lingo/pricing/manager_criteria_list.html'
    model = CriteriaCategory

    def get_queryset(self):
        return CriteriaCategory.objects.prefetch_related('criterias')


criteria_list = CriteriaListView.as_view()


class PricingAddView(CreateView):
    template_name = 'lingo/pricing/manager_pricing_form.html'
    model = Pricing
    fields = ['label']

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', args=[self.object.pk])


pricing_add = PricingAddView.as_view()


class PricingDetailView(DetailView):
    template_name = 'lingo/pricing/manager_pricing_detail.html'
    model = Pricing

    def get_queryset(self):
        return (
            super()
            .get_queryset()
            .prefetch_related(
                Prefetch(
                    'categories', queryset=CriteriaCategory.objects.order_by('pricingcriteriacategory__order')
                )
            )
        )

    def get_context_data(self, **kwargs):
        kwargs['agendas'] = Agenda.objects.filter(
            pk__in=AgendaPricing.objects.filter(pricing=self.object).values('agenda')
        )
        return super().get_context_data(**kwargs)


pricing_detail = PricingDetailView.as_view()


class PricingEditView(UpdateView):
    template_name = 'lingo/pricing/manager_pricing_form.html'
    model = Pricing
    fields = ['label', 'slug']

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', args=[self.object.pk])


pricing_edit = PricingEditView.as_view()


class PricingDeleteView(DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = Pricing

    def get_success_url(self):
        return reverse('lingo-manager-pricing-list')


pricing_delete = PricingDeleteView.as_view()


class PricingDuplicate(SingleObjectMixin, FormView):
    template_name = 'lingo/pricing/manager_pricing_duplicate_form.html'
    model = Pricing
    form_class = PricingDuplicateForm

    def dispatch(self, request, *args, **kwargs):
        self.object = self.get_object()
        return super().dispatch(request, *args, **kwargs)

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', kwargs={'pk': self.new_pricing.pk})

    def form_valid(self, form):
        self.new_pricing = self.object.duplicate(label=form.cleaned_data['label'])
        return super().form_valid(form)


pricing_duplicate = PricingDuplicate.as_view()


class PricingExport(DetailView):
    model = Pricing

    def get(self, request, *args, **kwargs):
        response = HttpResponse(content_type='application/json')
        today = datetime.date.today()
        attachment = 'attachment; filename="export_pricing_{}_{}.json"'.format(
            self.get_object().slug, today.strftime('%Y%m%d')
        )
        response['Content-Disposition'] = attachment
        json.dump({'pricing_models': [self.get_object().export_json()]}, response, indent=2)
        return response


pricing_export = PricingExport.as_view()


class PricingVariableEdit(FormView):
    template_name = 'lingo/pricing/manager_pricing_variable_form.html'
    model = Pricing
    form_class = PricingVariableFormSet

    def dispatch(self, request, *args, **kwargs):
        self.object = get_object_or_404(Pricing, pk=kwargs['pk'])
        return super().dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        kwargs['object'] = self.object
        return super().get_context_data(**kwargs)

    def get_initial(self):
        return sorted(
            ({'key': k, 'value': v} for k, v in self.object.extra_variables.items()),
            key=itemgetter('key'),
        )

    def form_valid(self, form):
        self.object.extra_variables = {}
        for sub_data in form.cleaned_data:
            if not sub_data.get('key'):
                continue
            self.object.extra_variables[sub_data['key']] = sub_data['value']
        self.object.save()
        return HttpResponseRedirect(self.get_success_url())

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', args=[self.object.pk])


pricing_variable_edit = PricingVariableEdit.as_view()


class PricingCriteriaCategoryAddView(FormView):
    template_name = 'lingo/pricing/manager_pricing_criteria_category_form.html'
    model = Pricing
    form_class = PricingCriteriaCategoryAddForm

    def dispatch(self, request, *args, **kwargs):
        self.object = get_object_or_404(Pricing, pk=kwargs['pk'])
        if self.object.categories.count() >= 3:
            raise Http404
        return super().dispatch(request, *args, **kwargs)

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['pricing'] = self.object
        return kwargs

    def get_context_data(self, **kwargs):
        kwargs['object'] = self.object
        return super().get_context_data(**kwargs)

    def form_valid(self, form):
        PricingCriteriaCategory.objects.create(pricing=self.object, category=form.cleaned_data['category'])
        return super().form_valid(form)

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', args=[self.object.pk])


pricing_criteria_category_add = PricingCriteriaCategoryAddView.as_view()


class PricingCriteriaCategoryEditView(FormView):
    template_name = 'lingo/pricing/manager_pricing_criteria_category_form.html'
    model = Pricing
    form_class = PricingCriteriaCategoryEditForm

    def dispatch(self, request, *args, **kwargs):
        self.object = get_object_or_404(Pricing, pk=kwargs['pk'])
        self.category = get_object_or_404(self.object.categories, pk=kwargs['category_pk'])
        return super().dispatch(request, *args, **kwargs)

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['pricing'] = self.object
        kwargs['category'] = self.category
        return kwargs

    def get_context_data(self, **kwargs):
        kwargs['object'] = self.object
        kwargs['category'] = self.category
        return super().get_context_data(**kwargs)

    def form_valid(self, form):
        old_criterias = self.object.criterias.filter(category=self.category)
        new_criterias = form.cleaned_data['criterias']
        removed_criterias = set(old_criterias) - set(new_criterias)
        self.object.criterias.remove(*removed_criterias)
        self.object.criterias.add(*new_criterias)
        return super().form_valid(form)

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', args=[self.object.pk])


pricing_criteria_category_edit = PricingCriteriaCategoryEditView.as_view()


class PricingCriteriaCategoryDeleteView(DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = CriteriaCategory
    pk_url_kwarg = 'category_pk'

    def dispatch(self, request, *args, **kwargs):
        self.pricing = get_object_or_404(Pricing, pk=kwargs['pk'])
        return super().dispatch(request, *args, **kwargs)

    def get_queryset(self):
        return self.pricing.categories.all()

    def delete(self, request, *args, **kwargs):
        self.object = self.get_object()
        self.pricing.categories.remove(self.object)
        self.pricing.criterias.remove(*self.pricing.criterias.filter(category=self.object))
        return HttpResponseRedirect(self.get_success_url())

    def get_success_url(self):
        return reverse('lingo-manager-pricing-detail', args=[self.pricing.pk])


pricing_criteria_category_delete = PricingCriteriaCategoryDeleteView.as_view()


class PricingCriteriaCategoryOrder(DetailView):
    model = Pricing

    def get(self, request, *args, **kwargs):
        if 'new-order' not in request.GET:
            return HttpResponseBadRequest('missing new-order parameter')
        pricing = self.get_object()
        try:
            new_order = [int(x) for x in request.GET['new-order'].split(',')]
        except ValueError:
            return HttpResponseBadRequest('incorrect new-order parameter')
        categories = pricing.categories.all()
        if set(new_order) != {x.pk for x in categories} or len(new_order) != len(categories):
            return HttpResponseBadRequest('incorrect new-order parameter')
        for i, c_id in enumerate(new_order):
            PricingCriteriaCategory.objects.filter(pricing=pricing, category=c_id).update(order=i + 1)
        return HttpResponse(status=204)


pricing_criteria_category_order = PricingCriteriaCategoryOrder.as_view()


class CriteriaCategoryAddView(CreateView):
    template_name = 'lingo/pricing/manager_criteria_category_form.html'
    model = CriteriaCategory
    fields = ['label']

    def get_success_url(self):
        return reverse('lingo-manager-pricing-criteria-list')


criteria_category_add = CriteriaCategoryAddView.as_view()


class CriteriaCategoryEditView(UpdateView):
    template_name = 'lingo/pricing/manager_criteria_category_form.html'
    model = CriteriaCategory
    fields = ['label', 'slug']

    def get_success_url(self):
        return reverse('lingo-manager-pricing-criteria-list')


criteria_category_edit = CriteriaCategoryEditView.as_view()


class CriteriaCategoryDeleteView(DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = CriteriaCategory

    def get_success_url(self):
        return reverse('lingo-manager-pricing-criteria-list')


criteria_category_delete = CriteriaCategoryDeleteView.as_view()


class CriteriaCategoryExport(DetailView):
    model = CriteriaCategory

    def get(self, request, *args, **kwargs):
        response = HttpResponse(content_type='application/json')
        today = datetime.date.today()
        attachment = 'attachment; filename="export_pricing_category_{}_{}.json"'.format(
            self.get_object().slug, today.strftime('%Y%m%d')
        )
        response['Content-Disposition'] = attachment
        json.dump({'pricing_categories': [self.get_object().export_json()]}, response, indent=2)
        return response


criteria_category_export = CriteriaCategoryExport.as_view()


class CriteriaOrder(DetailView):
    model = CriteriaCategory

    def get(self, request, *args, **kwargs):
        if 'new-order' not in request.GET:
            return HttpResponseBadRequest('missing new-order parameter')
        category = self.get_object()
        try:
            new_order = [int(x) for x in request.GET['new-order'].split(',')]
        except ValueError:
            return HttpResponseBadRequest('incorrect new-order parameter')
        criterias = category.criterias.filter(default=False)
        if set(new_order) != {x.pk for x in criterias} or len(new_order) != len(criterias):
            return HttpResponseBadRequest('incorrect new-order parameter')
        criterias_by_id = {c.pk: c for c in criterias}
        for i, c_id in enumerate(new_order):
            criterias_by_id[c_id].order = i + 1
            criterias_by_id[c_id].save()
        return HttpResponse(status=204)


criteria_order = CriteriaOrder.as_view()


class CriteriaAddView(CreateView):
    template_name = 'lingo/pricing/manager_criteria_form.html'
    model = Criteria
    form_class = NewCriteriaForm

    def dispatch(self, request, *args, **kwargs):
        self.category_pk = kwargs.pop('category_pk')
        return super().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'].category_id = self.category_pk
        return kwargs

    def get_success_url(self):
        return reverse('lingo-manager-pricing-criteria-list')


criteria_add = CriteriaAddView.as_view()


class CriteriaEditView(UpdateView):
    template_name = 'lingo/pricing/manager_criteria_form.html'
    model = Criteria
    form_class = CriteriaForm

    def dispatch(self, request, *args, **kwargs):
        self.category_pk = kwargs.pop('category_pk')
        return super().dispatch(request, *args, **kwargs)

    def get_queryset(self):
        return Criteria.objects.filter(category=self.category_pk)

    def get_success_url(self):
        return reverse('lingo-manager-pricing-criteria-list')


criteria_edit = CriteriaEditView.as_view()


class CriteriaDeleteView(DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = Criteria

    def dispatch(self, request, *args, **kwargs):
        self.category_pk = kwargs.pop('category_pk')
        return super().dispatch(request, *args, **kwargs)

    def get_queryset(self):
        return Criteria.objects.filter(category=self.category_pk)

    def get_success_url(self):
        return reverse('lingo-manager-pricing-criteria-list')


criteria_delete = CriteriaDeleteView.as_view()


class AgendaListView(ListView):
    template_name = 'lingo/pricing/manager_agenda_list.html'
    model = Agenda

    def get_queryset(self):
        queryset = super().get_queryset()
        return queryset.order_by('category_label', 'label')


agenda_list = AgendaListView.as_view()


class AgendaSyncView(RedirectView):
    def get(self, request, *args, **kwargs):
        refresh_agendas()
        messages.info(self.request, _('Agendas refreshed.'))
        return super().get(request, *args, **kwargs)

    def get_redirect_url(self, *args, **kwargs):
        return reverse('lingo-manager-agenda-list')


agenda_sync = AgendaSyncView.as_view()


class AgendaDetailView(AgendaMixin, DetailView):
    template_name = 'lingo/pricing/manager_agenda_detail.html'
    model = Agenda

    def get_context_data(self, **kwargs):
        kwargs['agenda_pricings'] = (
            AgendaPricing.objects.filter(agenda=self.agenda)
            .select_related('pricing')
            .order_by('date_start', 'date_end')
        )
        return super().get_context_data(**kwargs)


agenda_detail = AgendaDetailView.as_view()


class AgendaDetailRedirectView(RedirectView):
    def get_redirect_url(self, *args, **kwargs):
        agenda = get_object_or_404(Agenda, slug=kwargs['slug'])
        return reverse('lingo-manager-agenda-detail', kwargs={'pk': agenda.pk})


agenda_detail_redirect = AgendaDetailRedirectView.as_view()


class AgendaExport(AgendaMixin, 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_pricing_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 AgendaBookingCheckSettingsView(AgendaMixin, UpdateView):
    template_name = 'lingo/pricing/manager_agenda_form.html'
    model = Agenda
    fields = ['check_type_group']

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['form_url'] = reverse('lingo-manager-agenda-booking-check-settings', args=[self.agenda.pk])
        context['title'] = _("Configure booking check options")
        return context


agenda_booking_check_settings = AgendaBookingCheckSettingsView.as_view()


class AgendaPricingAddView(AgendaMixin, CreateView):
    template_name = 'lingo/pricing/manager_agenda_pricing_form.html'
    model = AgendaPricing
    form_class = AgendaPricingForm

    def get_success_url(self):
        return reverse('lingo-manager-agenda-pricing-detail', args=[self.agenda.pk, self.object.pk])


agenda_pricing_add = AgendaPricingAddView.as_view()


class AgendaPricingDetailView(AgendaMixin, DetailView):
    model = AgendaPricing
    pk_url_kwarg = 'pricing_pk'
    template_name = 'lingo/pricing/manager_agenda_pricing_detail.html'

    def get_queryset(self):
        return AgendaPricing.objects.filter(agenda=self.agenda).prefetch_related(
            'pricing__criterias__category'
        )


agenda_pricing_detail = AgendaPricingDetailView.as_view()


class AgendaPricingEditView(AgendaMixin, UpdateView):
    template_name = 'lingo/pricing/manager_agenda_pricing_form.html'
    model = AgendaPricing
    pk_url_kwarg = 'pricing_pk'
    form_class = AgendaPricingForm

    def get_queryset(self):
        return AgendaPricing.objects.filter(agenda=self.agenda)

    def get_success_url(self):
        return reverse('lingo-manager-agenda-pricing-detail', args=[self.agenda.pk, self.object.pk])


agenda_pricing_edit = AgendaPricingEditView.as_view()


class AgendaPricingDeleteView(AgendaMixin, DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = AgendaPricing
    pk_url_kwarg = 'pricing_pk'

    def get_queryset(self):
        return AgendaPricing.objects.filter(agenda=self.agenda)


agenda_pricing_delete = AgendaPricingDeleteView.as_view()


class AgendaPricingMatrixEdit(AgendaMixin, FormView):
    template_name = 'lingo/pricing/manager_agenda_pricing_matrix_form.html'

    def set_agenda(self, **kwargs):
        super().set_agenda(**kwargs)
        self.object = get_object_or_404(
            AgendaPricing.objects.filter(agenda=self.agenda), pk=kwargs['pricing_pk']
        )
        matrix_list = list(self.object.iter_pricing_matrix())
        if not matrix_list:
            raise Http404
        self.matrix = None
        if kwargs.get('slug'):
            for matrix in matrix_list:
                if matrix.criteria is None:
                    continue
                if matrix.criteria.slug == kwargs['slug']:
                    self.matrix = matrix
                    break
        else:
            if matrix_list[0].criteria is None:
                self.matrix = matrix_list[0]
        if self.matrix is None:
            raise Http404

    def get_context_data(self, **kwargs):
        kwargs['object'] = self.object
        kwargs['matrix'] = self.matrix
        return super().get_context_data(**kwargs)

    def get_form(self):
        count = len(self.matrix.rows)
        PricingMatrixFormSet = forms.formset_factory(
            PricingMatrixForm, min_num=count, max_num=count, extra=0, can_delete=False
        )
        kwargs = {
            'initial': [
                {'crit_%i' % i: cell.value for i, cell in enumerate(row.cells)} for row in self.matrix.rows
            ]
        }
        if self.request.method == 'POST':
            kwargs.update(
                {
                    'data': self.request.POST,
                }
            )
        return PricingMatrixFormSet(form_kwargs={'matrix': self.matrix}, **kwargs)

    def post(self, *args, **kwargs):
        form = self.get_form()
        if form.is_valid():
            # build prixing_data for this matrix
            matrix_pricing_data = defaultdict(dict)
            for i, sub_data in enumerate(form.cleaned_data):
                row = self.matrix.rows[i]
                for j, cell in enumerate(row.cells):
                    value = sub_data['crit_%s' % j]
                    key = cell.criteria.identifier if cell.criteria else None
                    matrix_pricing_data[key][row.criteria.identifier] = float(value)
            if self.matrix.criteria:
                # full pricing model with 3 categories
                self.object.pricing_data = self.object.pricing_data or {}
                self.object.pricing_data[self.matrix.criteria.identifier] = matrix_pricing_data
            elif list(matrix_pricing_data.keys()) == [None]:
                # only one category
                self.object.pricing_data = matrix_pricing_data[None]
            else:
                # 2 categories
                self.object.pricing_data = matrix_pricing_data
            self.object.save()
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def get_success_url(self):
        return reverse('lingo-manager-agenda-pricing-detail', args=[self.agenda.pk, self.object.pk])


agenda_pricing_matrix_edit = AgendaPricingMatrixEdit.as_view()


class CheckTypeListView(ListView):
    template_name = 'lingo/pricing/manager_check_type_list.html'
    model = CheckTypeGroup

    def get_queryset(self):
        return CheckTypeGroup.objects.prefetch_related('check_types')


check_type_list = CheckTypeListView.as_view()


class CheckTypeGroupAddView(CreateView):
    template_name = 'lingo/pricing/manager_check_type_group_form.html'
    model = CheckTypeGroup
    fields = ['label']

    def get_success_url(self):
        return reverse('lingo-manager-check-type-list')


check_type_group_add = CheckTypeGroupAddView.as_view()


class CheckTypeGroupEditView(UpdateView):
    template_name = 'lingo/pricing/manager_check_type_group_form.html'
    model = CheckTypeGroup
    fields = ['label', 'slug']

    def get_success_url(self):
        return reverse('lingo-manager-check-type-list')


check_type_group_edit = CheckTypeGroupEditView.as_view()


class CheckTypeGroupDeleteView(DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = CheckTypeGroup

    def get_success_url(self):
        return reverse('lingo-manager-check-type-list')


check_type_group_delete = CheckTypeGroupDeleteView.as_view()


class CheckTypeGroupExport(DetailView):
    model = CheckTypeGroup

    def get(self, request, *args, **kwargs):
        response = HttpResponse(content_type='application/json')
        today = datetime.date.today()
        attachment = 'attachment; filename="export_check_type_group_{}_{}.json"'.format(
            self.get_object().slug, today.strftime('%Y%m%d')
        )
        response['Content-Disposition'] = attachment
        json.dump({'check_type_groups': [self.get_object().export_json()]}, response, indent=2)
        return response


check_type_group_export = CheckTypeGroupExport.as_view()


class CheckTypeAddView(CreateView):
    template_name = 'lingo/pricing/manager_check_type_form.html'
    model = CheckType
    form_class = NewCheckTypeForm

    def dispatch(self, request, *args, **kwargs):
        self.group_pk = kwargs.pop('group_pk')
        return super().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'].group_id = self.group_pk
        return kwargs

    def get_success_url(self):
        return reverse('lingo-manager-check-type-list')


check_type_add = CheckTypeAddView.as_view()


class CheckTypeEditView(UpdateView):
    template_name = 'lingo/pricing/manager_check_type_form.html'
    model = CheckType
    form_class = CheckTypeForm

    def dispatch(self, request, *args, **kwargs):
        self.group_pk = kwargs.pop('group_pk')
        return super().dispatch(request, *args, **kwargs)

    def get_queryset(self):
        return CheckType.objects.filter(group=self.group_pk)

    def get_success_url(self):
        return reverse('lingo-manager-check-type-list')


check_type_edit = CheckTypeEditView.as_view()


class CheckTypeDeleteView(DeleteView):
    template_name = 'lingo/manager_confirm_delete.html'
    model = CheckType

    def dispatch(self, request, *args, **kwargs):
        self.group_pk = kwargs.pop('group_pk')
        return super().dispatch(request, *args, **kwargs)

    def get_queryset(self):
        return CheckType.objects.filter(group=self.group_pk)

    def get_success_url(self):
        return reverse('lingo-manager-check-type-list')


check_type_delete = CheckTypeDeleteView.as_view()