mirror of
https://gitlab.com/animath/si/plateforme.git
synced 2024-11-26 11:27:09 +00:00
2027 lines
96 KiB
Python
2027 lines
96 KiB
Python
# Copyright (C) 2020 by Animath
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
import csv
|
|
from io import BytesIO
|
|
import os
|
|
import subprocess
|
|
from tempfile import mkdtemp
|
|
from typing import Any, Dict
|
|
from zipfile import ZipFile
|
|
|
|
from django.conf import settings
|
|
from django.contrib import messages
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.contrib.sites.models import Site
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.core.mail import send_mail
|
|
from django.db import transaction
|
|
from django.db.models import F
|
|
from django.http import FileResponse, Http404, HttpResponse
|
|
from django.shortcuts import redirect
|
|
from django.template.loader import render_to_string
|
|
from django.urls import reverse_lazy
|
|
from django.utils import timezone
|
|
from django.utils.crypto import get_random_string
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.views.generic import CreateView, DetailView, FormView, RedirectView, TemplateView, UpdateView, View
|
|
from django.views.generic.detail import SingleObjectMixin
|
|
from django.views.generic.edit import FormMixin, ProcessFormView
|
|
from django_tables2 import MultiTableMixin, SingleTableMixin, SingleTableView
|
|
import gspread
|
|
from magic import Magic
|
|
from odf.opendocument import OpenDocumentSpreadsheet
|
|
from odf.style import Style, TableCellProperties, TableColumnProperties, TextProperties
|
|
from odf.table import CoveredTableCell, Table, TableCell, TableColumn, TableRow
|
|
from odf.text import P
|
|
from registration.models import Payment, VolunteerRegistration
|
|
from registration.tables import PaymentTable
|
|
from tfjm.lists import get_sympa_client
|
|
from tfjm.views import AdminMixin, VolunteerMixin
|
|
|
|
from .forms import AddJuryForm, JoinTeamForm, MotivationLetterForm, NoteForm, ParticipationForm, PassageForm, \
|
|
PoolForm, RequestValidationForm, SolutionForm, SynthesisForm, TeamForm, TournamentForm, \
|
|
UploadNotesForm, ValidateParticipationForm
|
|
from .models import Note, Participation, Passage, Pool, Solution, Synthesis, Team, Tournament, Tweak
|
|
from .tables import NoteTable, ParticipationTable, PassageTable, PoolTable, TeamTable, TournamentTable
|
|
|
|
|
|
class CreateTeamView(LoginRequiredMixin, CreateView):
|
|
"""
|
|
Display the page to create a team for new users.
|
|
"""
|
|
|
|
model = Team
|
|
form_class = TeamForm
|
|
extra_context = dict(title=_("Create team"))
|
|
template_name = "participation/create_team.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
user = request.user
|
|
if not user.is_authenticated:
|
|
return super().handle_no_permission()
|
|
registration = user.registration
|
|
if not registration.participates:
|
|
raise PermissionDenied(_("You don't participate, so you can't create a team."))
|
|
elif registration.team:
|
|
raise PermissionDenied(_("You are already in a team."))
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
"""
|
|
When a team is about to be created, the user automatically
|
|
joins the team, a mailing list got created and the user is
|
|
automatically subscribed to this mailing list.
|
|
"""
|
|
ret = super().form_valid(form)
|
|
# The user joins the team
|
|
user = self.request.user
|
|
registration = user.registration
|
|
registration.team = form.instance
|
|
registration.save()
|
|
|
|
# Subscribe the user mail address to the team mailing list
|
|
get_sympa_client().subscribe(user.email, f"equipe-{form.instance.trigram.lower()}", False,
|
|
f"{user.first_name} {user.last_name}")
|
|
|
|
return ret
|
|
|
|
|
|
class JoinTeamView(LoginRequiredMixin, FormView):
|
|
"""
|
|
Participants can join a team with the access code of the team.
|
|
"""
|
|
model = Team
|
|
form_class = JoinTeamForm
|
|
extra_context = dict(title=_("Join team"))
|
|
template_name = "participation/join_team.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
user = request.user
|
|
if not user.is_authenticated:
|
|
return super().handle_no_permission()
|
|
registration = user.registration
|
|
if not registration.participates:
|
|
raise PermissionDenied(_("You don't participate, so you can't create a team."))
|
|
elif registration.team:
|
|
raise PermissionDenied(_("You are already in a team."))
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
"""
|
|
When a user joins a team, the user is automatically subscribed to
|
|
the team mailing list.
|
|
"""
|
|
self.object = form.instance
|
|
ret = super().form_valid(form)
|
|
|
|
# Join the team
|
|
user = self.request.user
|
|
registration = user.registration
|
|
registration.team = form.instance
|
|
registration.save()
|
|
|
|
# Subscribe to the team mailing list
|
|
get_sympa_client().subscribe(user.email, f"equipe-{form.instance.trigram.lower()}", False,
|
|
f"{user.first_name} {user.last_name}")
|
|
|
|
return ret
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("participation:team_detail", args=(self.object.pk,))
|
|
|
|
|
|
class TeamListView(AdminMixin, SingleTableView):
|
|
"""
|
|
Display the whole list of teams
|
|
"""
|
|
model = Team
|
|
table_class = TeamTable
|
|
ordering = ('trigram',)
|
|
|
|
|
|
class MyTeamDetailView(LoginRequiredMixin, RedirectView):
|
|
"""
|
|
Redirect to the detail of the team in which the user is.
|
|
"""
|
|
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
user = self.request.user
|
|
registration = user.registration
|
|
if registration.participates:
|
|
if registration.team:
|
|
return reverse_lazy("participation:team_detail", args=(registration.team_id,))
|
|
raise PermissionDenied(_("You are not in a team."))
|
|
raise PermissionDenied(_("You don't participate, so you don't have any team."))
|
|
|
|
|
|
class TeamDetailView(LoginRequiredMixin, FormMixin, ProcessFormView, DetailView):
|
|
"""
|
|
Display the detail of a team.
|
|
"""
|
|
model = Team
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
user = request.user
|
|
self.object = self.get_object()
|
|
# Ensure that the user is an admin or a volunteer or a member of the team
|
|
if user.registration.is_admin or user.registration.participates and \
|
|
user.registration.team and user.registration.team.pk == kwargs["pk"] \
|
|
or user.registration.is_volunteer \
|
|
and (self.object.participation.tournament in user.registration.interesting_tournaments
|
|
or self.object.participation.final
|
|
and Tournament.final_tournament() in user.registration.interesting_tournaments):
|
|
return super().get(request, *args, **kwargs)
|
|
raise PermissionDenied
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
team = self.get_object()
|
|
context["title"] = _("Detail of team {trigram}").format(trigram=self.object.trigram)
|
|
context["request_validation_form"] = RequestValidationForm(self.request.POST or None)
|
|
context["validation_form"] = ValidateParticipationForm(self.request.POST or None)
|
|
# A team is complete when there are at least 4 members plus a coache that have sent their authorizations,
|
|
# their health sheet, they confirmed their email address and under-18 people sent their parental authorization.
|
|
context["can_validate"] = team.can_validate()
|
|
|
|
return context
|
|
|
|
def get_form_class(self):
|
|
if not self.request.POST:
|
|
return RequestValidationForm
|
|
elif self.request.POST["_form_type"] == "RequestValidationForm":
|
|
return RequestValidationForm
|
|
elif self.request.POST["_form_type"] == "ValidateParticipationForm":
|
|
return ValidateParticipationForm
|
|
|
|
def form_valid(self, form):
|
|
self.object = self.get_object()
|
|
if isinstance(form, RequestValidationForm):
|
|
return self.handle_request_validation(form)
|
|
elif isinstance(form, ValidateParticipationForm):
|
|
return self.handle_validate_participation(form)
|
|
|
|
def handle_request_validation(self, form):
|
|
"""
|
|
A team requests to be validated
|
|
"""
|
|
if not self.request.user.registration.participates:
|
|
form.add_error(None, _("You don't participate, so you can't request the validation of the team."))
|
|
return self.form_invalid(form)
|
|
if self.object.participation.valid is not None:
|
|
form.add_error(None, _("The validation of the team is already done or pending."))
|
|
return self.form_invalid(form)
|
|
if not self.get_context_data()["can_validate"]:
|
|
form.add_error(None, _("The team can't be validated: missing email address confirmations, "
|
|
"authorizations, people, motivation letter or the tournament is not set."))
|
|
return self.form_invalid(form)
|
|
|
|
self.object.participation.valid = False
|
|
self.object.participation.save()
|
|
|
|
mail_context = dict(team=self.object, domain=Site.objects.first().domain)
|
|
mail_plain = render_to_string("participation/mails/request_validation.txt", mail_context)
|
|
mail_html = render_to_string("participation/mails/request_validation.html", mail_context)
|
|
send_mail("[TFJM²] Validation d'équipe", mail_plain, settings.DEFAULT_FROM_EMAIL,
|
|
[self.object.participation.tournament.organizers_email], html_message=mail_html)
|
|
|
|
return super().form_valid(form)
|
|
|
|
def handle_validate_participation(self, form):
|
|
"""
|
|
An admin validates the team (or not)
|
|
"""
|
|
if not self.request.user.registration.is_admin and \
|
|
(not self.object.participation.tournament
|
|
or self.request.user.registration not in self.object.participation.tournament.organizers.all()):
|
|
form.add_error(None, _("You are not an organizer of the tournament."))
|
|
return self.form_invalid(form)
|
|
elif self.object.participation.valid is not False:
|
|
form.add_error(None, _("This team has no pending validation."))
|
|
return self.form_invalid(form)
|
|
|
|
if "validate" in self.request.POST:
|
|
self.object.participation.valid = True
|
|
self.object.participation.save()
|
|
|
|
domain = Site.objects.first().domain
|
|
for registration in self.object.participants.all():
|
|
if registration.is_student and self.object.participation.tournament.price:
|
|
payment = Payment.objects.get(registrations=registration, final=False)
|
|
else:
|
|
payment = None
|
|
mail_context = dict(domain=domain, registration=registration, team=self.object, payment=payment,
|
|
message=form.cleaned_data["message"])
|
|
mail_plain = render_to_string("participation/mails/team_validated.txt", mail_context)
|
|
mail_html = render_to_string("participation/mails/team_validated.html", mail_context)
|
|
registration.user.email_user("[TFJM²] Équipe validée", mail_plain, html_message=mail_html)
|
|
elif "invalidate" in self.request.POST:
|
|
self.object.participation.valid = None
|
|
self.object.participation.save()
|
|
mail_context = dict(team=self.object, message=form.cleaned_data["message"])
|
|
mail_plain = render_to_string("participation/mails/team_not_validated.txt", mail_context)
|
|
mail_html = render_to_string("participation/mails/team_not_validated.html", mail_context)
|
|
send_mail("[TFJM²] Équipe non validée", mail_plain, None, [self.object.email],
|
|
html_message=mail_html)
|
|
else:
|
|
form.add_error(None, _("You must specify if you validate the registration or not."))
|
|
return self.form_invalid(form)
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return self.request.path
|
|
|
|
|
|
class TeamUpdateView(LoginRequiredMixin, UpdateView):
|
|
"""
|
|
Update the detail of a team
|
|
"""
|
|
model = Team
|
|
form_class = TeamForm
|
|
template_name = "participation/update_team.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
user = request.user
|
|
if not user.is_authenticated:
|
|
return super().handle_no_permission()
|
|
if user.registration.is_admin or user.registration.participates and \
|
|
user.registration.team and user.registration.team.pk == kwargs["pk"] \
|
|
or user.registration.is_volunteer \
|
|
and (self.get_object().participation.tournament in user.registration.interesting_tournaments
|
|
or self.get_object().participation.final
|
|
and Tournament.final_tournament() in user.registration.interesting_tournaments):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
raise PermissionDenied
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["participation_form"] = ParticipationForm(data=self.request.POST or None,
|
|
instance=self.object.participation)
|
|
if not self.request.user.registration.is_volunteer:
|
|
del context["participation_form"].fields['final']
|
|
context["title"] = _("Update team {trigram}").format(trigram=self.object.trigram)
|
|
return context
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
participation_form = ParticipationForm(data=self.request.POST or None, instance=self.object.participation)
|
|
if not self.request.user.registration.is_volunteer:
|
|
del participation_form.fields['final']
|
|
if not participation_form.is_valid():
|
|
return self.form_invalid(form)
|
|
|
|
participation_form.save()
|
|
return super().form_valid(form)
|
|
|
|
|
|
class TeamUploadMotivationLetterView(LoginRequiredMixin, UpdateView):
|
|
"""
|
|
A team can send its motivation letter.
|
|
"""
|
|
model = Team
|
|
form_class = MotivationLetterForm
|
|
template_name = "participation/upload_motivation_letter.html"
|
|
extra_context = dict(title=_("Upload motivation letter"))
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not self.request.user.is_authenticated or \
|
|
not self.request.user.registration.is_admin \
|
|
and self.request.user.registration.team != self.get_object():
|
|
return self.handle_no_permission()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
old_instance = Team.objects.get(pk=self.object.pk)
|
|
if old_instance.motivation_letter:
|
|
old_instance.motivation_letter.delete()
|
|
old_instance.save()
|
|
return super().form_valid(form)
|
|
|
|
|
|
class MotivationLetterView(LoginRequiredMixin, View):
|
|
"""
|
|
Display the sent motivation letter.
|
|
"""
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
filename = kwargs["filename"]
|
|
path = f"media/authorization/motivation_letters/{filename}"
|
|
if not os.path.exists(path):
|
|
raise Http404
|
|
team = Team.objects.get(motivation_letter__endswith=filename)
|
|
user = request.user
|
|
if not (user.registration in team.participants.all() or user.registration.is_admin
|
|
or user.registration.is_volunteer
|
|
and team.participation.tournament in user.registration.organized_tournaments.all()):
|
|
raise PermissionDenied
|
|
# Guess mime type of the file
|
|
mime = Magic(mime=True)
|
|
mime_type = mime.from_file(path)
|
|
ext = mime_type.split("/")[1].replace("jpeg", "jpg")
|
|
# Replace file name
|
|
true_file_name = _("Motivation letter of {team}.{ext}").format(team=str(team), ext=ext)
|
|
return FileResponse(open(path, "rb"), content_type=mime_type, filename=true_file_name)
|
|
|
|
|
|
class TeamAuthorizationsView(LoginRequiredMixin, View):
|
|
"""
|
|
Get as a ZIP archive all the authorizations that are sent
|
|
"""
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
user = request.user
|
|
if not user.is_authenticated:
|
|
return super().handle_no_permission()
|
|
|
|
if 'team_id' in kwargs:
|
|
team = Team.objects.get(pk=kwargs["team_id"])
|
|
tournament = team.participation.tournament
|
|
else:
|
|
team = None
|
|
tournament = Tournament.objects.get(pk=kwargs["tournament_id"])
|
|
|
|
if user.registration.is_admin or user.registration.is_volunteer \
|
|
and (user.registration in tournament.organizers
|
|
or (team is not None and team.participation.final
|
|
and user.registration in Tournament.final_tournament().organizers)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
raise PermissionDenied
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if 'team_id' in kwargs:
|
|
team = Team.objects.get(pk=kwargs["team_id"])
|
|
teams = [team]
|
|
filename = _("Authorizations of team {trigram}.zip").format(trigram=team.trigram)
|
|
else:
|
|
tournament = Tournament.objects.get(pk=kwargs["tournament_id"])
|
|
teams = [p.team for p in tournament.participations.filter(valid=True)]
|
|
filename = _("Authorizations of {tournament}.zip").format(tournament=tournament.name)
|
|
|
|
magic = Magic(mime=True)
|
|
output = BytesIO()
|
|
zf = ZipFile(output, "w")
|
|
for team in teams:
|
|
team_prefix = f"{team.trigram}/" if len(teams) > 1 else ""
|
|
|
|
for participant in team.participants.all():
|
|
user_prefix = f"{team_prefix}{participant.user.first_name} {participant.user.last_name}/"
|
|
|
|
if participant.photo_authorization \
|
|
and participant.photo_authorization.storage.exists(participant.photo_authorization.path):
|
|
mime_type = magic.from_file("media/" + participant.photo_authorization.name)
|
|
ext = mime_type.split("/")[1].replace("jpeg", "jpg")
|
|
zf.write("media/" + participant.photo_authorization.name,
|
|
user_prefix + _("Photo authorization of {participant}.{ext}")
|
|
.format(participant=str(participant), ext=ext))
|
|
|
|
if participant.is_student and participant.parental_authorization \
|
|
and participant.parental_authorization.storage.exists(participant.parental_authorization.path):
|
|
mime_type = magic.from_file("media/" + participant.parental_authorization.name)
|
|
ext = mime_type.split("/")[1].replace("jpeg", "jpg")
|
|
zf.write("media/" + participant.parental_authorization.name,
|
|
user_prefix + _("Parental authorization of {participant}.{ext}")
|
|
.format(participant=str(participant), ext=ext))
|
|
|
|
if participant.is_student and participant.health_sheet \
|
|
and participant.health_sheet.storage.exists(participant.health_sheet.path):
|
|
mime_type = magic.from_file("media/" + participant.health_sheet.name)
|
|
ext = mime_type.split("/")[1].replace("jpeg", "jpg")
|
|
zf.write("media/" + participant.health_sheet.name,
|
|
user_prefix + _("Health sheet of {participant}.{ext}")
|
|
.format(participant=str(participant), ext=ext))
|
|
|
|
if participant.is_student and participant.vaccine_sheet \
|
|
and participant.vaccine_sheet.storage.exists(participant.vaccine_sheet.path):
|
|
mime_type = magic.from_file("media/" + participant.vaccine_sheet.name)
|
|
ext = mime_type.split("/")[1].replace("jpeg", "jpg")
|
|
zf.write("media/" + participant.vaccine_sheet.name,
|
|
user_prefix + _("Vaccine sheet of {participant}.{ext}")
|
|
.format(participant=str(participant), ext=ext))
|
|
|
|
if team.motivation_letter and team.motivation_letter.storage.exists(team.motivation_letter.path):
|
|
mime_type = magic.from_file("media/" + team.motivation_letter.name)
|
|
ext = mime_type.split("/")[1].replace("jpeg", "jpg")
|
|
zf.write("media/" + team.motivation_letter.name,
|
|
team_prefix + _("Motivation letter of {team}.{ext}")
|
|
.format(team=str(team), ext=ext))
|
|
|
|
zf.close()
|
|
response = HttpResponse(content_type="application/zip")
|
|
response["Content-Disposition"] = f"attachment; filename=\"{filename}\""
|
|
response.write(output.getvalue())
|
|
return response
|
|
|
|
|
|
class TeamLeaveView(LoginRequiredMixin, TemplateView):
|
|
"""
|
|
A team member leaves a team
|
|
"""
|
|
template_name = "participation/team_leave.html"
|
|
extra_context = dict(title=_("Leave team"))
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
if not request.user.registration.participates or not request.user.registration.team:
|
|
raise PermissionDenied(_("You are not in a team."))
|
|
if request.user.registration.team.participation.valid:
|
|
raise PermissionDenied(_("The team is already validated or the validation is pending."))
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
@transaction.atomic()
|
|
def post(self, request, *args, **kwargs):
|
|
"""
|
|
When the team is left, the user is unsubscribed from the team mailing list
|
|
and kicked from the team room.
|
|
"""
|
|
team = request.user.registration.team
|
|
request.user.registration.team = None
|
|
request.user.registration.save()
|
|
get_sympa_client().unsubscribe(request.user.email, f"equipe-{team.trigram.lower()}", False)
|
|
if team.students.count() + team.coaches.count() == 0:
|
|
team.delete()
|
|
return redirect(reverse_lazy("index"))
|
|
|
|
|
|
class MyParticipationDetailView(LoginRequiredMixin, RedirectView):
|
|
"""
|
|
Redirects to the detail view of the participation of the team.
|
|
"""
|
|
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
user = self.request.user
|
|
registration = user.registration
|
|
if registration.participates:
|
|
if registration.team:
|
|
return reverse_lazy("participation:participation_detail", args=(registration.team.participation.id,))
|
|
raise PermissionDenied(_("You are not in a team."))
|
|
raise PermissionDenied(_("You don't participate, so you don't have any team."))
|
|
|
|
|
|
class ParticipationDetailView(LoginRequiredMixin, DetailView):
|
|
"""
|
|
Display detail about the participation of a team, and manage the solution submission.
|
|
"""
|
|
model = Participation
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
user = request.user
|
|
if not user.is_authenticated:
|
|
return super().handle_no_permission()
|
|
if not self.get_object().valid:
|
|
raise PermissionDenied(_("The team is not validated yet."))
|
|
if user.registration.is_admin or user.registration.participates \
|
|
and user.registration.team.participation \
|
|
and user.registration.team.participation.pk == kwargs["pk"] \
|
|
or user.registration.is_volunteer \
|
|
and (self.get_object().tournament in user.registration.interesting_tournaments
|
|
or self.get_object().final
|
|
and Tournament.final_tournament() in user.registration.interesting_tournaments):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
raise PermissionDenied
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
context["title"] = lambda: _("Participation of team {trigram}").format(trigram=self.object.team.trigram)
|
|
|
|
return context
|
|
|
|
|
|
class TournamentListView(SingleTableView):
|
|
"""
|
|
Display the list of all tournaments.
|
|
"""
|
|
model = Tournament
|
|
table_class = TournamentTable
|
|
|
|
|
|
class TournamentCreateView(AdminMixin, CreateView):
|
|
"""
|
|
Create a new tournament.
|
|
"""
|
|
model = Tournament
|
|
form_class = TournamentForm
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("participation:tournament_detail", args=(self.object.pk,))
|
|
|
|
|
|
class TournamentUpdateView(VolunteerMixin, UpdateView):
|
|
"""
|
|
Update tournament detail.
|
|
"""
|
|
model = Tournament
|
|
form_class = TournamentForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated or not self.request.user.registration.is_admin \
|
|
and not (self.request.user.registration.is_volunteer
|
|
and self.request.user.registration.organized_tournaments.all()):
|
|
return self.handle_no_permission()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class TournamentDetailView(MultiTableMixin, DetailView):
|
|
"""
|
|
Display tournament detail.
|
|
"""
|
|
model = Tournament
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
tables = context['tables']
|
|
context["teams"] = tables[0]
|
|
context["pools"] = tables[1]
|
|
|
|
notes = dict()
|
|
for participation in self.object.participations.all():
|
|
note = sum(pool.average(participation)
|
|
for pool in self.object.pools.filter(participations=participation).all()
|
|
if pool.results_available
|
|
or (self.request.user.is_authenticated and self.request.user.registration.is_volunteer))
|
|
if note:
|
|
notes[participation] = note
|
|
context["notes"] = sorted(notes.items(), key=lambda x: x[1], reverse=True)
|
|
context["available_notes_1"] = all(pool.results_available for pool in self.object.pools.filter(round=1).all())
|
|
context["available_notes_2"] = all(pool.results_available for pool in self.object.pools.filter(round=2).all())
|
|
|
|
return context
|
|
|
|
def get_tables(self):
|
|
return [
|
|
ParticipationTable(self.object.participations.all()),
|
|
PoolTable(self.object.pools.order_by('id').all()),
|
|
]
|
|
|
|
|
|
class TournamentPaymentsView(VolunteerMixin, SingleTableMixin, DetailView):
|
|
"""
|
|
Display the list of payments of a tournament.
|
|
"""
|
|
model = Tournament
|
|
table_class = PaymentTable
|
|
template_name = "participation/tournament_payments.html"
|
|
|
|
def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
|
|
context = super().get_context_data(**kwargs)
|
|
context["title"] = _("Payments of {tournament}").format(tournament=self.object)
|
|
return context
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated or not self.request.user.registration.is_admin \
|
|
and not (self.request.user.registration.is_volunteer
|
|
and self.get_object() in self.request.user.registration.organized_tournaments.all()):
|
|
return self.handle_no_permission()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_table_data(self):
|
|
return Payment.objects.filter(registrations__team__participation__tournament=self.get_object()) \
|
|
.annotate(team_id=F('registrations__team')).order_by('-valid', 'registrations__team__trigram') \
|
|
.distinct().all()
|
|
|
|
|
|
class TournamentExportCSVView(VolunteerMixin, DetailView):
|
|
"""
|
|
Export all team informations in a CSV file.
|
|
"""
|
|
model = Tournament
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
tournament = self.get_object()
|
|
|
|
resp = HttpResponse(
|
|
content_type='text/csv',
|
|
headers={'Content-Disposition': f'attachment; filename="Tournoi de {tournament.name}.csv"'},
|
|
)
|
|
writer = csv.DictWriter(resp, ('Tournoi', 'Équipe', 'Trigramme', 'Sélectionnée',
|
|
'Nom', 'Prénom', 'Email', 'Type', 'Genre', 'Date de naissance',
|
|
'Adresse', 'Code postal', 'Ville', 'Téléphone',
|
|
'Classe', 'Établissement',
|
|
'Nom responsable légal⋅e', 'Téléphone responsable légal⋅e',
|
|
'Email responsable légal⋅e',
|
|
'Problèmes de santé', 'Contraintes de logement'))
|
|
writer.writeheader()
|
|
|
|
participations = tournament.participations
|
|
if 'all' not in request.GET:
|
|
participations = participations.filter(valid=True)
|
|
for participation in participations.order_by('-valid', 'team__trigram').all():
|
|
for registration in participation.team.participants \
|
|
.order_by('coachregistration', 'user__last_name').all():
|
|
writer.writerow({
|
|
'Tournoi': tournament.name,
|
|
'Équipe': participation.team.name,
|
|
'Trigramme': participation.team.trigram,
|
|
'Sélectionnée': ("oui" if participation.valid else
|
|
"en attente" if participation.valid is False else "non"),
|
|
'Nom': registration.user.last_name,
|
|
'Prénom': registration.user.first_name,
|
|
'Email': registration.user.email,
|
|
'Type': registration.type.capitalize(),
|
|
'Genre': registration.get_gender_display() if registration.is_student else '',
|
|
'Date de naissance': registration.birth_date if registration.is_student else '',
|
|
'Adresse': registration.address,
|
|
'Code postal': registration.zip_code,
|
|
'Ville': registration.city,
|
|
'Téléphone': registration.phone_number,
|
|
'Classe': registration.get_student_class_display() if registration.is_student
|
|
else registration.last_degree,
|
|
'Établissement': registration.school if registration.is_student
|
|
else registration.professional_activity,
|
|
'Nom responsable légal⋅e': registration.responsible_name if registration.is_student else '',
|
|
'Téléphone responsable légal⋅e': registration.responsible_phone if registration.is_student else '',
|
|
'Email responsable légal⋅e': registration.responsible_email if registration.is_student else '',
|
|
'Problèmes de santé': registration.health_issues,
|
|
'Contraintes de logement': registration.housing_constraints,
|
|
})
|
|
|
|
return resp
|
|
|
|
|
|
class TournamentPublishNotesView(VolunteerMixin, SingleObjectMixin, RedirectView):
|
|
"""
|
|
Publish notes of a tournament for a given round.
|
|
"""
|
|
model = Tournament
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
tournament = self.get_object()
|
|
reg = request.user.registration
|
|
if not reg.is_admin and (not reg.is_volunteer or tournament not in reg.organized_tournaments.all()):
|
|
return self.handle_no_permission()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if int(kwargs["round"]) not in (1, 2):
|
|
raise Http404
|
|
|
|
tournament = Tournament.objects.get(pk=kwargs["pk"])
|
|
tournament.pools.filter(round=kwargs["round"]).update(results_available='hide' not in request.GET)
|
|
if 'hide' not in request.GET:
|
|
messages.success(request, _("Notes published!"))
|
|
else:
|
|
messages.success(request, _("Notes hidden!"))
|
|
return super().get(request, *args, **kwargs)
|
|
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
return reverse_lazy("participation:tournament_detail", args=(kwargs['pk'],))
|
|
|
|
|
|
class TournamentHarmonizeView(VolunteerMixin, DetailView):
|
|
"""
|
|
Harmonize the notes of a tournament.
|
|
"""
|
|
model = Tournament
|
|
template_name = "participation/tournament_harmonize.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
tournament = self.get_object()
|
|
reg = request.user.registration
|
|
if not reg.is_admin and (not reg.is_volunteer or tournament not in reg.organized_tournaments.all()):
|
|
return self.handle_no_permission()
|
|
if self.kwargs['round'] not in (1, 2):
|
|
raise Http404
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
tournament = self.get_object()
|
|
context['round'] = self.kwargs['round']
|
|
context['pools'] = tournament.pools.filter(round=context["round"]).all()
|
|
context['title'] = _("Harmonize notes of {tournament} - Day {round}") \
|
|
.format(tournament=tournament, round=context["round"])
|
|
|
|
notes = dict()
|
|
for participation in self.object.participations.filter(valid=True).all():
|
|
note = sum(pool.average(participation) for pool in context['pools'])
|
|
tweak = sum(tweak.diff for tweak in participation.tweaks.filter(pool__in=context['pools']).all())
|
|
notes[participation] = {'note': note, 'tweak': tweak}
|
|
context["notes"] = sorted(notes.items(), key=lambda x: x[1]['note'], reverse=True)
|
|
|
|
return context
|
|
|
|
|
|
class TournamentHarmonizeNoteView(VolunteerMixin, DetailView):
|
|
model = Tournament
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
tournament = self.get_object()
|
|
reg = request.user.registration
|
|
if not reg.is_admin and (not reg.is_volunteer or tournament not in reg.organized_tournaments.all()):
|
|
return self.handle_no_permission()
|
|
if self.kwargs['round'] not in (1, 2) or self.kwargs['action'] not in ('add', 'remove') \
|
|
or self.kwargs['trigram'] not in [p.team.trigram
|
|
for p in tournament.participations.filter(valid=True).all()]:
|
|
raise Http404
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
tournament = self.get_object()
|
|
participation = tournament.participations.filter(valid=True).get(team__trigram=kwargs['trigram'])
|
|
pool = tournament.pools.get(round=kwargs['round'], participations=participation)
|
|
tweak_qs = Tweak.objects.filter(participation=participation, pool=pool)
|
|
old_diff = tweak_qs.first().diff if tweak_qs.exists() else 0
|
|
new_diff = old_diff + (1 if kwargs['action'] == 'add' else -1)
|
|
if new_diff == 0:
|
|
tweak_qs.delete()
|
|
else:
|
|
tweak_qs.update_or_create(defaults={'diff': new_diff},
|
|
create_defaults={'diff': new_diff, 'participation': participation, 'pool': pool})
|
|
|
|
gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
|
|
spreadsheet = gc.open_by_key(tournament.notes_sheet_id)
|
|
worksheet = spreadsheet.worksheet("Classement final")
|
|
column = 3 if kwargs['round'] == '1' else 5
|
|
row = worksheet.find(f"{participation.team.name} ({participation.team.trigram})", in_column=1).row
|
|
worksheet.update_cell(row, column, new_diff)
|
|
|
|
return redirect(reverse_lazy("participation:tournament_harmonize", args=(tournament.pk, kwargs['round'],)))
|
|
|
|
|
|
class SolutionUploadView(LoginRequiredMixin, FormView):
|
|
template_name = "participation/upload_solution.html"
|
|
form_class = SolutionForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
qs = Participation.objects.filter(pk=self.kwargs["pk"])
|
|
if not qs.exists():
|
|
raise Http404
|
|
self.participation = qs.get()
|
|
if not self.request.user.is_authenticated or not self.request.user.registration.is_admin \
|
|
and not (self.request.user.registration.participates
|
|
and self.request.user.registration.team == self.participation.team):
|
|
return self.handle_no_permission()
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
"""
|
|
When a solution is submitted, it replaces a previous solution if existing,
|
|
otherwise it creates a new solution.
|
|
It is discriminating whenever the team is selected for the final tournament or not.
|
|
"""
|
|
form_sol = form.instance
|
|
sol_qs = Solution.objects.filter(participation=self.participation,
|
|
problem=form_sol.problem,
|
|
final_solution=self.participation.final)
|
|
|
|
tournament = Tournament.final_tournament() if self.participation.final else self.participation.tournament
|
|
if timezone.now() > tournament.solution_limit and sol_qs.exists():
|
|
form.add_error(None, _("You can't upload a solution after the deadline."))
|
|
return self.form_invalid(form)
|
|
|
|
# Drop previous solution if existing
|
|
for sol in sol_qs.all():
|
|
sol.file.delete()
|
|
sol.save()
|
|
sol.delete()
|
|
form_sol.participation = self.participation
|
|
form_sol.final_solution = self.participation.final
|
|
form_sol.save()
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("participation:participation_detail", args=(self.participation.pk,))
|
|
|
|
|
|
class PoolCreateView(AdminMixin, CreateView):
|
|
model = Pool
|
|
form_class = PoolForm
|
|
|
|
|
|
class PoolDetailView(LoginRequiredMixin, DetailView):
|
|
model = Pool
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
if request.user.registration.is_admin or request.user.registration.participates \
|
|
and request.user.registration.team \
|
|
and request.user.registration.team.participation in self.get_object().participations.all() \
|
|
or request.user.registration.is_volunteer \
|
|
and self.get_object().tournament in request.user.registration.interesting_tournaments:
|
|
return super().dispatch(request, *args, **kwargs)
|
|
return self.handle_no_permission()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
context["passages"] = PassageTable(self.object.passages.order_by('id').all())
|
|
|
|
if self.object.results_available or self.request.user.registration.is_volunteer:
|
|
# Hide notes before the end of the turn
|
|
notes = dict()
|
|
for participation in self.object.participations.all():
|
|
note = self.object.average(participation)
|
|
if note:
|
|
notes[participation] = note
|
|
context["notes"] = sorted(notes.items(), key=lambda x: x[1], reverse=True)
|
|
|
|
return context
|
|
|
|
|
|
class PoolUpdateView(VolunteerMixin, UpdateView):
|
|
model = Pool
|
|
form_class = PoolForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
if request.user.registration.is_admin or request.user.registration.is_volunteer \
|
|
and self.get_object().tournament in request.user.registration.organized_tournaments.all():
|
|
return super().dispatch(request, *args, **kwargs)
|
|
return self.handle_no_permission()
|
|
|
|
def form_valid(self, form):
|
|
ret = super().form_valid(form)
|
|
# Update Google Sheets juries lines
|
|
if os.getenv('GOOGLE_PRIVATE_KEY_ID', None):
|
|
self.object.update_juries_lines_spreadsheet()
|
|
return ret
|
|
|
|
|
|
class SolutionsDownloadView(VolunteerMixin, View):
|
|
"""
|
|
Download all solutions or syntheses as a ZIP archive.
|
|
"""
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
|
|
reg = request.user.registration
|
|
if reg.is_admin:
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
if 'team_id' in kwargs:
|
|
team = Team.objects.get(pk=kwargs["team_id"])
|
|
tournament = team.participation.tournament
|
|
if reg.participates and reg.team == team \
|
|
or reg.is_volunteer and (reg in tournament.organizers.all() or team.participation.final
|
|
and reg in Tournament.final_tournament().organizers):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
elif 'tournament_id' in kwargs:
|
|
tournament = Tournament.objects.get(pk=kwargs["tournament_id"])
|
|
if reg.is_volunteer \
|
|
and (tournament in reg.organized_tournaments.all()
|
|
or reg.pools_presided.filter(tournament=tournament).exists()):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
else:
|
|
pool = Pool.objects.get(pk=kwargs["pool_id"])
|
|
tournament = pool.tournament
|
|
if reg.is_volunteer \
|
|
and (reg in tournament.organizers.all()
|
|
or reg in pool.juries.all()
|
|
or reg.pools_presided.filter(tournament=tournament).exists()):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
is_solution = 'solutions' in request.path
|
|
|
|
if 'team_id' in kwargs:
|
|
team = Team.objects.get(pk=kwargs["team_id"])
|
|
solutions = Solution.objects.filter(participation=team.participation).all()
|
|
syntheses = Synthesis.objects.filter(participation=team.participation).all()
|
|
filename = _("Solutions of team {trigram}.zip") if is_solution else _("Syntheses of team {trigram}.zip")
|
|
filename = filename.format(trigram=team.trigram)
|
|
|
|
def prefix(s: Solution | Synthesis) -> str:
|
|
return ""
|
|
elif 'tournament_id' in kwargs:
|
|
tournament = Tournament.objects.get(pk=kwargs["tournament_id"])
|
|
sort_by = request.GET.get('sort_by', 'team').lower()
|
|
|
|
if sort_by == 'pool':
|
|
pools = Pool.objects.filter(tournament=tournament).all()
|
|
solutions = []
|
|
for pool in pools:
|
|
for sol in pool.solutions:
|
|
sol.pool = pool
|
|
solutions.append(sol)
|
|
syntheses = Synthesis.objects.filter(passage__pool__tournament=tournament).all()
|
|
filename = _("Solutions of {tournament}.zip") if is_solution else _("Syntheses of {tournament}.zip")
|
|
filename = filename.format(tournament=tournament.name)
|
|
|
|
def prefix(s: Solution | Synthesis) -> str:
|
|
pool = s.pool if is_solution else s.passage.pool
|
|
p = f"Poule {pool.get_letter_display()}{pool.round}/"
|
|
if not is_solution:
|
|
p += f"Passage {s.passage.position}/"
|
|
return p
|
|
else:
|
|
if not tournament.final:
|
|
solutions = Solution.objects.filter(participation__tournament=tournament).all()
|
|
else:
|
|
solutions = Solution.objects.filter(final_solution=True).all()
|
|
syntheses = Synthesis.objects.filter(passage__pool__tournament=tournament).all()
|
|
filename = _("Solutions of {tournament}.zip") if is_solution else _("Syntheses of {tournament}.zip")
|
|
filename = filename.format(tournament=tournament.name)
|
|
|
|
def prefix(s: Solution | Synthesis) -> str:
|
|
return f"{s.participation.team.trigram}/" if sort_by == "team" else f"Problème {s.problem}/"
|
|
else:
|
|
pool = Pool.objects.get(pk=kwargs["pool_id"])
|
|
solutions = pool.solutions
|
|
syntheses = Synthesis.objects.filter(passage__pool=pool).all()
|
|
filename = _("Solutions for pool {pool} of tournament {tournament}.zip") \
|
|
if is_solution else _("Syntheses for pool {pool} of tournament {tournament}.zip")
|
|
filename = filename.format(pool=pool.get_letter_display() + str(pool.round),
|
|
tournament=pool.tournament.name)
|
|
|
|
def prefix(s: Solution | Synthesis) -> str:
|
|
return ""
|
|
|
|
output = BytesIO()
|
|
zf = ZipFile(output, "w")
|
|
for s in (solutions if is_solution else syntheses):
|
|
if s.file.storage.exists(s.file.path):
|
|
zf.write("media/" + s.file.name, prefix(s) + f"{s}.pdf")
|
|
|
|
zf.close()
|
|
response = HttpResponse(content_type="application/zip")
|
|
response["Content-Disposition"] = "attachment; filename=\"{filename}\"" \
|
|
.format(filename=filename)
|
|
response.write(output.getvalue())
|
|
return response
|
|
|
|
|
|
class PoolJuryView(VolunteerMixin, FormView, DetailView):
|
|
"""
|
|
This view lets organizers set jurys for a pool, without multiplying clicks.
|
|
"""
|
|
model = Pool
|
|
form_class = AddJuryForm
|
|
template_name = 'participation/pool_jury.html'
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if request.user.is_authenticated and \
|
|
(request.user.registration.is_admin or request.user.registration.is_volunteer
|
|
and (self.object.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration == self.object.jury_president)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['title'] = _("Jury of pool {pool} for {tournament} with teams {teams}") \
|
|
.format(pool=f"{self.object.get_letter_display()}{self.object.round}",
|
|
tournament=self.object.tournament.name,
|
|
teams=", ".join(participation.team.trigram for participation in self.object.participations.all()))
|
|
return context
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
self.object = self.get_object()
|
|
|
|
user = form.instance
|
|
if user.id:
|
|
# The user already exists, so we don't recreate it
|
|
user.refresh_from_db()
|
|
reg = user.registration
|
|
if reg in self.object.juries.all():
|
|
messages.warning(self.request, _("The jury {name} is already in the pool!")
|
|
.format(name=f"{user.first_name} {user.last_name}"))
|
|
return self.form_invalid(form)
|
|
else:
|
|
# Save the user object first
|
|
form.save()
|
|
# Create associated registration object to the new user
|
|
reg = VolunteerRegistration.objects.create(
|
|
user=user,
|
|
professional_activity="Juré⋅e du tournoi " + self.object.tournament.name,
|
|
)
|
|
|
|
reg.send_email_validation_link()
|
|
|
|
# Generate new password for the user
|
|
password = get_random_string(16)
|
|
user.set_password(password)
|
|
user.save()
|
|
|
|
# Send welcome mail
|
|
subject = "[TFJM²] " + str(_("New TFJM² jury account"))
|
|
site = Site.objects.first()
|
|
message = render_to_string('registration/mails/add_organizer.txt', dict(user=user,
|
|
inviter=self.request.user,
|
|
password=password,
|
|
domain=site.domain))
|
|
html = render_to_string('registration/mails/add_organizer.html', dict(user=user,
|
|
inviter=self.request.user,
|
|
password=password,
|
|
domain=site.domain))
|
|
user.email_user(subject, message, html_message=html)
|
|
|
|
# Add the user in the jury
|
|
self.object.juries.add(reg)
|
|
self.object.save()
|
|
|
|
# Update Google Sheets juries lines
|
|
if os.getenv('GOOGLE_PRIVATE_KEY_ID', None):
|
|
self.object.update_juries_lines_spreadsheet()
|
|
|
|
# Add notification
|
|
messages.success(self.request, _("The jury {name} has been successfully added!")
|
|
.format(name=f"{user.first_name} {user.last_name}"))
|
|
|
|
return super().form_valid(form)
|
|
|
|
def form_invalid(self, form):
|
|
# This is useful since we have a FormView + a DetailView
|
|
self.object = self.get_object()
|
|
return super().form_invalid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy('participation:pool_jury', args=(self.kwargs['pk'],))
|
|
|
|
|
|
class PoolRemoveJuryView(VolunteerMixin, DetailView):
|
|
model = Pool
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if request.user.is_authenticated and \
|
|
(request.user.registration.is_admin or request.user.registration.is_volunteer
|
|
and (self.object.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration == self.object.jury_president)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
pool = self.get_object()
|
|
if not pool.juries.filter(pk=kwargs['jury_id']).exists():
|
|
raise Http404
|
|
jury = pool.juries.get(pk=kwargs['jury_id'])
|
|
pool.juries.remove(jury)
|
|
pool.save()
|
|
Note.objects.filter(jury=jury, passage__pool=pool).delete()
|
|
messages.success(request, _("The jury {name} has been successfully removed!")
|
|
.format(name=f"{jury.user.first_name} {jury.user.last_name}"))
|
|
return redirect(reverse_lazy('participation:pool_jury', args=(pool.pk,)))
|
|
|
|
|
|
class PoolPresideJuryView(VolunteerMixin, DetailView):
|
|
model = Pool
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if request.user.is_authenticated and \
|
|
(request.user.registration.is_admin or request.user.registration.is_volunteer
|
|
and (self.object.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration == self.object.jury_president)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
pool = self.get_object()
|
|
if not pool.juries.filter(pk=kwargs['jury_id']).exists():
|
|
raise Http404
|
|
jury = pool.juries.get(pk=kwargs['jury_id'])
|
|
pool.jury_president = jury
|
|
pool.save()
|
|
messages.success(request, _("The jury {name} has been successfully promoted president!")
|
|
.format(name=f"{jury.user.first_name} {jury.user.last_name}"))
|
|
return redirect(reverse_lazy('participation:pool_jury', args=(pool.pk,)))
|
|
|
|
|
|
class PoolUploadNotesView(VolunteerMixin, FormView, DetailView):
|
|
model = Pool
|
|
form_class = UploadNotesForm
|
|
template_name = 'participation/upload_notes.html'
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if request.user.is_authenticated and \
|
|
(request.user.registration.is_admin or request.user.registration.is_volunteer
|
|
and (self.object.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration == self.object.jury_president)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
@transaction.atomic
|
|
def form_valid(self, form):
|
|
pool = self.get_object()
|
|
parsed_notes = form.cleaned_data['parsed_notes']
|
|
|
|
for vr in parsed_notes.keys():
|
|
if vr not in pool.juries.all():
|
|
form.add_error('file', _("The following user is not registered as a jury:") + " " + str(vr))
|
|
|
|
if form.errors:
|
|
return self.form_invalid(form)
|
|
|
|
for vr, notes in parsed_notes.items():
|
|
# There is an observer note for 4-teams pools
|
|
notes_count = 7 if pool.passages.count() == 4 else 6
|
|
for i, passage in enumerate(pool.passages.all()):
|
|
note = Note.objects.get_or_create(jury=vr, passage=passage)[0]
|
|
passage_notes = notes[notes_count * i:notes_count * (i + 1)]
|
|
note.set_all(*list(map(int, passage_notes)))
|
|
note.save()
|
|
|
|
if os.getenv('GOOGLE_PRIVATE_KEY_ID', None):
|
|
pool.update_notes_spreadsheet()
|
|
|
|
messages.success(self.request, _("Notes were successfully uploaded."))
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy('participation:pool_detail', args=(self.kwargs['pk'],))
|
|
|
|
|
|
class PoolNotesTemplateView(VolunteerMixin, DetailView):
|
|
"""
|
|
Generate an ODS sheet to fill the notes of the pool.
|
|
"""
|
|
model = Pool
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if request.user.is_authenticated and \
|
|
(request.user.registration.is_admin or request.user.registration.is_volunteer
|
|
and (self.object.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration == self.object.jury_president)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def render_to_response(self, context, **response_kwargs): # noqa: C901
|
|
pool_size = self.object.passages.count()
|
|
passage_width = 7 if pool_size == 4 else 6
|
|
line_length = pool_size * passage_width
|
|
|
|
def getcol(number: int) -> str:
|
|
"""
|
|
Translates the given number to the nth column name
|
|
"""
|
|
if number == 0:
|
|
return ''
|
|
return getcol((number - 1) // 26) + chr(65 + (number - 1) % 26)
|
|
|
|
doc = OpenDocumentSpreadsheet()
|
|
|
|
# Define styles
|
|
style = Style(name="Contenu", family="table-cell")
|
|
style.addElement(TableCellProperties(border="0.75pt solid #000000"))
|
|
doc.styles.addElement(style)
|
|
|
|
style_left = Style(name="Contenu gauche", family="table-cell")
|
|
style_left.addElement(TableCellProperties(border="0.75pt solid #000000", borderleft="2pt solid #000000"))
|
|
doc.styles.addElement(style_left)
|
|
|
|
style_right = Style(name="Contenu droite", family="table-cell")
|
|
style_right.addElement(TableCellProperties(border="0.75pt solid #000000", borderright="2pt solid #000000"))
|
|
doc.styles.addElement(style_right)
|
|
|
|
style_top = Style(name="Contenu haut", family="table-cell")
|
|
style_top.addElement(TableCellProperties(border="0.75pt solid #000000", bordertop="2pt solid #000000"))
|
|
doc.styles.addElement(style_top)
|
|
|
|
style_topright = Style(name="Contenu haut droite", family="table-cell")
|
|
style_topright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderright="2pt solid #000000",
|
|
bordertop="2pt solid #000000"))
|
|
doc.styles.addElement(style_topright)
|
|
|
|
style_topleftright = Style(name="Contenu haut gauche droite", family="table-cell")
|
|
style_topleftright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderleft="2pt solid #000000",
|
|
borderright="2pt solid #000000",
|
|
bordertop="2pt solid #000000"))
|
|
doc.styles.addElement(style_topleftright)
|
|
|
|
style_leftright = Style(name="Contenu haut gauche droite", family="table-cell")
|
|
style_leftright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderleft="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(style_leftright)
|
|
|
|
style_botleft = Style(name="Contenu bas gauche", family="table-cell")
|
|
style_botleft.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderbottom="2pt solid #000000",
|
|
borderleft="2pt solid #000000"))
|
|
doc.styles.addElement(style_botleft)
|
|
|
|
style_bot = Style(name="Contenu bas", family="table-cell")
|
|
style_bot.addElement(TableCellProperties(border="0.75pt solid #000000", borderbottom="2pt solid #000000"))
|
|
doc.styles.addElement(style_bot)
|
|
|
|
style_botright = Style(name="Contenu bas droite", family="table-cell")
|
|
style_botright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderbottom="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(style_botright)
|
|
|
|
title_style = Style(name="Titre", family="table-cell")
|
|
title_style.addElement(TextProperties(fontweight="bold"))
|
|
title_style.addElement(TableCellProperties(border="0.75pt solid #000000"))
|
|
doc.styles.addElement(title_style)
|
|
|
|
title_style_left = Style(name="Titre gauche", family="table-cell")
|
|
title_style_left.addElement(TextProperties(fontweight="bold"))
|
|
title_style_left.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderleft="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_left)
|
|
|
|
title_style_right = Style(name="Titre droite", family="table-cell")
|
|
title_style_right.addElement(TextProperties(fontweight="bold"))
|
|
title_style_right.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_right)
|
|
|
|
title_style_leftright = Style(name="Titre gauche droite", family="table-cell")
|
|
title_style_leftright.addElement(TextProperties(fontweight="bold"))
|
|
title_style_leftright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderleft="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_leftright)
|
|
|
|
title_style_top = Style(name="Titre haut", family="table-cell")
|
|
title_style_top.addElement(TextProperties(fontweight="bold"))
|
|
title_style_top.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_top)
|
|
|
|
title_style_topbot = Style(name="Titre haut bas", family="table-cell")
|
|
title_style_topbot.addElement(TextProperties(fontweight="bold"))
|
|
title_style_topbot.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000",
|
|
borderbottom="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_topbot)
|
|
|
|
title_style_topleft = Style(name="Titre haut gauche", family="table-cell")
|
|
title_style_topleft.addElement(TextProperties(fontweight="bold"))
|
|
title_style_topleft.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000",
|
|
borderleft="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_topleft)
|
|
|
|
title_style_topbotleft = Style(name="Titre haut bas gauche", family="table-cell")
|
|
title_style_topbotleft.addElement(TextProperties(fontweight="bold"))
|
|
title_style_topbotleft.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000",
|
|
borderbottom="2pt solid #000000",
|
|
borderleft="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_topbotleft)
|
|
|
|
title_style_topright = Style(name="Titre haut droite", family="table-cell")
|
|
title_style_topright.addElement(TextProperties(fontweight="bold"))
|
|
title_style_topright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_topright)
|
|
|
|
title_style_topbotright = Style(name="Titre haut bas droite", family="table-cell")
|
|
title_style_topbotright.addElement(TextProperties(fontweight="bold"))
|
|
title_style_topbotright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000",
|
|
borderbottom="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_topbotright)
|
|
|
|
title_style_topleftright = Style(name="Titre haut gauche droite", family="table-cell")
|
|
title_style_topleftright.addElement(TextProperties(fontweight="bold"))
|
|
title_style_topleftright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
bordertop="2pt solid #000000",
|
|
borderleft="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_topleftright)
|
|
|
|
title_style_bot = Style(name="Titre bas", family="table-cell")
|
|
title_style_bot.addElement(TextProperties(fontweight="bold"))
|
|
title_style_bot.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderbottom="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_bot)
|
|
|
|
title_style_botleft = Style(name="Titre bas gauche", family="table-cell")
|
|
title_style_botleft.addElement(TextProperties(fontweight="bold"))
|
|
title_style_botleft.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderbottom="2pt solid #000000",
|
|
borderleft="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_botleft)
|
|
|
|
title_style_botright = Style(name="Titre bas droite", family="table-cell")
|
|
title_style_botright.addElement(TextProperties(fontweight="bold"))
|
|
title_style_botright.addElement(TableCellProperties(border="0.75pt solid #000000",
|
|
borderbottom="2pt solid #000000",
|
|
borderright="2pt solid #000000"))
|
|
doc.styles.addElement(title_style_botright)
|
|
|
|
first_col_style = Style(name="co1", family="table-column")
|
|
first_col_style.addElement(TableColumnProperties(columnwidth="9cm", breakbefore="auto"))
|
|
doc.automaticstyles.addElement(first_col_style)
|
|
|
|
jury_id_style = Style(name="co_jury_id", family="table-column")
|
|
jury_id_style.addElement(TableColumnProperties(columnwidth="1cm", breakbefore="auto"))
|
|
doc.automaticstyles.addElement(jury_id_style)
|
|
|
|
col_style = Style(name="co2", family="table-column")
|
|
col_style.addElement(TableColumnProperties(columnwidth="2.6cm", breakbefore="auto"))
|
|
doc.automaticstyles.addElement(col_style)
|
|
|
|
obs_col_style = Style(name="co3", family="table-column")
|
|
obs_col_style.addElement(TableColumnProperties(columnwidth="5.2cm", breakbefore="auto"))
|
|
doc.automaticstyles.addElement(obs_col_style)
|
|
|
|
table = Table(name=f"Poule {self.object.get_letter_display()}{self.object.round}")
|
|
doc.spreadsheet.addElement(table)
|
|
|
|
table.addElement(TableColumn(stylename=first_col_style))
|
|
table.addElement(TableColumn(stylename=jury_id_style))
|
|
|
|
for i in range(line_length):
|
|
table.addElement(TableColumn(
|
|
stylename=obs_col_style if pool_size == 4 and i % passage_width == passage_width - 1 else col_style))
|
|
|
|
# Add line for the problems for different passages
|
|
header_pb = TableRow()
|
|
table.addElement(header_pb)
|
|
problems_tc = TableCell(valuetype="string", stylename=title_style_topleft)
|
|
problems_tc.addElement(P(text="Problème"))
|
|
problems_tc.setAttribute('numbercolumnsspanned', "2")
|
|
header_pb.addElement(problems_tc)
|
|
header_pb.addElement(CoveredTableCell())
|
|
for passage in self.object.passages.all():
|
|
tc = TableCell(valuetype="string", stylename=title_style_topleftright)
|
|
tc.addElement(P(text=f"Problème {passage.solution_number}"))
|
|
tc.setAttribute('numbercolumnsspanned', "7" if pool_size == 4 else "6")
|
|
tc.setAttribute("formula", f"of:=[.B{8 + self.object.juries.count() + passage.position}]")
|
|
header_pb.addElement(tc)
|
|
header_pb.addElement(CoveredTableCell(numbercolumnsrepeated=6 if pool_size == 4 else 5))
|
|
|
|
# Add roles on the second line of the table
|
|
header_role = TableRow()
|
|
table.addElement(header_role)
|
|
role_tc = TableCell(valuetype="string", stylename=title_style_left)
|
|
role_tc.addElement(P(text="Rôle"))
|
|
role_tc.setAttribute('numbercolumnsspanned', "2")
|
|
header_role.addElement(role_tc)
|
|
header_role.addElement(CoveredTableCell())
|
|
for i in range(pool_size):
|
|
defender_tc = TableCell(valuetype="string", stylename=title_style_left)
|
|
defender_tc.addElement(P(text="Défenseur⋅se"))
|
|
defender_tc.setAttribute('numbercolumnsspanned', "2")
|
|
header_role.addElement(defender_tc)
|
|
header_role.addElement(CoveredTableCell())
|
|
|
|
opponent_tc = TableCell(valuetype="string", stylename=title_style)
|
|
opponent_tc.addElement(P(text="Opposant⋅e"))
|
|
opponent_tc.setAttribute('numbercolumnsspanned', "2")
|
|
header_role.addElement(opponent_tc)
|
|
header_role.addElement(CoveredTableCell())
|
|
|
|
reporter_tc = TableCell(valuetype="string",
|
|
stylename=title_style_right if pool_size != 4 else title_style)
|
|
reporter_tc.addElement(P(text="Rapporteur⋅rice"))
|
|
reporter_tc.setAttribute('numbercolumnsspanned', "2")
|
|
header_role.addElement(reporter_tc)
|
|
header_role.addElement(CoveredTableCell())
|
|
|
|
if pool_size == 4:
|
|
observer_tc = TableCell(valuetype="string", stylename=title_style_right)
|
|
observer_tc.addElement(P(text="Intervention exceptionnelle"))
|
|
header_role.addElement(observer_tc)
|
|
|
|
# Add maximum notes on the third line
|
|
header_notes = TableRow()
|
|
table.addElement(header_notes)
|
|
jury_tc = TableCell(valuetype="string", value="Juré⋅e", stylename=title_style_botleft)
|
|
jury_tc.addElement(P(text="Juré⋅e"))
|
|
jury_tc.setAttribute('numbercolumnsspanned', "2")
|
|
header_notes.addElement(jury_tc)
|
|
header_notes.addElement(CoveredTableCell())
|
|
|
|
for i in range(pool_size):
|
|
defender_w_tc = TableCell(valuetype="string", stylename=title_style_botleft)
|
|
defender_w_tc.addElement(P(text="Écrit (/20)"))
|
|
header_notes.addElement(defender_w_tc)
|
|
|
|
defender_o_tc = TableCell(valuetype="string", stylename=title_style_bot)
|
|
defender_o_tc.addElement(P(text="Oral (/20)"))
|
|
header_notes.addElement(defender_o_tc)
|
|
|
|
opponent_w_tc = TableCell(valuetype="string", stylename=title_style_bot)
|
|
opponent_w_tc.addElement(P(text="Écrit (/10)"))
|
|
header_notes.addElement(opponent_w_tc)
|
|
|
|
opponent_o_tc = TableCell(valuetype="string", stylename=title_style_bot)
|
|
opponent_o_tc.addElement(P(text="Oral (/10)"))
|
|
header_notes.addElement(opponent_o_tc)
|
|
|
|
reporter_w_tc = TableCell(valuetype="string", stylename=title_style_bot)
|
|
reporter_w_tc.addElement(P(text="Écrit (/10)"))
|
|
header_notes.addElement(reporter_w_tc)
|
|
|
|
reporter_o_tc = TableCell(valuetype="string",
|
|
stylename=title_style_botright if pool_size != 4 else title_style_bot)
|
|
reporter_o_tc.addElement(P(text="Oral (/10)"))
|
|
header_notes.addElement(reporter_o_tc)
|
|
|
|
if pool_size == 4:
|
|
observer_tc = TableCell(valuetype="string",
|
|
stylename=title_style_botright)
|
|
observer_tc.addElement(P(text="Oral (± 4)"))
|
|
header_notes.addElement(observer_tc)
|
|
|
|
# Add a notation line for each jury
|
|
for jury in self.object.juries.all():
|
|
jury_row = TableRow()
|
|
table.addElement(jury_row)
|
|
|
|
name_tc = TableCell(valuetype="string", stylename=style_leftright)
|
|
name_tc.addElement(P(text=f"{jury.user.first_name} {jury.user.last_name}"))
|
|
jury_row.addElement(name_tc)
|
|
jury_id_tc = TableCell(valuetype="float", value=jury.pk, stylename=style_leftright)
|
|
jury_id_tc.addElement(P(text=str(jury.pk)))
|
|
jury_row.addElement(jury_id_tc)
|
|
|
|
for passage in self.object.passages.all():
|
|
notes = Note.objects.get(jury=jury, passage=passage)
|
|
for j, note in enumerate(notes.get_all()):
|
|
note_tc = TableCell(valuetype="float", value=note,
|
|
stylename=style_right if j == passage_width - 1 else style)
|
|
note_tc.addElement(P(text=str(note)))
|
|
jury_row.addElement(note_tc)
|
|
|
|
jury_size = self.object.juries.count()
|
|
min_row = 4
|
|
max_row = 4 + jury_size - 1
|
|
min_column = 3
|
|
|
|
# Add line for averages
|
|
average_row = TableRow()
|
|
table.addElement(average_row)
|
|
average_tc = TableCell(valuetype="string", stylename=title_style_topleftright)
|
|
average_tc.addElement(P(text="Moyenne"))
|
|
average_tc.setAttribute('numbercolumnsspanned', "2")
|
|
average_row.addElement(average_tc)
|
|
average_row.addElement(CoveredTableCell())
|
|
for i, passage in enumerate(self.object.passages.all()):
|
|
for j, note in enumerate(passage.averages):
|
|
tc = TableCell(valuetype="float", value=note,
|
|
stylename=style_topright if j == passage_width - 1 else style_top)
|
|
tc.addElement(P(text=str(note)))
|
|
column = getcol(min_column + i * passage_width + j)
|
|
tc.setAttribute("formula", f"of:=AVERAGEIF([.${getcol(min_column + i * passage_width)}${min_row}"
|
|
f":${getcol(min_column + i * passage_width)}{max_row}]; \">0\"; "
|
|
f"[.{column}${min_row}:{column}{max_row}])")
|
|
average_row.addElement(tc)
|
|
|
|
# Add coefficients for each note on the next line
|
|
coeff_row = TableRow()
|
|
table.addElement(coeff_row)
|
|
coeff_tc = TableCell(valuetype="string", stylename=title_style_leftright)
|
|
coeff_tc.addElement(P(text="Coefficient"))
|
|
coeff_tc.setAttribute('numbercolumnsspanned', "2")
|
|
coeff_row.addElement(coeff_tc)
|
|
coeff_row.addElement(CoveredTableCell())
|
|
for passage in self.object.passages.all():
|
|
defender_w_tc = TableCell(valuetype="float", value=1, stylename=style_left)
|
|
defender_w_tc.addElement(P(text="1"))
|
|
coeff_row.addElement(defender_w_tc)
|
|
|
|
defender_o_tc = TableCell(valuetype="float", value=1.6 - 0.4 * passage.defender_penalties, stylename=style)
|
|
defender_o_tc.addElement(P(text=str(2 - 0.4 * passage.defender_penalties)))
|
|
coeff_row.addElement(defender_o_tc)
|
|
|
|
opponent_w_tc = TableCell(valuetype="float", value=0.9, stylename=style)
|
|
opponent_w_tc.addElement(P(text="1"))
|
|
coeff_row.addElement(opponent_w_tc)
|
|
|
|
opponent_o_tc = TableCell(valuetype="float", value=2, stylename=style)
|
|
opponent_o_tc.addElement(P(text="2"))
|
|
coeff_row.addElement(opponent_o_tc)
|
|
|
|
reporter_w_tc = TableCell(valuetype="float", value=0.9, stylename=style)
|
|
reporter_w_tc.addElement(P(text="1"))
|
|
coeff_row.addElement(reporter_w_tc)
|
|
|
|
reporter_o_tc = TableCell(valuetype="float", value=1,
|
|
stylename=style_right if pool_size != 4 else style)
|
|
reporter_o_tc.addElement(P(text="1"))
|
|
coeff_row.addElement(reporter_o_tc)
|
|
|
|
if pool_size == 4:
|
|
observer_tc = TableCell(valuetype="float", value=1, stylename=style_right)
|
|
observer_tc.addElement(P(text="1"))
|
|
coeff_row.addElement(observer_tc)
|
|
|
|
# Add the subtotal on the next line
|
|
subtotal_row = TableRow()
|
|
table.addElement(subtotal_row)
|
|
subtotal_tc = TableCell(valuetype="string", stylename=title_style_botleft)
|
|
subtotal_tc.addElement(P(text="Sous-total"))
|
|
subtotal_tc.setAttribute('numbercolumnsspanned', "2")
|
|
subtotal_row.addElement(subtotal_tc)
|
|
subtotal_row.addElement(CoveredTableCell())
|
|
for i, passage in enumerate(self.object.passages.all()):
|
|
def_w_col = getcol(min_column + passage_width * i)
|
|
def_o_col = getcol(min_column + passage_width * i + 1)
|
|
defender_tc = TableCell(valuetype="float", value=passage.average_defender, stylename=style_botleft)
|
|
defender_tc.addElement(P(text=str(passage.average_defender)))
|
|
defender_tc.setAttribute('numbercolumnsspanned', "2")
|
|
defender_tc.setAttribute("formula", f"of:=[.{def_w_col}{max_row + 1}] * [.{def_w_col}{max_row + 2}]"
|
|
f" + [.{def_o_col}{max_row + 1}] * [.{def_o_col}{max_row + 2}]")
|
|
subtotal_row.addElement(defender_tc)
|
|
subtotal_row.addElement(CoveredTableCell())
|
|
|
|
opp_w_col = getcol(min_column + passage_width * i + 2)
|
|
opp_o_col = getcol(min_column + passage_width * i + 3)
|
|
opponent_tc = TableCell(valuetype="float", value=passage.average_opponent, stylename=style_bot)
|
|
opponent_tc.addElement(P(text=str(passage.average_opponent)))
|
|
opponent_tc.setAttribute('numbercolumnsspanned', "2")
|
|
opponent_tc.setAttribute("formula", f"of:=[.{opp_w_col}{max_row + 1}] * [.{opp_w_col}{max_row + 2}]"
|
|
f" + [.{opp_o_col}{max_row + 1}] * [.{opp_o_col}{max_row + 2}]")
|
|
subtotal_row.addElement(opponent_tc)
|
|
subtotal_row.addElement(CoveredTableCell())
|
|
|
|
rep_w_col = getcol(min_column + passage_width * i + 4)
|
|
rep_o_col = getcol(min_column + passage_width * i + 5)
|
|
reporter_tc = TableCell(valuetype="float", value=passage.average_reporter,
|
|
stylename=style_botright if pool_size != 4 else style_bot)
|
|
reporter_tc.addElement(P(text=str(passage.average_reporter)))
|
|
reporter_tc.setAttribute('numbercolumnsspanned', "2")
|
|
reporter_tc.setAttribute("formula", f"of:=[.{rep_w_col}{max_row + 1}] * [.{rep_w_col}{max_row + 2}]"
|
|
f" + [.{rep_o_col}{max_row + 1}] * [.{rep_o_col}{max_row + 2}]")
|
|
subtotal_row.addElement(reporter_tc)
|
|
subtotal_row.addElement(CoveredTableCell())
|
|
|
|
if pool_size == 4:
|
|
obs_col = getcol(min_column + passage_width * i + 6)
|
|
observer_tc = TableCell(valuetype="float", value=passage.average_observer,
|
|
stylename=style_botright)
|
|
observer_tc.addElement(P(text=str(passage.average_observer)))
|
|
observer_tc.setAttribute("formula", f"of:=[.{obs_col}{max_row + 1}] * [.{obs_col}{max_row + 2}]")
|
|
subtotal_row.addElement(observer_tc)
|
|
|
|
table.addElement(TableRow())
|
|
|
|
# Compute the total scores in a new table
|
|
scores_header = TableRow()
|
|
table.addElement(scores_header)
|
|
team_tc = TableCell(valuetype="string", stylename=title_style_topbotleft)
|
|
team_tc.addElement(P(text="Équipe"))
|
|
team_tc.setAttribute('numbercolumnsspanned', "2")
|
|
scores_header.addElement(team_tc)
|
|
problem_tc = TableCell(valuetype="string", stylename=title_style_topbot)
|
|
problem_tc.addElement(P(text="Problème"))
|
|
scores_header.addElement(problem_tc)
|
|
total_tc = TableCell(valuetype="string", stylename=title_style_topbot)
|
|
total_tc.addElement(P(text="Total"))
|
|
scores_header.addElement(total_tc)
|
|
rank_tc = TableCell(valuetype="string", stylename=title_style_topbotright)
|
|
rank_tc.addElement(P(text="Rang"))
|
|
scores_header.addElement(rank_tc)
|
|
|
|
# For each line of the matrix P, the ith team is defender on the passage number Pi0,
|
|
# opponent on the passage number Pi1, reporter on the passage number Pi2
|
|
# and eventually observer on the passage number Pi3.
|
|
passage_matrix = []
|
|
match pool_size:
|
|
case 3:
|
|
passage_matrix = [
|
|
[0, 2, 1],
|
|
[1, 0, 2],
|
|
[2, 1, 0],
|
|
]
|
|
case 4:
|
|
passage_matrix = [
|
|
[0, 3, 2, 1],
|
|
[1, 0, 3, 2],
|
|
[2, 1, 0, 3],
|
|
[3, 2, 1, 0],
|
|
]
|
|
case 5:
|
|
passage_matrix = [
|
|
[0, 2, 3],
|
|
[1, 4, 2],
|
|
[2, 0, 4],
|
|
[3, 1, 0],
|
|
[4, 3, 1],
|
|
]
|
|
|
|
sorted_participations = sorted(self.object.participations.all(), key=lambda p: -self.object.average(p))
|
|
for passage in self.object.passages.all():
|
|
team_row = TableRow()
|
|
table.addElement(team_row)
|
|
|
|
team_tc = TableCell(valuetype="string",
|
|
stylename=style_botleft if passage.position == pool_size else style_left)
|
|
team_tc.addElement(P(text=f"{passage.defender.team.name} ({passage.defender.team.trigram})"))
|
|
team_tc.setAttribute('numbercolumnsspanned', "2")
|
|
team_row.addElement(team_tc)
|
|
|
|
problem_tc = TableCell(valuetype="string",
|
|
stylename=style_bot if passage.position == pool_size else style)
|
|
problem_tc.addElement(P(text=f"Problème {passage.solution_number}"))
|
|
team_row.addElement(problem_tc)
|
|
|
|
passage_line = passage_matrix[passage.position - 1]
|
|
score_tc = TableCell(valuetype="float", value=self.object.average(passage.defender),
|
|
stylename=style_bot if passage.position == pool_size else style)
|
|
score_tc.addElement(P(text=self.object.average(passage.defender)))
|
|
formula = "of:="
|
|
formula += getcol(min_column + passage_line[0] * passage_width) + str(max_row + 3) # Defender
|
|
formula += " + " + getcol(min_column + passage_line[1] * passage_width + 2) + str(max_row + 3) # Opponent
|
|
formula += " + " + getcol(min_column + passage_line[2] * passage_width + 4) + str(max_row + 3) # Reporter
|
|
if pool_size == 4:
|
|
# Observer
|
|
formula += " + " + getcol(min_column + passage_line[3] * passage_width + 6) + str(max_row + 3)
|
|
score_tc.setAttribute("formula", formula)
|
|
team_row.addElement(score_tc)
|
|
|
|
score_col = 'C'
|
|
rank_tc = TableCell(valuetype="float", value=sorted_participations.index(passage.defender) + 1,
|
|
stylename=style_botright if passage.position == pool_size else style_right)
|
|
rank_tc.addElement(P(text=str(sorted_participations.index(passage.defender) + 1)))
|
|
rank_tc.setAttribute("formula", f"of:=RANK([.{score_col}{max_row + 5 + passage.position}]; "
|
|
f"[.{score_col}${max_row + 6}]:[.{score_col}${max_row + 5 + pool_size}])")
|
|
team_row.addElement(rank_tc)
|
|
|
|
table.addElement(TableRow())
|
|
|
|
# Add small instructions
|
|
instructions_tr = TableRow()
|
|
table.addElement(instructions_tr)
|
|
instructions_tc = TableCell()
|
|
instructions_tc.addElement(P(text="Merci de ne pas toucher aux noms des juré⋅es.\n"
|
|
"Si nécessaire, faites les modifications sur le site\n"
|
|
"et récupérez le nouveau template.\n"
|
|
"N'entrez que des notes entières.\n"
|
|
"Ne retirez pas de 0 : toute ligne incomplète sera ignorée.\n"
|
|
"Dans le cadre de poules à 5, laissez des 0 en face des\n"
|
|
"juré⋅es qui ne sont pas dans le passage souhaité,\n"
|
|
"et remplissez uniquement les notes nécessaires dans le tableau.\n"
|
|
"Les moyennes calculées ignorent les 0, donc pas d'inquiétude."))
|
|
instructions_tr.addElement(instructions_tc)
|
|
|
|
# Save the sheet in a temporary file and send it in the response
|
|
doc.save('/tmp/notes.ods')
|
|
|
|
return FileResponse(streaming_content=open("/tmp/notes.ods", "rb"),
|
|
content_type="application/vnd.oasis.opendocument.spreadsheet",
|
|
filename=f"Feuille de notes - {self.object.tournament.name} "
|
|
f"- Poule {self.object.get_letter_display()}{self.object.round}.ods")
|
|
|
|
|
|
class NotationSheetTemplateView(VolunteerMixin, DetailView):
|
|
"""
|
|
Generate a PDF from a LaTeX template for the notation papers.
|
|
"""
|
|
model = Pool
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if request.user.is_authenticated and \
|
|
(request.user.registration.is_admin or request.user.registration.is_volunteer
|
|
and (self.object.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration == self.object.jury_president)):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
passages = self.object.passages.all()
|
|
if passages.count() == 5:
|
|
page = self.request.GET.get('page', '1')
|
|
if not page.isnumeric() or page not in ['1', '2']:
|
|
page = '1'
|
|
passages = passages.filter(id__in=([passages[0].id, passages[2].id, passages[4].id]
|
|
if page == '1' else [passages[1].id, passages[3].id]))
|
|
context['page'] = page
|
|
|
|
context['passages'] = passages
|
|
context['esp'] = passages.count() * '&'
|
|
if self.request.user.registration in self.object.juries.all() and 'blank' not in self.request.GET:
|
|
context['jury'] = self.request.user.registration
|
|
context['tfjm_number'] = timezone.now().year - 2010
|
|
return context
|
|
|
|
def render_to_response(self, context, **response_kwargs):
|
|
tex = render_to_string(self.template_name, context=context, request=self.request)
|
|
temp_dir = mkdtemp()
|
|
with open(os.path.join(temp_dir, "texput.tex"), "w") as f:
|
|
f.write(tex)
|
|
process = subprocess.Popen(["pdflatex", "-interaction=nonstopmode", f"-output-directory={temp_dir}",
|
|
os.path.join(temp_dir, "texput.tex"), ])
|
|
process.wait()
|
|
return FileResponse(streaming_content=open(os.path.join(temp_dir, "texput.pdf"), "rb"),
|
|
content_type="application/pdf",
|
|
filename=self.template_name.split("/")[-1][:-3] + "pdf")
|
|
|
|
|
|
class ScaleNotationSheetTemplateView(NotationSheetTemplateView):
|
|
template_name = 'participation/tex/bareme.tex'
|
|
|
|
|
|
class FinalNotationSheetTemplateView(NotationSheetTemplateView):
|
|
template_name = 'participation/tex/finale.tex'
|
|
|
|
|
|
class NotationSheetsArchiveView(VolunteerMixin, DetailView):
|
|
@property
|
|
def model(self):
|
|
return Pool if 'pool_id' in self.kwargs else Tournament
|
|
|
|
@property
|
|
def pk_url_kwarg(self):
|
|
return 'pool_id' if 'pool_id' in self.kwargs else 'tournament_id'
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
|
|
reg = request.user.registration
|
|
|
|
if 'pool_id' in kwargs:
|
|
pool = self.get_object()
|
|
tournament = pool.tournament
|
|
if reg.is_admin or reg.is_volunteer \
|
|
and (tournament in reg.organized_tournaments.all() or reg in pool.juries.all()):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
else:
|
|
tournament = self.get_object()
|
|
if reg.is_admin or reg.is_volunteer and tournament in reg.organized_tournaments.all():
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if 'pool_id' in kwargs:
|
|
pool = self.get_object()
|
|
tournament = pool.tournament
|
|
pools = [pool]
|
|
filename = _("Notation sheets of pool {pool} of {tournament}.zip") \
|
|
.format(pool=pool.short_name, tournament=tournament.name)
|
|
else:
|
|
tournament = self.get_object()
|
|
pools = tournament.pools.all()
|
|
filename = _("Notation sheets of {tournament}.zip").format(tournament=tournament.name)
|
|
|
|
output = BytesIO()
|
|
with ZipFile(output, "w") as zf:
|
|
for pool in pools:
|
|
prefix = f"{pool.short_name}/" if len(pools) > 1 else ""
|
|
for template_name in ['bareme', 'finale']:
|
|
pages = [1] if pool.participations.count() < 5 else [1, 2]
|
|
for page in pages:
|
|
juries = list(pool.juries.all()) + [None]
|
|
|
|
for jury in juries:
|
|
if jury is not None and template_name == "bareme":
|
|
continue
|
|
|
|
context = {'jury': jury, 'page': page, 'pool': pool,
|
|
'tfjm_number': timezone.now().year - 2010}
|
|
|
|
passages = pool.passages.all()
|
|
if passages.count() == 5:
|
|
passages = passages.filter(
|
|
id__in=([passages[0].id, passages[2].id, passages[4].id]
|
|
if page == '1' else [passages[1].id, passages[3].id]))
|
|
|
|
context['passages'] = passages
|
|
context['esp'] = passages.count() * '&'
|
|
|
|
tex = render_to_string(f"participation/tex/{template_name}.tex",
|
|
context=context, request=self.request)
|
|
temp_dir = mkdtemp()
|
|
with open(os.path.join(temp_dir, "texput.tex"), "w") as f:
|
|
f.write(tex)
|
|
|
|
process = subprocess.Popen(
|
|
["pdflatex", "-interaction=nonstopmode", f"-output-directory={temp_dir}",
|
|
os.path.join(temp_dir, "texput.tex"), ])
|
|
process.wait()
|
|
|
|
sheet_name = f"Barème pour la poule {pool.short_name}" if template_name == "bareme" \
|
|
else (f"Feuille de notation pour la poule {pool.short_name}"
|
|
f" - {str(jury) if jury else 'Vierge'}")
|
|
sheet_name += " - page 2" if page == 2 else ""
|
|
|
|
zf.write(os.path.join(temp_dir, "texput.pdf"),
|
|
f"{prefix}{sheet_name}.pdf")
|
|
|
|
response = HttpResponse(content_type="application/zip")
|
|
response["Content-Disposition"] = f"attachment; filename=\"{filename}\""
|
|
response.write(output.getvalue())
|
|
return response
|
|
|
|
|
|
class PassageDetailView(LoginRequiredMixin, DetailView):
|
|
model = Passage
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
reg = request.user.registration
|
|
passage = self.get_object()
|
|
if reg.is_admin or reg.is_volunteer \
|
|
and (self.get_object().pool.tournament in reg.organized_tournaments.all()
|
|
or reg in passage.pool.juries.all()
|
|
or reg.pools_presided.filter(tournament=passage.pool.tournament).exists()) \
|
|
or reg.participates and reg.team \
|
|
and reg.team.participation in [passage.defender, passage.opponent, passage.reporter, passage.observer]:
|
|
return super().dispatch(request, *args, **kwargs)
|
|
return self.handle_no_permission()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
reg = self.request.user.registration
|
|
passage = self.object
|
|
if reg in passage.pool.juries.all():
|
|
context["my_note"] = Note.objects.get_or_create(passage=passage, jury=self.request.user.registration)[0]
|
|
if reg.is_volunteer:
|
|
notes = passage.notes.all()
|
|
if not reg.is_admin \
|
|
and (reg != passage.pool.jury_president
|
|
or reg not in passage.pool.tournament.organizers.all()):
|
|
notes = [note for note in notes if note.has_any_note() or note.jury == reg]
|
|
context["notes"] = NoteTable(notes)
|
|
|
|
# Only display the observer column for 4-teams pools
|
|
if passage.pool.participations.count() != 4:
|
|
context['notes']._sequence.remove('observer_oral')
|
|
if 'notes' in context and not self.request.user.registration.is_admin:
|
|
context['notes']._sequence.remove('update')
|
|
|
|
context['notes'].columns['defender_writing'].column.verbose_name += f" ({passage.defender.team.trigram})"
|
|
context['notes'].columns['defender_oral'].column.verbose_name += f" ({passage.defender.team.trigram})"
|
|
context['notes'].columns['opponent_writing'].column.verbose_name += f" ({passage.opponent.team.trigram})"
|
|
context['notes'].columns['opponent_oral'].column.verbose_name += f" ({passage.opponent.team.trigram})"
|
|
context['notes'].columns['reporter_writing'].column.verbose_name += f" ({passage.reporter.team.trigram})"
|
|
context['notes'].columns['reporter_oral'].column.verbose_name += f" ({passage.reporter.team.trigram})"
|
|
if self.object.observer:
|
|
context['notes'].columns['observer_oral'].column.verbose_name += f" ({passage.observer.team.trigram})"
|
|
|
|
return context
|
|
|
|
|
|
class PassageUpdateView(VolunteerMixin, UpdateView):
|
|
model = Passage
|
|
form_class = PassageForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
|
|
if request.user.registration.is_admin or request.user.registration.is_volunteer \
|
|
and (self.get_object().pool.tournament in request.user.registration.organized_tournaments.all()
|
|
or request.user.registration in self.get_object().pool.juries.all()):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
|
|
class SynthesisUploadView(LoginRequiredMixin, FormView):
|
|
template_name = "participation/upload_synthesis.html"
|
|
form_class = SynthesisForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated or not request.user.registration.participates:
|
|
return self.handle_no_permission()
|
|
|
|
qs = Passage.objects.filter(pk=self.kwargs["pk"])
|
|
if not qs.exists():
|
|
raise Http404
|
|
self.participation = self.request.user.registration.team.participation
|
|
self.passage = qs.get()
|
|
|
|
if self.participation not in [self.passage.opponent, self.passage.reporter]:
|
|
return self.handle_no_permission()
|
|
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
"""
|
|
When a solution is submitted, it replaces a previous solution if existing,
|
|
otherwise it creates a new solution.
|
|
It is discriminating whenever the team is selected for the final tournament or not.
|
|
"""
|
|
form_syn = form.instance
|
|
form_syn.type = 1 if self.participation == self.passage.opponent else 2
|
|
syn_qs = Synthesis.objects.filter(participation=self.participation,
|
|
passage=self.passage,
|
|
type=form_syn.type).all()
|
|
|
|
deadline = self.passage.pool.tournament.syntheses_first_phase_limit if self.passage.pool.round == 1 \
|
|
else self.passage.pool.tournament.syntheses_second_phase_limit
|
|
if syn_qs.exists() and timezone.now() > deadline:
|
|
form.add_error(None, _("You can't upload a synthesis after the deadline."))
|
|
return self.form_invalid(form)
|
|
|
|
# Drop previous solution if existing
|
|
for syn in syn_qs.all():
|
|
syn.file.delete()
|
|
syn.save()
|
|
syn.delete()
|
|
form_syn.participation = self.participation
|
|
form_syn.passage = self.passage
|
|
form_syn.save()
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("participation:passage_detail", args=(self.passage.pk,))
|
|
|
|
|
|
class NoteUpdateView(VolunteerMixin, UpdateView):
|
|
model = Note
|
|
form_class = NoteForm
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not request.user.is_authenticated:
|
|
return self.handle_no_permission()
|
|
|
|
reg = request.user.registration
|
|
note = self.get_object()
|
|
if reg.is_admin or reg.is_volunteer and (note.jury == reg or note.passage.pool.jury_president == reg):
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
return self.handle_no_permission()
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
form.fields['defender_writing'].label += f" ({self.object.passage.defender.team.trigram})"
|
|
form.fields['defender_oral'].label += f" ({self.object.passage.defender.team.trigram})"
|
|
form.fields['opponent_writing'].label += f" ({self.object.passage.opponent.team.trigram})"
|
|
form.fields['opponent_oral'].label += f" ({self.object.passage.opponent.team.trigram})"
|
|
form.fields['reporter_writing'].label += f" ({self.object.passage.reporter.team.trigram})"
|
|
form.fields['reporter_oral'].label += f" ({self.object.passage.reporter.team.trigram})"
|
|
if self.object.passage.observer:
|
|
form.fields['observer_oral'].label += f" ({self.object.passage.observer.team.trigram})"
|
|
else:
|
|
# Set the note of the observer only for 4-teams pools
|
|
del form.fields['observer_oral']
|
|
return form
|
|
|
|
def form_valid(self, form):
|
|
ret = super().form_valid(form)
|
|
self.object.update_spreadsheet()
|
|
return ret
|