2021-12-09 16:53:44 +01:00
|
|
|
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
|
2022-01-28 10:55:24 +01:00
|
|
|
from django.db.models import Q, Min, Avg, Max, Sum
|
2021-12-28 10:25:29 +01:00
|
|
|
from django.urls import reverse
|
2021-12-09 16:53:44 +01:00
|
|
|
|
2022-02-06 15:44:55 +01:00
|
|
|
from django.contrib.auth import get_user_model
|
|
|
|
User = get_user_model()
|
|
|
|
|
2021-12-09 16:53:44 +01:00
|
|
|
from ultron.people.models import Gymnast
|
|
|
|
from ultron.planning.models import Event
|
|
|
|
from ultron.objective.models import Skill
|
2022-01-07 18:08:39 +01:00
|
|
|
|
2021-12-24 07:48:46 +01:00
|
|
|
from .models import (
|
2022-01-05 18:54:02 +01:00
|
|
|
Plan,
|
2021-12-24 07:48:46 +01:00
|
|
|
Point,
|
2022-01-05 18:54:02 +01:00
|
|
|
Chrono,
|
2021-12-24 07:48:46 +01:00
|
|
|
Accident,
|
2022-01-05 18:54:02 +01:00
|
|
|
MindState,
|
2021-12-24 07:48:46 +01:00
|
|
|
LearnedSkill,
|
|
|
|
HeightWeight,
|
2022-01-25 19:03:43 +01:00
|
|
|
ChronoDetails,
|
2021-12-24 07:48:46 +01:00
|
|
|
NumberOfRoutineDone,
|
|
|
|
)
|
2022-01-07 18:08:39 +01:00
|
|
|
|
2021-12-19 09:30:51 +01:00
|
|
|
from .forms import (
|
2022-01-05 18:54:02 +01:00
|
|
|
PlanForm,
|
2021-12-19 09:30:51 +01:00
|
|
|
ScoreForm,
|
2022-01-05 18:54:02 +01:00
|
|
|
ChronoForm,
|
2021-12-19 09:30:51 +01:00
|
|
|
AccidentForm,
|
|
|
|
MindStateForm,
|
|
|
|
HeightWeightForm,
|
2022-01-05 18:54:02 +01:00
|
|
|
LearnedSkillForm,
|
2021-12-24 07:48:46 +01:00
|
|
|
NumberOfRoutineDoneForm,
|
2021-12-19 09:30:51 +01:00
|
|
|
)
|
2021-12-09 16:53:44 +01:00
|
|
|
|
2022-09-29 10:43:48 +02:00
|
|
|
from datetime import date, datetime
|
|
|
|
import pendulum
|
|
|
|
|
2021-12-19 09:30:51 +01:00
|
|
|
|
2022-01-20 21:42:48 +01:00
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2022-01-25 19:03:43 +01:00
|
|
|
def jump_chrono_details(request, chrono_id):
|
2022-01-20 21:42:48 +01:00
|
|
|
"""Récupère toutes les informations d'un chrono"""
|
|
|
|
|
|
|
|
chrono = get_object_or_404(Chrono, pk=chrono_id)
|
2022-09-01 16:17:19 +02:00
|
|
|
|
2022-01-28 10:55:24 +01:00
|
|
|
sum_value = chrono.details.all().aggregate(total=Sum('value'))
|
|
|
|
chrono.score = sum_value['total']
|
|
|
|
if chrono.score_type == 0:
|
|
|
|
chrono.tof = Chrono.compute_tof(sum_value['total'])
|
|
|
|
chrono.save()
|
|
|
|
|
2022-01-25 08:49:30 +01:00
|
|
|
mean_value = chrono.details.all().aggregate(Avg('value'))
|
|
|
|
tmp_min_value = chrono.details.all().aggregate(Min('value'))
|
|
|
|
tmp_max_value = chrono.details.all().aggregate(Max('value'))
|
|
|
|
min_value = mean_value['value__avg'] - (tmp_min_value['value__min'] / 20)
|
|
|
|
max_value = mean_value['value__avg'] - (tmp_max_value['value__max'] / 20)
|
|
|
|
context = {"chrono": chrono, "average_value": mean_value['value__avg'], "min_value": min_value, "max_value": max_value}
|
2022-01-20 21:42:48 +01:00
|
|
|
return render(request, "followup/chronos/details.html", context)
|
|
|
|
|
|
|
|
|
2021-12-09 16:53:44 +01:00
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2021-12-19 19:59:20 +01:00
|
|
|
def chrono_listing(request, gymnast_id=None):
|
2022-09-01 16:23:16 +02:00
|
|
|
"""
|
|
|
|
Si la personne connectée est un entraîneur, la fonction récupère la liste des chronos suivant
|
|
|
|
d'un gymnaste précis ou de tout le monde.
|
|
|
|
Si la peronne connectée est un gymnaste, la fonction récupère la liste de ses chronos à
|
|
|
|
lui/elle.
|
|
|
|
"""
|
2021-12-09 16:53:44 +01:00
|
|
|
|
2021-12-24 12:14:03 +01:00
|
|
|
gymnast = None
|
2022-09-01 16:23:16 +02:00
|
|
|
if request.user.groups.filter(name='trainer').exists():
|
|
|
|
if gymnast_id:
|
|
|
|
chrono_list = Chrono.objects.filter(gymnast=gymnast_id)
|
|
|
|
gymnast = Gymnast.objects.get(pk=gymnast_id)
|
|
|
|
else:
|
|
|
|
chrono_list = Chrono.objects.all()
|
2021-12-19 19:59:20 +01:00
|
|
|
else:
|
2022-09-01 16:23:16 +02:00
|
|
|
chrono_list = Chrono.objects.filter(
|
|
|
|
Q(gymnast__last_name=request.user.last_name)
|
|
|
|
& Q(gymnast__first_name=request.user.first_name)
|
|
|
|
)
|
2021-12-19 19:59:20 +01:00
|
|
|
|
2021-12-24 12:14:03 +01:00
|
|
|
context = {"chrono_list": chrono_list, "gymnast": gymnast}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/chronos/list.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
2022-02-01 11:08:02 +01:00
|
|
|
def chrono_create_or_update(request, chrono_id=None, gymnast_id=None):
|
2021-12-19 09:30:51 +01:00
|
|
|
"""Création ou modification d'un chrono"""
|
2021-12-09 16:53:44 +01:00
|
|
|
|
2022-02-01 11:08:02 +01:00
|
|
|
if chrono_id:
|
|
|
|
chrono = get_object_or_404(Chrono, pk=chrono_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
data = {
|
|
|
|
"gymnast": chrono.gymnast.id,
|
|
|
|
"gymnast_related": str(chrono.gymnast),
|
|
|
|
}
|
|
|
|
else:
|
|
|
|
chrono = None
|
|
|
|
data = None
|
2021-12-24 07:48:46 +01:00
|
|
|
if gymnast_id is not None:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast": gymnast_id, "gymnast_related": gymnast}
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
|
|
|
form = ChronoForm(request.POST, instance=chrono)
|
|
|
|
|
|
|
|
if form.is_valid():
|
|
|
|
new_chrono = form.save(commit=False)
|
2022-01-28 10:55:24 +01:00
|
|
|
|
2021-12-09 16:53:44 +01:00
|
|
|
if new_chrono.score_type == 1:
|
|
|
|
new_chrono.tof = new_chrono.score
|
|
|
|
else:
|
2022-01-28 10:55:24 +01:00
|
|
|
new_chrono.tof = Chrono.compute_tof(new_chrono.score)
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
new_chrono.save()
|
2022-02-01 11:08:02 +01:00
|
|
|
return HttpResponseRedirect(reverse("gymnast_details", args=(new_chrono.gymnast.id,)))
|
2022-02-06 15:44:55 +01:00
|
|
|
else:
|
2022-02-15 18:30:03 +01:00
|
|
|
return render(request, "followup/chronos/create.html", {'form': form})
|
2021-12-09 16:53:44 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = ChronoForm(instance=chrono, initial=data)
|
2022-02-01 11:08:02 +01:00
|
|
|
context = {"form": form, "chrono_id": chrono_id}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/chronos/create.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["POST"])
|
|
|
|
def gymnast_learn_skill(request):
|
|
|
|
"""
|
|
|
|
Lie un gymnast à une figure.
|
|
|
|
"""
|
|
|
|
# utiliser un FORM pour cette fonction.
|
2021-12-19 19:59:20 +01:00
|
|
|
gymnast_id = request.POST.get("gymnast_id", None)
|
2022-01-05 18:44:15 +01:00
|
|
|
skill_id = request.POST.get("skill_id", None)
|
2021-12-09 16:53:44 +01:00
|
|
|
cando = request.POST.get("cando", 0)
|
|
|
|
|
2022-01-05 18:44:15 +01:00
|
|
|
if gymnast_id and skill_id:
|
2021-12-24 19:59:12 +01:00
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-05 18:44:15 +01:00
|
|
|
skill = Skill.objects.get(pk=skill_id)
|
|
|
|
learned_skill = LearnedSkill(
|
2021-12-19 09:30:51 +01:00
|
|
|
gymnast=gymnast, skill=skill, cando=cando, date=datetime.now()
|
|
|
|
)
|
2022-01-05 18:44:15 +01:00
|
|
|
learned_skill.save()
|
2021-12-09 16:53:44 +01:00
|
|
|
return HttpResponse(status=200)
|
2022-01-07 18:08:39 +01:00
|
|
|
|
|
|
|
if gymnast_id:
|
|
|
|
print("Error : can not link Gymnast and skill. Missing Skill_ID.")
|
2021-12-09 16:53:44 +01:00
|
|
|
else:
|
2022-01-07 18:08:39 +01:00
|
|
|
print("Error : can not link Gymnast and skill. Missing Gymnast_ID.")
|
|
|
|
return HttpResponse(status=500)
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
2021-12-19 19:59:20 +01:00
|
|
|
def learnedskill_create_or_update(request, gymnast_id=None):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Formulaire de creation et modification d'un lien skill/gymnaste.
|
|
|
|
"""
|
|
|
|
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
data = {
|
|
|
|
"gymnast": gymnast.id,
|
|
|
|
"gymnast_related": str(gymnast),
|
|
|
|
}
|
|
|
|
else:
|
2021-12-28 10:25:29 +01:00
|
|
|
data = None
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
2021-12-28 10:25:29 +01:00
|
|
|
form = LearnedSkillForm(request.POST)
|
2021-12-09 16:53:44 +01:00
|
|
|
|
2021-12-28 10:25:29 +01:00
|
|
|
if form.is_valid():
|
|
|
|
form.save()
|
2022-01-07 18:08:39 +01:00
|
|
|
return HttpResponseRedirect(
|
|
|
|
reverse("gymnast_details", args=(form.cleaned_data["gymnast"].id,))
|
|
|
|
)
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
render(request, "followup/learnedskills/create.html", {"form": form})
|
2022-01-07 18:08:39 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = LearnedSkillForm(initial=data)
|
2021-12-19 19:59:20 +01:00
|
|
|
context = {"form": form, "gymnast_id": gymnast_id}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/learnedskills/create.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
2022-02-01 11:08:02 +01:00
|
|
|
def score_create_or_update(request, score_id=None, gymnast_id=None):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Formulaire de création d'un nouveau score.
|
|
|
|
"""
|
|
|
|
|
2022-02-01 11:08:02 +01:00
|
|
|
if score_id:
|
|
|
|
score = get_object_or_404(Point, pk=score_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
data = {
|
|
|
|
"gymnast_related": str(score.gymnast),
|
|
|
|
"event_related": str(score.event),
|
|
|
|
}
|
|
|
|
else:
|
|
|
|
score = None
|
2021-12-28 10:25:29 +01:00
|
|
|
data = None
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id is not None:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast": gymnast_id, "gymnast_related": str(gymnast)}
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
|
|
|
form = ScoreForm(request.POST, instance=score)
|
|
|
|
|
|
|
|
if form.is_valid():
|
|
|
|
form.save()
|
2022-02-01 17:28:57 +01:00
|
|
|
|
2022-02-02 12:37:18 +01:00
|
|
|
if form.cleaned_data['add_to_chrono']:
|
2022-02-01 17:28:57 +01:00
|
|
|
new_chrono = Chrono(
|
|
|
|
gymnast=form.cleaned_data["gymnast"],
|
|
|
|
chrono_type=form.cleaned_data["routine_type"],
|
|
|
|
score_type=1,
|
|
|
|
score=form.cleaned_data["point_time_of_flight"],
|
|
|
|
tof=form.cleaned_data["point_time_of_flight"],
|
2022-09-23 16:02:20 +02:00
|
|
|
date=form.cleaned_data["event"].date_begin,
|
2022-02-01 17:28:57 +01:00
|
|
|
)
|
|
|
|
new_chrono.save()
|
|
|
|
|
2022-01-07 18:08:39 +01:00
|
|
|
return HttpResponseRedirect(
|
2022-02-01 11:08:02 +01:00
|
|
|
reverse(
|
|
|
|
"gymnast_details",
|
|
|
|
args=(form.cleaned_data["gymnast"].id,)
|
|
|
|
)
|
2022-01-07 18:08:39 +01:00
|
|
|
)
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
render(request, "followup/scores/create.html", {"form": form})
|
2022-01-07 18:08:39 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = ScoreForm(instance=score, initial=data)
|
2022-02-01 11:08:02 +01:00
|
|
|
context = {"form": form, "score_id": score_id}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/scores/create.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2021-12-19 19:59:20 +01:00
|
|
|
def score_listing(request, gymnast_id=None):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Revoie la liste des scores
|
|
|
|
"""
|
|
|
|
|
|
|
|
pattern = request.GET.get("pattern", None)
|
2021-12-24 12:14:03 +01:00
|
|
|
gymnast = None
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
if pattern:
|
|
|
|
score_list = Point.objects.filter(
|
2022-01-07 18:08:39 +01:00
|
|
|
Q(event__icontains=pattern) | Q(gymnast__icontains=pattern)
|
2021-12-09 16:53:44 +01:00
|
|
|
)
|
2021-12-19 19:59:20 +01:00
|
|
|
elif gymnast_id:
|
|
|
|
score_list = Point.objects.filter(gymnast=gymnast_id)
|
2021-12-24 19:59:12 +01:00
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
else:
|
|
|
|
score_list = Point.objects.all()
|
|
|
|
|
2021-12-24 12:14:03 +01:00
|
|
|
context = {"score_list": score_list, "gymnast": gymnast}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/scores/list.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
|
|
|
def accident_listing(request):
|
|
|
|
"""
|
2022-09-01 16:17:19 +02:00
|
|
|
Récupère la liste des accidents.
|
|
|
|
Si c'est un gymnaste qui est connecté, il ne peut récupérer que la liste de ses accidents.
|
|
|
|
Si c'est un autre utilisateur (entraîneur), la liste peut répondre à un pattern si celui-ci est
|
|
|
|
définit.
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
|
2022-09-01 16:17:19 +02:00
|
|
|
if request.user.groups.filter(name='trainer').exists():
|
|
|
|
pattern = request.GET.get("pattern", None)
|
|
|
|
if pattern:
|
|
|
|
accident_list = Accident.objects.filter(
|
|
|
|
Q(gymnast__last_name__icontains=pattern)
|
|
|
|
| Q(gymnast__first_name__icontains=pattern)
|
|
|
|
)
|
|
|
|
else:
|
|
|
|
accident_list = Accident.objects.all()
|
2021-12-09 16:53:44 +01:00
|
|
|
else:
|
2022-09-01 16:17:19 +02:00
|
|
|
accident_list = Accident.objects.filter(
|
|
|
|
Q(gymnast__last_name=request.user.last_name)
|
|
|
|
& Q(gymnast__first_name=request.user.first_name)
|
|
|
|
)
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
context = {"accident_list": accident_list}
|
|
|
|
return render(request, "followup/accidents/list.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
2022-02-01 11:08:02 +01:00
|
|
|
def accident_create_or_update(request, accident_id=None, gymnast_id=None):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Formulaire de création d'un nouvel accident.
|
|
|
|
"""
|
|
|
|
|
2022-02-01 11:08:02 +01:00
|
|
|
if accident_id:
|
|
|
|
accident = get_object_or_404(Accident, pk=accident_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
data = {
|
|
|
|
"gymnast_related": accident.gymnast,
|
|
|
|
"skill_related": accident.skill,
|
|
|
|
}
|
|
|
|
else:
|
|
|
|
accident = None
|
2021-12-28 10:25:29 +01:00
|
|
|
data = None
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id is not None:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast": gymnast_id, "gymnast_related": str(gymnast)}
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
|
|
|
form = AccidentForm(request.POST, instance=accident)
|
|
|
|
|
|
|
|
if form.is_valid():
|
2022-02-01 11:08:02 +01:00
|
|
|
accident = form.save()
|
|
|
|
return HttpResponseRedirect(reverse("accident_details", args=(accident.pk,)))
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
return render(request, "followup/accidents/create.html", {"form": form})
|
2022-01-07 18:08:39 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = AccidentForm(instance=accident, initial=data)
|
2022-02-01 11:08:02 +01:00
|
|
|
context = {"form": form, "accident_id": accident_id}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/accidents/create.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2022-02-01 11:08:02 +01:00
|
|
|
def accident_detail(request, accident_id):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Récupère toutes les informations d'un accident.
|
|
|
|
"""
|
2022-02-01 11:08:02 +01:00
|
|
|
accident = get_object_or_404(Accident, pk=accident_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
context = {"accident": accident}
|
|
|
|
return render(request, "followup/accidents/details.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2021-12-19 19:59:20 +01:00
|
|
|
def mindstate_listing(request, gymnast_id=None):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
2021-12-24 12:14:03 +01:00
|
|
|
Récupère la liste des évaluations mentales suivant (d'un gymnaste si définit en paramètre).
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
2021-12-24 12:14:03 +01:00
|
|
|
gymnast = None
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id:
|
|
|
|
mindstate_list = MindState.objects.filter(gymnast=gymnast_id)
|
2021-12-24 19:59:12 +01:00
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
else:
|
|
|
|
mindstate_list = MindState.objects.all()
|
|
|
|
|
2021-12-24 12:14:03 +01:00
|
|
|
context = {"mindstate_list": mindstate_list, "gymnast": gymnast}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/mindstates/list.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
2022-01-07 18:08:39 +01:00
|
|
|
def mindstate_create_or_update(
|
2022-02-01 11:08:02 +01:00
|
|
|
request, mindstate_id=None, gymnast_id=None, event_id=None
|
2022-01-07 18:08:39 +01:00
|
|
|
):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Formulaire de création d'un nouvel accident.
|
|
|
|
"""
|
|
|
|
|
2022-02-01 11:08:02 +01:00
|
|
|
if mindstate_id:
|
|
|
|
mindstate = get_object_or_404(MindState, pk=mindstate_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast_related": mindstate.gymnast, "event_related": mindstate.event}
|
2021-12-09 16:53:44 +01:00
|
|
|
else:
|
|
|
|
mindstate = None
|
2021-12-28 10:25:29 +01:00
|
|
|
data = None
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id is not None:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast": gymnast_id, "gymnast_related": str(gymnast)}
|
2022-02-01 11:08:02 +01:00
|
|
|
if event_id is not None:
|
|
|
|
event = get_object_or_404(Event, pk=event_id)
|
|
|
|
data = {"event": event_id, "event_related": str(event)}
|
2021-12-09 16:53:44 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
|
|
|
form = MindStateForm(request.POST, instance=mindstate)
|
|
|
|
|
|
|
|
if form.is_valid():
|
2022-02-01 11:08:02 +01:00
|
|
|
mindstate = form.save()
|
|
|
|
return HttpResponseRedirect(reverse("mindstate_details", args=(mindstate.pk,)))
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
return render(request, "followup/mindstates/create.html", {"form": form})
|
2022-01-07 18:08:39 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = MindStateForm(instance=mindstate, initial=data)
|
2022-02-01 11:08:02 +01:00
|
|
|
context = {"form": form, "mindstate_id": mindstate_id}
|
2021-12-09 16:53:44 +01:00
|
|
|
return render(request, "followup/mindstates/create.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2022-02-01 11:08:02 +01:00
|
|
|
def mindstate_detail(request, mindstate_id):
|
2021-12-09 16:53:44 +01:00
|
|
|
"""
|
|
|
|
Récupère toutes les informations d'une évaluation psychologique.
|
|
|
|
"""
|
2022-02-01 11:08:02 +01:00
|
|
|
mindstate = get_object_or_404(MindState, pk=mindstate_id)
|
2021-12-09 16:53:44 +01:00
|
|
|
context = {"mindstate": mindstate}
|
|
|
|
return render(request, "followup/mindstates/details.html", context)
|
2021-12-14 17:16:49 +01:00
|
|
|
|
|
|
|
|
2021-12-19 19:59:20 +01:00
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
|
|
|
def heightweight_listing(request, gymnast_id=None):
|
|
|
|
"""
|
|
|
|
Récupère la liste des couples taille/poids suivant (d'un gymnast si définit en paramètre).
|
|
|
|
"""
|
2021-12-24 12:14:03 +01:00
|
|
|
gymnast = None
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id:
|
|
|
|
heightweight_list = HeightWeight.objects.filter(gymnast=gymnast_id)
|
2021-12-24 12:14:03 +01:00
|
|
|
gymnast = Gymnast.objects.get(pk=gymnast_id)
|
2021-12-19 19:59:20 +01:00
|
|
|
else:
|
|
|
|
heightweight_list = HeightWeight.objects.all()
|
|
|
|
|
2021-12-24 12:14:03 +01:00
|
|
|
context = {"heightweight_list": heightweight_list, "gymnast": gymnast}
|
2021-12-19 19:59:20 +01:00
|
|
|
return render(request, "followup/heightweight/list.html", context)
|
|
|
|
|
|
|
|
|
2021-12-14 17:16:49 +01:00
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
2021-12-20 09:47:19 +01:00
|
|
|
def heightweight_create_or_update(request, heightweight_id=None, gymnast_id=None):
|
2021-12-14 17:16:49 +01:00
|
|
|
"""
|
|
|
|
Formulaire de creation et modification d'un couple taille/couple.
|
|
|
|
"""
|
|
|
|
|
2021-12-20 09:47:19 +01:00
|
|
|
if heightweight_id:
|
|
|
|
heightweight = get_object_or_404(HeightWeight, pk=heightweight_id)
|
2021-12-19 09:30:51 +01:00
|
|
|
data = {"gymnast_related": heightweight.gymnast}
|
2021-12-14 17:16:49 +01:00
|
|
|
else:
|
2021-12-22 14:47:00 +01:00
|
|
|
heightweight = None
|
2021-12-28 10:25:29 +01:00
|
|
|
data = None
|
2021-12-19 19:59:20 +01:00
|
|
|
if gymnast_id:
|
2022-01-07 18:08:39 +01:00
|
|
|
heightweight = (
|
|
|
|
HeightWeight.objects.filter(gymnast=gymnast_id)
|
|
|
|
.order_by("-date")
|
|
|
|
.first()
|
|
|
|
)
|
2021-12-19 19:59:20 +01:00
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast": gymnast_id, "gymnast_related": str(gymnast)}
|
2021-12-14 17:16:49 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
2021-12-28 10:25:29 +01:00
|
|
|
form = HeightWeightForm(request.POST, instance=heightweight)
|
2021-12-14 17:16:49 +01:00
|
|
|
|
2021-12-28 10:25:29 +01:00
|
|
|
if form.is_valid():
|
|
|
|
form.save()
|
2022-01-07 18:08:39 +01:00
|
|
|
return HttpResponseRedirect(
|
|
|
|
reverse("gymnast_details", args=(form.cleaned_data["gymnast"].id,))
|
|
|
|
)
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
return render(request, "followup/heightweight/create.html", {"form": form})
|
2022-09-01 16:17:19 +02:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = HeightWeightForm(instance=heightweight, initial=data)
|
2022-01-07 18:08:39 +01:00
|
|
|
context = {
|
|
|
|
"form": form,
|
|
|
|
"gymnast_id": gymnast_id,
|
|
|
|
"heightweight_id": heightweight_id,
|
|
|
|
}
|
2021-12-19 09:30:51 +01:00
|
|
|
return render(request, "followup/heightweight/create.html", context)
|
2021-12-24 07:48:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET"])
|
2021-12-24 19:59:12 +01:00
|
|
|
def routine_done_listing(request, gymnast_id=None):
|
2021-12-24 07:48:46 +01:00
|
|
|
"""
|
|
|
|
Liste tous les record de la table NumberOfRoutineDone
|
|
|
|
"""
|
2021-12-24 19:59:12 +01:00
|
|
|
if gymnast_id:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
|
|
routine_done_list = gymnast.number_of_routine_done.all()
|
|
|
|
else:
|
2022-02-12 19:50:08 +01:00
|
|
|
gymnast = None
|
2021-12-24 19:59:12 +01:00
|
|
|
routine_done_list = NumberOfRoutineDone.objects.all()
|
2022-02-12 19:50:08 +01:00
|
|
|
print(routine_done_list)
|
2021-12-24 19:59:12 +01:00
|
|
|
|
|
|
|
context = {"routine_done_list": routine_done_list, "gymnast": gymnast}
|
2021-12-24 07:48:46 +01:00
|
|
|
return render(request, "followup/routinedone/list.html", context)
|
|
|
|
|
|
|
|
|
2022-02-08 18:55:48 +01:00
|
|
|
@require_http_methods(["POST"])
|
|
|
|
def increment_routinedone(request):
|
|
|
|
"""
|
|
|
|
Incrémente le nombre de routine faite pour aujourd'hui et incrémente, si besoin, le nombre
|
|
|
|
de routine réussie
|
|
|
|
"""
|
2022-02-10 19:35:27 +01:00
|
|
|
|
|
|
|
data = {
|
|
|
|
'gymnast': get_object_or_404(Gymnast, pk=request.POST.get("gymnast_id", None)),
|
|
|
|
'routine_type': request.POST.get("routine_type", 1),
|
|
|
|
'date': request.POST.get("date", date.today()),
|
|
|
|
}
|
|
|
|
|
2022-09-22 12:45:02 +02:00
|
|
|
routine = data['gymnast'].has_routine.filter(routine_type=request.POST.get("routine_type", 1)).first()
|
|
|
|
data['routine'] = routine.routine
|
|
|
|
|
2022-02-10 19:35:27 +01:00
|
|
|
routinedone, _ = NumberOfRoutineDone.objects.get_or_create(date=data["date"], gymnast=data["gymnast"], routine_type=data["routine_type"])
|
|
|
|
data["number_of_try"] = routinedone.number_of_try + 1
|
|
|
|
success = request.POST.get("success", 0)
|
2022-02-08 18:55:48 +01:00
|
|
|
if int(success) == 1:
|
2022-02-10 19:35:27 +01:00
|
|
|
data["number_of_successes"] = routinedone.number_of_successes + 1
|
|
|
|
else:
|
|
|
|
data["number_of_successes"] = routinedone.number_of_successes
|
|
|
|
form = NumberOfRoutineDoneForm(data, instance=routinedone)
|
|
|
|
|
|
|
|
if form.is_valid():
|
|
|
|
form.save()
|
|
|
|
return HttpResponse(status=200)
|
|
|
|
else:
|
|
|
|
return HttpResponse(status=406)
|
2022-02-08 18:55:48 +01:00
|
|
|
|
|
|
|
|
2021-12-24 07:48:46 +01:00
|
|
|
@login_required
|
|
|
|
@require_http_methods(["GET", "POST"])
|
|
|
|
def routinedone_create_or_update(request, routinedone_id=None, gymnast_id=None):
|
|
|
|
"""Création ou modification d'un chrono"""
|
|
|
|
|
|
|
|
if routinedone_id:
|
|
|
|
routinedone = get_object_or_404(NumberOfRoutineDone, pk=routinedone_id)
|
|
|
|
data = {
|
|
|
|
"gymnast": routinedone.gymnast.id,
|
|
|
|
"gymnast_related": str(routinedone.gymnast),
|
|
|
|
"routine": routinedone.routine.id,
|
2022-01-07 18:08:39 +01:00
|
|
|
"routine_related": str(routinedone.routine),
|
2021-12-24 07:48:46 +01:00
|
|
|
}
|
|
|
|
else:
|
|
|
|
routinedone = None
|
|
|
|
data = None
|
|
|
|
if gymnast_id is not None:
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
2022-01-07 18:08:39 +01:00
|
|
|
data = {"gymnast": gymnast_id, "gymnast_related": gymnast}
|
2021-12-24 07:48:46 +01:00
|
|
|
|
|
|
|
if request.method == "POST":
|
|
|
|
form = NumberOfRoutineDoneForm(request.POST, instance=routinedone)
|
|
|
|
|
|
|
|
if form.is_valid():
|
|
|
|
form.save()
|
2022-01-07 18:08:39 +01:00
|
|
|
return HttpResponseRedirect(
|
|
|
|
reverse("gymnast_details", args=(form.cleaned_data["gymnast"].id,))
|
|
|
|
)
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
return render(request, "followup/routinedone/create.html", {"form": form})
|
2022-01-07 19:28:33 +01:00
|
|
|
|
2021-12-24 07:48:46 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = NumberOfRoutineDoneForm(instance=routinedone, initial=data)
|
2021-12-24 07:48:46 +01:00
|
|
|
context = {"form": form, "routinedone_id": routinedone_id}
|
2022-01-05 18:44:15 +01:00
|
|
|
return render(request, "followup/routinedone/create.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@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()
|
2022-02-10 10:33:37 +01:00
|
|
|
return HttpResponseRedirect(
|
|
|
|
reverse("gymnast_details", args=(form.cleaned_data["gymnast"].id,))
|
|
|
|
)
|
2022-02-15 18:30:03 +01:00
|
|
|
else:
|
|
|
|
return render(request, "followup/plan/create.html", {"form": form})
|
2022-02-01 11:08:02 +01:00
|
|
|
|
2022-02-15 18:30:03 +01:00
|
|
|
form = PlanForm(instance=plan, initial=data)
|
2022-01-05 18:44:15 +01:00
|
|
|
context = {"form": form, "plan_id": plan_id}
|
2022-01-06 10:04:36 +01:00
|
|
|
return render(request, "followup/plan/create.html", context)
|