785 lines
25 KiB
Python
785 lines
25 KiB
Python
from django.contrib.auth.decorators import login_required
|
||
from django.contrib.auth.models import Group
|
||
from django.contrib.auth import get_user_model
|
||
|
||
User = get_user_model()
|
||
|
||
from django.db.models import BooleanField, ExpressionWrapper, Q, F, Avg, IntegerField
|
||
from django.db.models.functions import TruncDay
|
||
from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
|
||
from django.shortcuts import render, get_object_or_404
|
||
from django.views.decorators.http import require_http_methods
|
||
from django.urls import reverse
|
||
|
||
|
||
import pendulum
|
||
from datetime import date
|
||
|
||
from ultron.followup.models import Event
|
||
from ultron.followup.forms import GymnastHasRoutineForm
|
||
from ultron.followup.models import (
|
||
Note,
|
||
Plan,
|
||
Skill,
|
||
Point,
|
||
Chrono,
|
||
Accident,
|
||
MindState,
|
||
LearnedSkill,
|
||
HeightWeight,
|
||
SeasonInformation,
|
||
NumberOfRoutineDone,
|
||
)
|
||
|
||
from ultron.followup.models import CATEGORY_CHOICES
|
||
|
||
from ultron.tools.models import Season
|
||
|
||
from ultron.tools.pdf_generator import GymnastReportDocument
|
||
|
||
from .models import Gymnast
|
||
from .forms import GymnastForm, UserForm
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["POST"])
|
||
def gymnast_lookup(request):
|
||
"""
|
||
Récupère la liste des gymnastes à la volée suivant des caractères de
|
||
recherche entrés. (min 3 caractères)
|
||
"""
|
||
|
||
results = []
|
||
pattern = request.POST.get("pattern", None)
|
||
|
||
if pattern is not None and len(pattern) > 3:
|
||
model_results = Gymnast.objects.filter(
|
||
Q(last_name__icontains=pattern) | Q(first_name__icontains=pattern)
|
||
)
|
||
results = [{"ID": x.id, "Name": str(x)} for x in model_results]
|
||
|
||
return JsonResponse(results, safe=False)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_listing(request):
|
||
"""
|
||
Si la personne connectée est un entraîneur : liste tous les gymnasts connus.
|
||
Si la personne connectée est un gymnaste : renvoie sa fiche détaillée.
|
||
"""
|
||
season = Season()
|
||
if request.user.groups.filter(name="trainer").exists():
|
||
season_information_list = SeasonInformation.objects.filter(
|
||
season=season.label
|
||
).select_related("gymnast")
|
||
context = {"season_information_list": season_information_list}
|
||
return render(request, "people/gymnasts/list.html", context)
|
||
else:
|
||
gymnast = Gymnast.objects.get(user=request.user)
|
||
return gymnast_details(request, gymnast.id)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_details(request, gymnast_id, tab=None):
|
||
"""
|
||
Récupère toutes les informations d'un gymnaste si la personne connectée est un "trainer".
|
||
Si la personne connectée est un gymnaste : renvoie sa fiche détaillée.
|
||
"""
|
||
|
||
if request.user.groups.filter(name="trainer").exists():
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
else:
|
||
gymnast = Gymnast.objects.get(user=request.user)
|
||
|
||
last_season_information = gymnast.season_informations.order_by("-season").first()
|
||
|
||
gymnast_nb_known_skills = gymnast.known_skills.distinct(
|
||
"skill"
|
||
).count() # devrait disparaitre
|
||
|
||
nb_skill = Skill.objects.all().count()
|
||
nb_known_skill = (
|
||
LearnedSkill.objects.filter(gymnast=gymnast_id).distinct("skill").count()
|
||
)
|
||
|
||
if nb_skill != 0:
|
||
percentage_known_skill = (nb_known_skill / nb_skill) * 100
|
||
else:
|
||
percentage_known_skill = 0
|
||
|
||
# base_queryset = Chrono.objects.filter(gymnast=gymnast_id).order_by("-date")
|
||
chronos_list = Chrono.objects.filter(gymnast=gymnast_id).order_by("-date")[:10]
|
||
straightjump_score = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=0)
|
||
.order_by("-date")
|
||
)
|
||
best_straightjump = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=0)
|
||
.order_by("-score")[:1]
|
||
)
|
||
best_routine = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=1)
|
||
.order_by("-score")[:1]
|
||
)
|
||
|
||
context = {
|
||
"gymnast": gymnast,
|
||
"last_season_information": last_season_information,
|
||
"gymnast_nb_known_skills": gymnast_nb_known_skills,
|
||
"chronos_list": chronos_list,
|
||
"straightjump_score": straightjump_score,
|
||
"best_routine": best_routine,
|
||
"best_straightjump": best_straightjump,
|
||
"nb_skill": nb_skill,
|
||
"nb_known_skill": nb_known_skill,
|
||
"percentage_known_skill": percentage_known_skill,
|
||
"tab": tab,
|
||
}
|
||
context["user_is_trainer"] = request.user.groups.filter(
|
||
name="trainer"
|
||
).exists() # TODO: utiliser les {{ perms }}
|
||
return render(request, "people/gymnasts/details.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def preview_gymnast_report(request, gymnast_id):
|
||
"""Génère la preview pour le rapport"""
|
||
if request.user.groups.filter(name="trainer").exists():
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
else:
|
||
gymnast = Gymnast.objects.get(user=request.user)
|
||
|
||
gymnast_nb_known_skills = gymnast.known_skills.distinct(
|
||
"skill"
|
||
).count() # devrait disparaitre
|
||
|
||
nb_skill = Skill.objects.all().count()
|
||
nb_known_skill = (
|
||
LearnedSkill.objects.filter(gymnast=gymnast_id).distinct("skill").count()
|
||
)
|
||
|
||
if nb_skill != 0:
|
||
percentage_known_skill = (nb_known_skill / nb_skill) * 100
|
||
else:
|
||
percentage_known_skill = 0
|
||
|
||
# base_queryset = Chrono.objects.filter(gymnast=gymnast_id).order_by("-date")
|
||
chronos_list = Chrono.objects.filter(gymnast=gymnast_id).order_by("-date")[:10]
|
||
straightjump_score = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=0)
|
||
.order_by("-date")
|
||
)
|
||
best_straightjump = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=0)
|
||
.order_by("-score")[:1]
|
||
)
|
||
best_tof_routine_1 = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=1)
|
||
.order_by("-score")[:1]
|
||
)
|
||
best_tof_routine_2 = (
|
||
Chrono.objects.filter(gymnast=gymnast_id)
|
||
.filter(chrono_type=2)
|
||
.order_by("-score")[:1]
|
||
)
|
||
|
||
context = {
|
||
"gymnast": gymnast,
|
||
"gymnast_nb_known_skills": gymnast_nb_known_skills,
|
||
"chronos_list": chronos_list,
|
||
"straightjump_score": straightjump_score,
|
||
"best_tof_routine_1": best_tof_routine_1,
|
||
"best_tof_routine_2": best_tof_routine_2,
|
||
"best_straightjump": best_straightjump,
|
||
"nb_skill": nb_skill,
|
||
"nb_known_skill": nb_known_skill,
|
||
"percentage_known_skill": percentage_known_skill,
|
||
}
|
||
context["user_is_trainer"] = request.user.groups.filter(
|
||
name="trainer"
|
||
).exists() # TODO: utiliser les {{ perms }}
|
||
return render(request, "people/gymnasts/report.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def generate_gymnast_report(request, gymnast_id):
|
||
"""Génère un fichier PDF suivant contenant les informations du gymnast
|
||
|
||
Args:
|
||
gymnast_id (int): gymnast
|
||
|
||
Returns:
|
||
???
|
||
"""
|
||
|
||
if request.user.groups.filter(name="trainer").exists():
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
else:
|
||
gymnast = Gymnast.objects.get(user=request.user)
|
||
|
||
response = HttpResponse(content_type="application/pdf")
|
||
response["Content-Disposition"] = (
|
||
'attachment; filename="report_'
|
||
+ gymnast.first_name
|
||
+ "_"
|
||
+ gymnast.last_name
|
||
+ '.pdf"'
|
||
)
|
||
document = GymnastReportDocument(response)
|
||
document.generate(gymnast_id)
|
||
document.download()
|
||
|
||
return response
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_events_and_notes(request, gymnast_id):
|
||
"""
|
||
Renvoie deux listes d'évènements : ceux à venir et ceux passés.
|
||
"""
|
||
today = pendulum.now().date()
|
||
next_event_list = Event.objects.filter(gymnasts=gymnast_id, date_begin__gte=today)
|
||
previous_event_list = Event.objects.filter(
|
||
gymnasts=gymnast_id, date_begin__lte=today
|
||
)
|
||
|
||
base_queryset = Note.objects.filter(gymnast=gymnast_id)
|
||
if not request.user.groups.filter(name="trainer").exists():
|
||
notes_list = base_queryset.filter(status=1)
|
||
else:
|
||
notes_list = base_queryset
|
||
notes_list = notes_list.order_by("-created_at")
|
||
|
||
last_notes_list = notes_list[:5]
|
||
latest_published_note = (
|
||
base_queryset.filter(status=1).order_by("-created_at").first()
|
||
)
|
||
|
||
context = {
|
||
"next_event_list": next_event_list,
|
||
"previous_event_list": previous_event_list,
|
||
"last_notes_list": last_notes_list,
|
||
"latest_published_note": latest_published_note,
|
||
"gymnast_id": gymnast_id,
|
||
}
|
||
return render(request, "people/gymnasts/tab_events_and_notes.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_accident(request, gymnast_id):
|
||
"""
|
||
Renvoie la liste des accidents d'un gymnaste.
|
||
"""
|
||
accident_list = Accident.objects.filter(gymnast=gymnast_id)
|
||
context = {"accident_list": accident_list, "gymnast_id": gymnast_id}
|
||
return render(request, "people/gymnasts/list_accident.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_physiological(request, gymnast_id):
|
||
"""
|
||
Renvoie les listes des tailles/poids, état d'esprit et accidents.
|
||
"""
|
||
accident_list = Accident.objects.filter(gymnast=gymnast_id).order_by("date")
|
||
mindstate_list = MindState.objects.filter(gymnast=gymnast_id).order_by("date")
|
||
height_weight_list = HeightWeight.objects.filter(gymnast=gymnast_id).order_by(
|
||
"date"
|
||
)
|
||
|
||
context = {
|
||
"accident_list": accident_list,
|
||
"mindstate_list": mindstate_list,
|
||
"height_weight_list": height_weight_list,
|
||
"gymnast_id": gymnast_id,
|
||
}
|
||
return render(request, "people/gymnasts/tab_physiological.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_scores_chrono(request, gymnast_id):
|
||
"""
|
||
Selectionne tous les scores réalisés par le gymnaste
|
||
|
||
Afin de ne pas avoir plusieurs valeurs pour une même date, nous faisons une
|
||
moyenne par date.
|
||
"""
|
||
score_list = Point.objects.filter(gymnast=gymnast_id).order_by("-event__date_begin")
|
||
chrono_list = Chrono.objects.filter(gymnast=gymnast_id).order_by("date")
|
||
base_queryset = chrono_list.values("date").annotate(score_avg=Avg("tof"))
|
||
|
||
context = {
|
||
"score_list": score_list,
|
||
"score_routine1_list": score_list.filter(routine_type=1),
|
||
"score_routine2_list": score_list.filter(routine_type=2),
|
||
"score_routine3_list": score_list.filter(routine_type=3),
|
||
"chrono_list": chrono_list,
|
||
"chrono_10c": base_queryset.filter(chrono_type=0),
|
||
"chrono_r1": base_queryset.filter(chrono_type=1),
|
||
"chrono_r2": base_queryset.filter(chrono_type=2),
|
||
"chrono_rf": base_queryset.filter(chrono_type=3),
|
||
"gymnast_id": gymnast_id,
|
||
}
|
||
return render(request, "people/gymnasts/tab_scores_and_chronos.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_mindstate(request, gymnast_id):
|
||
"""
|
||
Selectionne tous les scores réalisés par le gymnaste
|
||
"""
|
||
mindstate_list = MindState.objects.filter(gymnast=gymnast_id).order_by("-date")
|
||
|
||
context = {
|
||
"mindstate_list": mindstate_list,
|
||
"gymnast_id": gymnast_id,
|
||
}
|
||
return render(request, "people/gymnasts/list_mindstate.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_routine_statistics(request, gymnast_id):
|
||
"""
|
||
Tag affichant les statistiques et informations de séries d'un gymnaste.
|
||
"""
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
ghr_list = gymnast.has_routine.prefetch_related("routine").filter(
|
||
Q(date_end__gte=date.today()) | Q(date_end__isnull=True)
|
||
)
|
||
|
||
has_routine_1 = ghr_list.filter(routine_type=1)
|
||
has_routine_2 = ghr_list.filter(routine_type=2)
|
||
has_routine_3 = ghr_list.filter(routine_type=3)
|
||
has_routine_4 = ghr_list.filter(routine_type=4)
|
||
|
||
routine_one_done_list = NumberOfRoutineDone.objects.filter(
|
||
gymnast=gymnast_id, routine_type=1
|
||
).order_by("date")
|
||
routine_two_done_list = NumberOfRoutineDone.objects.filter(
|
||
gymnast=gymnast_id, routine_type=2
|
||
).order_by("date")
|
||
|
||
context = {
|
||
"ghr_list": ghr_list,
|
||
"has_routine_1": has_routine_1,
|
||
"has_routine_2": has_routine_2,
|
||
"has_routine_3": has_routine_3,
|
||
"has_routine_4": has_routine_4,
|
||
"routine_one_done_list": routine_one_done_list,
|
||
"routine_two_done_list": routine_two_done_list,
|
||
"gymnast_id": gymnast_id,
|
||
}
|
||
return render(
|
||
request, "people/gymnasts/tab_routines_and_routine_stats.html", context
|
||
)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET", "POST"])
|
||
def link_routine_to_gymnast(request, gymnast_id=None):
|
||
""" """
|
||
|
||
if gymnast_id:
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
data = {
|
||
"gymnast": gymnast_id,
|
||
"gymnast_related": str(gymnast),
|
||
"date_end": None,
|
||
}
|
||
else:
|
||
gymnast = None
|
||
data = {"date_end": None}
|
||
|
||
if request.method == "POST":
|
||
form = GymnastHasRoutineForm(request.POST)
|
||
|
||
if form.is_valid():
|
||
form.save()
|
||
if gymnast_id is not None:
|
||
return HttpResponseRedirect(
|
||
reverse("gymnast_details", args=(gymnast_id,))
|
||
)
|
||
|
||
return HttpResponseRedirect(reverse("gymnast_list"))
|
||
|
||
else:
|
||
form = GymnastHasRoutineForm(instance=gymnast, initial=data)
|
||
|
||
context = {"form": form, "gymnast_id": gymnast_id}
|
||
return render(request, "people/gymnasts/link_to_routine.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET", "POST"])
|
||
def gymnast_create_or_update(request, gymnast_id=None):
|
||
"""
|
||
Formulaire de creation et modification d'un gymnaste.
|
||
"""
|
||
|
||
if gymnast_id:
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
data = {"club_related": gymnast.club}
|
||
else:
|
||
gymnast = None
|
||
data = {}
|
||
|
||
if request.method == "POST":
|
||
gymnast_form = GymnastForm(request.POST, instance=gymnast)
|
||
|
||
if gymnast_form.is_valid():
|
||
gymnast = gymnast_form.save()
|
||
form_data = request.POST.dict()
|
||
user_data = {}
|
||
user_data["first_name"] = form_data["first_name"]
|
||
user_data["last_name"] = form_data["last_name"]
|
||
user_data["username"] = (
|
||
form_data["first_name"].lower() + "_" + form_data["last_name"].lower()
|
||
)
|
||
user_data["email"] = form_data["email"].lower()
|
||
user_data["is_active"] = True
|
||
user_form = UserForm(user_data, instance=gymnast.user)
|
||
|
||
if user_form.is_valid():
|
||
user = user_form.save()
|
||
|
||
gymnast_group, _ = Group.objects.get_or_create(name="gymnast")
|
||
user.groups.add(gymnast_group)
|
||
gymnast.user = user
|
||
gymnast.save()
|
||
|
||
# if not user.has_usable_password():
|
||
# user.set_password(gymnast.last_name.lower() + _ + str(gymnast.birthdate)[-2:])
|
||
|
||
return HttpResponseRedirect(reverse("gymnast_details", args=(gymnast.pk,)))
|
||
else:
|
||
return render(
|
||
request, "people/gymnasts/create.html", {"form": gymnast_form}
|
||
)
|
||
|
||
form = GymnastForm(instance=gymnast, initial=data)
|
||
context = {"form": form, "gymnast_id": gymnast_id}
|
||
return render(request, "people/gymnasts/create.html", context)
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def gymnast_display_skill(request, gymnast_id):
|
||
"""Tag affichant les statistiques de skill d'un gymnaste
|
||
|
||
Le nombre de saut qu'il sait faire (total, par niveau, par rank, …), calcule la complétude, …
|
||
|
||
.. todo:: Générer UNE fois la liste de skill que le gymnaste ne sait pas faire (1 query)
|
||
et les counts puis, dans le template on parcourt plusieurs fois cette même liste mais on
|
||
affiche conditionnellement (par age, par rank, ...)
|
||
|
||
Il y a 4 étapes dans l'apprentissage :
|
||
- skill confusion syndrom "No" - 0
|
||
- avec aide (tapis, manip, …) "with help" - 1
|
||
- sans aide () "without help" - 2
|
||
- enchaîné (un saut avec et après) "chained" - 3
|
||
- maitrisé (dans n'importe quelle condition) "masterised" - 4
|
||
"""
|
||
|
||
context = {}
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
gymnast_nb_known_skills = gymnast.known_skills.distinct("skill").count()
|
||
context = gymnast.get_informations_from_type("level")
|
||
context.update(gymnast.get_informations_from_type("rank"))
|
||
|
||
planned_skill = (
|
||
Plan.objects.filter(gymnast=gymnast.id, educative__in=(Skill.objects.all()))
|
||
.select_related("educative", "educative__skill")
|
||
.order_by("-date", "educative__long_label")
|
||
)
|
||
|
||
context["planned_skill"] = planned_skill
|
||
|
||
if gymnast.gender:
|
||
context["skill_by_age"] = Skill.objects.filter(
|
||
age_girl_masterised__lte=gymnast.age
|
||
).exclude(known_by__gymnast=gymnast.id)
|
||
else:
|
||
context["skill_by_age"] = Skill.objects.filter(
|
||
age_boy_masterised__lte=gymnast.age
|
||
).exclude(known_by__gymnast=gymnast.id)
|
||
|
||
learned_skills = (
|
||
LearnedSkill.objects.filter(gymnast=gymnast_id)
|
||
.select_related("skill")
|
||
.order_by("skill_id", "-date")
|
||
.distinct("skill_id")
|
||
)
|
||
|
||
# skill_learned_by_phase = [[]] * 5
|
||
## print(skill_learned_by_phase)
|
||
confused_skill = list()
|
||
skill_whith_help = list()
|
||
skill_without_help = list()
|
||
skill_chained = list()
|
||
skill_masterised = list()
|
||
for learned_skill in learned_skills:
|
||
# print('Add skill for ' + str(learned_skill.learning_step) + ' phase')
|
||
# skill_learned_by_phase[learned_skill.learning_step].append(learned_skill.skill)
|
||
if learned_skill.learning_step == 0:
|
||
confused_skill.append(learned_skill.skill)
|
||
elif learned_skill.learning_step == 1:
|
||
skill_whith_help.append(learned_skill.skill)
|
||
elif learned_skill.learning_step == 2:
|
||
skill_without_help.append(learned_skill.skill)
|
||
elif learned_skill.learning_step == 3:
|
||
skill_chained.append(learned_skill.skill)
|
||
else:
|
||
skill_masterised.append(learned_skill.skill)
|
||
|
||
# for i in range(0,4):
|
||
# print(skill_learned_by_phase[i])
|
||
|
||
# context["confused_skill"] = skill_learned_by_phase[0]
|
||
# context["skill_whith_help"] = skill_learned_by_phase[1]
|
||
# context["skill_without_help"] = skill_learned_by_phase[2]
|
||
# context["skill_chained"] = skill_learned_by_phase[3]
|
||
# context["skill_masterised"] = skill_learned_by_phase[4]
|
||
context["confused_skill"] = confused_skill
|
||
context["skill_whith_help"] = skill_whith_help
|
||
context["skill_without_help"] = skill_without_help
|
||
context["skill_chained"] = skill_chained
|
||
context["skill_masterised"] = skill_masterised
|
||
|
||
context["gymnast"] = gymnast
|
||
context["gymnast_nb_known_skills"] = gymnast_nb_known_skills
|
||
context["user_is_trainer"] = request.user.groups.filter(
|
||
name="trainer"
|
||
).exists() # TODO: utiliser les {{ perms }}
|
||
return render(request, "people/gymnasts/tab_skill.html", context)
|
||
|
||
|
||
def analyse_score(value, value_list):
|
||
"""Analyse une value (value) par rapport à la moyenne de value_list et à la dernière
|
||
valeur de value_list
|
||
|
||
Args:
|
||
value float valeur
|
||
value_list array<float> liste de valeurs
|
||
|
||
Returns:
|
||
string
|
||
|
||
Examples:
|
||
"""
|
||
res = ""
|
||
mean_value = mean(value_list)
|
||
|
||
if value > value_list[-1]:
|
||
res += "+"
|
||
elif value < value_list[-1]:
|
||
res += "-"
|
||
else:
|
||
res += "="
|
||
|
||
if value > mean_value:
|
||
res = "+" + res
|
||
elif value < mean_value:
|
||
res = "-" + res
|
||
else:
|
||
res = "=" + res
|
||
|
||
return res
|
||
|
||
|
||
@login_required
|
||
@require_http_methods(["GET"])
|
||
def generate_report(request, gymnast_id):
|
||
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
||
today = pendulum.now().date()
|
||
season, week_number = from_date_to_week_number(today)
|
||
# season = Season()
|
||
|
||
#
|
||
# PHYSIOLOGICAL INFORMATIONS
|
||
#
|
||
mindstate_queryset = MindState.objects.filter(gymnast=gymnast).order_by("-date")
|
||
last_mindstate = mindstate_queryset.first()
|
||
lasts_mindstate = list(mindstate_queryset.values_list("score", flat=True)[1:6])
|
||
|
||
have_physiological = False
|
||
if lasts_mindstate:
|
||
mindstate_analyse = analyse_score(last_mindstate.score, lasts_mindstate)
|
||
|
||
height_weight_queryset = HeightWeight.objects.filter(gymnast=gymnast).order_by(
|
||
"-date"
|
||
)
|
||
last_height_weigth = height_weight_queryset.first()
|
||
lasts_height = list(height_weight_queryset.values_list("height", flat=True)[1:6])
|
||
lasts_weight = list(height_weight_queryset.values_list("weight", flat=True)[1:6])
|
||
|
||
if lasts_height:
|
||
height_analyse = analyse_score(last_height_weigth.height, lasts_height)
|
||
|
||
if lasts_weight:
|
||
weight_analyse = analyse_score(last_height_weigth.weight, lasts_weight)
|
||
|
||
#
|
||
# BEST TOF
|
||
#
|
||
best_tof_straightjump = (
|
||
Chrono.objects.filter(gymnast=gymnast)
|
||
.filter(chrono_type=0)
|
||
.order_by("-score")
|
||
.first()
|
||
)
|
||
best_tof_routine_1 = (
|
||
Chrono.objects.filter(gymnast=gymnast)
|
||
.filter(chrono_type=1)
|
||
.order_by("-score")
|
||
.first()
|
||
)
|
||
best_tof_routine_2 = (
|
||
Chrono.objects.filter(gymnast=gymnast)
|
||
.filter(chrono_type=2)
|
||
.order_by("-score")
|
||
.first()
|
||
)
|
||
|
||
#
|
||
# BEST SCORES
|
||
#
|
||
best_point_routine_1 = (
|
||
Point.objects.filter(gymnast=gymnast)
|
||
.filter(routine_type=1)
|
||
.order_by("-total")
|
||
.first()
|
||
)
|
||
best_point_routine_2 = (
|
||
Point.objects.filter(gymnast=gymnast)
|
||
.filter(routine_type=2)
|
||
.order_by("-total")
|
||
.first()
|
||
)
|
||
|
||
#
|
||
# ROUTINES
|
||
#
|
||
routine_1 = (
|
||
gymnast.has_routine.filter(routine_type=1)
|
||
.filter(date_begin__lte=today)
|
||
.filter(Q(date_end__gte=today) | Q(date_end__isnull=True))
|
||
.first()
|
||
)
|
||
routine_2 = (
|
||
gymnast.has_routine.filter(routine_type=2)
|
||
.filter(date_begin__lte=today)
|
||
.filter(Q(date_end__gte=today) | Q(date_end__isnull=True))
|
||
.first()
|
||
)
|
||
# print(routine_2)
|
||
|
||
#
|
||
# LAST LEARNED SKILLS
|
||
#
|
||
learned_skills = (
|
||
LearnedSkill.objects.filter(gymnast=gymnast.id)
|
||
.annotate(skill_notation=F("skill__notation"))
|
||
.order_by("skill_notation", "-date")
|
||
.distinct("skill_notation")[:6]
|
||
)
|
||
|
||
#
|
||
# PLANNED SKILLS
|
||
#
|
||
plan_list = (
|
||
Plan.objects.filter(gymnast=gymnast, educative__in=(Skill.objects.all()))
|
||
.filter(Q(is_done=False) | Q(date__gte=date.today()))
|
||
.order_by("educative", "-date")
|
||
.distinct()[:6]
|
||
)
|
||
|
||
#
|
||
# NEXT EVENTS
|
||
#
|
||
next_event_list = Event.objects.filter(
|
||
gymnasts=gymnast.id, date_begin__gte=today
|
||
).order_by("date_begin")[:5]
|
||
|
||
#
|
||
# NOTES
|
||
#
|
||
begin_of_the_week = today
|
||
if today.weekday() != 0:
|
||
begin_of_the_week -= timedelta(today.weekday())
|
||
|
||
notes = (
|
||
gymnast.remarks.filter(date__gte=begin_of_the_week)
|
||
.filter(status=1)
|
||
.order_by("date")
|
||
)
|
||
|
||
context = {
|
||
"SITE_TITLE": settings.SITE_TITLE,
|
||
"CLUB_NAME": settings.CLUB_NAME,
|
||
"ADDRESS": settings.ADDRESS,
|
||
"CITY": settings.CITY,
|
||
"ZIP": settings.ZIP,
|
||
"HEAD_COACH": settings.HEAD_COACH,
|
||
"MOBILE_PHONE": settings.MOBILE_PHONE,
|
||
"HEAD_COACH_EMAIL": settings.HEAD_COACH_EMAIL,
|
||
"week_number": week_number,
|
||
"gymnast": gymnast,
|
||
"today": today,
|
||
"season": season,
|
||
"last_mindstate": last_mindstate,
|
||
"mindstate_analyse": mindstate_analyse,
|
||
"last_height_weigth": last_height_weigth,
|
||
"height_analyse": height_analyse,
|
||
"weight_analyse": weight_analyse,
|
||
"best_tof_straightjump": best_tof_straightjump,
|
||
"best_tof_routine_1": best_tof_routine_1,
|
||
"best_tof_routine_2": best_tof_routine_2,
|
||
"best_point_routine_1": best_point_routine_1,
|
||
"best_point_routine_2": best_point_routine_2,
|
||
"routine_1": routine_1,
|
||
"routine_2": routine_2,
|
||
"LEARNING_STEP_CHOICES": LEARNING_STEP_CHOICES,
|
||
"learned_skills": learned_skills,
|
||
"plan_list": plan_list,
|
||
"next_event_list": next_event_list,
|
||
"notes": notes,
|
||
}
|
||
|
||
# return render(request, "people/gymnasts/report.html", context)
|
||
|
||
response = HttpResponse(content_type="application/pdf")
|
||
response[
|
||
"Content-Disposition"
|
||
] = "inline; filename={lastname}-{firstname}-report.pdf".format(
|
||
lastname=gymnast.last_name,
|
||
firstname=gymnast.first_name,
|
||
)
|
||
|
||
html = render_to_string("people/gymnasts/report.html", context)
|
||
|
||
# font_config = FontConfiguration()
|
||
HTML(string=html).write_pdf(
|
||
response,
|
||
stylesheets=[
|
||
CSS(settings.STATICFILES_DIRS[0] + "/css/gymnast_report.css"),
|
||
CSS(settings.STATICFILES_DIRS[0] + "/css/black-dashboard_report.css"),
|
||
CSS(settings.STATICFILES_DIRS[0] + "/css/font_awesome_all_5.15.3.css"),
|
||
],
|
||
) # , font_config=font_config)
|
||
return response
|