433 lines
14 KiB
Python
433 lines
14 KiB
Python
import os
|
|
import random
|
|
|
|
from django.core.mail import send_mail
|
|
from django.db import models
|
|
from django.template.loader import render_to_string
|
|
from django.urls import reverse_lazy
|
|
from django.utils import timezone
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
|
|
class Tournament(models.Model):
|
|
"""
|
|
Store the information of a tournament.
|
|
"""
|
|
|
|
name = models.CharField(
|
|
max_length=255,
|
|
verbose_name=_("name"),
|
|
)
|
|
|
|
organizers = models.ManyToManyField(
|
|
'member.TFJMUser',
|
|
related_name="organized_tournaments",
|
|
verbose_name=_("organizers"),
|
|
help_text=_("List of all organizers that can see and manipulate data of the tournament and the teams."),
|
|
)
|
|
|
|
size = models.PositiveSmallIntegerField(
|
|
verbose_name=_("size"),
|
|
help_text=_("Number of teams that are allowed to join the tournament."),
|
|
)
|
|
|
|
place = models.CharField(
|
|
max_length=255,
|
|
verbose_name=_("place"),
|
|
)
|
|
|
|
price = models.PositiveSmallIntegerField(
|
|
verbose_name=_("price"),
|
|
help_text=_("Price asked to participants. Free with a scholarship."),
|
|
)
|
|
|
|
description = models.TextField(
|
|
verbose_name=_("description"),
|
|
)
|
|
|
|
date_start = models.DateField(
|
|
default=timezone.now,
|
|
verbose_name=_("date start"),
|
|
)
|
|
|
|
date_end = models.DateField(
|
|
default=timezone.now,
|
|
verbose_name=_("date end"),
|
|
)
|
|
|
|
date_inscription = models.DateTimeField(
|
|
default=timezone.now,
|
|
verbose_name=_("date of registration closing"),
|
|
)
|
|
|
|
date_solutions = models.DateTimeField(
|
|
default=timezone.now,
|
|
verbose_name=_("date of maximal solution submission"),
|
|
)
|
|
|
|
date_syntheses = models.DateTimeField(
|
|
default=timezone.now,
|
|
verbose_name=_("date of maximal syntheses submission for the first round"),
|
|
)
|
|
|
|
date_solutions_2 = models.DateTimeField(
|
|
default=timezone.now,
|
|
verbose_name=_("date when solutions of round 2 are available"),
|
|
)
|
|
|
|
date_syntheses_2 = models.DateTimeField(
|
|
default=timezone.now,
|
|
verbose_name=_("date of maximal syntheses submission for the second round"),
|
|
)
|
|
|
|
final = models.BooleanField(
|
|
verbose_name=_("final tournament"),
|
|
help_text=_("It should be only one final tournament."),
|
|
)
|
|
|
|
year = models.PositiveIntegerField(
|
|
default=os.getenv("TFJM_YEAR", timezone.now().year),
|
|
verbose_name=_("year"),
|
|
)
|
|
|
|
@property
|
|
def teams(self):
|
|
"""
|
|
Get all teams that are registered to this tournament, with a distinction for the final tournament.
|
|
"""
|
|
return self._teams if not self.final else Team.objects.filter(selected_for_final=True)
|
|
|
|
@property
|
|
def linked_organizers(self):
|
|
"""
|
|
Display a list of the organizers with links to their personal page.
|
|
"""
|
|
return ['<a href="{url}">'.format(url=reverse_lazy("member:information", args=(user.pk,))) + str(user) + '</a>'
|
|
for user in self.organizers.all()]
|
|
|
|
@property
|
|
def solutions(self):
|
|
"""
|
|
Get all sent solutions for this tournament.
|
|
"""
|
|
from member.models import Solution
|
|
return Solution.objects.filter(final=self.final) if self.final \
|
|
else Solution.objects.filter(team__tournament=self, final=False)
|
|
|
|
@property
|
|
def syntheses(self):
|
|
"""
|
|
Get all sent syntheses for this tournament.
|
|
"""
|
|
from member.models import Synthesis
|
|
return Synthesis.objects.filter(final=self.final) if self.final \
|
|
else Synthesis.objects.filter(team__tournament=self, final=False)
|
|
|
|
@classmethod
|
|
def get_final(cls):
|
|
"""
|
|
Get the final tournament.
|
|
This should exist and be unique.
|
|
"""
|
|
return cls.objects.get(year=os.getenv("TFJM_YEAR"), final=True)
|
|
|
|
class Meta:
|
|
verbose_name = _("tournament")
|
|
verbose_name_plural = _("tournaments")
|
|
|
|
def send_mail_to_organizers(self, template_name, subject="Contact TFJM²", **kwargs):
|
|
"""
|
|
Send a mail to all organizers of the tournament.
|
|
The template of the mail should be found either in templates/mail_templates/<template_name>.html for the HTML
|
|
version and in templates/mail_templates/<template_name>.txt for the plain text version.
|
|
The context of the template contains the tournament and the user. Extra context can be given through the kwargs.
|
|
"""
|
|
context = kwargs
|
|
context["tournament"] = self
|
|
for user in self.organizers.all():
|
|
context["user"] = user
|
|
message = render_to_string("mail_templates/" + template_name + ".txt", context=context)
|
|
message_html = render_to_string("mail_templates/" + template_name + ".html", context=context)
|
|
send_mail(subject, message, "contact@tfjm.org", [user.email], html_message=message_html)
|
|
from member.models import TFJMUser
|
|
for user in TFJMUser.objects.get(is_superuser=True).all():
|
|
context["user"] = user
|
|
message = render_to_string("mail_templates/" + template_name + ".txt", context=context)
|
|
message_html = render_to_string("mail_templates/" + template_name + ".html", context=context)
|
|
send_mail(subject, message, "contact@tfjm.org", [user.email], html_message=message_html)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Team(models.Model):
|
|
"""
|
|
Store information about a registered team.
|
|
"""
|
|
|
|
name = models.CharField(
|
|
max_length=255,
|
|
verbose_name=_("name"),
|
|
)
|
|
|
|
trigram = models.CharField(
|
|
max_length=3,
|
|
verbose_name=_("trigram"),
|
|
help_text=_("The trigram should be composed of 3 capitalize letters, that is a funny acronym for the team."),
|
|
)
|
|
|
|
tournament = models.ForeignKey(
|
|
Tournament,
|
|
on_delete=models.PROTECT,
|
|
related_name="_teams",
|
|
verbose_name=_("tournament"),
|
|
help_text=_("The tournament where the team is registered."),
|
|
)
|
|
|
|
inscription_date = models.DateTimeField(
|
|
auto_now_add=True,
|
|
verbose_name=_("inscription date"),
|
|
)
|
|
|
|
validation_status = models.CharField(
|
|
max_length=8,
|
|
choices=[
|
|
("0invalid", _("Registration not validated")),
|
|
("1waiting", _("Waiting for validation")),
|
|
("2valid", _("Registration validated")),
|
|
],
|
|
verbose_name=_("validation status"),
|
|
)
|
|
|
|
selected_for_final = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("selected for final"),
|
|
)
|
|
|
|
access_code = models.CharField(
|
|
max_length=6,
|
|
unique=True,
|
|
verbose_name=_("access code"),
|
|
)
|
|
|
|
year = models.PositiveIntegerField(
|
|
default=os.getenv("TFJM_YEAR", timezone.now().year),
|
|
verbose_name=_("year"),
|
|
)
|
|
|
|
@property
|
|
def valid(self):
|
|
return self.validation_status == "2valid"
|
|
|
|
@property
|
|
def waiting(self):
|
|
return self.validation_status == "1waiting"
|
|
|
|
@property
|
|
def invalid(self):
|
|
return self.validation_status == "0invalid"
|
|
|
|
@property
|
|
def coaches(self):
|
|
"""
|
|
Get all coaches of a team.
|
|
"""
|
|
return self.users.all().filter(role="2coach")
|
|
|
|
@property
|
|
def linked_coaches(self):
|
|
"""
|
|
Get a list of the coaches of a team with html links to their pages.
|
|
"""
|
|
return ['<a href="{url}">'.format(url=reverse_lazy("member:information", args=(user.pk,))) + str(user) + '</a>'
|
|
for user in self.coaches]
|
|
|
|
@property
|
|
def participants(self):
|
|
"""
|
|
Get all particpants of a team, coaches excluded.
|
|
"""
|
|
return self.users.all().filter(role="3participant")
|
|
|
|
@property
|
|
def linked_participants(self):
|
|
"""
|
|
Get a list of the participants of a team with html links to their pages.
|
|
"""
|
|
return ['<a href="{url}">'.format(url=reverse_lazy("member:information", args=(user.pk,))) + str(user) + '</a>'
|
|
for user in self.participants]
|
|
|
|
@property
|
|
def future_tournament(self):
|
|
"""
|
|
Get the last tournament where the team is registered.
|
|
Only matters if the team is selected for final: if this is the case, we return the final tournament.
|
|
Useful for deadlines.
|
|
"""
|
|
return Tournament.get_final() if self.selected_for_final else self.tournament
|
|
|
|
@property
|
|
def can_validate(self):
|
|
"""
|
|
Check if a given team is able to ask for validation.
|
|
A team can validate if:
|
|
* All participants filled the photo consent
|
|
* Minor participants filled the parental consent
|
|
* Minor participants filled the sanitary plug
|
|
* Teams sent their motivation letter
|
|
* The team contains at least 4 participants
|
|
* The team contains at least 1 coach
|
|
"""
|
|
# TODO In a normal time, team needs a motivation letter and authorizations.
|
|
return self.coaches.exists() and self.participants.count() >= 4\
|
|
and self.tournament.date_inscription <= timezone.now()
|
|
|
|
class Meta:
|
|
verbose_name = _("team")
|
|
verbose_name_plural = _("teams")
|
|
unique_together = (('name', 'year',), ('trigram', 'year',),)
|
|
|
|
def send_mail(self, template_name, subject="Contact TFJM²", **kwargs):
|
|
"""
|
|
Send a mail to all members of a team with a given template.
|
|
The template of the mail should be found either in templates/mail_templates/<template_name>.html for the HTML
|
|
version and in templates/mail_templates/<template_name>.txt for the plain text version.
|
|
The context of the template contains the team and the user. Extra context can be given through the kwargs.
|
|
"""
|
|
context = kwargs
|
|
context["team"] = self
|
|
for user in self.users.all():
|
|
context["user"] = user
|
|
message = render_to_string("mail_templates/" + template_name + ".txt", context=context)
|
|
message_html = render_to_string("mail_templates/" + template_name + ".html", context=context)
|
|
send_mail(subject, message, "contact@tfjm.org", [user.email], html_message=message_html)
|
|
|
|
def __str__(self):
|
|
return self.trigram + " — " + self.name
|
|
|
|
|
|
class Pool(models.Model):
|
|
"""
|
|
Store information of a pool.
|
|
A pool is only a list of accessible solutions to some teams and some juries.
|
|
TODO: check that the set of teams is equal to the set of the teams that have a solution in this set.
|
|
TODO: Moreover, a team should send only one solution.
|
|
"""
|
|
teams = models.ManyToManyField(
|
|
Team,
|
|
related_name="pools",
|
|
verbose_name=_("teams"),
|
|
)
|
|
|
|
solutions = models.ManyToManyField(
|
|
"member.Solution",
|
|
related_name="pools",
|
|
verbose_name=_("solutions"),
|
|
)
|
|
|
|
round = models.PositiveIntegerField(
|
|
choices=[
|
|
(1, _("Round 1")),
|
|
(2, _("Round 2")),
|
|
],
|
|
verbose_name=_("round"),
|
|
)
|
|
|
|
juries = models.ManyToManyField(
|
|
"member.TFJMUser",
|
|
related_name="pools",
|
|
verbose_name=_("juries"),
|
|
)
|
|
|
|
extra_access_token = models.CharField(
|
|
max_length=64,
|
|
default="",
|
|
verbose_name=_("extra access token"),
|
|
help_text=_("Let other users access to the pool data without logging in."),
|
|
)
|
|
|
|
@property
|
|
def problems(self):
|
|
"""
|
|
Get problem numbers of the sent solutions as a list of integers.
|
|
"""
|
|
return list(d["problem"] for d in self.solutions.values("problem").all())
|
|
|
|
@property
|
|
def tournament(self):
|
|
"""
|
|
Get the concerned tournament.
|
|
We assume that the pool is correct, so all solutions belong to the same tournament.
|
|
"""
|
|
return self.solutions.first().tournament
|
|
|
|
@property
|
|
def syntheses(self):
|
|
"""
|
|
Get the syntheses of the teams that are in this pool, for the correct round.
|
|
"""
|
|
from member.models import Synthesis
|
|
return Synthesis.objects.filter(team__in=self.teams.all(), round=self.round, final=self.tournament.final)
|
|
|
|
def save(self, **kwargs):
|
|
if not self.extra_access_token:
|
|
alphabet = "0123456789abcdefghijklmnopqrstuvwxyz0123456789"
|
|
code = "".join(random.choice(alphabet) for _ in range(64))
|
|
self.extra_access_token = code
|
|
super().save(**kwargs)
|
|
|
|
class Meta:
|
|
verbose_name = _("pool")
|
|
verbose_name_plural = _("pools")
|
|
|
|
|
|
class Payment(models.Model):
|
|
"""
|
|
Store some information about payments, to recover data.
|
|
TODO: handle it...
|
|
"""
|
|
user = models.OneToOneField(
|
|
'member.TFJMUser',
|
|
on_delete=models.CASCADE,
|
|
related_name="payment",
|
|
verbose_name=_("user"),
|
|
)
|
|
|
|
team = models.ForeignKey(
|
|
Team,
|
|
on_delete=models.CASCADE,
|
|
related_name="payments",
|
|
verbose_name=_("team"),
|
|
)
|
|
|
|
method = models.CharField(
|
|
max_length=16,
|
|
choices=[
|
|
("not_paid", _("Not paid")),
|
|
("credit_card", _("Credit card")),
|
|
("check", _("Bank check")),
|
|
("transfer", _("Bank transfer")),
|
|
("cash", _("Cash")),
|
|
("scholarship", _("Scholarship")),
|
|
],
|
|
default="not_paid",
|
|
verbose_name=_("payment method"),
|
|
)
|
|
|
|
validation_status = models.CharField(
|
|
max_length=8,
|
|
choices=[
|
|
("0invalid", _("Registration not validated")),
|
|
("1waiting", _("Waiting for validation")),
|
|
("2valid", _("Registration validated")),
|
|
],
|
|
verbose_name=_("validation status"),
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("payment")
|
|
verbose_name_plural = _("payments")
|
|
|
|
def __str__(self):
|
|
return _("Payment of {user}").format(str(self.user))
|