316 lines
9.3 KiB
Python
316 lines
9.3 KiB
Python
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 django.urls import reverse
|
|
|
|
from ultron.people.models import Gymnast
|
|
from .models import Skill, Routine, RoutineSkill, Plan
|
|
from .forms import RoutineForm, PlanForm
|
|
|
|
import simplejson
|
|
|
|
|
|
@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 2
|
|
if pattern is not None and len(pattern) > 2:
|
|
model_results = Skill.objects.filter(
|
|
Q(short_label__icontains=pattern) | Q(long_label__icontains=pattern)
|
|
)
|
|
results = [
|
|
{"ID": x.id, "Name": str(x), "Notation": x.notation} 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(long_label__icontains=pattern) | Q(short_label__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, "objectives/skills/list.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def skill_details(request, skillid):
|
|
"""
|
|
Récupère toutes les informations d'un skill.
|
|
La méthode en profite pour vérifier les champs level, rank, age_boy et age_girl par rapport aux pré-requis.
|
|
|
|
:param skillig: id d'un `skill`
|
|
:type skillid: int
|
|
|
|
:return: skill
|
|
"""
|
|
skill = get_object_or_404(Skill, pk=skillid)
|
|
|
|
for prerequisite in skill.prerequisites.all():
|
|
if prerequisite.level >= skill.level:
|
|
skill.level = prerequisite.level + 1
|
|
|
|
if prerequisite.rank >= skill.rank:
|
|
skill.rank = prerequisite.rank + 1
|
|
|
|
if prerequisite.age_boy > skill.age_boy:
|
|
skill.age_boy = prerequisite.age_boy
|
|
|
|
if prerequisite.age_girl > skill.age_girl:
|
|
skill.age_girl = prerequisite.age_girl
|
|
|
|
skill.save()
|
|
|
|
context = {"skill": skill}
|
|
return render(request, "objectives/skills/details.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def routine_listing(request):
|
|
"""
|
|
Récupère la liste des routines (série) suivant un pattern si celui-ci est définit.
|
|
"""
|
|
|
|
pattern = request.GET.get("pattern", None)
|
|
if pattern:
|
|
routine_list = Routine.objects.filter(
|
|
Q(long_label__icontains=pattern) | Q(short_label__icontains=pattern)
|
|
)
|
|
else:
|
|
routine_list = Routine.objects.all()
|
|
|
|
context = {"routine_list": routine_list}
|
|
return render(request, "objectives/routines/list.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def routine_lookup(request):
|
|
"""
|
|
Récupère la liste des lieux à la volée suivant des caractères de recherche entrés.
|
|
"""
|
|
pattern = request.GET.get("pattern", 0)
|
|
|
|
if pattern is not None and len(pattern) >= 3:
|
|
results = Routine.objects.filter(
|
|
Q(long_label__icontains=pattern) | Q(short_label__icontains=pattern)
|
|
)
|
|
place_list = [{"id": x.id, "label": str(x)} for x in results]
|
|
|
|
json = simplejson.dumps(place_list)
|
|
return HttpResponse(json, content_type="application/json")
|
|
|
|
|
|
@login_required
|
|
def routine_details(request, routineid):
|
|
"""
|
|
Récupère toutes les informations d'une routine (série).
|
|
|
|
:param routineid: id d'une `routine`
|
|
:type routineid: int
|
|
:return: routineid
|
|
"""
|
|
|
|
routine = get_object_or_404(Routine, pk=routineid)
|
|
|
|
rank = 0
|
|
level = 0
|
|
difficulty = 0
|
|
age_boy = 0
|
|
age_girl = 0
|
|
is_competitive = True
|
|
|
|
for skill_link in routine.skill_links.all():
|
|
|
|
difficulty += skill_link.skill.difficulty
|
|
|
|
if skill_link.skill.level > level:
|
|
level = skill_link.skill.level
|
|
|
|
if skill_link.skill.rank > rank:
|
|
rank = skill_link.skill.rank + 1
|
|
|
|
if not skill_link.skill.is_competitive:
|
|
is_competitive = False
|
|
|
|
if skill_link.skill.age_boy is not None and skill_link.skill.age_boy > age_boy:
|
|
age_boy = skill_link.skill.age_boy
|
|
|
|
if (
|
|
skill_link.skill.age_girl is not None
|
|
and skill_link.skill.age_girl > age_girl
|
|
):
|
|
age_girl = skill_link.skill.age_girl
|
|
|
|
if routine.skill_links.all().count() != 10:
|
|
is_competitive = False
|
|
|
|
routine.difficulty = difficulty
|
|
|
|
if routine.level < level:
|
|
routine.level = level
|
|
|
|
if routine.rank is None or routine.rank < rank:
|
|
routine.rank = rank
|
|
|
|
if routine.age_boy is None or routine.age_boy < age_boy:
|
|
routine.age_boy = age_boy
|
|
|
|
if routine.age_girl is None or routine.age_girl < age_girl:
|
|
routine.age_girl = age_girl
|
|
|
|
routine.is_competitive = is_competitive
|
|
|
|
routine.save()
|
|
|
|
context = {"routine": routine, "skill_link_list": routine.skill_links.all()}
|
|
return render(request, "objectives/routines/details.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def routine_create_or_update(request, routineid=None):
|
|
"""Création d'une série.
|
|
|
|
Args:
|
|
routine_id (int): identifiant d'un object de classe <routine>.
|
|
"""
|
|
|
|
if routineid:
|
|
routine = get_object_or_404(Routine, pk=routineid)
|
|
else:
|
|
routine = None
|
|
|
|
if request.method == "POST":
|
|
form = RoutineForm(request.POST, instance=routine)
|
|
|
|
if form.is_valid():
|
|
routine = form.save()
|
|
# ici faire un FOR skill in form_skills_list:
|
|
# record.save() # ca sauve le record dans la table RoutineSkill
|
|
# something like this : http://stackoverflow.com/questions/3074938/django-m2m-form-save-through-table
|
|
# TO_FRED : can you help me ?
|
|
return HttpResponseRedirect(reverse("routine_details", args=(routine.pk,)))
|
|
else:
|
|
print(form.errors)
|
|
else:
|
|
form = RoutineForm(instance=routine)
|
|
|
|
context = {"form": form, "routineid": routineid}
|
|
return render(request, "objectives/routines/create.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def compose_routine(request, routineid):
|
|
"""
|
|
Récupère une routine et les sauts associés.
|
|
"""
|
|
|
|
routine = get_object_or_404(Routine, pk=routineid)
|
|
number_of_skill = routine.skill_links.all().count()
|
|
context = {
|
|
"routine": routine,
|
|
"skill_link_list": routine.skill_links.all(),
|
|
"number_of_skill": number_of_skill,
|
|
}
|
|
return render(request, "objectives/routines/compose.html", context)
|
|
|
|
|
|
@require_http_methods(["GET"])
|
|
def link_skill_to_routine(request, routineid, skillid, order):
|
|
"""
|
|
Recoit trois informations permettant de lier complètement un saut à une routine
|
|
"""
|
|
routine = get_object_or_404(Routine, pk=routineid)
|
|
skill = get_object_or_404(Skill, pk=skillid)
|
|
link, created = RoutineSkill.objects.get_or_create(
|
|
routine=routine, skill=skill, rank=order
|
|
)
|
|
# context = {'link':link, 'created':created}
|
|
# return render(request, 'compose_routine.html', context)
|
|
|
|
return HttpResponse(200, (link, created))
|
|
# except:
|
|
# return False
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def plan_create_or_update(request, plan_id=None, gymnast_id=None, skill_id=None):
|
|
"""Création d'un plan.
|
|
|
|
Args:
|
|
plan_id (int): identifiant d'un plan (classe <Plan>).
|
|
gymnast_id (int): identifiant d'un gymnaste (classe <Gymnast>).
|
|
skill_id (int): identifiant d'un skill (classe <Skill>).
|
|
"""
|
|
|
|
if plan_id:
|
|
plan = get_object_or_404(Plan, pk=plan_id)
|
|
data = {
|
|
"gymnast": plan.gymnast.id,
|
|
"gymnast_related": str(plan.gymnast),
|
|
"skill": plan.skill.id,
|
|
"skill_related": str(plan.skill),
|
|
}
|
|
else:
|
|
plan = None
|
|
data = {}
|
|
|
|
if gymnast_id:
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
data["gymnast"] = gymnast_id
|
|
data["gymnast_related"] = str(gymnast)
|
|
|
|
if skill_id:
|
|
skill = get_object_or_404(Skill, pk=skill_id)
|
|
data["educative"] = skill_id
|
|
data["educative_related"] = str(skill)
|
|
|
|
if request.method == "POST":
|
|
form = PlanForm(request.POST, instance=plan)
|
|
|
|
if form.is_valid():
|
|
plan = form.save()
|
|
else:
|
|
print(form.errors)
|
|
else:
|
|
form = PlanForm(instance=plan, initial=data)
|
|
|
|
context = {"form": form, "plan_id": plan_id}
|
|
return render(request, "objectives/plan/create.html", context)
|