Ultron/followup/views.py

from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.http import HttpResponse, HttpResponseRedirect
from django.db.models import Q

from people.models import Gymnast
from .models import Chrono, Skill, Point, Accident
from .forms import ChronoForm, LearnedSkillForm, ScoreForm, AccidentForm

import simplejson

@login_required
@require_http_methods(["GET"])
def chrono_listing(request):
    """ Récupère la liste des chronos """

    chrono_list = Chrono.objects.all()
    context = {'chrono_list': chrono_list}
    return render(request, "followup/chronos/list.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def chrono_create_or_update(request, chronoid=None, gymnastid=None):
    """ Création ou modification d'un chrono """

    if chronoid:
        chrono = get_object_or_404(Chrono, pk=chronoid)
        data = {
            "gymnast": chrono.gymnast.id,
            "gymnast_related": str(chrono.gymnast),
        }
    else:
        chrono = None
        data = None

    if request.method == "POST":
        form = ChronoForm(request.POST, instance=chrono)

        if form.is_valid():
            new_chrono = form.save(commit=False)
            # Calcul du ToF
            if new_chrono.score_type == 1:
                new_chrono.tof = new_chrono.score
            else:
                tof = round(( new_chrono.score * 13 ) / 15, 3) * 1000
                tof = tof - (tof % 5)
                new_chrono.tof = tof  / 1000

            new_chrono.save()
            return HttpResponseRedirect("/gymnast/details/" + str(new_chrono.gymnast.id) + "/")

    else:
        if data is None and gymnastid is not None:
            gymnast = get_object_or_404(Gymnast, pk=gymnastid)
            data = {"gymnast": gymnastid, "gymnast_related": gymnast}

        form = ChronoForm(instance=chrono, initial=data)

    context = {"form": form, "chronoid": chronoid}
    return render(request, "followup/chronos/create.html", context)


@login_required
@require_http_methods(["GET"])
def skill_lookup(request):
    """
    Récupère la liste des skill à la volée suivant des caractères de
    recherche entrés. (min 3 caractères)
    """

    results = []
    pattern = request.GET.get("pattern", None)

    # Ignore queries shorter than length 3
    if pattern is not None and len(pattern) > 3:
        model_results = Skill.objects.filter(
            Q(short_label__icontains=pattern) | Q(long_label__icontains=pattern)
        )
        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"])
def skill_listing(request, field=None, expression=None, value=None, level=None):
    """
    Récupère la liste des skills suivant un pattern si celui-ci est définit.
    """

    pattern = None

    if not field or not value or not expression:
        pattern = request.GET.get("pattern", None)

    if pattern:
        skill_list = Skill.objects.filter(
            Q(longLabel__icontains=pattern) | Q(shortLabel__icontains=pattern)
        )
    elif field and expression and value:
        kwargs = {"{0}__{1}".format(field, expression): value}
        skill_list = Skill.objects.filter(**kwargs)
    elif level is not None:
        skill_list = Skill.objects.filter
    else:
        skill_list = Skill.objects.all()

    context = {'skill_list': skill_list}
    return render(request, 'skills/list.html', context)


@login_required
@require_http_methods(["GET"])
def skill_details(request, skillid):
    """
    Récupère toutes les informations d'un skill.

    :param skillig:     id d'un `skill`
    :type skillid:      int

    :return: skill
    """
    context = {"skill": get_object_or_404(Skill, pk=skillid)}
    return render(request, "skills/details.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def learnedskill_create_or_update(request, gymnastid=None):
    """
    Formulaire de creation et modification d'un lien skill/gymnaste.
    """

    if gymnastid:
        gymnast = get_object_or_404(Gymnast, pk=gymnastid)
        data = {
            "gymnast": gymnast.id,
            "gymnast_related": str(gymnast),
        }
    else:
        data = {}

    if request.method == "POST":
        learnedskill_form = LearnedSkillForm(request.POST)

        if learnedskill_form.is_valid():
            learnedskill_form.save()
            return HttpResponseRedirect("/gymnast/details/" + str(learnedskill_form.cleaned_data['gymnast'].id))
        else:
            print(learnedskill_form.errors)

    form = LearnedSkillForm(initial=data)

    context = {"form": form, "gymnastid": gymnastid}
    return render(request, "followup/learnedskills/create.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def score_create_or_update(request, scoreid=None, gymnastid=None):
    """
    Formulaire de création d'un nouveau score.
    """

    if scoreid:
        score = get_object_or_404(Point, pk=scoreid)
        data = {
            "gymnast_related": str(score.gymnast),
            "event_related": str(score.event),
        }
    else:
        score = None
        data = {}
        if gymnastid is not None:
            gymnast = get_object_or_404(Gymnast, pk=gymnastid)
            data["gymnast"] = gymnastid
            data["gymnast_related"] = str(gymnast)

    if request.method == "POST":
        form = ScoreForm(request.POST, instance=score)

        if form.is_valid():
            # print(form.cleaned_data)
            form.save()
            return HttpResponseRedirect(
                "/gymnast/" + str(form.cleaned_data["gymnast"].id) + "/tab/scores/"
            )
            # return HttpResponseRedirect("/score/")

    else:
        form = ScoreForm(instance=score, initial=data)

    context = {"form": form, "scoreid": scoreid}
    return render(request, "followup/scores/create.html", context)


@login_required
@require_http_methods(["GET"])
def score_listing(request):
    """
    Revoie la liste des scores
    """

    pattern = request.GET.get("pattern", None)

    if pattern:
        score_list = Point.objects.filter(
            Q(event__icontains=pattern) | Q(gymnast__icontains=pattern)
        )
    else:
        score_list = Point.objects.all()

    context = {"score_list": score_list}
    return render(request, "followup/scores/list.html", context)




@login_required
@require_http_methods(["GET"])
def accident_listing(request):
    """
    Récupère la liste des accidents suivant un pattern si celui-ci est définit.
    """
    pattern = request.GET.get("pattern", None)

    if pattern:
        accident_list = Accident.objects.filter(
            Q(gymnast__lastname__icontains=pattern)
            | Q(gymnast__firstname__icontains=pattern)
        )
    else:
        accident_list = Accident.objects.all()

    context = {"accident_list": accident_list}
    return render(request, "followup/accidents/list.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def accident_create_or_update(request, accidentid=None):
    """
    Formulaire de création d'un nouvel accident.
    """

    if accidentid:
        accident = get_object_or_404(Accident, pk=accidentid)
        data = {
            "gymnast_related": accident.gymnast,
            "educative_related": accident.educative,
        }
    else:
        accident = None
        data = {}

    if request.method == "POST":
        form = AccidentForm(request.POST, instance=accident)

        if form.is_valid():
            form.save()
            if accidentid:
                return HttpResponseRedirect("/accident/" + str(accidentid) + "/")
            else:
                return HttpResponseRedirect("/accident/")
    else:

        form = AccidentForm(instance=accident, initial=data)

    context = {"form": form, "accidentid": accidentid}
    return render(request, "followup/accidents/create.html", context)


@login_required
@require_http_methods(["GET"])
def accident_detail(request, accidentid):
    """
    Récupère toutes les informations d'un accident.
    """
    accident = get_object_or_404(Accident, pk=accidentid)
    context = {"accident": accident}
    return render(request, "followup/accidents/details.html", context)