web2.0-backend/kaehmy/views.py

from django.db.models import Count
from django.shortcuts import render, redirect
from django.contrib.auth import login, logout, authenticate
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import ensure_csrf_cookie
from django.http import HttpResponse, HttpResponseRedirect
from django.contrib.auth.decorators import permission_required, login_required
from django.conf import settings

import logging
import requests
from dealer.git import git
from sikweb.settings import URL

from members.views.utils import *
from kaehmy.models import Application, CustomRole, PresetRole
from kaehmy.forms import ApplicationForm, CommentForm
from kaehmy.tables import ExportTable
from webapp.utils import send_email
from webapp.models import processHooks


@ensure_csrf_cookie
@require_http_methods(["GET"])
def list_view(request, *args, **kwargs):
    """Kaehmy application list"""

    role_filter = request.GET.get("role", None)
    if role_filter is not None and str(role_filter) != "-1":
        applications = Application.objects.filter(
            custom_roles__id=role_filter
        ) | Application.objects.filter(preset_roles__id=role_filter)
    else:
        applications = Application.objects.all()

    applications = applications.order_by("-timestamp")
    filter_options_preset = PresetRole.objects.annotate(
        form_count=Count("forms")
    ).filter(form_count__gt=0)
    filter_options_preset_list = [
        (r.id, r.name, r.form_count) for r in filter_options_preset
    ]
    filter_options_custom = CustomRole.objects.annotate(
        form_count=Count("forms")
    ).filter(form_count__gt=0)
    filter_options_custom_list = [
        (r.id, r.name, r.form_count) for r in filter_options_custom
    ]

    filter_options = filter_options_preset_list + filter_options_custom_list
    filter_options.sort(key=lambda f: f[1])

    context = {
        "applications": applications,
        "application_count": len(applications),
        "filter_options": filter_options,
    }

    return render(request, "kaehmy:list.html", context)


@ensure_csrf_cookie
@require_http_methods(["POST"])
def comment(request, *args, **kwargs):
    """POST endpoint for commenting"""

    form = CommentForm(request.POST)
    if form.is_valid():
        comment = form.save()
        name = comment.name

        to_email = comment.parent.email
        subject = "Kaehmyysi tai kommenttiisi on vastattu!"
        email_body = (
            f"{name.capitalize()} on vastannut kaehmyhakemukseesi tai kommenttiisi kaehmypalvelussa.\r\n\r\n"
            "Käy lukemassa viesti osoitteessa https://{URL}/kaehmy"
        )
        send_email(to=to_email, subject=subject, body=email_body)
        logging.debug(f"Sent kaehmy comment email to recipient <{to_email}>")

        return redirect("/kaehmy")
    else:
        context = {"error": form.errors}
        return render(request, "kaehmy:error.html", context)


@require_http_methods(["GET"])
def statistics_view(request, *args, **kwargs):
    """Kaehmys roles listed by applications"""

    applications = Application.objects.all()
    role_list = []

    preset_roles = PresetRole.objects.all()
    custom_roles = CustomRole.objects.all()

    for preset in preset_roles:
        people = [form.name for form in preset.forms.all()]
        role_list.append((preset.name, len(people), ", ".join(people)))
    for custom in custom_roles:
        people = [form.name for form in custom.forms.all()]
        role_list.append((custom.name, len(people), ", ".join(people)))

    context = {
        "applications": applications,
        "application_count": len(applications),
        "role_list": role_list,
    }
    return render(request, "kaehmy:statistics.html", context)


@require_http_methods(["GET"])
def view(request, *args, **kwargs):
    """Render Kaehmy form page."""
    form = ApplicationForm()
    return render(request, "kaehmy:kaehmy.html", {"form": form})


@ensure_csrf_cookie
@require_http_methods(["POST"])
def submit(request, *args, **kwargs):
    """Submit Kaehmy form."""
    form = ApplicationForm(request.POST)
    if form.is_valid():
        application = form.save()
        custom_name = form.cleaned_data.get("custom_role_name")
        custom_is_board = form.cleaned_data.get("custom_role_is_board")

        if len(custom_name) > 0:
            custom_role = CustomRole(name=custom_name, is_board=custom_is_board)
            custom_role.save()
            application.custom_roles.add(custom_role)

        url = f"https://{URL}/kaehmy"
        name = form.cleaned_data.get("name", "Anonymous")
        email_body = (
            f"Moikka {name}!\r\n\r\nHienoa, että kilta kiinnostaa! Kaehmysi on vastaanotettu.\r\n"
            "Mahdollisista kommenteista tulee ilmoitus sähköpostitse.\r\n\r\n"
            "Käy katsomassa kaehmytilanne osoitteessa {url}"
        )

        to_email = form.cleaned_data.get("email", "")
        subject = "Arwokas kirjattu kirje mahdolliselle tulewalle kiltahenkilölle"

        send_email(to_email, subject, email_body)
        logging.debug(f"Sent kaehmy email to recipient <{to_email}>")

        processHooks(message=f"Uusi New kaehmy! {name} -> {url}", eventType="kaehmy")
    else:
        context = {"error": form.errors}
        return render(request, "kaehmy:error.html", context)
    return HttpResponseRedirect("/kaehmy")


@require_http_methods(["GET"])
@login_required(login_url="/admin/login")
def export_view(request, *args, **kwargs):
    def make_table(queryset):
        table = ExportTable(
            queryset,
            request=request,
            exclude=["id"],
            attrs={"class": "table table-bordered table-hover"},
        )

        table.paginate(page=request.GET.get("page", 1), per_page=9999)
        table_html = convert_table_to_html(table, request)
        return table_html

    kaehmys = Application.objects.all()
    non_board = filter(lambda q: not q.has_any_board_role(), kaehmys)
    board = filter(lambda q: q.has_any_board_role(), kaehmys)

    context = {
        "non_board_table": make_table(non_board),
        "board_table": make_table(board),
    }
    return render(request, "kaehmy:export.html", context)