Ultron/planning/views.py

from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render, get_object_or_404
from django.utils import timezone
from django.views.decorators.http import require_http_methods

# from followup.models import Chrono, Skill
from people.models import Gymnast

from .models import (
    Event,
    Event_Participation,
    # get_number_of_weeks_between,
)

from .forms import EventForm


# import pendulum
import simplejson
# import collections
# import locale


@login_required
@require_http_methods(["GET"])
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.GET.get("pattern", None)

    # Ignore queries shorter than length 3
    if pattern is not None and len(pattern) > 3:
        model_results = Event.objects.filter(name__icontains=pattern).order_by(
            "datebegin"
        )
        results = [{"ID": x.id, "Name": str(x)} for x in model_results]

    json = simplejson.dumps(results)
    return HttpResponse(json, content_type="application/json")


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

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

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

        if event_form.is_valid():
            event = event_form.save()
            return HttpResponseRedirect("/event/" + str(event.id) + "/")
        else:
            print(event_form.errors)

    form = EventForm(instance=event, initial=data)

    context = {"form": form, "eventid": eventid}
    return render(request, "planning/events/create.html", context)


@require_http_methods(["GET"])
def link_gymnast_to_event(request, eventid, gymnastid):
    """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:
        gymnast = get_object_or_404(Gymnast, pk=gymnastid)
        print(gymnast)
        event = get_object_or_404(Event, pk=eventid)
        print(event)
        link = Event_Participation(gymnast=gymnast, event=event)
        print(link)
        link.save()

    except:
        return HttpResponse(409)

    return HttpResponse(200)


@require_http_methods(["GET"])
def remove_link_between_gymnast_and_event(request, eventid, gymnastid):
    """Supprime le lien entre un gymnaste et un évènement.

    Remarks:
        En fait, tes fonctions `link_gymnast_to_event`
        et `remove_link_between_gymnast_and_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.
    """
    try:
        gymnast = get_object_or_404(Gymnast, pk=gymnastid)
        event = get_object_or_404(Event, pk=eventid)
        link = Event_Participation.objects.get(event=event, gymnast=gymnast)
        link.delete()
    except:
        return HttpResponse(409)

    return HttpResponse(200)


def __get_event_list(request):
    """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)

    if pattern:
        event_list = Event.objects.filter(name__icontains=pattern)
    else:
        event_list = Event.objects.all()

    return event_list.order_by("datebegin")


@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, "calendar.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, "planning/events/list.html", context)


@login_required
@require_http_methods(["GET"])
def event_detail(request, eventid=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=eventid)
    event = Event.objects.get(pk=eventid)

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

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

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

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