747 lines
25 KiB
Python
747 lines
25 KiB
Python
from datetime import date, datetime
|
|
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 django.conf import settings
|
|
from django.contrib.auth import get_user_model
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.core.mail import send_mail
|
|
|
|
import pendulum
|
|
|
|
from jarvis.core.models import Email
|
|
from jarvis.people.models import Gymnast
|
|
from jarvis.people.views import gymnast_listing
|
|
from jarvis.objective.models import Skill
|
|
from jarvis.tools.date_week_transition import from_date_to_week_number
|
|
from .models import (
|
|
Plan,
|
|
Note,
|
|
Point,
|
|
Chrono,
|
|
LearnedSkill,
|
|
GymnastHasRoutine,
|
|
SeasonInformation,
|
|
NumberOfRoutineDone,
|
|
)
|
|
|
|
from .forms import (
|
|
PlanForm,
|
|
NoteForm,
|
|
ScoreForm,
|
|
LearnedSkillForm,
|
|
SeasonInformationForm,
|
|
NumberOfRoutineDoneForm,
|
|
)
|
|
|
|
from .email_vars import MAIL_HEADER, MAIL_FOOTER
|
|
|
|
User = get_user_model()
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def note_listing(request, gymnast_id=None):
|
|
"""
|
|
Récupère les notes des gymnastes autorisé(e)s
|
|
|
|
Args:
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
gymnast = None
|
|
if gymnast_id and (
|
|
request.user.is_superuser
|
|
or (
|
|
request.session.has_key("available_gymnast")
|
|
and gymnast_id in request.session["available_gymnast"]
|
|
)
|
|
):
|
|
note_list = Note.objects.filter(gymnast=gymnast_id)
|
|
gymnast = Gymnast.objects.get(pk=gymnast_id)
|
|
else:
|
|
if request.user.is_superuser:
|
|
note_list = Note.objects.all()
|
|
else:
|
|
note_list = Note.objects.filter(
|
|
gymnast__in=request.session["available_gymnast"]
|
|
)
|
|
|
|
context = {"note_list": note_list, "gymnast": gymnast}
|
|
return render(request, "notes/list.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def note_details(request, note_id):
|
|
"""
|
|
Récupère toutes les informations d'un note et vérifie si le demandeur peut avoir accès à la
|
|
note. S'il ne peut pas il est redirigé vers le listing des notes.
|
|
|
|
Args:
|
|
note_id (int) identifiant d'une note
|
|
"""
|
|
note = get_object_or_404(Note, pk=note_id)
|
|
|
|
if not request.user.is_superuser and (
|
|
request.session.has_key("available_gymnast")
|
|
and note.gymnast.id not in request.session["available_gymnast"]
|
|
):
|
|
return note_listing(request)
|
|
|
|
return render(request, "notes/details.html", {"note": note})
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def note_create_or_update(request, note_id=None, gymnast_id=None):
|
|
"""Création ou modification d'une note
|
|
|
|
Args:
|
|
note_id (int) identifiant d'une note
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
|
|
TODO: pq ne puis-je pas récuperer l'idantifiant du coach via le form ?
|
|
"""
|
|
|
|
coach = User.objects.get(pk=request.user.id)
|
|
if note_id:
|
|
note = get_object_or_404(Note, pk=note_id)
|
|
if not request.user.is_superuser and (
|
|
request.session.has_key("available_gymnast")
|
|
and note.gymnast.id not in request.session["available_gymnast"]
|
|
):
|
|
return note_listing(request)
|
|
data = {
|
|
"coach": coach.id,
|
|
"gymnast": note.gymnast.id,
|
|
"gymnast_related": str(note.gymnast),
|
|
}
|
|
else:
|
|
note = None
|
|
today = pendulum.now().date()
|
|
season, week_number = from_date_to_week_number(today)
|
|
data = {
|
|
"coach": coach.id,
|
|
"title": f"Note of the week {week_number} ({season})",
|
|
}
|
|
if gymnast_id is not None:
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
data["gymnast"] = gymnast_id
|
|
data["gymnast_related"] = str(gymnast)
|
|
|
|
if request.method == "POST":
|
|
form = NoteForm(request.POST, instance=note)
|
|
|
|
if form.is_valid():
|
|
new_note = form.save()
|
|
if (
|
|
(new_note.gymnast.user.email or new_note.gymnast.email_trainer)
|
|
and ((not note_id) or (note_id and note.status == 0))
|
|
and new_note.status == 1
|
|
):
|
|
|
|
url = request.build_absolute_uri(
|
|
reverse("gymnast_details_tab", args=(new_note.gymnast.id, "event"))
|
|
)
|
|
receivers = [
|
|
new_note.gymnast.user.email,
|
|
new_note.gymnast.email_trainer,
|
|
]
|
|
title = f"{new_note.gymnast} : Nouvelle note"
|
|
body = f"""<p>Bonjour,</p><p>Une nouvelle note vous a été envoyée. Vous pouvez la consulter en cliquant <a href='{url}'>ici</a>.</p>"""
|
|
|
|
send_mail(
|
|
title,
|
|
"Une nouvelle note vous a été envoyée",
|
|
settings.EMAIL_HOST_USER,
|
|
receivers,
|
|
fail_silently=False,
|
|
html_message=body + MAIL_FOOTER,
|
|
)
|
|
return HttpResponseRedirect(
|
|
reverse("gymnast_details_tab", args=(new_note.gymnast.id, "event"))
|
|
)
|
|
|
|
return render(request, "notes/create.html", {"form": form})
|
|
|
|
last_note = (
|
|
Note.objects.filter(gymnast=gymnast_id, status=1).order_by("-date").first()
|
|
)
|
|
if last_note:
|
|
data["informations"] = last_note.informations
|
|
|
|
form = NoteForm(instance=note, initial=data)
|
|
context = {"form": form, "note_id": note_id}
|
|
return render(request, "notes/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.
|
|
gymnast_id = request.POST.get("gymnast_id", None)
|
|
skill_id = request.POST.get("skill_id", None)
|
|
learning_step = request.POST.get("learning_step", 0)
|
|
|
|
if gymnast_id and skill_id:
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
skill = Skill.objects.get(pk=skill_id)
|
|
learned_skill = LearnedSkill(
|
|
gymnast=gymnast,
|
|
skill=skill,
|
|
learning_step=learning_step,
|
|
date=datetime.now(),
|
|
)
|
|
learned_skill.save()
|
|
return HttpResponse(status=200)
|
|
|
|
if gymnast_id:
|
|
print("Error : can not link Gymnast and skill. Missing skill_id.")
|
|
else:
|
|
print("Error : can not link Gymnast and skill. Missing gymnast_id.")
|
|
return HttpResponse(status=500)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def learnedskill_create_or_update(request, gymnast_id=None):
|
|
"""
|
|
Formulaire de creation et modification d'un lien skill/gymnaste.
|
|
|
|
Args:
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
if gymnast_id:
|
|
if not request.user.is_superuser and (
|
|
request.session.has_key("available_gymnast")
|
|
and gymnast_id not in request.session["available_gymnast"]
|
|
):
|
|
return gymnast_listing(request)
|
|
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
data = {
|
|
"gymnast": gymnast.id,
|
|
"gymnast_related": str(gymnast),
|
|
}
|
|
else:
|
|
data = None
|
|
|
|
if request.method == "POST":
|
|
form = LearnedSkillForm(request.POST)
|
|
|
|
if form.is_valid():
|
|
learned_skill = form.save()
|
|
|
|
# notification
|
|
receivers = []
|
|
functionality = ContentType.objects.get(model="learnedskill")
|
|
for notification in gymnast.notifications.filter(
|
|
functionality=functionality
|
|
):
|
|
receivers.append(notification.user.email)
|
|
|
|
title = f"{learned_skill.gymnast} : Nouveau skill appris"
|
|
html_message = f"""<p>Bonjour,</p><p>{learned_skill.gymnast} a appris {learned_skill.skill} ({learned_skill.learning_step}).</p>"""
|
|
|
|
Email.objects.create(
|
|
receivers=receivers,
|
|
title=title,
|
|
body=html_message,
|
|
)
|
|
|
|
send_mail(
|
|
title,
|
|
f"{learned_skill.gymnast} a appris une nouvelle figure ({date})",
|
|
settings.EMAIL_HOST_USER,
|
|
receivers,
|
|
fail_silently=False,
|
|
html_message=html_message + MAIL_FOOTER,
|
|
)
|
|
|
|
return HttpResponseRedirect(
|
|
reverse("gymnast_details", args=(form.cleaned_data["gymnast"].id,))
|
|
)
|
|
|
|
return render(request, "learnedskills/create.html", {"form": form})
|
|
|
|
form = LearnedSkillForm(initial=data)
|
|
context = {"form": form, "gymnast_id": gymnast_id}
|
|
return render(request, "learnedskills/create.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def score_create_or_update(request, score_id=None, gymnast_id=None):
|
|
"""
|
|
Formulaire de création d'un nouveau score.
|
|
|
|
Args:
|
|
score_id (int) identifiant d'un score
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
if score_id:
|
|
score = get_object_or_404(Point, pk=score_id)
|
|
if not request.user.is_superuser and (
|
|
request.session.has_key("available_gymnast")
|
|
and score.gymnast.id not in request.session["available_gymnast"]
|
|
):
|
|
return score_listing(request)
|
|
data = {
|
|
"gymnast_related": str(score.gymnast),
|
|
"event_related": str(score.event),
|
|
}
|
|
else:
|
|
score = None
|
|
data = None
|
|
if gymnast_id is not None:
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
data = {"gymnast": gymnast_id, "gymnast_related": str(gymnast)}
|
|
|
|
if request.method == "POST":
|
|
form = ScoreForm(request.POST, instance=score)
|
|
|
|
if form.is_valid():
|
|
score = form.save()
|
|
|
|
# notification
|
|
receivers = []
|
|
functionality = ContentType.objects.get(model="point")
|
|
for notification in score.gymnast.notifications.filter(
|
|
functionality=functionality
|
|
):
|
|
receivers.append(notification.user.email)
|
|
|
|
title = f"{score.gymnast} : Nouveau score enregistré"
|
|
html_message = f"""<p>Bonjour,</p><p>Un nouveau score a été enregistré pour {score.gymnast} :<br /><br />
|
|
{score.event.name} à {score.event.place.address} - {score.event.place.postal} {score.event.place.city}
|
|
{score.routine_type} : {score.total} points
|
|
<ul>
|
|
<li>Diff: {score.point_difficulty}</li>
|
|
<li>ToF: {score.point_time_of_flight}</li>
|
|
<li>Exe: {score.point_execution}</li>
|
|
<li>HD: {score.point_horizontal_displacement}</li>
|
|
<li>Pen: {score.penality}</li>
|
|
</ul></p>"""
|
|
|
|
Email.objects.create(
|
|
receivers=receivers,
|
|
title=title,
|
|
body=html_message,
|
|
)
|
|
|
|
send_mail(
|
|
title,
|
|
f"{score.gymnast} a ajouté un nouveau score ({date})",
|
|
settings.EMAIL_HOST_USER,
|
|
receivers,
|
|
fail_silently=False,
|
|
html_message=html_message + MAIL_FOOTER,
|
|
)
|
|
|
|
if form.cleaned_data["add_to_chrono"]:
|
|
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"],
|
|
date=form.cleaned_data["event"].date_begin,
|
|
)
|
|
new_chrono.save()
|
|
|
|
return HttpResponseRedirect(
|
|
reverse(
|
|
"gymnast_details_tab",
|
|
args=(form.cleaned_data["gymnast"].id, "routine"),
|
|
)
|
|
)
|
|
|
|
return render(request, "scores/create.html", {"form": form})
|
|
|
|
form = ScoreForm(instance=score, initial=data)
|
|
context = {"form": form, "score_id": score_id}
|
|
return render(request, "scores/create.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def score_listing(request, gymnast_id=None):
|
|
"""
|
|
Revoie la liste des scores
|
|
|
|
Args:
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
# pattern = request.GET.get("pattern", None)
|
|
# JE NE SAIS PLUS POURQUOI JE GERE UN PATTERN -> code commenté.
|
|
# if pattern:
|
|
# score_list = Point.objects.filter(
|
|
# Q(event__icontains=pattern) | Q(gymnast__icontains=pattern)
|
|
# )
|
|
# el
|
|
gymnast = None
|
|
if gymnast_id and (
|
|
request.user.is_superuser
|
|
or (
|
|
request.session.has_key("available_gymnast")
|
|
and gymnast_id in request.session["available_gymnast"]
|
|
)
|
|
):
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
score_list = Point.objects.filter(gymnast=gymnast_id)
|
|
else:
|
|
if request.user.is_superuser:
|
|
score_list = Point.objects.all()
|
|
else:
|
|
score_list = Point.objects.filter(
|
|
gymnast__in=request.session["available_gymnast"]
|
|
)
|
|
|
|
context = {"score_list": score_list, "gymnast": gymnast}
|
|
return render(request, "scores/list.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def routine_done_listing(request, gymnast_id=None):
|
|
"""
|
|
Liste tous les record de la table NumberOfRoutineDone
|
|
|
|
Args:
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
gymnast = None
|
|
if gymnast_id and (
|
|
request.user.is_superuser
|
|
or (
|
|
request.session.has_key("available_gymnast")
|
|
and gymnast_id in request.session["available_gymnast"]
|
|
)
|
|
):
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
routine_done_list = gymnast.number_of_routine_done.all()
|
|
else:
|
|
if request.user.is_superuser:
|
|
routine_done_list = NumberOfRoutineDone.objects.all()
|
|
else:
|
|
routine_done_list = NumberOfRoutineDone.objects.filter(
|
|
gymnast__in=request.session["available_gymnast"]
|
|
)
|
|
|
|
context = {"routine_done_list": routine_done_list, "gymnast": gymnast}
|
|
return render(request, "routinedone/list.html", context)
|
|
|
|
|
|
@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
|
|
"""
|
|
|
|
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()),
|
|
}
|
|
|
|
routine = (
|
|
data["gymnast"]
|
|
.has_routine.filter(routine_type=request.POST.get("routine_type", 1))
|
|
.first()
|
|
)
|
|
data["routine"] = routine.routine
|
|
|
|
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)
|
|
if int(success) == 1:
|
|
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)
|
|
|
|
return HttpResponse(status=406)
|
|
|
|
|
|
@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 nombre de série tentée.
|
|
|
|
Args:
|
|
routinedone_id (int) identifiant d'une routinedone
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
if routinedone_id:
|
|
routinedone = get_object_or_404(NumberOfRoutineDone, pk=routinedone_id)
|
|
data = {
|
|
"gymnast": routinedone.gymnast.id,
|
|
"gymnast_related": str(routinedone.gymnast),
|
|
}
|
|
if routinedone.routine:
|
|
data["routine"] = routinedone.routine.id
|
|
data["routine_related"] = str(routinedone.routine)
|
|
else:
|
|
routine = (
|
|
GymnastHasRoutine.objects.filter(gymnast=routinedone.gymnast)
|
|
.filter(routine_type=routinedone.routine_type)
|
|
.filter(date_begin__lte=routinedone.date)
|
|
.filter(Q(date_end__gte=routinedone.date) | Q(date_end__isnull=True))
|
|
.first()
|
|
)
|
|
if routine:
|
|
data["routine"] = routine.id
|
|
data["routine_related"] = str(routine)
|
|
else:
|
|
data = None
|
|
routinedone = None
|
|
if gymnast_id is not None:
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
data = {"gymnast": gymnast_id, "gymnast_related": gymnast}
|
|
|
|
if request.method == "POST":
|
|
form = NumberOfRoutineDoneForm(request.POST, instance=routinedone)
|
|
|
|
if form.is_valid():
|
|
routine_done = form.save()
|
|
|
|
# notification
|
|
receivers = []
|
|
gymnast = Gymnast.objects.get(pk=form.cleaned_data["gymnast"].id)
|
|
functionality = ContentType.objects.get(model="numberofroutinedone")
|
|
for notification in routine_done.gymnast.notifications.filter(
|
|
functionality=functionality
|
|
):
|
|
receivers.append(notification.user.email)
|
|
|
|
title = f"{routine_done.gymnast} : Nouvelle série comptabilisée"
|
|
body = f"""<p>Bonjour,</p>
|
|
<p>Nouvelle série comptabilisée pour {routine_done.gymnast}.</p>"""
|
|
|
|
Email.objects.create(receivers=receivers, title=title, body=body)
|
|
|
|
send_mail(
|
|
title,
|
|
f"Nouvelle série comptabilisée pour {routine_done.gymnast}",
|
|
settings.EMAIL_HOST_USER,
|
|
receivers,
|
|
fail_silently=False,
|
|
html_message=body + MAIL_FOOTER,
|
|
)
|
|
|
|
return HttpResponseRedirect(
|
|
reverse(
|
|
"gymnast_details_tab",
|
|
args=(form.cleaned_data["gymnast"].id, "routine"),
|
|
)
|
|
)
|
|
|
|
return render(request, "routinedone/create.html", {"form": form})
|
|
|
|
form = NumberOfRoutineDoneForm(instance=routinedone, initial=data)
|
|
context = {"form": form, "routinedone_id": routinedone_id}
|
|
return render(request, "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),
|
|
"educative": plan.educative.id,
|
|
"educative_related": str(plan.educative),
|
|
}
|
|
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()
|
|
|
|
# notification
|
|
receivers = []
|
|
date = form.cleaned_data["date"]
|
|
functionality = ContentType.objects.get(model="plan")
|
|
for notification in plan.gymnast.notifications.filter(
|
|
functionality=functionality
|
|
):
|
|
receivers.append(notification.user.email)
|
|
|
|
title = f"{plan.gymnast} : Nouvel objectif fixé"
|
|
body = f"""<p>Bonjour,</p>
|
|
<p>Nouvel objectif fixé pour {plan.gymnast} : {plan.educative} ({plan.learning_step}) pour le {date.strftime('%d %B %Y')} au plus tard.</p>"""
|
|
|
|
Email.objects.create(receivers=receivers, title=title, body=body)
|
|
|
|
send_mail(
|
|
title,
|
|
f"Nouvel objectif fixé pour {plan.gymnast}",
|
|
settings.EMAIL_HOST_USER,
|
|
receivers,
|
|
fail_silently=False,
|
|
html_message=body + MAIL_FOOTER,
|
|
)
|
|
|
|
return HttpResponseRedirect(
|
|
reverse("gymnast_details", args=(form.cleaned_data["gymnast"].id,))
|
|
)
|
|
|
|
return render(request, "plan/create.html", {"form": form})
|
|
|
|
form = PlanForm(instance=plan, initial=data)
|
|
context = {"form": form, "plan_id": plan_id}
|
|
return render(request, "plan/create.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def season_information_create_or_update(
|
|
request, season_information_id=None, gymnast_id=None
|
|
):
|
|
"""Création d'un record de la class SeasonInformation.
|
|
|
|
Args:
|
|
season_information_id (int): identifiant d'un plan (classe <SeasonInformation>).
|
|
gymnast_id (int): identifiant d'un gymnaste (classe <Gymnast>).
|
|
"""
|
|
|
|
if season_information_id:
|
|
season_information = get_object_or_404(
|
|
SeasonInformation, pk=season_information_id
|
|
)
|
|
if not request.user.is_superuser and (
|
|
request.session.has_key("available_gymnast")
|
|
and season_information.gymnast.id
|
|
not in request.session["available_gymnast"]
|
|
):
|
|
return season_information_listing(request)
|
|
data = {
|
|
"gymnast": season_information.gymnast.id,
|
|
"gymnast_related": str(season_information.gymnast),
|
|
"club": season_information.club.id,
|
|
"club_related": str(season_information.club),
|
|
}
|
|
else:
|
|
season_information = None
|
|
data = {}
|
|
|
|
if gymnast_id:
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
data["gymnast"] = gymnast_id
|
|
data["gymnast_related"] = str(gymnast)
|
|
|
|
if request.method == "POST":
|
|
form = SeasonInformationForm(request.POST, instance=season_information)
|
|
|
|
if form.is_valid():
|
|
season_information = form.save()
|
|
|
|
# notification
|
|
receivers = []
|
|
functionality = ContentType.objects.get(model="seasoninformation")
|
|
for notification in season_information.gymnast.notifications.filter(
|
|
functionality=functionality
|
|
):
|
|
receivers.append(notification.user.email)
|
|
|
|
title = f"{season_information.gymnast} : Nouvelle information de saison"
|
|
body = f"""<p>Bonjour,</p>
|
|
<p>Une nouvelle information de saison enregistrée pour {season_information.gymnast}.</p>"""
|
|
|
|
Email.objects.create(receivers=receivers, title=title, body=body)
|
|
|
|
send_mail(
|
|
title,
|
|
f"Une nouvelle information de saison enregistrée pour {season_information.gymnast}",
|
|
settings.EMAIL_HOST_USER,
|
|
receivers,
|
|
fail_silently=False,
|
|
html_message=body + MAIL_FOOTER,
|
|
)
|
|
|
|
return HttpResponseRedirect(
|
|
reverse(
|
|
"gymnast_details",
|
|
args=(form.cleaned_data["gymnast"].id,),
|
|
)
|
|
)
|
|
|
|
return render(request, "seasoninformations/create.html", {"form": form})
|
|
|
|
form = SeasonInformationForm(instance=season_information, initial=data)
|
|
context = {"form": form, "season_information_id": season_information_id}
|
|
return render(request, "seasoninformations/create.html", context)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def season_information_listing(request, gymnast_id=None):
|
|
"""Liste toutes les informations de saison pour un gymnaste.
|
|
|
|
Args:
|
|
gymnast_id (int) identifiant d'un gymnaste
|
|
"""
|
|
|
|
if gymnast_id and (
|
|
request.user.is_superuser
|
|
or (
|
|
request.session.has_key("available_gymnast")
|
|
and gymnast_id in request.session["available_gymnast"]
|
|
)
|
|
):
|
|
gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
|
|
season_information_list = SeasonInformation.objects.filter(gymnast=gymnast_id)
|
|
else:
|
|
if request.user.is_superuser:
|
|
season_information_list = SeasonInformation.objects.all()
|
|
else:
|
|
season_information_list = SeasonInformation.objects.filter(
|
|
gymnast__in=request.session["available_gymnast"]
|
|
)
|
|
|
|
context = {"season_information_list": season_information_list, "gymnast": gymnast}
|
|
return render(request, "seasoninformations/list.html", context)
|