Jarvis/jarvis/planning/views.py

from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect, HttpResponse, JsonResponse
from django.shortcuts import render, get_object_or_404
from django.views.decorators.http import require_http_methods
from django.urls import reverse
from django.core.mail import send_mail
from django.conf import settings

import pendulum

from jarvis.people.models import Gymnast

from .models import (
    Event,
    EventParticipation,
)

from .forms import EventForm


@login_required
@require_http_methods(["POST"])
def event_lookup(request):
    """
    Récupère la liste de tous évènements suivant un pattern si celui-ci est
    définit.
    """
    results = []
    pattern = request.POST.get("pattern", None)

    if pattern is not None and len(pattern) >= 3:
        model_results = Event.objects.filter(name__icontains=pattern).order_by(
            "date_begin"
        )
        results = [{"ID": x.id, "Name": str(x)} for x in model_results]
    return JsonResponse(results, safe=False)


@login_required
@require_http_methods(["GET", "POST"])
def event_create_or_update(request, event_id=None):
    """
    Création ou mise à jour d'un évènement.
    """

    if event_id:
        event = get_object_or_404(Event, pk=event_id)
        data = {"place_related": event.place}
    else:
        event = None
        data = {}

    if request.method == "POST":
        form = EventForm(request.POST, instance=event)

        if form.is_valid():
            event = form.save()
            return HttpResponseRedirect(reverse("event_details", args=(event.pk,)))

        return render(request, "objectives/routines/create.html", {"form": form})

    form = EventForm(instance=event, initial=data)
    context = {"form": form, "event_id": event_id}
    return render(request, "events/create.html", context)


@require_http_methods(["POST"])
def link_gymnast_to_event(request):
    """Crée un lien entre un gymnaste et un évènement.

    Returns:
        Si tout se passe bien, un code 200 (Success) est retourné.

    Excepts:
        Si une erreur se produit lors de l'association, un code HTTP 409 (Conflict) est retourné.

    Remarks:
        Tu ne veux pas retourner le lien qui vient d'être créé ?
    """
    try:
        event_id = request.POST.get("event_id", None)
        gymnast_id = request.POST.get("gymnast_id", None)
        gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
        event = get_object_or_404(Event, pk=event_id)
        EventParticipation.objects.create(gymnast=gymnast, event=event)
        url = request.build_absolute_uri(reverse("event_details", args=(event_id,)))

        send_mail(
            "Association à un évènement.",
            "Vous avez été associé(e) à un évènement.",
            settings.EMAIL_HOST_USER,
            [gymnast.user.email, gymnast.email_trainer],
            fail_silently=False,
            html_message=f"""<p>Bonjour,</p>
                <p>
                    Vous avez été associé(e) à un évènement.
                    Vous pouvez consulter les détails de l'évènement <a href='{url}'>ici</a>.
                </p>
                <br />
                <p>Excellente journée</p><p>Jarvis</p>""",
        )
    except Exception:
        return HttpResponse(409)

    return HttpResponse(200)


@require_http_methods(["POST"])
def unlink_gymnast_from_event(request):
    """Supprime le lien entre un gymnaste et un évènement.

    Remarks:
        Fonctions `link_gymnast_to_event` et `unlink_gymnast_from_event` sont _très_ similaires.
        Il faudrait sans doute mieux passer par une CBV, voire mieux: DRF ;-)
        Surtout qu'ici, on gère directement des `link_between_g_and_e`, à ajouter ou supprimer.
    """
    event_id = request.POST.get("event_id", None)
    gymnast_id = request.POST.get("gymnast_id", None)

    try:
        EventParticipation.objects.get(event=event_id, gymnast=gymnast_id).delete()
    except Exception:
        return HttpResponse(409)

    return HttpResponse(200)


def __get_event_list(request, from_date=None, to_date=None):
    """Récupère une liste d'évènement.

    Par défaut, la liste est triée chronologiquement - le plus ancien étant le premier élément.

    Cette fonction est utilisée pour l'affichage des évènements et au niveau du calendrier.

    Args:
        request (HttpRequest): La requête en entrée
        pattern (str?): Optionnel. Permet de spécifier un pattern à appliquer à la recherche.
    """
    pattern = request.GET.get("pattern", None)

    event_list = Event.objects.all()

    if pattern:
        event_list = event_list.filter(name__icontains=pattern)

    if from_date:
        event_list = event_list.filter(date_end__gte=from_date)

    if to_date:
        event_list = event_list.filter(date_begin__lte=to_date)

    return event_list.order_by("date_begin")


@login_required
@require_http_methods(["GET"])
def calendar(request):
    """Récupère la liste de tous évènements suivant un pattern si celui-ci est définit."""
    event_list = __get_event_list(request)
    context = {"event_list": event_list}
    return render(request, "events/grid.html", context)


@login_required
@require_http_methods(["GET"])
def next_event_listing(request):
    """
    Récupère la liste de tous évènements suivant un pattern si celui-ci est
    définit.
    """
    today = pendulum.today()
    event_list = __get_event_list(request, from_date=today)
    context = {"event_list": event_list}
    return render(request, "events/list.html", context)


@login_required
@require_http_methods(["GET"])
def event_listing(request):
    """
    Récupère la liste de tous évènements suivant un pattern si celui-ci est
    définit.
    """
    event_list = __get_event_list(request)
    context = {"event_list": event_list}
    return render(request, "events/list.html", context)


@login_required
@require_http_methods(["GET"])
def event_detail(request, event_id=None):
    """
    Récupère toutes les informations d'un event.

    :return: une instance de la classe `Event` et une liste de gymnastes liés
    à l'évènement.
    """
    # event = get_object_or_404(Event, pk=event_id)
    event = Event.objects.get(pk=event_id)

    gymnast_list = []
    # today = timezone.now().date()
    # tohour = timezone.now().time()

    # if event.date_begin.date() > today:
    #     for gymnast in event.gymnasts.all():
    #         # pass
    #         gymnast_list.append((gymnast, counted, int((counted / 16) * 100)))
    # else:
    #     gymnast_list = [(x, None, None) for x in event.gymnasts.all()]
    gymnast_list = [(x, None, None) for x in event.gymnasts.all()]

    context = {"event": event, "gymnast_list": gymnast_list}

    return render(request, "events/details.html", context)