views.py

import json

from django.contrib import messages
from django.db.models import Count, Q
from django.http import HttpRequest, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse, reverse_lazy
from django.utils.translation import gettext as _
from django.views import View
from django.views.generic.detail import DetailView, SingleObjectMixin

from django_tables2 import SingleTableView
from reversion.views import RevisionMixin
from rules.contrib.views import PermissionRequiredMixin

from aleksis.apps.kort.forms import CardForm, CardPrinterForm, PrinterSelectForm
from aleksis.apps.kort.models import Card, CardPrinter, PrintStatus
from aleksis.apps.kort.tables import CardPrinterTable, CardTable
from aleksis.core.mixins import AdvancedCreateView, AdvancedDeleteView, AdvancedEditView
from aleksis.core.util.celery_progress import render_progress_page
from aleksis.core.views import RenderPDFView


class TestPDFView(RenderPDFView):
    template_name = "kort/pdf.html"

    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        context = self.get_context_data(**kwargs)
        return render(request, self.template_name, context)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["title"] = "Test PDF"
        return context


class PrinterSelectMixin:
    def get_context_data(self, **kwargs):
        print("Called and used?")
        context = super().get_context_data(**kwargs)
        context["printers"] = CardPrinter.objects.all()
        context["printer_form"] = PrinterSelectForm()
        return context


class CardListView(PermissionRequiredMixin, RevisionMixin, PrinterSelectMixin, SingleTableView):
    """List view for all cards."""

    permission_required = "core.view_cards_rule"
    template_name = "kort/card/list.html"
    model = Card
    table_class = CardTable


class CardCreateView(PermissionRequiredMixin, RevisionMixin, AdvancedCreateView):
    """View used to create a card."""

    permission_required = "core.create_card_rule"
    context_object_name = "application"
    template_name = "kort/card/create.html"
    form_class = CardForm
    success_message = _("The card has been created successfully.")
    success_url = reverse_lazy("cards")


class CardDeleteView(PermissionRequiredMixin, RevisionMixin, AdvancedDeleteView):
    """View used to delete a card."""

    permission_required = "core.delete_card_rule"
    success_url = reverse_lazy("cards")
    template_name = "kort/card/delete.html"
    model = Card
    success_message = _("The card has been deleted successfully.")


class CardDeactivateView(PermissionRequiredMixin, RevisionMixin, SingleObjectMixin, View):
    """View used to deactivate a card."""

    permission_required = "core.delete_card_rule"
    model = Card
    success_url = reverse_lazy("cards")

    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        self.object = self.get_object()
        self.object.deactivate()
        messages.success(request, _("The card has been deactivated successfully."))
        return redirect(self.success_url)


class CardPrintView(PermissionRequiredMixin, RevisionMixin, SingleObjectMixin, View):
    """View used to create a print job for a card."""

    permission_required = "core.delete_card_rule"
    model = Card
    success_url = reverse_lazy("cards")

    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        self.object = self.get_object()

        printer = self.request.GET.get("printer")
        printer = get_object_or_404(CardPrinter, pk=printer)

        self.object.print_card(printer)
        messages.success(
            request,
            _(
                "The print job for the card {} on the printer {} has been created successfully."
            ).format(self.object.person, printer.name),
        )

        return redirect(self.success_url)


class CardDetailView(PermissionRequiredMixin, RevisionMixin, PrinterSelectMixin, DetailView):
    permission_required = "core.view_card_rule"
    model = Card
    template_name = "kort/card/detail.html"


class CardGeneratePDFView(PermissionRequiredMixin, RevisionMixin, SingleObjectMixin, View):
    permission_required = "views.view_card_rule"
    model = Card

    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        self.object = self.get_object()

        if not self.object.chip_number:
            messages.error(request, _("The chip number is missing."))
            return redirect("cards")

        redirect_url = reverse("card", args=[self.object.pk])
        result = self.object.generate_pdf()

        if result is True:
            return redirect(redirect_url)

        return render_progress_page(
            request,
            result,
            title=_("Progress: Generate card layout as PDF file"),
            progress_title=_("Generating PDF file …"),
            success_message=_("The PDF file with the card layout has been generated successfully."),
            error_message=_("There was a problem while generating the PDF file."),
            redirect_on_success_url=redirect_url,
            button_title=_("Show card"),
            button_url=redirect_url,
            button_icon="credit_card",
        )


class CardPrinterListView(PermissionRequiredMixin, RevisionMixin, SingleTableView):
    """List view for all card printers."""

    permission_required = "core.view_cardprinters_rule"
    template_name = "kort/printer/list.html"
    model = CardPrinter
    table_class = CardPrinterTable

    def get_queryset(self):
        return CardPrinter.objects.all().annotate(
            jobs_count=Count(
                "jobs", filter=~Q(jobs__status__in=[PrintStatus.FINISHED, PrintStatus.FAILED])
            )
        )

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        CardPrinter.check_online_status_for_all()
        return context


class CardPrinterCreateView(PermissionRequiredMixin, RevisionMixin, AdvancedCreateView):
    """View used to create a card printer."""

    permission_required = "core.create_cardprinter_rule"
    template_name = "kort/printer/create.html"
    form_class = CardPrinterForm
    model = CardPrinter
    success_message = _("The card printer has been created successfully.")

    def get_success_url(self):
        return reverse("card_printer", args=[self.object.pk])


class CardPrinterEditView(PermissionRequiredMixin, RevisionMixin, AdvancedEditView):
    """View used to edit a card printer."""

    permission_required = "core.edit_cardprinter_rule"
    template_name = "kort/printer/edit.html"
    form_class = CardPrinterForm
    model = CardPrinter
    success_message = _("The card printer has been changed successfully.")

    def get_success_url(self):
        return reverse("card_printer", args=[self.object.pk])


class CardPrinterDeleteView(PermissionRequiredMixin, RevisionMixin, AdvancedDeleteView):
    """View used to delete a card printer."""

    permission_required = "core.delete_cardprinter_rule"
    success_url = reverse_lazy("card_printers")
    template_name = "kort/printer/delete.html"
    model = CardPrinter
    success_message = _("The card printer has been deleted successfully.")


class CardPrinterDetailView(PermissionRequiredMixin, RevisionMixin, DetailView):
    permission_required = "core.view_cardprinter_rule"
    model = CardPrinter
    template_name = "kort/printer/detail.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        self.object.check_online_status()
        return context


class CardPrinterConfigView(PermissionRequiredMixin, RevisionMixin, SingleObjectMixin, View):
    permission_required = "core.view_cardprinter_rule"
    model = CardPrinter

    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        self.object = self.get_object()
        response = HttpResponse(
            json.dumps(self.object.generate_config()), content_type="application/json"
        )
        response["Content-Disposition"] = f'attachment; filename="{self.object.config_filename}"'
        return response