369 lines
9.5 KiB
Python
369 lines
9.5 KiB
Python
import os
|
|
from datetime import date
|
|
|
|
from django.contrib.auth.models import AbstractUser
|
|
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
from polymorphic.models import PolymorphicModel
|
|
|
|
from tournament.models import Team, Tournament
|
|
|
|
|
|
class TFJMUser(AbstractUser):
|
|
"""
|
|
The model of registered users (organizers/juries/admins/coachs/participants)
|
|
"""
|
|
USERNAME_FIELD = 'email'
|
|
REQUIRED_FIELDS = []
|
|
|
|
email = models.EmailField(
|
|
unique=True,
|
|
verbose_name=_("email"),
|
|
help_text=_("This should be valid and will be controlled."),
|
|
)
|
|
|
|
team = models.ForeignKey(
|
|
Team,
|
|
null=True,
|
|
on_delete=models.SET_NULL,
|
|
related_name="users",
|
|
verbose_name=_("team"),
|
|
help_text=_("Concerns only coaches and participants."),
|
|
)
|
|
|
|
birth_date = models.DateField(
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("birth date"),
|
|
)
|
|
|
|
gender = models.CharField(
|
|
max_length=16,
|
|
null=True,
|
|
default=None,
|
|
choices=[
|
|
("male", _("Male")),
|
|
("female", _("Female")),
|
|
("non-binary", _("Non binary")),
|
|
],
|
|
verbose_name=_("gender"),
|
|
)
|
|
|
|
address = models.CharField(
|
|
max_length=255,
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("address"),
|
|
)
|
|
|
|
postal_code = models.PositiveIntegerField(
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("postal code"),
|
|
)
|
|
|
|
city = models.CharField(
|
|
max_length=255,
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("city"),
|
|
)
|
|
|
|
country = models.CharField(
|
|
max_length=255,
|
|
default="France",
|
|
null=True,
|
|
verbose_name=_("country"),
|
|
)
|
|
|
|
phone_number = models.CharField(
|
|
max_length=20,
|
|
null=True,
|
|
blank=True,
|
|
default=None,
|
|
verbose_name=_("phone number"),
|
|
)
|
|
|
|
school = models.CharField(
|
|
max_length=255,
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("school"),
|
|
)
|
|
|
|
student_class = models.CharField(
|
|
max_length=16,
|
|
choices=[
|
|
('seconde', _("Seconde or less")),
|
|
('première', _("Première")),
|
|
('terminale', _("Terminale")),
|
|
],
|
|
null=True,
|
|
default=None,
|
|
verbose_name="class",
|
|
)
|
|
|
|
responsible_name = models.CharField(
|
|
max_length=255,
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("responsible name"),
|
|
)
|
|
|
|
responsible_phone = models.CharField(
|
|
max_length=20,
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("responsible phone"),
|
|
)
|
|
|
|
responsible_email = models.EmailField(
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("responsible email"),
|
|
)
|
|
|
|
description = models.TextField(
|
|
null=True,
|
|
default=None,
|
|
verbose_name=_("description"),
|
|
)
|
|
|
|
role = models.CharField(
|
|
max_length=16,
|
|
choices=[
|
|
("0admin", _("Admin")),
|
|
("1volunteer", _("Organizer")),
|
|
("2coach", _("Coach")),
|
|
("3participant", _("Participant")),
|
|
]
|
|
)
|
|
|
|
year = models.PositiveIntegerField(
|
|
default=os.getenv("TFJM_YEAR", date.today().year),
|
|
verbose_name=_("year"),
|
|
)
|
|
|
|
@property
|
|
def participates(self):
|
|
"""
|
|
Return True iff this user is a participant or a coach, ie. if the user is a member of a team that worked
|
|
for the tournament.
|
|
"""
|
|
return self.role == "3participant" or self.role == "2coach"
|
|
|
|
@property
|
|
def organizes(self):
|
|
"""
|
|
Return True iff this user is a local or global organizer of the tournament. This includes juries.
|
|
"""
|
|
return self.role == "1volunteer" or self.role == "0admin"
|
|
|
|
@property
|
|
def admin(self):
|
|
"""
|
|
Return True iff this user is a global organizer, ie. an administrator. This should be equivalent to be
|
|
a superuser.
|
|
"""
|
|
return self.role == "0admin"
|
|
|
|
class Meta:
|
|
verbose_name = _("user")
|
|
verbose_name_plural = _("users")
|
|
|
|
def save(self, *args, **kwargs):
|
|
# We ensure that the username is the email of the user.
|
|
self.username = self.email
|
|
super().save(*args, **kwargs)
|
|
|
|
def __str__(self):
|
|
return self.first_name + " " + self.last_name
|
|
|
|
|
|
class Document(PolymorphicModel):
|
|
"""
|
|
Abstract model of any saved document (solution, synthesis, motivation letter, authorization)
|
|
"""
|
|
file = models.FileField(
|
|
unique=True,
|
|
verbose_name=_("file"),
|
|
)
|
|
|
|
uploaded_at = models.DateTimeField(
|
|
auto_now_add=True,
|
|
verbose_name=_("uploaded at"),
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("document")
|
|
verbose_name_plural = _("documents")
|
|
|
|
def delete(self, *args, **kwargs):
|
|
self.file.delete(True)
|
|
return super().delete(*args, **kwargs)
|
|
|
|
|
|
class Authorization(Document):
|
|
"""
|
|
Model for authorization papers (parental consent, photo consent, sanitary plug, ...)
|
|
"""
|
|
user = models.ForeignKey(
|
|
TFJMUser,
|
|
on_delete=models.CASCADE,
|
|
related_name="authorizations",
|
|
verbose_name=_("user"),
|
|
)
|
|
|
|
type = models.CharField(
|
|
max_length=32,
|
|
choices=[
|
|
("parental_consent", _("Parental consent")),
|
|
("photo_consent", _("Photo consent")),
|
|
("sanitary_plug", _("Sanitary plug")),
|
|
("scholarship", _("Scholarship")),
|
|
],
|
|
verbose_name=_("type"),
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("authorization")
|
|
verbose_name_plural = _("authorizations")
|
|
|
|
def __str__(self):
|
|
return _("{authorization} for user {user}").format(authorization=self.type, user=str(self.user))
|
|
|
|
|
|
class MotivationLetter(Document):
|
|
"""
|
|
Model for motivation letters of a team.
|
|
"""
|
|
team = models.ForeignKey(
|
|
Team,
|
|
on_delete=models.CASCADE,
|
|
related_name="motivation_letters",
|
|
verbose_name=_("team"),
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("motivation letter")
|
|
verbose_name_plural = _("motivation letters")
|
|
|
|
def __str__(self):
|
|
return _("Motivation letter of team {team} ({trigram})").format(team=self.team.name, trigram=self.team.trigram)
|
|
|
|
|
|
class Solution(Document):
|
|
"""
|
|
Model for solutions of team for a given problem, for the regional or final tournament.
|
|
"""
|
|
team = models.ForeignKey(
|
|
Team,
|
|
on_delete=models.CASCADE,
|
|
related_name="solutions",
|
|
verbose_name=_("team"),
|
|
)
|
|
|
|
problem = models.PositiveSmallIntegerField(
|
|
verbose_name=_("problem"),
|
|
)
|
|
|
|
final = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("final solution"),
|
|
)
|
|
|
|
@property
|
|
def tournament(self):
|
|
"""
|
|
Get the concerned tournament of a solution.
|
|
Generally the local tournament of a team, but it can be the final tournament if this is a solution for the
|
|
final tournament.
|
|
"""
|
|
return Tournament.get_final() if self.final else self.team.tournament
|
|
|
|
class Meta:
|
|
verbose_name = _("solution")
|
|
verbose_name_plural = _("solutions")
|
|
unique_together = ('team', 'problem', 'final',)
|
|
|
|
def __str__(self):
|
|
if self.final:
|
|
return _("Solution of team {trigram} for problem {problem} for final")\
|
|
.format(trigram=self.team.trigram, problem=self.problem)
|
|
else:
|
|
return _("Solution of team {trigram} for problem {problem}")\
|
|
.format(trigram=self.team.trigram, problem=self.problem)
|
|
|
|
|
|
class Synthesis(Document):
|
|
"""
|
|
Model for syntheses of a team for a given round and for a given role, for the regional or final tournament.
|
|
"""
|
|
team = models.ForeignKey(
|
|
Team,
|
|
on_delete=models.CASCADE,
|
|
related_name="syntheses",
|
|
verbose_name=_("team"),
|
|
)
|
|
|
|
source = models.CharField(
|
|
max_length=16,
|
|
choices=[
|
|
("opponent", _("Opponent")),
|
|
("rapporteur", _("Rapporteur")),
|
|
],
|
|
verbose_name=_("source"),
|
|
)
|
|
|
|
round = models.PositiveSmallIntegerField(
|
|
choices=[
|
|
(1, _("Round 1")),
|
|
(2, _("Round 2")),
|
|
],
|
|
verbose_name=_("round"),
|
|
)
|
|
|
|
final = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("final synthesis"),
|
|
)
|
|
|
|
@property
|
|
def tournament(self):
|
|
"""
|
|
Get the concerned tournament of a solution.
|
|
Generally the local tournament of a team, but it can be the final tournament if this is a solution for the
|
|
final tournament.
|
|
"""
|
|
return Tournament.get_final() if self.final else self.team.tournament
|
|
|
|
class Meta:
|
|
verbose_name = _("synthesis")
|
|
verbose_name_plural = _("syntheses")
|
|
unique_together = ('team', 'source', 'round', 'final',)
|
|
|
|
def __str__(self):
|
|
return _("Synthesis of team {trigram} that is {source} for the round {round} of tournament {tournament}")\
|
|
.format(trigram=self.team.trigram, source=self.get_source_display().lower(), round=self.round,
|
|
tournament=self.tournament)
|
|
|
|
|
|
class Config(models.Model):
|
|
"""
|
|
Dictionary of configuration variables.
|
|
"""
|
|
key = models.CharField(
|
|
max_length=255,
|
|
primary_key=True,
|
|
verbose_name=_("key"),
|
|
)
|
|
|
|
value = models.TextField(
|
|
default="",
|
|
verbose_name=_("value"),
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("configuration")
|
|
verbose_name_plural = _("configurations")
|