Minify CSS and JavaScript files

Signed-off-by: Emmy D'Anello <emmy.danello@animath.fr>

.gitignore

@@ -15,16 +15,6 @@ coverage
 *.mo
 *.pot
 
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
 # PyCharm project settings
 .idea
 
@@ -32,7 +22,7 @@ coverage
 .vscode
 
 # Local data
-secrets.py
+settings_local.py
 *.log
 media/
 output/
@@ -42,6 +32,3 @@ output/
 env/
 venv/
 db.sqlite3
-
-# Don't git index
-whoosh_index/

.gitlab-ci.yml

@@ -7,7 +7,7 @@ py311:
   image: python:3.11-alpine
   before_script:
     - apk add --no-cache libmagic
-    - apk add --no-cache git  # Useful for django-haystack, remove when the newer versions are in PyPI
+    - apk add --no-cache gettext git  # Useful for django-haystack, remove when the newer versions are in PyPI
     - pip install tox --no-cache-dir
   script: tox -e py311
 
@@ -16,7 +16,7 @@ py312:
   image: python:3.12-alpine
   before_script:
     - apk add --no-cache libmagic
-    - apk add --no-cache git  # Useful for django-haystack, remove when the newer versions are in PyPI
+    - apk add --no-cache gettext git  # Useful for django-haystack, remove when the newer versions are in PyPI
     - pip install tox --no-cache-dir
   script: tox -e py312
 

Dockerfile

@@ -3,10 +3,12 @@ FROM python:3.12-alpine
 ENV PYTHONUNBUFFERED 1
 ENV DJANGO_ALLOW_ASYNC_UNSAFE 1
 
-RUN apk add --no-cache gettext nginx gcc git libc-dev libffi-dev libxml2-dev libxslt-dev postgresql-dev libmagic texlive texmf-dist-latexextra
+RUN apk add --no-cache gettext nginx gcc git libc-dev libffi-dev libxml2-dev libxslt-dev npm postgresql-dev libmagic texlive texmf-dist-latexextra
 
 RUN apk add --no-cache bash
 
+RUN npm install -g yuglify
+
 RUN mkdir /code /code/docs
 WORKDIR /code
 COPY requirements.txt /code/requirements.txt

chat/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later

chat/admin.py

@@ -0,0 +1,28 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.contrib import admin
+
+from .models import Channel, Message
+
+
+@admin.register(Channel)
+class ChannelAdmin(admin.ModelAdmin):
+    """
+    Modèle d'administration des canaux de chat.
+    """
+    list_display = ('name', 'category', 'read_access', 'write_access', 'tournament', 'private',)
+    list_filter = ('category', 'read_access', 'write_access', 'tournament', 'private',)
+    search_fields = ('name', 'tournament__name', 'team__name', 'team__trigram',)
+    autocomplete_fields = ('tournament', 'pool', 'team', 'invited', )
+
+
+@admin.register(Message)
+class MessageAdmin(admin.ModelAdmin):
+    """
+    Modèle d'administration des messages de chat.
+    """
+    list_display = ('channel', 'author', 'created_at', 'updated_at', 'content',)
+    list_filter = ('channel', 'created_at', 'updated_at',)
+    search_fields = ('author__username', 'author__first_name', 'author__last_name', 'content',)
+    autocomplete_fields = ('channel', 'author', 'users_read',)

chat/apps.py

@@ -0,0 +1,16 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.apps import AppConfig
+from django.db.models.signals import post_save
+
+
+class ChatConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "chat"
+
+    def ready(self):
+        from chat import signals
+        post_save.connect(signals.create_tournament_channels, "participation.Tournament")
+        post_save.connect(signals.create_pool_channels, "participation.Pool")
+        post_save.connect(signals.create_team_channel, "participation.Participation")

chat/consumers.py

@@ -0,0 +1,370 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from channels.generic.websocket import AsyncJsonWebsocketConsumer
+from django.contrib.auth.models import User
+from django.db.models import Count, F, Q
+from registration.models import Registration
+
+from .models import Channel, Message
+
+
+class ChatConsumer(AsyncJsonWebsocketConsumer):
+    """
+    Ce consommateur gère les connexions WebSocket pour le chat.
+    """
+    async def connect(self) -> None:
+        """
+        Cette fonction est appelée lorsqu'un nouveau websocket tente de se connecter au serveur.
+        On n'accept que si c'est un⋅e utilisateur⋅rice connecté⋅e.
+        """
+        if '_fake_user_id' in self.scope['session']:
+            # Dans le cas d'une impersonification, on charge l'utilisateur⋅rice concerné
+            self.scope['user'] = await User.objects.aget(pk=self.scope['session']['_fake_user_id'])
+
+        # Récupération de l'utilisateur⋅rice courant⋅e
+        user = self.scope['user']
+        if user.is_anonymous:
+            # L'utilisateur⋅rice n'est pas connecté⋅e
+            await self.close()
+            return
+
+        reg = await Registration.objects.aget(user_id=user.id)
+        self.registration = reg
+
+        # Acceptation de la connexion
+        await self.accept()
+
+        # Récupération des canaux accessibles en lecture et/ou en écriture
+        self.read_channels = await Channel.get_accessible_channels(user, 'read')
+        self.write_channels = await Channel.get_accessible_channels(user, 'write')
+
+        # Abonnement aux canaux de diffusion Websocket pour les différents canaux de chat
+        async for channel in self.read_channels.all():
+            await self.channel_layer.group_add(f"chat-{channel.id}", self.channel_name)
+        # Abonnement à un canal de diffusion Websocket personnel, utile pour s'adresser à une unique personne
+        await self.channel_layer.group_add(f"user-{user.id}", self.channel_name)
+
+    async def disconnect(self, close_code: int) -> None:
+        """
+        Cette fonction est appelée lorsqu'un websocket se déconnecte du serveur.
+        :param close_code: Le code d'erreur.
+        """
+        if self.scope['user'].is_anonymous:
+            # L'utilisateur⋅rice n'était pas connecté⋅e, on ne fait rien
+            return
+
+        async for channel in self.read_channels.all():
+            # Désabonnement des canaux de diffusion Websocket liés aux canaux de chat
+            await self.channel_layer.group_discard(f"chat-{channel.id}", self.channel_name)
+        # Désabonnement du canal de diffusion Websocket personnel
+        await self.channel_layer.group_discard(f"user-{self.scope['user'].id}", self.channel_name)
+
+    async def receive_json(self, content: dict, **kwargs) -> None:
+        """
+        Appelée lorsque le client nous envoie des données, décodées depuis du JSON.
+        :param content: Les données envoyées par le client, décodées depuis du JSON. Doit contenir un champ 'type'.
+        """
+        match content['type']:
+            case 'fetch_channels':
+                # Demande de récupération des canaux disponibles
+                await self.fetch_channels()
+            case 'send_message':
+                # Envoi d'un message dans un canal
+                await self.receive_message(**content)
+            case 'edit_message':
+                # Modification d'un message
+                await self.edit_message(**content)
+            case 'delete_message':
+                # Suppression d'un message
+                await self.delete_message(**content)
+            case 'fetch_messages':
+                # Récupération des messages d'un canal (ou d'une partie)
+                await self.fetch_messages(**content)
+            case 'mark_read':
+                # Marquage de messages comme lus
+                await self.mark_read(**content)
+            case 'start_private_chat':
+                # Démarrage d'une conversation privée avec un⋅e autre utilisateur⋅rice
+                await self.start_private_chat(**content)
+            case unknown:
+                # Type inconnu, on soulève une erreur
+                raise ValueError(f"Unknown message type: {unknown}")
+
+    async def fetch_channels(self) -> None:
+        """
+        L'utilisateur⋅rice demande à récupérer la liste des canaux disponibles.
+        On lui renvoie alors la liste des canaux qui lui sont accessibles en lecture,
+        en fournissant nom, catégorie, permission de lecture et nombre de messages non lus.
+        """
+        user = self.scope['user']
+
+        # Récupération des canaux accessibles en lecture, avec le nombre de messages non lus
+        channels = self.read_channels.prefetch_related('invited') \
+            .annotate(total_messages=Count('messages', distinct=True)) \
+            .annotate(read_messages=Count('messages', filter=Q(messages__users_read=user), distinct=True)) \
+            .annotate(unread_messages=F('total_messages') - F('read_messages')).all()
+
+        # Envoi de la liste des canaux
+        message = {
+            'type': 'fetch_channels',
+            'channels': [
+                {
+                    'id': channel.id,
+                    'name': channel.get_visible_name(user),
+                    'category': channel.category,
+                    'read_access': True,
+                    'write_access': await self.write_channels.acontains(channel),
+                    'unread_messages': channel.unread_messages,
+                }
+                async for channel in channels
+            ]
+        }
+        await self.send_json(message)
+
+    async def receive_message(self, channel_id: int, content: str, **kwargs) -> None:
+        """
+        L'utilisateur⋅ice a envoyé un message dans un canal.
+        On vérifie d'abord la permission d'écriture, puis on crée le message et on l'envoie à tou⋅tes les
+        utilisateur⋅ices abonné⋅es au canal.
+
+        :param channel_id: Identifiant du canal où envoyer le message.
+        :param content: Contenu du message.
+        """
+        user = self.scope['user']
+
+        # Récupération du canal
+        channel = await Channel.objects.prefetch_related('tournament__pools__juries', 'pool', 'team', 'invited') \
+            .aget(id=channel_id)
+        if not await self.write_channels.acontains(channel):
+            # L'utilisateur⋅ice n'a pas la permission d'écrire dans ce canal, on abandonne
+            return
+
+        # Création du message
+        message = await Message.objects.acreate(
+            author=user,
+            channel=channel,
+            content=content,
+        )
+
+        # Envoi du message à toutes les personnes connectées sur le canal
+        await self.channel_layer.group_send(f'chat-{channel.id}', {
+            'type': 'chat.send_message',
+            'id': message.id,
+            'channel_id': channel.id,
+            'timestamp': message.created_at.isoformat(),
+            'author_id': message.author_id,
+            'author': await message.aget_author_name(),
+            'content': message.content,
+        })
+
+    async def edit_message(self, message_id: int, content: str, **kwargs) -> None:
+        """
+        L'utilisateur⋅ice a modifié un message.
+        On vérifie d'abord que l'utilisateur⋅ice a le droit de modifier le message, puis on modifie le message
+        et on envoie la modification à tou⋅tes les utilisateur⋅ices abonné⋅es au canal.
+
+        :param message_id: Identifiant du message à modifier.
+        :param content: Nouveau contenu du message.
+        """
+        user = self.scope['user']
+
+        # Récupération du message
+        message = await Message.objects.aget(id=message_id)
+        if user.id != message.author_id and not user.is_superuser:
+            # Seul⋅e l'auteur⋅ice du message ou un⋅e admin peut modifier un message
+            return
+
+        # Modification du contenu du message
+        message.content = content
+        await message.asave()
+
+        # Envoi de la modification à tou⋅tes les personnes connectées sur le canal
+        await self.channel_layer.group_send(f'chat-{message.channel_id}', {
+            'type': 'chat.edit_message',
+            'id': message_id,
+            'channel_id': message.channel_id,
+            'content': content,
+        })
+
+    async def delete_message(self, message_id: int, **kwargs) -> None:
+        """
+        L'utilisateur⋅ice a supprimé un message.
+        On vérifie d'abord que l'utilisateur⋅ice a le droit de supprimer le message, puis on supprime le message
+        et on envoie la suppression à tou⋅tes les utilisateur⋅ices abonné⋅es au canal.
+
+        :param message_id: Identifiant du message à supprimer.
+        """
+        user = self.scope['user']
+
+        # Récupération du message
+        message = await Message.objects.aget(id=message_id)
+        if user.id != message.author_id and not user.is_superuser:
+            return
+
+        # Suppression effective du message
+        await message.adelete()
+
+        # Envoi de la suppression à tou⋅tes les personnes connectées sur le canal
+        await self.channel_layer.group_send(f'chat-{message.channel_id}', {
+            'type': 'chat.delete_message',
+            'id': message_id,
+            'channel_id': message.channel_id,
+        })
+
+    async def fetch_messages(self, channel_id: int, offset: int = 0, limit: int = 50, **_kwargs) -> None:
+        """
+        L'utilisateur⋅ice demande à récupérer les messages d'un canal.
+        On vérifie la permission de lecture, puis on renvoie les messages demandés.
+
+        :param channel_id: Identifiant du canal où récupérer les messages.
+        :param offset: Décalage pour la pagination, à partir du dernier message.
+                       Par défaut : 0, on commence au dernier message.
+        :param limit: Nombre de messages à récupérer. Par défaut, on récupère 50 messages.
+        """
+        # Récupération du canal
+        channel = await Channel.objects.aget(id=channel_id)
+        if not await self.read_channels.acontains(channel):
+            # L'utilisateur⋅rice n'a pas la permission de lire ce canal, on abandonne
+            return
+
+        limit = min(limit, 200)  # On limite le nombre de messages à 200 maximum
+
+        # Récupération des messages, avec un indicateur de lecture pour l'utilisateur⋅ice courant⋅e
+        messages = Message.objects \
+            .filter(channel=channel) \
+            .annotate(read=Count('users_read', filter=Q(users_read=self.scope['user']))) \
+            .order_by('-created_at')[offset:offset + limit].all()
+
+        # Envoi de la liste des messages, en les renvoyant dans l'ordre chronologique
+        await self.send_json({
+            'type': 'fetch_messages',
+            'channel_id': channel_id,
+            'messages': list(reversed([
+                {
+                    'id': message.id,
+                    'timestamp': message.created_at.isoformat(),
+                    'author_id': message.author_id,
+                    'author': await message.aget_author_name(),
+                    'content': message.content,
+                    'read': message.read > 0,
+                }
+                async for message in messages
+            ]))
+        })
+
+    async def mark_read(self, message_ids: list[int], **_kwargs) -> None:
+        """
+        L'utilisateur⋅ice marque des messages comme lus, après les avoir affichés à l'écran.
+
+        :param message_ids: Liste des identifiants des messages qu'il faut marquer comme lus.
+        """
+        # Récupération des messages à marquer comme lus
+        messages = Message.objects.filter(id__in=message_ids)
+        async for message in messages.all():
+            # Ajout de l'utilisateur⋅ice courant⋅e à la liste des personnes ayant lu le message
+            await message.users_read.aadd(self.scope['user'])
+
+        # Actualisation du nombre de messages non lus par canal
+        unread_messages_by_channel = Message.objects.exclude(users_read=self.scope['user']).values('channel_id') \
+            .annotate(unread_messages=Count('channel_id'))
+
+        # Envoi des identifiants des messages non lus et du nombre de messages non lus par canal, actualisés
+        await self.send_json({
+            'type': 'mark_read',
+            'messages': [{'id': message.id, 'channel_id': message.channel_id} async for message in messages.all()],
+            'unread_messages': {group['channel_id']: group['unread_messages']
+                                async for group in unread_messages_by_channel.all()},
+        })
+
+    async def start_private_chat(self, user_id: int, **kwargs) -> None:
+        """
+        L'utilisateur⋅ice souhaite démarrer une conversation privée avec un⋅e autre utilisateur⋅ice.
+        Pour cela, on récupère le salon privé s'il existe, sinon on en crée un.
+        Dans le cas d'une création, les deux personnes sont transférées immédiatement dans ce nouveau canal.
+
+        :param user_id: L'utilisateur⋅rice avec qui démarrer la conversation privée.
+        """
+        user = self.scope['user']
+        # Récupération de l'autre utilisateur⋅ice avec qui démarrer la conversation
+        other_user = await User.objects.aget(id=user_id)
+
+        # Vérification de l'existence d'un salon privé entre les deux personnes
+        channel_qs = Channel.objects.filter(private=True).filter(invited=user).filter(invited=other_user)
+        if not await channel_qs.aexists():
+            # Le salon privé n'existe pas, on le crée alors
+            channel = await Channel.objects.acreate(
+                name=f"{user.first_name} {user.last_name}, {other_user.first_name} {other_user.last_name}",
+                category=Channel.ChannelCategory.PRIVATE,
+                private=True,
+            )
+            await channel.invited.aset([user, other_user])
+
+            # On s'ajoute au salon privé
+            await self.channel_layer.group_add(f"chat-{channel.id}", self.channel_name)
+
+            if user != other_user:
+                # On transfère l'autre utilisateur⋅ice dans le salon privé
+                await self.channel_layer.group_send(f"user-{other_user.id}", {
+                    'type': 'chat.start_private_chat',
+                    'channel': {
+                        'id': channel.id,
+                        'name': f"{user.first_name} {user.last_name}",
+                        'category': channel.category,
+                        'read_access': True,
+                        'write_access': True,
+                    }
+                })
+        else:
+            # Récupération dudit salon privé
+            channel = await channel_qs.afirst()
+
+        # Invitation de l'autre utilisateur⋅rice à rejoindre le salon privé
+        await self.channel_layer.group_send(f"user-{user.id}", {
+            'type': 'chat.start_private_chat',
+            'channel': {
+                'id': channel.id,
+                'name': f"{other_user.first_name} {other_user.last_name}",
+                'category': channel.category,
+                'read_access': True,
+                'write_access': True,
+            }
+        })
+
+    async def chat_send_message(self, message) -> None:
+        """
+        Envoi d'un message à tou⋅tes les personnes connectées sur un canal.
+        :param message: Dictionnaire contenant les informations du message à envoyer,
+                contenant l'identifiant du message "id", l'identifiant du canal "channel_id",
+                l'heure de création "timestamp", l'identifiant de l'auteur "author_id",
+                le nom de l'auteur "author" et le contenu du message "content".
+        """
+        await self.send_json({'type': 'send_message', 'id': message['id'], 'channel_id': message['channel_id'],
+                              'timestamp': message['timestamp'], 'author': message['author'],
+                              'content': message['content']})
+
+    async def chat_edit_message(self, message) -> None:
+        """
+        Envoi d'une modification de message à tou⋅tes les personnes connectées sur un canal.
+        :param message: Dictionnaire contenant les informations du message à modifier,
+                contenant l'identifiant du message "id", l'identifiant du canal "channel_id"
+                et le nouveau contenu "content".
+        """
+        await self.send_json({'type': 'edit_message', 'id': message['id'], 'channel_id': message['channel_id'],
+                              'content': message['content']})
+
+    async def chat_delete_message(self, message) -> None:
+        """
+        Envoi d'une suppression de message à tou⋅tes les personnes connectées sur un canal.
+        :param message: Dictionnaire contenant les informations du message à supprimer,
+                contenant l'identifiant du message "id" et l'identifiant du canal "channel_id".
+        """
+        await self.send_json({'type': 'delete_message', 'id': message['id'], 'channel_id': message['channel_id']})
+
+    async def chat_start_private_chat(self, message) -> None:
+        """
+        Envoi d'un message pour démarrer une conversation privée à une personne connectée.
+        :param message: Dictionnaire contenant les informations du nouveau canal privé.
+        """
+        await self.channel_layer.group_add(f"chat-{message['channel']['id']}", self.channel_name)
+        await self.send_json({'type': 'start_private_chat', 'channel': message['channel']})

chat/management/commands/create_chat_channels.py

@@ -0,0 +1,166 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.core.management import BaseCommand
+from django.utils.translation import activate
+from participation.models import Team, Tournament
+from tfjm.permissions import PermissionType
+
+from ...models import Channel
+
+
+class Command(BaseCommand):
+    """
+    Cette commande permet de créer les canaux de chat pour les tournois et les équipes.
+    Différents canaux sont créés pour chaque tournoi, puis pour chaque poule.
+    Enfin, un canal de communication par équipe est créé.
+    """
+    help = "Create chat channels for tournaments and teams."
+
+    def handle(self, *args, **kwargs):
+        activate('fr')
+
+        # Création de canaux généraux, d'annonces, d'aide jurys et orgas, etc.
+        # Le canal d'annonces est accessibles à tous⋅tes, mais seul⋅es les admins peuvent y écrire.
+        Channel.objects.update_or_create(
+            name="Annonces",
+            defaults=dict(
+                category=Channel.ChannelCategory.GENERAL,
+                read_access=PermissionType.AUTHENTICATED,
+                write_access=PermissionType.ADMIN,
+            ),
+        )
+
+        # Un canal d'aide pour les bénévoles est dédié.
+        Channel.objects.update_or_create(
+            name="Aide jurys et orgas",
+            defaults=dict(
+                category=Channel.ChannelCategory.GENERAL,
+                read_access=PermissionType.VOLUNTEER,
+                write_access=PermissionType.VOLUNTEER,
+            ),
+        )
+
+        # Un canal de discussion générale en lien avec le tournoi est accessible librement.
+        Channel.objects.update_or_create(
+            name="Général",
+            defaults=dict(
+                category=Channel.ChannelCategory.GENERAL,
+                read_access=PermissionType.AUTHENTICATED,
+                write_access=PermissionType.AUTHENTICATED,
+            ),
+        )
+
+        # Un canal de discussion entre participant⋅es est accessible à tous⋅tes,
+        # dont l'objectif est de faciliter la mise en relation entre élèves afin de constituer une équipe.
+        Channel.objects.update_or_create(
+            name="Je cherche une équipe",
+            defaults=dict(
+                category=Channel.ChannelCategory.GENERAL,
+                read_access=PermissionType.AUTHENTICATED,
+                write_access=PermissionType.AUTHENTICATED,
+            ),
+        )
+
+        # Un canal de discussion libre est accessible pour tous⋅tes.
+        Channel.objects.update_or_create(
+            name="Détente",
+            defaults=dict(
+                category=Channel.ChannelCategory.GENERAL,
+                read_access=PermissionType.AUTHENTICATED,
+                write_access=PermissionType.AUTHENTICATED,
+            ),
+        )
+
+        for tournament in Tournament.objects.all():
+            # Pour chaque tournoi, on crée un canal d'annonces, un canal général et un de détente,
+            # qui sont comme les canaux généraux du même nom mais réservés aux membres du tournoi concerné.
+            # Les membres d'un tournoi sont les organisateur⋅rices, les juré⋅es d'une poule du tournoi
+            # ainsi que les membres d'une équipe inscrite au tournoi et qui est validée.
+            Channel.objects.update_or_create(
+                name=f"{tournament.name} - Annonces",
+                defaults=dict(
+                    category=Channel.ChannelCategory.TOURNAMENT,
+                    read_access=PermissionType.TOURNAMENT_MEMBER,
+                    write_access=PermissionType.TOURNAMENT_ORGANIZER,
+                    tournament=tournament,
+                ),
+            )
+
+            Channel.objects.update_or_create(
+                name=f"{tournament.name} - Général",
+                defaults=dict(
+                    category=Channel.ChannelCategory.TOURNAMENT,
+                    read_access=PermissionType.TOURNAMENT_MEMBER,
+                    write_access=PermissionType.TOURNAMENT_MEMBER,
+                    tournament=tournament,
+                ),
+            )
+
+            Channel.objects.update_or_create(
+                name=f"{tournament.name} - Détente",
+                defaults=dict(
+                    category=Channel.ChannelCategory.TOURNAMENT,
+                    read_access=PermissionType.TOURNAMENT_MEMBER,
+                    write_access=PermissionType.TOURNAMENT_MEMBER,
+                    tournament=tournament,
+                ),
+            )
+
+            # Un canal réservé à tous⋅tes les juré⋅es du tournoi est créé.
+            Channel.objects.update_or_create(
+                name=f"{tournament.name} - Juré⋅es",
+                defaults=dict(
+                    category=Channel.ChannelCategory.TOURNAMENT,
+                    read_access=PermissionType.JURY_MEMBER,
+                    write_access=PermissionType.JURY_MEMBER,
+                    tournament=tournament,
+                ),
+            )
+
+            if tournament.remote:
+                # Dans le cadre d'un tournoi distanciel, un canal pour les président⋅es de jury est créé.
+                Channel.objects.update_or_create(
+                    name=f"{tournament.name} - Président⋅es de jury",
+                    defaults=dict(
+                        category=Channel.ChannelCategory.TOURNAMENT,
+                        read_access=PermissionType.TOURNAMENT_JURY_PRESIDENT,
+                        write_access=PermissionType.TOURNAMENT_JURY_PRESIDENT,
+                        tournament=tournament,
+                    ),
+                )
+
+                for pool in tournament.pools.all():
+                    # Pour chaque poule d'un tournoi distanciel, on crée un canal pour les membres de la poule
+                    # (équipes et juré⋅es), et un pour les juré⋅es uniquement.
+                    Channel.objects.update_or_create(
+                        name=f"{tournament.name} - Poule {pool.short_name}",
+                        defaults=dict(
+                            category=Channel.ChannelCategory.TOURNAMENT,
+                            read_access=PermissionType.POOL_MEMBER,
+                            write_access=PermissionType.POOL_MEMBER,
+                            pool=pool,
+                        ),
+                    )
+
+                    Channel.objects.update_or_create(
+                        name=f"{tournament.name} - Poule {pool.short_name} - Jury",
+                        defaults=dict(
+                            category=Channel.ChannelCategory.TOURNAMENT,
+                            read_access=PermissionType.JURY_MEMBER,
+                            write_access=PermissionType.JURY_MEMBER,
+                            pool=pool,
+                        ),
+                    )
+
+        for team in Team.objects.filter(participation__valid=True).all():
+            # Chaque équipe validée a le droit à son canal de communication.
+            Channel.objects.update_or_create(
+                name=f"Équipe {team.trigram}",
+                defaults=dict(
+                    category=Channel.ChannelCategory.TEAM,
+                    read_access=PermissionType.TEAM_MEMBER,
+                    write_access=PermissionType.TEAM_MEMBER,
+                    team=team,
+                ),
+            )

chat/migrations/0001_initial.py

@@ -0,0 +1,200 @@
+# Generated by Django 5.0.3 on 2024-04-27 07:00
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("participation", "0013_alter_pool_options_pool_room"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Channel",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=255, verbose_name="name")),
+                (
+                    "read_access",
+                    models.CharField(
+                        choices=[
+                            ("anonymous", "Everyone, including anonymous users"),
+                            ("authenticated", "Authenticated users"),
+                            ("volunteer", "All volunteers"),
+                            ("tournament", "All members of a given tournament"),
+                            ("organizer", "Tournament organizers only"),
+                            (
+                                "jury_president",
+                                "Tournament organizers and jury presidents of the tournament",
+                            ),
+                            ("jury", "Jury members of the pool"),
+                            ("pool", "Jury members and participants of the pool"),
+                            (
+                                "team",
+                                "Members of the team and organizers of concerned tournaments",
+                            ),
+                            (
+                                "private",
+                                "Private, reserved to explicit authorized users",
+                            ),
+                            ("admin", "Admin users"),
+                        ],
+                        max_length=16,
+                        verbose_name="read permission",
+                    ),
+                ),
+                (
+                    "write_access",
+                    models.CharField(
+                        choices=[
+                            ("anonymous", "Everyone, including anonymous users"),
+                            ("authenticated", "Authenticated users"),
+                            ("volunteer", "All volunteers"),
+                            ("tournament", "All members of a given tournament"),
+                            ("organizer", "Tournament organizers only"),
+                            (
+                                "jury_president",
+                                "Tournament organizers and jury presidents of the tournament",
+                            ),
+                            ("jury", "Jury members of the pool"),
+                            ("pool", "Jury members and participants of the pool"),
+                            (
+                                "team",
+                                "Members of the team and organizers of concerned tournaments",
+                            ),
+                            (
+                                "private",
+                                "Private, reserved to explicit authorized users",
+                            ),
+                            ("admin", "Admin users"),
+                        ],
+                        max_length=16,
+                        verbose_name="write permission",
+                    ),
+                ),
+                (
+                    "private",
+                    models.BooleanField(
+                        default=False,
+                        help_text="If checked, only users who have been explicitly added to the channel will be able to access it.",
+                        verbose_name="private",
+                    ),
+                ),
+                (
+                    "invited",
+                    models.ManyToManyField(
+                        blank=True,
+                        help_text="Extra users who have been invited to the channel, in addition to the permitted group of the channel.",
+                        related_name="+",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="invited users",
+                    ),
+                ),
+                (
+                    "pool",
+                    models.ForeignKey(
+                        blank=True,
+                        default=None,
+                        help_text="For a permission that concerns a pool, indicates what is the concerned pool.",
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="chat_channels",
+                        to="participation.pool",
+                        verbose_name="pool",
+                    ),
+                ),
+                (
+                    "team",
+                    models.ForeignKey(
+                        blank=True,
+                        default=None,
+                        help_text="For a permission that concerns a team, indicates what is the concerned team.",
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="chat_channels",
+                        to="participation.team",
+                        verbose_name="team",
+                    ),
+                ),
+                (
+                    "tournament",
+                    models.ForeignKey(
+                        blank=True,
+                        default=None,
+                        help_text="For a permission that concerns a tournament, indicates what is the concerned tournament.",
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="chat_channels",
+                        to="participation.tournament",
+                        verbose_name="tournament",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "channel",
+                "verbose_name_plural": "channels",
+                "ordering": ("name",),
+            },
+        ),
+        migrations.CreateModel(
+            name="Message",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(auto_now_add=True, verbose_name="created at"),
+                ),
+                (
+                    "updated_at",
+                    models.DateTimeField(auto_now=True, verbose_name="updated at"),
+                ),
+                ("content", models.TextField(verbose_name="content")),
+                (
+                    "author",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="chat_messages",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="author",
+                    ),
+                ),
+                (
+                    "channel",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="messages",
+                        to="chat.channel",
+                        verbose_name="channel",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "message",
+                "verbose_name_plural": "messages",
+                "ordering": ("created_at",),
+            },
+        ),
+    ]

chat/migrations/0002_alter_channel_options_channel_category.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.0.3 on 2024-04-28 11:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("chat", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="channel",
+            options={
+                "ordering": ("category", "name"),
+                "verbose_name": "channel",
+                "verbose_name_plural": "channels",
+            },
+        ),
+        migrations.AddField(
+            model_name="channel",
+            name="category",
+            field=models.CharField(
+                choices=[
+                    ("general", "General channels"),
+                    ("tournament", "Tournament channels"),
+                    ("team", "Team channels"),
+                    ("private", "Private channels"),
+                ],
+                default="general",
+                max_length=255,
+                verbose_name="category",
+            ),
+        ),
+    ]

chat/migrations/0003_message_users_read.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.0.3 on 2024-04-28 18:52
+
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("chat", "0002_alter_channel_options_channel_category"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="message",
+            name="users_read",
+            field=models.ManyToManyField(
+                blank=True,
+                help_text="Users who have read the message.",
+                related_name="+",
+                to=settings.AUTH_USER_MODEL,
+                verbose_name="users read",
+            ),
+        ),
+    ]

chat/migrations/0004_alter_channel_category_alter_channel_name_and_more.py

@@ -0,0 +1,94 @@
+# Generated by Django 5.0.6 on 2024-05-26 20:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("chat", "0003_message_users_read"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="channel",
+            name="category",
+            field=models.CharField(
+                choices=[
+                    ("general", "General channels"),
+                    ("tournament", "Tournament channels"),
+                    ("team", "Team channels"),
+                    ("private", "Private channels"),
+                ],
+                default="general",
+                help_text="Category of the channel, between general channels, tournament-specific channels, team channels or private channels. Will be used to sort channels in the channel list.",
+                max_length=255,
+                verbose_name="category",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="channel",
+            name="name",
+            field=models.CharField(
+                help_text="Visible name of the channel.",
+                max_length=255,
+                verbose_name="name",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="channel",
+            name="read_access",
+            field=models.CharField(
+                choices=[
+                    ("anonymous", "Everyone, including anonymous users"),
+                    ("authenticated", "Authenticated users"),
+                    ("volunteer", "All volunteers"),
+                    ("tournament", "All members of a given tournament"),
+                    ("organizer", "Tournament organizers only"),
+                    (
+                        "jury_president",
+                        "Tournament organizers and jury presidents of the tournament",
+                    ),
+                    ("jury", "Jury members of the pool"),
+                    ("pool", "Jury members and participants of the pool"),
+                    (
+                        "team",
+                        "Members of the team and organizers of concerned tournaments",
+                    ),
+                    ("private", "Private, reserved to explicit authorized users"),
+                    ("admin", "Admin users"),
+                ],
+                help_text="Permission type that is required to read the messages of the channels.",
+                max_length=16,
+                verbose_name="read permission",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="channel",
+            name="write_access",
+            field=models.CharField(
+                choices=[
+                    ("anonymous", "Everyone, including anonymous users"),
+                    ("authenticated", "Authenticated users"),
+                    ("volunteer", "All volunteers"),
+                    ("tournament", "All members of a given tournament"),
+                    ("organizer", "Tournament organizers only"),
+                    (
+                        "jury_president",
+                        "Tournament organizers and jury presidents of the tournament",
+                    ),
+                    ("jury", "Jury members of the pool"),
+                    ("pool", "Jury members and participants of the pool"),
+                    (
+                        "team",
+                        "Members of the team and organizers of concerned tournaments",
+                    ),
+                    ("private", "Private, reserved to explicit authorized users"),
+                    ("admin", "Admin users"),
+                ],
+                help_text="Permission type that is required to write a message to a channel.",
+                max_length=16,
+                verbose_name="write permission",
+            ),
+        ),
+    ]

chat/migrations/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later

chat/models.py

@@ -0,0 +1,365 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from asgiref.sync import sync_to_async
+from django.contrib.auth.models import User
+from django.db import models
+from django.db.models import Q, QuerySet
+from django.utils.text import format_lazy
+from django.utils.translation import gettext_lazy as _
+from participation.models import Pool, Team, Tournament
+from registration.models import ParticipantRegistration, Registration, VolunteerRegistration
+from tfjm.permissions import PermissionType
+
+
+class Channel(models.Model):
+    """
+    Ce modèle représente un canal de chat, défini par son nom, sa catégorie, les permissions de lecture et d'écriture
+    requises pour accéder au canal, et éventuellement un tournoi, une poule ou une équipe associée.
+    """
+
+    class ChannelCategory(models.TextChoices):
+        GENERAL = 'general', _("General channels")
+        TOURNAMENT = 'tournament', _("Tournament channels")
+        TEAM = 'team', _("Team channels")
+        PRIVATE = 'private', _("Private channels")
+
+    name = models.CharField(
+        max_length=255,
+        verbose_name=_("name"),
+        help_text=_("Visible name of the channel."),
+    )
+
+    category = models.CharField(
+        max_length=255,
+        verbose_name=_("category"),
+        choices=ChannelCategory,
+        default=ChannelCategory.GENERAL,
+        help_text=_("Category of the channel, between general channels, tournament-specific channels, team channels "
+                    "or private channels. Will be used to sort channels in the channel list."),
+    )
+
+    read_access = models.CharField(
+        max_length=16,
+        verbose_name=_("read permission"),
+        choices=PermissionType,
+        help_text=_("Permission type that is required to read the messages of the channels."),
+    )
+
+    write_access = models.CharField(
+        max_length=16,
+        verbose_name=_("write permission"),
+        choices=PermissionType,
+        help_text=_("Permission type that is required to write a message to a channel."),
+    )
+
+    tournament = models.ForeignKey(
+        'participation.Tournament',
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        default=None,
+        verbose_name=_("tournament"),
+        related_name='chat_channels',
+        help_text=_("For a permission that concerns a tournament, indicates what is the concerned tournament."),
+    )
+
+    pool = models.ForeignKey(
+        'participation.Pool',
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        default=None,
+        verbose_name=_("pool"),
+        related_name='chat_channels',
+        help_text=_("For a permission that concerns a pool, indicates what is the concerned pool."),
+    )
+
+    team = models.ForeignKey(
+        'participation.Team',
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        default=None,
+        verbose_name=_("team"),
+        related_name='chat_channels',
+        help_text=_("For a permission that concerns a team, indicates what is the concerned team."),
+    )
+
+    private = models.BooleanField(
+        verbose_name=_("private"),
+        default=False,
+        help_text=_("If checked, only users who have been explicitly added to the channel will be able to access it."),
+    )
+
+    invited = models.ManyToManyField(
+        'auth.User',
+        verbose_name=_("invited users"),
+        related_name='+',
+        blank=True,
+        help_text=_("Extra users who have been invited to the channel, "
+                    "in addition to the permitted group of the channel."),
+    )
+
+    def get_visible_name(self, user: User) -> str:
+        """
+        Renvoie le nom du channel tel qu'il est visible pour l'utilisateur⋅rice donné.
+        Dans le cas d'un canal classique, renvoie directement le nom.
+        Dans le cas d'un canal privé, renvoie la liste des personnes membres du canal,
+        à l'exception de la personne connectée, afin de ne pas afficher son propre nom.
+        Dans le cas d'un chat avec uniquement soi-même, on affiche que notre propre nom.
+        """
+        if self.private:
+            # Le canal est privé, on renvoie la liste des personnes membres du canal
+            # à l'exception de soi-même (sauf si on est la seule personne dans le canal)
+            users = [f"{u.first_name} {u.last_name}" for u in self.invited.all() if u != user] \
+                    or [f"{user.first_name} {user.last_name}"]
+            return ", ".join(users)
+        # Le canal est public, on renvoie directement le nom
+        return self.name
+
+    def __str__(self):
+        return str(format_lazy(_("Channel {name}"), name=self.name))
+
+    @staticmethod
+    async def get_accessible_channels(user: User, permission_type: str = 'read') -> QuerySet["Channel"]:
+        """
+        Renvoie les canaux auxquels l'utilisateur⋅rice donné a accès, en lecture ou en écriture.
+
+        Types de permissions :
+        ANONYMOUS : Tout le monde, y compris les utilisateur⋅rices non connecté⋅es
+        AUTHENTICATED : Toustes les utilisateur⋅rices connecté⋅es
+        VOLUNTEER : Toustes les bénévoles
+        TOURNAMENT_MEMBER : Toustes les membres d'un tournoi donné (orgas, juré⋅es, participant⋅es)
+        TOURNAMENT_ORGANIZER : Les organisateur⋅rices d'un tournoi donné
+        TOURNAMENT_JURY_PRESIDENT : Les organisateur⋅rices et les président⋅es de jury d'un tournoi donné
+        JURY_MEMBER : Les membres du jury d'une poule donnée, ou les organisateur⋅rices du tournoi
+        POOL_MEMBER : Les membres du jury et les participant⋅es d'une poule donnée, ou les organisateur⋅rices du tournoi
+        TEAM_MEMBER : Les membres d'une équipe donnée
+        PRIVATE : Les utilisateur⋅rices explicitement invité⋅es
+        ADMIN : Les utilisateur⋅rices administrateur⋅rices (qui ont accès à tout)
+
+        Les canaux privés sont utilisés pour les messages privés, et ne sont pas affichés aux admins.
+
+        :param user: L'utilisateur⋅rice dont on veut récupérer la liste des canaux.
+        :param permission_type: Le type de permission concerné (read ou write).
+        :return: Le Queryset des canaux autorisés.
+        """
+        permission_type = 'write_access' if 'write' in permission_type.lower() else 'read_access'
+
+        qs = Channel.objects.none()
+        if user.is_anonymous:
+            # Les utilisateur⋅rices non connecté⋅es ont accès aux canaux publics pour toustes
+            return Channel.objects.filter(**{permission_type: PermissionType.ANONYMOUS})
+
+        # Les utilisateur⋅rices connecté⋅es ont accès aux canaux publics pour les personnes connectées
+        qs |= Channel.objects.filter(**{permission_type: PermissionType.AUTHENTICATED})
+        registration = await Registration.objects.prefetch_related('user').aget(user_id=user.id)
+
+        if registration.is_admin:
+            # Les administrateur⋅rices ont accès à tous les canaux, sauf les canaux privés sont iels ne sont pas membres
+            return Channel.objects.prefetch_related('invited').exclude(~Q(invited=user) & Q(private=True)).all()
+
+        if registration.is_volunteer:
+            registration = await VolunteerRegistration.objects \
+                .prefetch_related('jury_in__tournament', 'organized_tournaments').aget(user_id=user.id)
+
+            # Les bénévoles ont accès aux canaux pour bénévoles
+            qs |= Channel.objects.filter(**{permission_type: PermissionType.VOLUNTEER})
+
+            # Iels ont accès aux tournois dont iels sont organisateur⋅rices ou juré⋅es
+            # pour la permission TOURNAMENT_MEMBER
+            qs |= Channel.objects.filter(Q(tournament__in=registration.interesting_tournaments),
+                                         **{permission_type: PermissionType.TOURNAMENT_MEMBER})
+
+            # Iels ont accès aux canaux pour les organisateur⋅rices des tournois dont iels sont organisateur⋅rices
+            # pour la permission TOURNAMENT_ORGANIZER
+            qs |= Channel.objects.filter(Q(tournament__in=registration.organized_tournaments.all()),
+                                         **{permission_type: PermissionType.TOURNAMENT_ORGANIZER})
+
+            # Iels ont accès aux canaux pour les organisateur⋅rices et président⋅es de jury des tournois dont iels sont
+            # organisateur⋅rices ou juré⋅es pour la permission TOURNAMENT_JURY_PRESIDENT
+            qs |= Channel.objects.filter(Q(tournament__pools__in=registration.pools_presided.all())
+                                         | Q(tournament__in=registration.organized_tournaments.all()),
+                                         **{permission_type: PermissionType.TOURNAMENT_JURY_PRESIDENT})
+
+            # Iels ont accès aux canaux pour les juré⋅es des poules dont iels sont juré⋅es
+            # ou les organisateur⋅rices des tournois dont iels sont organisateur⋅rices
+            # pour la permission JURY_MEMBER
+            qs |= Channel.objects.filter(Q(pool__in=registration.jury_in.all())
+                                         | Q(pool__tournament__in=registration.organized_tournaments.all())
+                                         | Q(pool__tournament__pools__in=registration.pools_presided.all()),
+                                         **{permission_type: PermissionType.JURY_MEMBER})
+
+            # Iels ont accès aux canaux pour les juré⋅es et participant⋅es des poules dont iels sont juré⋅es
+            # ou les organisateur⋅rices des tournois dont iels sont organisateur⋅rices
+            # pour la permission POOL_MEMBER
+            qs |= Channel.objects.filter(Q(pool__in=registration.jury_in.all())
+                                         | Q(pool__tournament__in=registration.organized_tournaments.all())
+                                         | Q(pool__tournament__pools__in=registration.pools_presided.all()),
+                                         **{permission_type: PermissionType.POOL_MEMBER})
+        else:
+            registration = await ParticipantRegistration.objects \
+                .prefetch_related('team__participation__pools', 'team__participation__tournament').aget(user_id=user.id)
+
+            team = registration.team
+            tournaments = []
+            if team.participation.valid:
+                tournaments.append(team.participation.tournament)
+            if team.participation.final:
+                tournaments.append(await Tournament.objects.aget(final=True))
+
+            # Les participant⋅es ont accès aux canaux généraux pour le tournoi dont iels sont membres
+            # Cela comprend la finale s'iels sont finalistes
+            qs |= Channel.objects.filter(Q(tournament__in=tournaments),
+                                         **{permission_type: PermissionType.TOURNAMENT_MEMBER})
+
+            # Iels ont accès aux canaux généraux pour les poules dont iels sont participant⋅es
+            qs |= Channel.objects.filter(Q(pool__in=team.participation.pools.all()),
+                                         **{permission_type: PermissionType.POOL_MEMBER})
+
+            # Iels ont accès aux canaux propres à leur équipe
+            qs |= Channel.objects.filter(Q(team=team),
+                                         **{permission_type: PermissionType.TEAM_MEMBER})
+
+        # Les utilisateur⋅rices ont de plus accès aux messages privés qui leur sont adressés
+        qs |= Channel.objects.filter(invited=user).prefetch_related('invited')
+
+        return qs
+
+    class Meta:
+        verbose_name = _("channel")
+        verbose_name_plural = _("channels")
+        ordering = ('category', 'name',)
+
+
+class Message(models.Model):
+    """
+    Ce modèle représente un message de chat.
+    Un message appartient à un canal, et est défini par son contenu, son auteur⋅rice, sa date de création et sa date
+    de dernière modification.
+    De plus, on garde en mémoire les utilisateur⋅rices qui ont lu le message.
+    """
+    channel = models.ForeignKey(
+        Channel,
+        on_delete=models.CASCADE,
+        verbose_name=_("channel"),
+        related_name='messages',
+    )
+
+    author = models.ForeignKey(
+        'auth.User',
+        verbose_name=_("author"),
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name='chat_messages',
+    )
+
+    created_at = models.DateTimeField(
+        verbose_name=_("created at"),
+        auto_now_add=True,
+    )
+
+    updated_at = models.DateTimeField(
+        verbose_name=_("updated at"),
+        auto_now=True,
+    )
+
+    content = models.TextField(
+        verbose_name=_("content"),
+    )
+
+    users_read = models.ManyToManyField(
+        'auth.User',
+        verbose_name=_("users read"),
+        related_name='+',
+        blank=True,
+        help_text=_("Users who have read the message."),
+    )
+
+    def get_author_name(self) -> str:
+        """
+        Renvoie le nom de l'auteur⋅rice du message, en fonction de son rôle dans l'organisation
+        dans le cadre d'un⋅e bénévole, ou de son équipe dans le cadre d'un⋅e participant⋅e.
+        """
+        registration = self.author.registration
+
+        author_name = f"{self.author.first_name} {self.author.last_name}"
+        if registration.is_volunteer:
+            if registration.is_admin:
+                # Les administrateur⋅rices ont le suffixe (CNO)
+                author_name += " (CNO)"
+
+            if self.channel.pool:
+                if registration == self.channel.pool.jury_president:
+                    # Læ président⋅e de jury de la poule a le suffixe (P. jury)
+                    author_name += " (P. jury)"
+                elif registration in self.channel.pool.juries.all():
+                    # Les juré⋅es de la poule ont le suffixe (Juré⋅e)
+                    author_name += " (Juré⋅e)"
+                elif registration in self.channel.pool.tournament.organizers.all():
+                    # Les organisateur⋅rices du tournoi ont le suffixe (CRO)
+                    author_name += " (CRO)"
+                else:
+                    # Les éventuel⋅les autres bénévoles ont le suffixe (Bénévole)
+                    author_name += " (Bénévole)"
+            elif self.channel.tournament:
+                if registration in self.channel.tournament.organizers.all():
+                    # Les organisateur⋅rices du tournoi ont le suffixe (CRO)
+                    author_name += " (CRO)"
+                elif any([registration.id == pool.jury_president
+                          for pool in self.channel.tournament.pools.all()]):
+                    # Les président⋅es de jury des poules ont le suffixe (P. jury)
+                    # mentionnant l'ensemble des poules qu'iels président
+                    pools = ", ".join([pool.short_name
+                                       for pool in self.channel.tournament.pools.all()
+                                       if pool.jury_president == registration])
+                    author_name += f" (P. jury {pools})"
+                elif any([pool.juries.contains(registration)
+                          for pool in self.channel.tournament.pools.all()]):
+                    # Les juré⋅es des poules ont le suffixe (Juré⋅e)
+                    # mentionnant l'ensemble des poules auxquelles iels participent
+                    pools = ", ".join([pool.short_name
+                                       for pool in self.channel.tournament.pools.all()
+                                       if pool.juries.acontains(registration)])
+                    author_name += f" (Juré⋅e {pools})"
+                else:
+                    # Les éventuel⋅les autres bénévoles ont le suffixe (Bénévole)
+                    author_name += " (Bénévole)"
+            else:
+                if registration.organized_tournaments.exists():
+                    # Les organisateur⋅rices de tournois ont le suffixe (CRO) mentionnant les tournois organisés
+                    tournaments = ", ".join([tournament.name
+                                             for tournament in registration.organized_tournaments.all()])
+                    author_name += f" (CRO {tournaments})"
+                if Pool.objects.filter(jury_president=registration).exists():
+                    # Les président⋅es de jury ont le suffixe (P. jury) mentionnant les tournois présidés
+                    tournaments = Tournament.objects.filter(pools__jury_president=registration).distinct()
+                    tournaments = ", ".join([tournament.name for tournament in tournaments])
+                    author_name += f" (P. jury {tournaments})"
+                elif registration.jury_in.exists():
+                    # Les juré⋅es ont le suffixe (Juré⋅e) mentionnant les tournois auxquels iels participent
+                    tournaments = Tournament.objects.filter(pools__juries=registration).distinct()
+                    tournaments = ", ".join([tournament.name for tournament in tournaments])
+                    author_name += f" (Juré⋅e {tournaments})"
+        else:
+            if registration.team_id:
+                # Le trigramme de l'équipe de læ participant⋅e est ajouté en suffixe
+                team = Team.objects.get(id=registration.team_id)
+                author_name += f" ({team.trigram})"
+            else:
+                author_name += " (sans équipe)"
+
+        return author_name
+
+    async def aget_author_name(self) -> str:
+        """
+        Fonction asynchrone pour récupérer le nom de l'auteur⋅rice du message.
+        Voir `get_author_name` pour plus de détails.
+        """
+        return await sync_to_async(self.get_author_name)()
+
+    class Meta:
+        verbose_name = _("message")
+        verbose_name_plural = _("messages")
+        ordering = ('created_at',)

chat/signals.py

@@ -0,0 +1,120 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from chat.models import Channel
+from participation.models import Participation, Pool, Tournament
+from tfjm.permissions import PermissionType
+
+
+def create_tournament_channels(instance: Tournament, **_kwargs):
+    """
+    Lorsqu'un tournoi est créé, on crée les canaux de chat associés.
+    On crée notamment un canal d'annonces (accessible en écriture uniquement aux orgas),
+    un canal général, un de détente, un pour les juré⋅es et un pour les président⋅es de jury.
+    """
+    tournament = instance
+
+    # Création du canal « Tournoi - Annonces »
+    Channel.objects.update_or_create(
+        name=f"{tournament.name} - Annonces",
+        defaults=dict(
+            category=Channel.ChannelCategory.TOURNAMENT,
+            read_access=PermissionType.TOURNAMENT_MEMBER,
+            write_access=PermissionType.TOURNAMENT_ORGANIZER,
+            tournament=tournament,
+        ),
+    )
+
+    # Création du canal « Tournoi - Général »
+    Channel.objects.update_or_create(
+        name=f"{tournament.name} - Général",
+        defaults=dict(
+            category=Channel.ChannelCategory.TOURNAMENT,
+            read_access=PermissionType.TOURNAMENT_MEMBER,
+            write_access=PermissionType.TOURNAMENT_MEMBER,
+            tournament=tournament,
+        ),
+    )
+
+    # Création du canal « Tournoi - Détente »
+    Channel.objects.update_or_create(
+        name=f"{tournament.name} - Détente",
+        defaults=dict(
+            category=Channel.ChannelCategory.TOURNAMENT,
+            read_access=PermissionType.TOURNAMENT_MEMBER,
+            write_access=PermissionType.TOURNAMENT_MEMBER,
+            tournament=tournament,
+        ),
+    )
+
+    # Création du canal « Tournoi - Juré⋅es »
+    Channel.objects.update_or_create(
+        name=f"{tournament.name} - Juré⋅es",
+        defaults=dict(
+            category=Channel.ChannelCategory.TOURNAMENT,
+            read_access=PermissionType.JURY_MEMBER,
+            write_access=PermissionType.JURY_MEMBER,
+            tournament=tournament,
+        ),
+    )
+
+    if tournament.remote:
+        # Création du canal « Tournoi - Président⋅es de jury » dans le cas d'un tournoi distanciel
+        Channel.objects.update_or_create(
+            name=f"{tournament.name} - Président⋅es de jury",
+            defaults=dict(
+                category=Channel.ChannelCategory.TOURNAMENT,
+                read_access=PermissionType.TOURNAMENT_JURY_PRESIDENT,
+                write_access=PermissionType.TOURNAMENT_JURY_PRESIDENT,
+                tournament=tournament,
+            ),
+        )
+
+
+def create_pool_channels(instance: Pool, **_kwargs):
+    """
+    Lorsqu'une poule est créée, on crée les canaux de chat associés.
+    On crée notamment un canal pour les membres de la poule et un pour les juré⋅es.
+    Cela ne concerne que les tournois distanciels.
+    """
+    pool = instance
+    tournament = pool.tournament
+
+    if tournament.remote:
+        # Dans le cadre d'un tournoi distanciel, on crée un canal pour les membres de la poule
+        # et un pour les juré⋅es de la poule.
+        Channel.objects.update_or_create(
+            name=f"{tournament.name} - Poule {pool.short_name}",
+            defaults=dict(
+                category=Channel.ChannelCategory.TOURNAMENT,
+                read_access=PermissionType.POOL_MEMBER,
+                write_access=PermissionType.POOL_MEMBER,
+                pool=pool,
+            ),
+        )
+
+        Channel.objects.update_or_create(
+            name=f"{tournament.name} - Poule {pool.short_name} - Jury",
+            defaults=dict(
+                category=Channel.ChannelCategory.TOURNAMENT,
+                read_access=PermissionType.JURY_MEMBER,
+                write_access=PermissionType.JURY_MEMBER,
+                pool=pool,
+            ),
+        )
+
+
+def create_team_channel(instance: Participation, **_kwargs):
+    """
+    Lorsqu'une équipe est validée, on crée un canal de chat associé.
+    """
+    if instance.valid:
+        Channel.objects.update_or_create(
+            name=f"Équipe {instance.team.trigram}",
+            defaults=dict(
+                category=Channel.ChannelCategory.TEAM,
+                read_access=PermissionType.TEAM_MEMBER,
+                write_access=PermissionType.TEAM_MEMBER,
+                team=instance.team,
+            ),
+        )

chat/static/tfjm/chat.webmanifest

@@ -0,0 +1,29 @@
+{
+    "background_color": "white",
+    "description": "Chat pour le TFJM²",
+    "display": "standalone",
+    "icons": [
+        {
+            "src": "/static/tfjm/img/tfjm-square.svg",
+            "sizes": "any",
+            "type": "image/svg+xml",
+            "purpose": "maskable"
+        },
+        {
+            "src": "/static/tfjm/img/tfjm-512.png",
+            "sizes": "512x512",
+            "type": "image/png",
+            "purpose": "maskable"
+        },
+        {
+            "src": "/static/tfjm/img/tfjm-192.png",
+            "sizes": "192x192",
+            "type": "image/png",
+            "purpose": "maskable"
+        }
+    ],
+    "name": "Chat TFJM²",
+    "short_name": "Chat TFJM²",
+    "start_url": "/chat/fullscreen",
+    "theme_color": "black"
+}

chat/static/tfjm/js/chat.js

@@ -0,0 +1,912 @@
+(async () => {
+    // Vérification de la permission pour envoyer des notifications
+    // C'est utile pour prévenir les utilisateur⋅rices de l'arrivée de nouveaux messages les mentionnant
+    await Notification.requestPermission()
+})()
+
+const MAX_MESSAGES = 50  // Nombre maximal de messages à charger à la fois
+
+const channel_categories = ['general', 'tournament', 'team', 'private']  // Liste des catégories de canaux
+let channels = {}  // Liste des canaux disponibles
+let messages = {}  // Liste des messages reçus par canal
+let selected_channel_id = null  // Canal courant
+
+/**
+ * Affiche une nouvelle notification avec le titre donné et le contenu donné.
+ * @param title Le titre de la notification
+ * @param body Le contenu de la notification
+ * @param timeout La durée (en millisecondes) après laquelle la notification se ferme automatiquement.
+ *                Définir à 0 (défaut) pour la rendre infinie.
+ * @return Notification
+ */
+function showNotification(title, body, timeout = 0) {
+    Notification.requestPermission().then((status) => {
+        if (status === 'granted') {
+            // On envoie la notification que si la permission a été donnée
+            let notif = new Notification(title, {'body': body, 'icon': "/static/tfjm-192.png"})
+            if (timeout > 0)
+                setTimeout(() => notif.close(), timeout)
+            return notif
+        }
+    })
+}
+
+/**
+ * Sélectionne le canal courant à afficher sur l'interface de chat.
+ * Va alors définir le canal courant et mettre à jour les messages affichés.
+ * @param channel_id L'identifiant du canal à afficher.
+ */
+function selectChannel(channel_id) {
+    let channel = channels[channel_id]
+    if (!channel) {
+        // Le canal n'existe pas
+        console.error('Channel not found:', channel_id)
+        return
+    }
+
+    selected_channel_id = channel_id
+    // On stocke dans le stockage local l'identifiant du canal
+    // pour pouvoir rouvrir le dernier canal ouvert dans le futur
+    localStorage.setItem('chat.last-channel-id', channel_id)
+
+    // Définition du titre du contenu
+    let channelTitle = document.getElementById('channel-title')
+    channelTitle.innerText = channel.name
+
+    // Si on a pas le droit d'écrire dans le canal, on désactive l'input de message
+    // On l'active sinon
+    let messageInput = document.getElementById('input-message')
+    messageInput.disabled = !channel.write_access
+
+    // On redessine la liste des messages à partir des messages stockés
+    redrawMessages()
+}
+
+/**
+ * On récupère le message écrit par l'utilisateur⋅rice dans le champ de texte idoine,
+ * et on le transmet ensuite au serveur.
+ * Il ne s'affiche pas instantanément sur l'interface,
+ * mais seulement une fois que le serveur aura validé et retransmis le message.
+ */
+function sendMessage() {
+    // Récupération du message à envoyer
+    let messageInput = document.getElementById('input-message')
+    let message = messageInput.value
+    // On efface le champ de texte après avoir récupéré le message
+    messageInput.value = ''
+
+    if (!message) {
+        return
+    }
+
+    // Envoi du message au serveur
+    socket.send(JSON.stringify({
+        'type': 'send_message',
+        'channel_id': selected_channel_id,
+        'content': message,
+    }))
+}
+
+/**
+ * Met à jour la liste des canaux disponibles, à partir de la liste récupérée du serveur.
+ * @param new_channels La liste des canaux à afficher.
+ *                     Chaque canal doit être un objet avec les clés `id`, `name`, `category`
+ *                     `read_access`, `write_access` et `unread_messages`, correspondant à l'identifiant du canal,
+ *                     son nom, sa catégorie, la permission de lecture, d'écriture et le nombre de messages non lus.
+ */
+function setChannels(new_channels) {
+    channels = {}
+    for (let category of channel_categories) {
+        // On commence par vider la liste des canaux sélectionnables
+        let categoryList = document.getElementById(`nav-${category}-channels-tab`)
+        categoryList.innerHTML = ''
+        categoryList.parentElement.classList.add('d-none')
+    }
+
+    for (let channel of new_channels)
+        // On ajoute chaque canal à la liste des canaux
+        addChannel(channel)
+
+    if (new_channels && (!selected_channel_id || !channels[selected_channel_id])) {
+        // Si aucun canal n'a encore été sélectionné et qu'il y a des canaux disponibles,
+        // on commence par vérifier si on a stocké un canal précédemment sélectionné et on l'affiche si c'est le cas
+        // Sinon, on affiche le premier canal disponible
+        let last_channel_id = parseInt(localStorage.getItem('chat.last-channel-id'))
+        if (last_channel_id && channels[last_channel_id])
+            selectChannel(last_channel_id)
+        else
+            selectChannel(Object.keys(channels)[0])
+    }
+}
+
+/**
+ * Ajoute un canal à la liste des canaux disponibles.
+ * @param channel Le canal à ajouter. Doit être un objet avec les clés `id`, `name`, `category`,
+ *               `read_access`, `write_access` et `unread_messages`, correspondant à l'identifiant du canal,
+ *               son nom, sa catégorie, la permission de lecture, d'écriture et le nombre de messages non lus.
+ */
+async function addChannel(channel) {
+    channels[channel.id] = channel
+    if (!messages[channel.id])
+        messages[channel.id] = new Map()
+
+    // On récupère la liste des canaux de la catégorie concernée
+    let categoryList = document.getElementById(`nav-${channel.category}-channels-tab`)
+    // On la rend visible si elle ne l'était pas déjà
+    categoryList.parentElement.classList.remove('d-none')
+
+    // On crée un nouvel élément de liste pour la catégorie concernant le canal
+    let navItem = document.createElement('li')
+    navItem.classList.add('list-group-item', 'tab-channel')
+    navItem.id = `tab-channel-${channel.id}`
+    navItem.setAttribute('data-bs-dismiss', 'offcanvas')
+    navItem.onclick = () => selectChannel(channel.id)
+    categoryList.appendChild(navItem)
+
+    // L'élément est cliquable afin de sélectionner le canal
+    let channelButton = document.createElement('button')
+    channelButton.classList.add('nav-link')
+    channelButton.type = 'button'
+    channelButton.innerText = channel.name
+    navItem.appendChild(channelButton)
+
+    // Affichage du nombre de messages non lus
+    let unreadBadge = document.createElement('span')
+    unreadBadge.classList.add('badge', 'rounded-pill', 'text-bg-light', 'ms-2')
+    unreadBadge.id = `unread-messages-${channel.id}`
+    unreadBadge.innerText = channel.unread_messages || 0
+    if (!channel.unread_messages)
+        unreadBadge.classList.add('d-none')
+    channelButton.appendChild(unreadBadge)
+
+    // Si on veut trier les canaux par nombre décroissant de messages non lus,
+    // on définit l'ordre de l'élément (propriété CSS) en fonction du nombre de messages non lus
+    if (document.getElementById('sort-by-unread-switch').checked)
+        navItem.style.order = `${-channel.unread_messages}`
+
+    // On demande enfin à récupérer les derniers messages du canal en question afin de les stocker / afficher
+    fetchMessages(channel.id)
+}
+
+/**
+ * Un⋅e utilisateur⋅rice a envoyé un message, qui a été retransmis par le serveur.
+ * On le stocke alors et on l'affiche sur l'interface si nécessaire.
+ * On affiche également une notification si le message contient une mention pour tout le monde.
+ * @param message Le message qui a été transmis. Doit être un objet avec
+ *                les clés `id`, `channel_id`, `author`, `author_id`, `content` et `timestamp`,
+ *                correspondant à l'identifiant du message, du canal, le nom de l'auteur⋅rice et l'heure d'envoi.
+ */
+function receiveMessage(message) {
+    // On vérifie si la barre de défilement est tout en bas
+    let scrollableContent = document.getElementById('chat-messages')
+    let isScrolledToBottom = scrollableContent.scrollHeight - scrollableContent.clientHeight <= scrollableContent.scrollTop + 1
+
+    // On stocke le message dans la liste des messages du canal concerné
+    // et on redessine les messages affichés si on est dans le canal concerné
+    messages[message.channel_id].set(message.id, message)
+    if (message.channel_id === selected_channel_id)
+        redrawMessages()
+
+    // Si la barre de défilement était tout en bas, alors on la remet tout en bas après avoir redessiné les messages
+    if (isScrolledToBottom)
+        scrollableContent.scrollTop = scrollableContent.scrollHeight - scrollableContent.clientHeight
+
+    // On ajoute un à la liste des messages non lus du canal (il pourra être lu plus tard)
+    updateUnreadBadge(message.channel_id, channels[message.channel_id].unread_messages + 1)
+
+    // Si le message contient une mention à @everyone, alors on envoie une notification (si la permission est donnée)
+    if (message.content.includes("@everyone"))
+        showNotification(channels[message.channel_id].name, `${message.author} : ${message.content}`)
+
+    // On envoie un événement personnalisé pour indiquer que les messages ont été mis à jour
+    // Permettant entre autres de marquer le message comme lu si c'est le cas
+    document.getElementById('message-list').dispatchEvent(new CustomEvent('updatemessages'))
+}
+
+/**
+ * Un message a été modifié, et le serveur nous a transmis les nouvelles informations.
+ * @param data Le nouveau message qui a été modifié.
+ */
+function editMessage(data) {
+    // On met à jour le contenu du message
+    messages[data.channel_id].get(data.id).content = data.content
+    // Si le message appartient au canal courant, on redessine les messages
+    if (data.channel_id === selected_channel_id)
+        redrawMessages()
+}
+
+/**
+ * Un message a été supprimé, et le serveur nous a transmis les informations.
+ * @param data Le message qui a été supprimé.
+ */
+function deleteMessage(data) {
+    // On supprime le message de la liste des messages du canal concerné
+    messages[data.channel_id].delete(data.id)
+    // Si le message appartient au canal courant, on redessine les messages
+    if (data.channel_id === selected_channel_id)
+        redrawMessages()
+}
+
+/**
+ * Demande au serveur de récupérer les messages du canal donné.
+ * @param channel_id L'identifiant du canal dont on veut récupérer les messages.
+ * @param offset Le décalage à partir duquel on veut récupérer les messages,
+ *               correspond au nombre de messages en mémoire.
+ * @param limit Le nombre maximal de messages à récupérer.
+ */
+function fetchMessages(channel_id, offset = 0, limit = MAX_MESSAGES) {
+    // Envoi de la requête au serveur avec les différents paramètres
+    socket.send(JSON.stringify({
+        'type': 'fetch_messages',
+        'channel_id': channel_id,
+        'offset': offset,
+        'limit': limit,
+    }))
+}
+
+/**
+ * Demande au serveur de récupérer les messages précédents du canal courant.
+ * Par défaut, on récupère `MAX_MESSAGES` messages avant tous ceux qui ont été reçus sur ce canal.
+ */
+function fetchPreviousMessages() {
+    let channel_id = selected_channel_id
+    let offset = messages[channel_id].size
+    fetchMessages(channel_id, offset, MAX_MESSAGES)
+}
+
+/**
+ * L'utilisateur⋅rice a demandé à récupérer une partie des messages d'un canal.
+ * Cette fonction est alors appelée lors du retour du serveur.
+ * @param data Dictionnaire contenant l'identifiant du canal concerné, et la liste des messages récupérés.
+ */
+function receiveFetchedMessages(data) {
+    // Récupération du canal concerné ainsi que des nouveaux messages à mémoriser
+    let channel_id = data.channel_id
+    let new_messages = data.messages
+
+    if (!messages[channel_id])
+        messages[channel_id] = new Map()
+
+    // Ajout des nouveaux messages à la liste des messages du canal
+    for (let message of new_messages)
+        messages[channel_id].set(message.id, message)
+
+    // On trie les messages reçus par date et heure d'envoi
+    messages[channel_id] = new Map([...messages[channel_id].values()]
+      .sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp))
+      .map(message => [message.id, message]))
+
+    // Enfin, si le canal concerné est le canal courant, on redessine les messages
+    if (channel_id === selected_channel_id)
+        redrawMessages()
+}
+
+/**
+ * L'utilisateur⋅rice a indiqué au serveur que des messages ont été lus.
+ * Cette fonction est appelée en retour, pour confirmer, et stocke quels messages ont été lus
+ * et combien de messages sont non lus par canal.
+ * @param data Dictionnaire contenant une clé `read`, contenant la liste des identifiants des messages
+ *             marqués comme lus avec leur canal respectif, et une clé `unread_messages` contenant le nombre
+ *             de messages non lus par canal.
+ */
+function markMessageAsRead(data) {
+    for (let message of data.messages) {
+        // Récupération du message à marquer comme lu
+        let stored_message = messages[message.channel_id].get(message.id)
+        // Marquage du message comme lu
+        if (stored_message)
+            stored_message.read = true
+    }
+    // Actualisation des badges contenant le nombre de messages non lus par canal
+    updateUnreadBadges(data.unread_messages)
+}
+
+/**
+ * Mise à jour des badges contenant le nombre de messages non lus par canal.
+ * @param unreadMessages Dictionnaire des nombres de messages non lus par canal (identifiés par leurs identifiants)
+ */
+function updateUnreadBadges(unreadMessages) {
+    for (let channel of Object.values(channels)) {
+        // Récupération du nombre de messages non lus pour le canal en question et mise à jour du badge pour ce canal
+        updateUnreadBadge(channel.id, unreadMessages[channel.id] || 0)
+    }
+}
+
+/**
+ * Mise à jour du badge du nombre de messages non lus d'un canal.
+ * Actualise sa visibilité.
+ * @param channel_id Identifiant du canal concerné.
+ * @param unreadMessagesCount Nombre de messages non lus du canal.
+ */
+function updateUnreadBadge(channel_id, unreadMessagesCount = 0) {
+    // Vaut true si on veut trier les canaux par nombre de messages non lus ou non
+    const sortByUnread = document.getElementById('sort-by-unread-switch').checked
+
+    // Récupération du canal concerné
+    let channel = channels[channel_id]
+
+    // Récupération du nombre de messages non lus pour le canal en question, que l'on stocke
+    channel.unread_messages = unreadMessagesCount
+
+    // On met à jour le badge du canal contenant le nombre de messages non lus
+    let unreadBadge = document.getElementById(`unread-messages-${channel.id}`)
+    unreadBadge.innerText = unreadMessagesCount.toString()
+
+    // Le badge est visible si et seulement si il y a au moins un message non lu
+    if (unreadMessagesCount)
+        unreadBadge.classList.remove('d-none')
+    else
+        unreadBadge.classList.add('d-none')
+
+    // S'il faut trier les canaux par nombre de messages non lus, on ajoute la propriété CSS correspondante
+    if (sortByUnread)
+        document.getElementById(`tab-channel-${channel.id}`).style.order = `${-unreadMessagesCount}`
+}
+
+/**
+ * La création d'un canal privé entre deux personnes a été demandée.
+ * Cette fonction est appelée en réponse du serveur.
+ * Le canal est ajouté à la liste s'il est nouveau, et automatiquement sélectionné.
+ * @param data Dictionnaire contenant une unique clé `channel` correspondant aux informations du canal privé.
+ */
+function startPrivateChat(data) {
+    // Récupération du canal
+    let channel = data.channel
+    if (!channel) {
+        console.error('Private chat not found:', data)
+        return
+    }
+
+    if (!channels[channel.id]) {
+        // Si le canal n'est pas récupéré, on l'ajoute à la liste
+        channels[channel.id] = channel
+        messages[channel.id] = new Map()
+        addChannel(channel)
+    }
+
+    // Sélection immédiate du canal privé
+    selectChannel(channel.id)
+}
+
+/**
+ * Met à jour le composant correspondant à la liste des messages du canal sélectionné.
+ * Le conteneur est d'abord réinitialisé, puis les messages sont affichés un à un à partir de ceux stockés.
+ */
+function redrawMessages() {
+    // Récupération du composant HTML <ul> correspondant à la liste des messages affichés
+    let messageList = document.getElementById('message-list')
+    // On commence par le vider
+    messageList.innerHTML = ''
+
+    let lastMessage = null
+    let lastContentDiv = null
+
+    for (let message of messages[selected_channel_id].values()) {
+        if (lastMessage && lastMessage.author === message.author) {
+            // Si le message est écrit par læ même auteur⋅rice que le message précédent,
+            // alors on les groupe ensemble
+            let lastTimestamp = new Date(lastMessage.timestamp)
+            let newTimestamp = new Date(message.timestamp)
+            if ((newTimestamp - lastTimestamp) / 1000 < 60 * 10) {
+                // Les messages sont groupés uniquement s'il y a une différence maximale de 10 minutes
+                // entre le premier message du groupe et celui en étude
+                // On ajoute alors le contenu du message en cours dans le dernier div de message
+                let messageContentDiv = document.createElement('div')
+                messageContentDiv.classList.add('message')
+                messageContentDiv.setAttribute('data-message-id', message.id)
+                lastContentDiv.appendChild(messageContentDiv)
+                let messageContentSpan = document.createElement('span')
+                messageContentSpan.innerHTML = markdownToHTML(message.content)
+                messageContentDiv.appendChild(messageContentSpan)
+
+                // Enregistrement du menu contextuel pour le message permettant la modification, la suppression
+                // et l'envoi de messages privés
+                registerMessageContextMenu(message, messageContentDiv, messageContentSpan)
+                continue
+            }
+        }
+
+        // Création de l'élément <li> pour le bloc de messages
+        let messageElement = document.createElement('li')
+        messageElement.classList.add('list-group-item')
+        messageList.appendChild(messageElement)
+
+        // Ajout d'un div contenant le nom de l'auteur⋅rice du message ainsi que la date et heure d'envoi
+        let authorDiv = document.createElement('div')
+        messageElement.appendChild(authorDiv)
+
+        // Ajout du nom de l'auteur⋅rice du message
+        let authorSpan = document.createElement('span')
+        authorSpan.classList.add('text-muted', 'fw-bold')
+        authorSpan.innerText = message.author
+        authorDiv.appendChild(authorSpan)
+
+        // Ajout de la date du message
+        let dateSpan = document.createElement('span')
+        dateSpan.classList.add('text-muted', 'float-end')
+        dateSpan.innerText = new Date(message.timestamp).toLocaleString()
+        authorDiv.appendChild(dateSpan)
+
+        // Enregistrement du menu contextuel pour le message permettant l'envoi de messages privés à l'auteur⋅rice
+        registerSendPrivateMessageContextMenu(message, authorDiv, authorSpan)
+
+        let contentDiv = document.createElement('div')
+        messageElement.appendChild(contentDiv)
+
+        // Ajout du contenu du message
+        // Le contenu est mis dans un span lui-même inclus dans un div,
+        let messageContentDiv = document.createElement('div')
+        messageContentDiv.classList.add('message')
+        messageContentDiv.setAttribute('data-message-id', message.id)
+        contentDiv.appendChild(messageContentDiv)
+        let messageContentSpan = document.createElement('span')
+        messageContentSpan.innerHTML = markdownToHTML(message.content)
+        messageContentDiv.appendChild(messageContentSpan)
+
+        // Enregistrement du menu contextuel pour le message permettant la modification, la suppression
+        // et l'envoi de messages privés
+        registerMessageContextMenu(message, messageContentDiv, messageContentSpan)
+
+        lastMessage = message
+        lastContentDiv = contentDiv
+    }
+
+    // Le bouton « Afficher les messages précédents » est affiché si et seulement si
+    // il y a des messages à récupérer (c'est-à-dire si le nombre de messages récupérés est un multiple de MAX_MESSAGES)
+    let fetchMoreButton = document.getElementById('fetch-previous-messages')
+    if (!messages[selected_channel_id].size || messages[selected_channel_id].size % MAX_MESSAGES !== 0)
+        fetchMoreButton.classList.add('d-none')
+    else
+        fetchMoreButton.classList.remove('d-none')
+
+    // On envoie un événement personnalisé pour indiquer que les messages ont été mis à jour
+    // Permettant entre autres de marquer les messages visibles comme lus si c'est le cas
+    messageList.dispatchEvent(new CustomEvent('updatemessages'))
+}
+
+/**
+ * Convertit un texte écrit en Markdown en HTML.
+ * Les balises Markdown suivantes sont supportées :
+ * - Souligné : `_texte_`
+ * - Gras : `**texte**`
+ * - Italique : `*texte*`
+ * - Code : `` `texte` ``
+ * - Les liens sont automatiquement convertis
+ * - Les esperluettes, guillemets et chevrons sont échappés.
+ * @param text Le texte écrit en Markdown.
+ * @return {string} Le texte converti en HTML.
+ */
+function markdownToHTML(text) {
+    // On échape certains caractères spéciaux (esperluettes, chevrons, guillemets)
+    let safeText = text.replace(/&/g, "&amp;")
+         .replace(/</g, "&lt;")
+         .replace(/>/g, "&gt;")
+         .replace(/"/g, "&quot;")
+         .replace(/'/g, "&#039;")
+    let lines = safeText.split('\n')
+    let htmlLines = []
+    for (let line of lines) {
+        // Pour chaque ligne, on remplace le Markdown par un équivalent HTML (pour ce qui est supporté)
+        let htmlLine = line
+            .replaceAll(/_(.*)_/gim, '<span class="text-decoration-underline">$1</span>')  // Souligné
+            .replaceAll(/\*\*(.*)\*\*/gim, '<span class="fw-bold">$1</span>')  // Gras
+            .replaceAll(/\*(.*)\*/gim, '<span class="fst-italic">$1</span>')  // Italique
+            .replaceAll(/`(.*)`/gim, '<pre>$1</pre>')  // Code
+            .replaceAll(/(https?:\/\/\S+)/g, '<a href="$1" target="_blank">$1</a>')  // Liens
+        htmlLines.push(htmlLine)
+    }
+    // On joint enfin toutes les lignes par des balises de saut de ligne
+    return htmlLines.join('<br>')
+}
+
+/**
+ * Ferme toutes les popovers ouvertes.
+ */
+function removeAllPopovers() {
+    for (let popover of document.querySelectorAll('*[aria-describedby*="popover"]')) {
+        let instance = bootstrap.Popover.getInstance(popover)
+        if (instance)
+            instance.dispose()
+    }
+}
+
+/**
+ * Enregistrement du menu contextuel pour un⋅e auteur⋅rice de message,
+ * donnant la possibilité d'envoyer un message privé.
+ * @param message Le message écrit par l'auteur⋅rice du bloc en question.
+ * @param div Le bloc contenant le nom de l'auteur⋅rice et de la date d'envoi du message.
+ *            Un clic droit sur lui affichera le menu contextuel.
+ * @param span Le span contenant le nom de l'auteur⋅rice.
+ *             Il désignera l'emplacement d'affichage du popover.
+ */
+function registerSendPrivateMessageContextMenu(message, div, span) {
+    // Enregistrement de l'écouteur d'événement pour le clic droit
+    div.addEventListener('contextmenu', (menu_event) => {
+        // On empêche le menu traditionnel de s'afficher
+        menu_event.preventDefault()
+        // On retire toutes les popovers déjà ouvertes
+        removeAllPopovers()
+
+        // On crée le popover contenant le lien pour envoyer un message privé, puis on l'affiche
+        const popover = bootstrap.Popover.getOrCreateInstance(span, {
+            'title': message.author,
+            'content': `<a id="send-private-message-link-${message.id}" class="nav-link" href="#" tabindex="0">Envoyer un message privé</a>`,
+            'html': true,
+        })
+        popover.show()
+
+        // Lorsqu'on clique sur le lien, on ferme le popover
+        // et on demande à ouvrir le canal privé avec l'auteur⋅rice du message
+        document.getElementById('send-private-message-link-' + message.id).addEventListener('click', event => {
+            event.preventDefault()
+            popover.dispose()
+            socket.send(JSON.stringify({
+                'type': 'start_private_chat',
+                'user_id': message.author_id,
+            }))
+        })
+    })
+}
+
+/**
+ * Enregistrement du menu contextuel pour un message,
+ * donnant la possibilité de modifier ou de supprimer le message, ou d'envoyer un message privé à l'auteur⋅rice.
+ * @param message Le message en question.
+ * @param div Le bloc contenant le contenu du message.
+ *            Un clic droit sur lui affichera le menu contextuel.
+ * @param span Le span contenant le contenu du message.
+ *             Il désignera l'emplacement d'affichage du popover.
+ */
+function registerMessageContextMenu(message, div, span) {
+    // Enregistrement de l'écouteur d'événement pour le clic droit
+    div.addEventListener('contextmenu', (menu_event) => {
+        // On empêche le menu traditionnel de s'afficher
+        menu_event.preventDefault()
+        // On retire toutes les popovers déjà ouvertes
+        removeAllPopovers()
+
+        // On crée le popover contenant les liens pour modifier, supprimer le message ou envoyer un message privé.
+        let content = `<a id="send-private-message-link-msg-${message.id}" class="nav-link" href="#" tabindex="0">Envoyer un message privé</a>`
+
+        // On ne peut modifier ou supprimer un message que si on est l'auteur⋅rice ou que l'on est administrateur⋅rice.
+        let has_right_to_edit = message.author_id === USER_ID || IS_ADMIN
+        if (has_right_to_edit) {
+            content += `<hr class="my-1">`
+            content += `<a id="edit-message-${message.id}" class="nav-link" href="#" tabindex="0">Modifier</a>`
+            content += `<a id="delete-message-${message.id}" class="nav-link" href="#" tabindex="0">Supprimer</a>`
+        }
+
+        const popover = bootstrap.Popover.getOrCreateInstance(span, {
+            'content': content,
+            'html': true,
+            'placement': 'bottom',
+        })
+        popover.show()
+
+        // Lorsqu'on clique sur le lien d'envoi de message privé, on ferme le popover
+        // et on demande à ouvrir le canal privé avec l'auteur⋅rice du message
+        document.getElementById('send-private-message-link-msg-' + message.id).addEventListener('click', event => {
+            event.preventDefault()
+            popover.dispose()
+            socket.send(JSON.stringify({
+                'type': 'start_private_chat',
+                'user_id': message.author_id,
+            }))
+        })
+
+        if (has_right_to_edit) {
+            // Si on a le droit de modifier ou supprimer le message, on enregistre les écouteurs d'événements
+            // Le bouton de modification de message ouvre une boîte de dialogue pour modifier le message
+            document.getElementById('edit-message-' + message.id).addEventListener('click', event => {
+                event.preventDefault()
+                // Fermeture du popover
+                popover.dispose()
+
+                // Ouverture d'une boîte de diaologue afin de modifier le message
+                let new_message = prompt("Modifier le message", message.content)
+                if (new_message) {
+                    // Si le message a été modifié, on envoie la demande de modification au serveur
+                    socket.send(JSON.stringify({
+                        'type': 'edit_message',
+                        'message_id': message.id,
+                        'content': new_message,
+                    }))
+                }
+            })
+
+            // Le bouton de suppression de message demande une confirmation avant de supprimer le message
+            document.getElementById('delete-message-' + message.id).addEventListener('click', event => {
+                event.preventDefault()
+                // Fermeture du popover
+                popover.dispose()
+
+                // Demande de confirmation avant de supprimer le message
+                if (confirm(`Supprimer le message ?\n${message.content}`)) {
+                    socket.send(JSON.stringify({
+                        'type': 'delete_message',
+                        'message_id': message.id,
+                    }))
+                }
+            })
+        }
+    })
+}
+
+/**
+ * Passe le chat en version plein écran, ou l'inverse si c'est déjà le cas.
+ */
+function toggleFullscreen() {
+    let chatContainer = document.getElementById('chat-container')
+    if (!chatContainer.getAttribute('data-fullscreen')) {
+        // Le chat n'est pas en plein écran.
+        // On le passe en plein écran en le plaçant en avant plan en position absolue
+        // prenant toute la hauteur et toute la largeur
+        chatContainer.setAttribute('data-fullscreen', 'true')
+        chatContainer.classList.add('position-absolute', 'top-0', 'start-0', 'vh-100', 'z-3')
+        window.history.replaceState({}, null, `?fullscreen=1`)
+    }
+    else {
+        // Le chat est déjà en plein écran. On retire les tags CSS correspondant au plein écran.
+        chatContainer.removeAttribute('data-fullscreen')
+        chatContainer.classList.remove('position-absolute', 'top-0', 'start-0', 'vh-100', 'z-3')
+        window.history.replaceState({}, null, `?fullscreen=0`)
+    }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    // Lorsqu'on effectue le moindre clic, on ferme les éventuelles popovers ouvertes
+    document.addEventListener('click', removeAllPopovers)
+
+    // Lorsqu'on change entre le tri des canaux par ordre alphabétique et par nombre de messages non lus,
+    // on met à jour l'ordre des canaux
+    document.getElementById('sort-by-unread-switch').addEventListener('change', event => {
+        const sortByUnread = event.target.checked
+        for (let channel of Object.values(channels)) {
+            let item = document.getElementById(`tab-channel-${channel.id}`)
+            if (sortByUnread)
+                // Si on trie par nombre de messages non lus,
+                // on définit l'ordre de l'élément en fonction du nombre de messages non lus
+                // à l'aide d'une propriété CSS
+                item.style.order = `${-channel.unread_messages}`
+            else
+                // Sinon, les canaux sont de base triés par ordre alphabétique
+                item.style.removeProperty('order')
+        }
+
+        // On stocke le mode de tri dans le stockage local
+        localStorage.setItem('chat.sort-by-unread', sortByUnread)
+    })
+
+    // On récupère le mode de tri des canaux depuis le stockage local
+    if (localStorage.getItem('chat.sort-by-unread') === 'true') {
+        document.getElementById('sort-by-unread-switch').checked = true
+        document.getElementById('sort-by-unread-switch').dispatchEvent(new Event('change'))
+    }
+
+    /**
+     * Des données sont reçues depuis le serveur. Elles sont traitées dans cette fonction,
+     * qui a pour but de trier et de répartir dans d'autres sous-fonctions.
+     * @param data Le message reçu.
+     */
+    function processMessage(data) {
+        // On traite le message en fonction de son type
+        switch (data.type) {
+            case 'fetch_channels':
+                setChannels(data.channels)
+                break
+            case 'send_message':
+                receiveMessage(data)
+                break
+            case 'edit_message':
+                editMessage(data)
+                break
+            case 'delete_message':
+                deleteMessage(data)
+                break
+            case 'fetch_messages':
+                receiveFetchedMessages(data)
+                break
+            case 'mark_read':
+                markMessageAsRead(data)
+                break
+            case 'start_private_chat':
+                startPrivateChat(data)
+                break
+            default:
+                // Le type de message est inconnu. On affiche une erreur dans la console.
+                console.log(data)
+                console.error('Unknown message type:', data.type)
+                break
+        }
+    }
+
+    /**
+     * Configuration du socket de chat, permettant de communiquer avec le serveur.
+     * @param nextDelay Correspond au délai de reconnexion en cas d'erreur.
+     *                  Augmente exponentiellement en cas d'erreurs répétées,
+     *                  et se réinitialise à 1s en cas de connexion réussie.
+     */
+    function setupSocket(nextDelay = 1000) {
+        // Ouverture du socket
+        socket = new WebSocket(
+            (document.location.protocol === 'https:' ? 'wss' : 'ws') + '://' + window.location.host + '/ws/chat/'
+        )
+        let socketOpen = false
+
+        // Écoute des messages reçus depuis le serveur
+        socket.addEventListener('message', e => {
+            // Analyse du message reçu en tant que JSON
+            const data = JSON.parse(e.data)
+
+            // Traite le message reçu
+            processMessage(data)
+        })
+
+        // En cas d'erreur, on affiche un message et on réessaie de se connecter après un certain délai
+        // Ce délai double après chaque erreur répétée, jusqu'à un maximum de 2 minutes
+        socket.addEventListener('close', e => {
+            console.error('Chat socket closed unexpectedly, restarting…')
+            setTimeout(() => setupSocket(Math.max(socketOpen ? 1000 : 2 * nextDelay, 120000)), nextDelay)
+        })
+
+        // En cas de connexion réussie, on demande au serveur les derniers messages pour chaque canal
+        socket.addEventListener('open', e => {
+            socketOpen = true
+            socket.send(JSON.stringify({
+                'type': 'fetch_channels',
+            }))
+        })
+    }
+
+    /**
+     * Configuration du swipe pour ouvrir et fermer le sélecteur de canaux.
+     * Fonctionne a priori uniquement sur les écrans tactiles.
+     * Lorsqu'on swipe de la gauche vers la droite, depuis le côté gauche de l'écran, on ouvre le sélecteur de canaux.
+     * Quand on swipe de la droite vers la gauche, on ferme le sélecteur de canaux.
+     */
+    function setupSwipeOffscreen() {
+        // Récupération du sélecteur de canaux
+        const offcanvas = new bootstrap.Offcanvas(document.getElementById('channelSelector'))
+
+        // L'écran a été touché. On récupère la coordonnée X de l'emplacement touché.
+        let lastX = null
+        document.addEventListener('touchstart', (event) => {
+            if (event.touches.length === 1)
+                lastX = event.touches[0].clientX
+        })
+
+        // Le doigt a été déplacé. Selon le nouvel emplacement du doigt, on ouvre ou on ferme le sélecteur de canaux.
+        document.addEventListener('touchmove', (event) => {
+            if (event.touches.length === 1 && lastX !== null) {
+                // L'écran a été touché à un seul doigt, et on a déjà récupéré la coordonnée X touchée.
+                const diff = event.touches[0].clientX - lastX
+                if (diff > window.innerWidth / 10 && lastX < window.innerWidth / 4) {
+                    // Si le déplacement correspond à au moins 10 % de la largeur de l'écran vers la droite
+                    // et que le point de départ se trouve dans le quart gauche de l'écran, alors on ouvre le sélecteur
+                    offcanvas.show()
+                    lastX = null
+                }
+                else if (diff < -window.innerWidth / 10) {
+                    // Si le déplacement correspond à au moins 10 % de la largeur de l'écran vers la gauche,
+                    // alors on ferme le sélecteur
+                    offcanvas.hide()
+                    lastX = null
+                }
+            }
+        })
+
+        // Le doigt a été relâché. On réinitialise la coordonnée X touchée.
+        document.addEventListener('touchend', () => {
+            lastX = null
+        })
+    }
+
+    /**
+     * Configuration du suivi de lecture des messages.
+     * Lorsque l'utilisateur⋅rice scrolle dans la fenêtre de chat, on vérifie quels sont les messages qui sont
+     * visibles à l'écran, et on les marque comme lus.
+     */
+    function setupReadTracker() {
+        // Récupération du conteneur de messages
+        const scrollableContent = document.getElementById('chat-messages')
+        const messagesList = document.getElementById('message-list')
+        let markReadBuffer = []
+        let markReadTimeout = null
+
+        // Lorsqu'on scrolle, on récupère les anciens messages si on est tout en haut,
+        // et on marque les messages visibles comme lus
+        scrollableContent.addEventListener('scroll', () => {
+            if (scrollableContent.clientHeight - scrollableContent.scrollTop === scrollableContent.scrollHeight
+                && !document.getElementById('fetch-previous-messages').classList.contains('d-none')) {
+                // Si l'utilisateur⋅rice est en haut du chat, on récupère la liste des anciens messages
+                fetchPreviousMessages()}
+
+            // On marque les messages visibles comme lus
+            markVisibleMessagesAsRead()
+        })
+
+        // Lorsque les messages stockés sont mis à jour, on vérifie quels sont les messages visibles à marquer comme lus
+        messagesList.addEventListener('updatemessages', () => markVisibleMessagesAsRead())
+
+        /**
+         * Marque les messages visibles à l'écran comme lus.
+         * On récupère pour cela les coordonnées du conteneur de messages ainsi que les coordonnées de chaque message
+         * et on vérifie si le message est visible à l'écran. Si c'est le cas, on le marque comme lu.
+         * Après 3 secondes d'attente après qu'aucun message n'ait été lu,
+         * on envoie la liste des messages lus au serveur.
+         */
+        function markVisibleMessagesAsRead() {
+            // Récupération des coordonnées visibles du conteneur de messages
+            let viewport = scrollableContent.getBoundingClientRect()
+
+            for (let item of messagesList.querySelectorAll('.message')) {
+                let message = messages[selected_channel_id].get(parseInt(item.getAttribute('data-message-id')))
+                if (!message.read) {
+                    // Si le message n'a pas déjà été lu, on récupère ses coordonnées
+                    let rect = item.getBoundingClientRect()
+                    if (rect.top >= viewport.top && rect.bottom <= viewport.bottom) {
+                        // Si les coordonnées sont entièrement incluses dans le rectangle visible, on le marque comme lu
+                        // et comme étant à envoyer au serveur
+                        message.read = true
+                        markReadBuffer.push(message.id)
+                        if (markReadTimeout)
+                            clearTimeout(markReadTimeout)
+                        // 3 secondes après qu'aucun nouveau message n'ait été rajouté, on envoie la liste des messages
+                        // lus au serveur
+                        markReadTimeout = setTimeout(() => {
+                            socket.send(JSON.stringify({
+                                'type': 'mark_read',
+                                'message_ids': markReadBuffer,
+                            }))
+                            markReadBuffer = []
+                            markReadTimeout = null
+                        }, 3000)
+                    }
+                }
+            }
+        }
+
+        // On considère les messages d'ores-et-déjà visibles comme lus
+        markVisibleMessagesAsRead()
+    }
+
+    /**
+     * Configuration de la demande d'installation de l'application en tant qu'application web progressive (PWA).
+     * Lorsque l'utilisateur⋅rice arrive sur la page, on lui propose de télécharger l'application
+     * pour l'ajouter à son écran d'accueil.
+     * Fonctionne uniquement sur les navigateurs compatibles.
+     */
+    function setupPWAPrompt() {
+        let deferredPrompt = null
+
+        window.addEventListener("beforeinstallprompt", (e) => {
+            // Une demande d'installation a été faite. On commence par empêcher l'action par défaut.
+            e.preventDefault()
+            deferredPrompt = e
+
+            // L'installation est possible, on rend visible le bouton de téléchargement
+            // ainsi que le message qui indique c'est possible.
+            let btn = document.getElementById('install-app-home-screen')
+            let alert = document.getElementById('alert-download-chat-app')
+            btn.classList.remove('d-none')
+            alert.classList.remove('d-none')
+            btn.onclick = function () {
+                // Lorsque le bouton de téléchargement est cliqué, on lance l'installation du PWA.
+                deferredPrompt.prompt()
+                deferredPrompt.userChoice.then((choiceResult) => {
+                    if (choiceResult.outcome === 'accepted') {
+                        // Si l'installation a été acceptée, on masque le bouton de téléchargement.
+                        deferredPrompt = null
+                        btn.classList.add('d-none')
+                        alert.classList.add('d-none')
+                    }
+                })
+            }
+        })
+    }
+
+    setupSocket()  // Configuration du Websocket
+    setupSwipeOffscreen()  // Configuration du swipe sur les écrans tactiles pour le sélecteur de canaux
+    setupReadTracker()  // Configuration du suivi de lecture des messages
+    setupPWAPrompt()  // Configuration de l'installateur d'application en tant qu'application web progressive
+})

chat/templates/chat/chat.html

@@ -0,0 +1,21 @@
+{% extends "base.html" %}
+
+{% load static %}
+{% load i18n %}
+{% load pipeline %}
+
+{% block extracss %}
+    {# Webmanifest PWA permettant l'installation de l'application sur un écran d'accueil, pour navigateurs supportés #}
+    <link rel="manifest" href="{% static "tfjm/chat.webmanifest" %}">
+{% endblock %}
+
+{% block content-title %}{% endblock %}
+
+{% block content %}
+    {% include "chat/content.html" %}
+{% endblock %}
+
+{% block extrajavascript %}
+    {# Ce script contient toutes les données pour la gestion du chat. #}
+    {% javascript 'chat' %}
+{% endblock %}

chat/templates/chat/content.html

@@ -0,0 +1,126 @@
+{% load i18n %}
+
+<noscript>
+    {# Le chat fonctionne à l'aide d'un script JavaScript, sans JavaScript activé il n'est pas possible d'utiliser le chat. #}
+    {% trans "JavaScript must be enabled on your browser to access chat." %}
+</noscript>
+<div class="offcanvas offcanvas-start" tabindex="-1" id="channelSelector" aria-labelledby="offcanvasTitle">
+    <div class="offcanvas-header">
+        {# Titre du sélecteur de canaux #}
+        <h3 class="offcanvas-title" id="offcanvasTitle">{% trans "Chat channels" %}</h3>
+        <button type="button" class="btn-close" data-bs-dismiss="offcanvas" aria-label="Close"></button>
+    </div>
+    <div class="offcanvas-body">
+        {# Contenu du sélecteur de canaux #}
+        <div class="form-switch form-switch">
+            <input class="form-check-input" type="checkbox" role="switch" id="sort-by-unread-switch">
+            <label class="form-check-label" for="sort-by-unread-switch">{% trans "Sort by unread messages" %}</label>
+        </div>
+        <ul class="list-group list-group-flush" id="nav-channels-tab">
+            {# Liste des différentes catégories, avec les canaux par catégorie #}
+            <li class="list-group-item d-none">
+                {# Canaux généraux #}
+                <h4>{% trans "General channels" %}</h4>
+                <ul class="list-group list-group-flush" id="nav-general-channels-tab"></ul>
+            </li>
+            <li class="list-group-item d-none">
+                {# Canaux liés à un tournoi #}
+                <h4>{% trans "Tournament channels" %}</h4>
+                <ul class="list-group list-group-flush" id="nav-tournament-channels-tab"></ul>
+            </li>
+            <li class="list-group-item d-none">
+                {# Canaux d'équipes #}
+                <h4>{% trans "Team channels" %}</h4>
+                <ul class="list-group list-group-flush" id="nav-team-channels-tab"></ul>
+            </li>
+            <li class="list-group-item d-none">
+                {# Échanges privés #}
+                <h4>{% trans "Private channels" %}</h4>
+                <ul class="list-group list-group-flush" id="nav-private-channels-tab"></ul>
+            </li>
+        </ul>
+    </div>
+</div>
+
+<div class="alert alert-info d-none" id="alert-download-chat-app">
+    {# Lorsque l'application du chat est installable (par exemple sur un Chrome sur Android), on affiche le message qui indique que c'est bien possible. #}
+    {% trans "You can install a shortcut to the chat on your home screen using the download button on the header." %}
+</div>
+
+{# Conteneur principal du chat. #}
+{# Lorsque le chat est en plein écran, on le place en coordonnées absolues, occupant tout l'espace de l'écran. #}
+<div class="card tab-content w-100 mh-100{% if request.GET.fullscreen == '1' or fullscreen %} position-absolute top-0 start-0 vh-100 z-3{% endif %}"
+     style="height: 95vh" id="chat-container">
+    <div class="card-header">
+        <h3>
+        {% if fullscreen %}
+            {# Lorsque le chat est en plein écran, on affiche le bouton de déconnexion. #}
+            {# Le bouton de déconnexion doit être présent dans un formulaire. Le formulaire doit inclure toute la ligne. #}
+            <form action="{% url 'chat:logout' %}" method="post">
+                {% csrf_token %}
+        {% endif %}
+            {# Bouton qui permet d'ouvrir le sélecteur de canaux #}
+            <button class="navbar-toggler" type="button" data-bs-toggle="offcanvas" data-bs-target="#channelSelector"
+                    aria-controls="channelSelector" aria-expanded="false" aria-label="Toggle channel selector">
+                <span class="navbar-toggler-icon"></span>
+            </button>
+
+            <span id="channel-title"></span> {# Titre du canal sélectionné #}
+            {% if not fullscreen %}
+                {# Dans le cas où on est pas uniquement en plein écran (cas de l'application), on affiche les boutons pour passer en ou quitter le mode plein écran. #}
+                <button class="btn float-end" type="button" onclick="toggleFullscreen()" title="{% trans "Toggle fullscreen mode" %}">
+                    <i class="fas fa-expand"></i>
+                </button>
+            {% else %}
+                {# Le bouton de déconnexion n'est affiché que sur l'application. #}
+                <button class="btn float-end" title="{% trans "Log out" %}">
+                    <i class="fas fa-sign-out-alt"></i>
+                </button>
+            {% endif %}
+            {# On affiche le bouton d'installation uniquement dans le cas où l'application est installable sur l'écran d'accueil. #}
+            <button class="btn float-end d-none" type="button" id="install-app-home-screen" title="{% trans "Install app on home screen" %}">
+                <i class="fas fa-download"></i>
+            </button>
+            {% if fullscreen %}
+                </form>
+            {% endif %}
+        </h3>
+    </div>
+
+    {# Contenu de la carte, contenant la liste des messages. La liste des messages est affichée à l'envers pour avoir un scroll plus cohérent. #}
+    <div class="card-body d-flex flex-column-reverse flex-grow-0 overflow-y-scroll" id="chat-messages">
+        {# Correspond à la liste des messages à afficher. #}
+        <ul class="list-group list-group-flush" id="message-list"></ul>
+        {# S'il y a des messages à récupérer, on affiche un lien qui permet de récupérer les anciens messages. #}
+        <div class="text-center d-none" id="fetch-previous-messages">
+            <a href="#" class="nav-link" onclick="event.preventDefault(); fetchPreviousMessages()">
+                {% trans "Fetch previous messages…" %}
+            </a>
+            <hr>
+        </div>
+    </div>
+    
+    {# Pied de la carte, contenant le formulaire pour envoyer un message. #}
+    <div class="card-footer mt-auto">
+        {# Lorsqu'on souhaite envoyer un message, on empêche le formulaire de s'envoyer et on envoie le message par websocket. #}
+        <form onsubmit="event.preventDefault(); sendMessage()">
+            <div class="input-group">
+                <label for="input-message" class="input-group-text">
+                    <i class="fas fa-comment"></i>
+                </label>
+                {# Affichage du contrôleur de texte pour rédiger le message à envoyer. #}
+                <input type="text" class="form-control" id="input-message" placeholder="{% trans "Send message…" %}" autofocus autocomplete="off">
+                <button class="input-group-text btn btn-success" type="submit">
+                    <i class="fas fa-paper-plane"></i>
+                </button>
+            </div>
+        </form>
+    </div>
+</div>
+
+<script>
+    {# Récupération de l'utilisateur⋅rice courant⋅e afin de pouvoir effectuer des tests plus tard. #}
+    const USER_ID = {{ request.user.id }}
+    {# Récupération du statut administrateur⋅rice de l'utilisateur⋅rice connecté⋅e afin de pouvoir effectuer des tests plus tard. #}
+    const IS_ADMIN = {{ request.user.registration.is_admin|yesno:"true,false" }}
+</script>

chat/templates/chat/fullscreen.html

@@ -0,0 +1,35 @@
+{% load i18n pipeline static %}
+
+<!DOCTYPE html>
+{% get_current_language as LANGUAGE_CODE %}{% get_current_language_bidi as LANGUAGE_BIDI %}
+<html lang="{{ LANGUAGE_CODE|default:"fr" }}" {% if LANGUAGE_BIDI %}dir="rtl"{% endif %}>
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+    <title>
+        {% trans "TFJM² Chat" %}
+    </title>
+    <meta name="description" content="{% trans "TFJM² Chat" %}">
+
+    {# Favicon #}
+    <link rel="shortcut icon" href="{% static "favicon.ico" %}">
+    <meta name="theme-color" content="#ffffff">
+
+    {# Bootstrap + Font Awesome CSS #}
+    {% stylesheet 'bootstrap_fontawesome' %}
+
+    {# Bootstrap JavaScript #}
+    {% javascript 'bootstrap' %}
+
+    {# Webmanifest PWA permettant l'installation de l'application sur un écran d'accueil, pour navigateurs supportés #}
+    <link rel="manifest" href="{% static "tfjm/chat.webmanifest" %}">
+</head>
+<body class="d-flex w-100 h-100 flex-column">
+{% include "chat/content.html" with fullscreen=True %}
+
+{# Inclusion du script permettant de gérer le thème sombre et le thème clair #}
+{% javascript 'theme' %}
+{# Inclusion du script gérant le chat #}
+{% javascript 'chat' %}
+</body>
+</html>

chat/templates/chat/login.html

@@ -0,0 +1,36 @@
+{% load i18n pipeline static %}
+
+<!DOCTYPE html>
+{% get_current_language as LANGUAGE_CODE %}{% get_current_language_bidi as LANGUAGE_BIDI %}
+<html lang="{{ LANGUAGE_CODE|default:"fr" }}" {% if LANGUAGE_BIDI %}dir="rtl"{% endif %}>
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+    <title>
+        {% trans "TFJM² Chat" %} - {% trans "Log in" %}
+    </title>
+    <meta name="description" content="{% trans "TFJM² Chat" %}">
+
+    {# Favicon #}
+    <link rel="shortcut icon" href="{% static "favicon.ico" %}">
+    <meta name="theme-color" content="#ffffff">
+
+    {# Bootstrap CSS #}
+    {% stylesheet 'bootstrap_fontawesome' %}
+
+    {# Bootstrap JavaScript #}
+    {% javascript 'bootstrap' %}
+
+    {# Webmanifest PWA permettant l'installation de l'application sur un écran d'accueil, pour navigateurs supportés #}
+    <link rel="manifest" href="{% static "tfjm/chat.webmanifest" %}">
+</head>
+<body class="d-flex w-100 h-100 flex-column">
+    <div class="container">
+        <h1>{% trans "Log in" %}</h1>
+        {% include "registration/includes/login.html" %}
+    </div>
+
+{# Inclusion du script permettant de gérer le thème sombre et le thème clair #}
+{% javascript 'theme' %}
+</body>
+</html>

chat/tests.py

@@ -0,0 +1,2 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later

chat/urls.py

@@ -0,0 +1,18 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.contrib.auth.views import LoginView, LogoutView
+from django.urls import path
+from django.utils.translation import gettext_lazy as _
+from tfjm.views import LoginRequiredTemplateView
+
+app_name = 'chat'
+
+urlpatterns = [
+    path('', LoginRequiredTemplateView.as_view(template_name="chat/chat.html",
+                                               extra_context={'title': _("Chat")}), name='chat'),
+    path('fullscreen/', LoginRequiredTemplateView.as_view(template_name="chat/fullscreen.html", login_url='chat:login'),
+         name='fullscreen'),
+    path('login/', LoginView.as_view(template_name="chat/login.html"), name='login'),
+    path('logout/', LogoutView.as_view(next_page='chat:fullscreen'), name='logout'),
+]

docs/conf.py

@@ -29,6 +29,7 @@ author = "Animath"
 # ones.
 extensions = [
     "sphinx_rtd_theme",
+    "sphinx_rtd_dark_mode",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -58,3 +59,5 @@ html_theme = 'sphinx_rtd_theme'
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
+
+default_dark_mode = True

docs/dev/install.rst

@@ -60,7 +60,7 @@ Dans le fichier ``docker-compose.yml``, configurer :
         networks:
           - tfjm
         labels:
-          - "traefik.http.routers.inscription-tfjm2.rule=Host(`inscription.tfjm.org`, `plateforme.tfjm.org`)"
+          - "traefik.http.routers.inscription-tfjm2.rule=Host(`inscription.tfjm.org`, `inscriptions.tfjm.org`, `plateforme.tfjm.org`)"
           - "traefik.http.routers.inscription-tfjm2.entrypoints=websecure"
           - "traefik.http.routers.inscription-tfjm2.tls.certresolver=mytlschallenge"
 

docs/requirements.txt

@@ -1,2 +1,3 @@
 sphinx>=3.3
-sphinx-rtd-theme>=0.5
+sphinx-rtd-theme>=2.0
+sphinx_rtd_dark_mode>=1.3.0

docs/user.rst

@@ -178,17 +178,126 @@ Vous recevrez par mail une réponse des organisateur⋅rices locaux⋅ales. En c
 Payer son inscription
 ---------------------
 
-Une fois votre inscription validée, il vous faudra payer votre inscription. Les frais s'élèvent à
+Une fois votre inscription validée, il vous faudra payer votre participation. Les frais s'élèvent à
-23 € par élève, sauf pour les élèves boursièr⋅es qui en sont exonéré⋅es. Les encadrant⋅es n'ont pas
+21 € par élève, sauf pour les élèves boursièr⋅es qui en sont exonéré⋅es. Les encadrant⋅es n'ont pas
-à payer.
+à payer. Pour la finale, les frais sont de 35 € par élève.
 
 .. note::
    Ces frais couvrent une partie des frais de restauration et d'hébergement. L'organisation reste
    bénévole.
 
-.. TODO
+Il est possible de payer par carte bancaire ou virement bancaire. Pour d'autres types de paiement,
+merci de nous contacter.
+
+Pour payer, si votre équipe est bien validée, vous pouvez vous rendre sur la page de votre compte
+ou celle de votre équipe, et cliquer sur le bouton « Modifier le paiement », qui devrais désormais
+apparaître. Vous pouvez également utiliser le lien présent dans le volet « Informations ».
+
+.. image:: /_static/img/payment_index.png
+   :alt: Page de paiement
+
 .. note::
-   Cette section sera mise à jour plus tard.
+
+   Vous recevrez un mail de rappel chaque semaine. Le paiement doit être effectué avant le début du
+   tournoi, sans quoi votre participation pourrait être refusée. En cas de difficultés de paiement,
+   merci de nous contacter.
+
+Carte bancaire
+""""""""""""""
+
+La façon la plus simple de payer son inscription est de payer par carte bancaire. Animath utilise
+`Hello Asso <https://helloasso.com/>`_ en guise de solution de paiements en ligne.
+
+Il vous suffit de cliquer sur le bouton « Aller à la page Hello Asso ». Vous serez redirigé⋅e ensuite
+vers la page de paiement.
+
+.. warning::
+
+   Pour procéder au paiement, si vous êtes mineur⋅e, vous devrez demander à un⋅e adulte de payer à
+   votre place. Il est important dans la suite de bien mettre les coordonnées du payeur ou de la payeuse,
+   majeur⋅e, et non celles de l'élève.
+
+.. image:: /_static/img/payment_hello_asso_step_1.png
+   :alt: Formulaire de paiement Hello Asso
+
+La personne qui paie peut rentrer ses informations demandées (nom, prénom, e-mail, date de naissance).
+
+Notez que, par défaut, Hello Asso ajoute automatiquement une participation à ses frais de fonctionnement,
+d'environ 15 à 20 % du prix payé. Ces frais ne sont pas obligatoires, ne sont pas versés à Animath et
+représentent la seule source de revenus à Hello Asso. En effet : Animath ne verse aucune commission lors
+de ses transactions, et seules les contributions volontaires financent leur service.
+
+Sur la page suivante, vous pouvez indiquer vos coordonnées bancaires :
+
+.. image:: /_static/img/payment_hello_asso_step_2.png
+   :alt: Formulaire de paiement Hello Asso - coordonnées bancaires
+
+Vous devez ensuite éventuellement confirmer votre paiement auprès de votre banque.
+
+Une fois ceci fait, vous êtes automatiquement redirigé⋅es vers la plateforme du TFJM² :
+
+.. image:: /_static/img/payment_hello_asso_confirmation.png
+   :alt: Confirmation de paiement Hello Asso
+
+Il se peut que la validation ne soit pas instantanée. Elle peut prendre au plus quelques minutes.
+Si le délai est plus long, merci de nous contacter.
+
+Vous recevrez ensuite un mail de confirmation de la plateforme, ainsi qu'un justificatif de paiement
+de la part de Hello Asso.
+
+
+Carte bancaire - paiement par un tiers
+""""""""""""""""""""""""""""""""""""""
+
+Il est possible, si nécessaire, de faire payer l'inscription par carte bancaire par un tiers. Pour cela,
+vous pouvez lui transmettre le lien de paiement qui apparaît au centre de l'écran. Cela est notamment
+utile pour faire payer l'inscription par un établissement scolaire, ou par des parents.
+
+L'interface de paiement sera ensuite identique.
+
+
+Virement bancaire
+"""""""""""""""""
+
+Il est possible de payer par virement bancaire. Pour cela, vous pouvez ouvrir l'onglet virement bancaire :
+
+.. image:: /_static/img/payment_bank_transfer.png
+   :alt: Formulaire de paiement par virement bancaire
+
+Pour effectuer le virement, merci de mettre en référence du virement « TFJMpu » suivi du nom et du prénom de l'élève.
+
+Les coordonnées bancaires sont :
+
+* IBAN : FR76 1027 8065 0000 0206 4290 127
+* BIC : CMCIFR2A
+
+Une fois le paiment effectué, vous pouvez envoyer une preuve de virement via le formulaire ci-dessus. Le paiement
+sera ensuite validé manuellement par les organisateur⋅rices après réception.
+
+Si vous avez besoin d'une facture, merci de nous contacter.
+
+
+Exonération - boursièr⋅es
+"""""""""""""""""""""""""
+
+Si vous bénéficiez d'une bourse, vous pouvez être exonéré⋅es des frais de participation. Pour cela, il vous suffit
+de nous envoyer une copie de votre notification de bourse, ou tout autre document justifiant de votre situation.
+Vous pouvez envoyer ce document en vous rendant sur l'onglet dédié :
+
+.. image:: /_static/img/payment_scholarship.png
+   :alt: Formulaire de soumission de notification de bourse
+
+
+Paiements groupés
+"""""""""""""""""
+
+Il est possible de payer en une seule fois pour toute l'équipe. Cela est notamment utile si l'inscription est
+payée par l'établissement. Pour cela, il suffit de cliquer sur le bouton « Regrouper les paiements de mon équipe ».
+Cela a pour effet d'unifier les paiements de l'équipe, et de ne pas demander à chaque membre de payer individuellement.
+Attention : cette fonction n'est possible que si aucun membre de l'équipe n'a encore payé son inscription.
+
+.. image:: /_static/img/payment_grouped.png
+   :alt: Page de paiement groupé
 
 
 Envoyer ses solutions

draw/admin.py

@@ -7,11 +7,34 @@ from django.utils.translation import gettext_lazy as _
 from .models import Draw, Pool, Round, TeamDraw
 
 
+class RoundInline(admin.TabularInline):
+    model = Round
+    extra = 0
+    autocomplete_fields = ('draw', 'current_pool',)
+    show_change_link = True
+
+
+class PoolInline(admin.TabularInline):
+    model = Pool
+    extra = 0
+    autocomplete_fields = ('round', 'current_team', 'associated_pool',)
+    show_change_link = True
+
+
+class TeamDrawInline(admin.TabularInline):
+    model = TeamDraw
+    extra = 0
+    autocomplete_fields = ('participation', 'round', 'pool',)
+    show_change_link = True
+
+
 @admin.register(Draw)
 class DrawAdmin(admin.ModelAdmin):
     list_display = ('tournament', 'teams', 'current_round', 'get_state',)
-    list_filter = ('tournament', 'current_round',)
+    list_filter = ('tournament', 'current_round__number',)
     search_fields = ('tournament__name', 'tournament__participation__team__trigram',)
+    autocomplete_fields = ('tournament',)
+    inlines = (RoundInline,)
 
     @admin.display(description=_("teams"))
     def teams(self, record: Draw):
@@ -20,10 +43,16 @@ class DrawAdmin(admin.ModelAdmin):
 
 @admin.register(Round)
 class RoundAdmin(admin.ModelAdmin):
-    list_display = ('draw', 'number', 'teams',)
+    list_display = ('draw', 'tournament', 'number', 'teams',)
     list_filter = ('draw__tournament', 'number',)
     search_fields = ('draw__tournament__name', 'pool__teamdraw__participation__team__trigram')
     ordering = ('draw__tournament__name', 'number')
+    autocomplete_fields = ('draw', 'current_pool',)
+    inlines = (PoolInline,)
+
+    @admin.display(description=_("tournament"), ordering='draw__tournament__name')
+    def tournament(self, record):
+        return record.draw.tournament
 
     @admin.display(description=_("teams"))
     def teams(self, record: Round):
@@ -36,6 +65,8 @@ class PoolAdmin(admin.ModelAdmin):
     list_filter = ('round__draw__tournament', 'round__number', 'letter')
     ordering = ('round__draw__tournament__name', 'round', 'letter')
     search_fields = ('round__draw__tournament__name', 'teamdraw__participation__team__trigram',)
+    autocomplete_fields = ('round', 'current_team', 'associated_pool',)
+    inlines = (TeamDrawInline,)
 
     @admin.display(ordering='round__draw__tournament__name', description=_("tournament"))
     def tournament(self, record):
@@ -52,6 +83,7 @@ class TeamDrawAdmin(admin.ModelAdmin):
                     'passage_index', 'choose_index', 'passage_dice', 'choice_dice',)
     list_filter = ('round__draw__tournament', 'round__number', 'pool__letter',)
     search_fields = ('round__draw__tournament__name', 'participation__team__trigram',)
+    autocomplete_fields = ('participation', 'round', 'pool',)
 
     @admin.display(ordering='round__draw__tournament__name', description=_("tournament"))
     def tournament(self, record):

draw/consumers.py

@@ -3,10 +3,13 @@
 
 from collections import OrderedDict
 import json
+import os
 from random import randint, shuffle
 
+from asgiref.sync import sync_to_async
 from channels.generic.websocket import AsyncJsonWebsocketConsumer
 from django.conf import settings
+from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 from django.utils import translation
 from django.utils.translation import gettext_lazy as _
@@ -42,10 +45,17 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
         We accept only if this is a user of a team of the associated tournament, or a volunteer
         of the tournament.
         """
+        if '_fake_user_id' in self.scope['session']:
+            self.scope['user'] = await User.objects.aget(pk=self.scope['session']['_fake_user_id'])
 
         # Fetch the registration of the current user
         user = self.scope['user']
-        reg = await Registration.objects.aget(user=user)
+        if user.is_anonymous:
+            # User is not authenticated
+            await self.close()
+            return
+
+        reg = await Registration.objects.aget(user_id=user.id)
         self.registration = reg
 
         # Accept the connection
@@ -69,6 +79,10 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
         Called when the websocket got disconnected, for any reason.
         :param close_code: The error code.
         """
+        if self.scope['user'].is_anonymous:
+            # User is not authenticated
+            return
+
         # Unregister from channel layers
         if not self.registration.is_volunteer:
             await self.channel_layer.group_discard(f"team-{self.registration.team.trigram}", self.channel_name)
@@ -152,7 +166,7 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
 
         try:
             # Parse format from string
-            fmt: list[int] = sorted(map(int, fmt.split('+')), reverse=True)
+            fmt: list[int] = sorted(map(int, fmt.split('+')))
         except ValueError:
             return await self.alert(_("Invalid format"), 'danger')
 
@@ -416,10 +430,8 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
 
         # For each pool of size N, put the N next teams into this pool
         async for p in Pool.objects.filter(round_id=self.tournament.draw.current_round_id).order_by('letter').all():
-            # Fetch the N teams, then order them in a new order for the passages inside the pool
+            # Fetch the N teams
-            # We multiply the dice scores by 27 mod 100 (which order is 20 mod 100) for this new order
+            pool_tds = tds_copy[:p.size].copy()
-            # This simulates a deterministic shuffle
-            pool_tds = sorted(tds_copy[:p.size], key=lambda td: (td.passage_dice * 27) % 100)
             # Remove the head
             tds_copy = tds_copy[p.size:]
             for i, td in enumerate(pool_tds):
@@ -428,34 +440,62 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
                 td.passage_index = i
                 await td.asave()
 
-        # The passages of the second round are determined from the scores of the dices
+        # The passages of the second round are determined from the order of the passages of the first round.
-        # The team that has the lowest dice score goes to the first pool, then the team
+        # We order teams by increasing passage index, and then by decreasing pool number.
-        # that has the second-lowest score goes to the second pool, etc.
+        # We keep teams that were at the last position in a 5-teams pool apart, as "jokers".
-        # This also determines the passage order, in the natural order this time.
+        # Then, we fill pools one team by one team.
-        # If there is a 5-teams pool, we force the last team to be in the first pool,
+        # As we fill one pool for the second round, we check if we can place a joker in it.
-        # which is this specific pool since they are ordered by decreasing size.
+        # We can add a joker team if there is not already a team in the pool that was in the same pool
-        # This is not true for the final tournament, which considers the scores of the
+        # in the first round, and such that the number of such jokers is exactly the free space of the current pool.
-        # first round.
+        # Exception: if there is one only pool with 5 teams, we exchange the first and the last teams of the pool.
         if not self.tournament.final:
-            tds_copy = tds.copy()
+            tds_copy = sorted(tds, key=lambda td: (td.passage_index, -td.pool.letter,))
+            jokers = [td for td in tds if td.passage_index == 4]
             round2 = await self.tournament.draw.round_set.filter(number=2).aget()
             round2_pools = [p async for p in Pool.objects.filter(round__draw__tournament=self.tournament, round=round2)
                             .order_by('letter').all()]
             current_pool_id, current_passage_index = 0, 0
             for i, td in enumerate(tds_copy):
-                if i == len(tds) - 1 and round2_pools[0].size == 5:
-                    current_pool_id = 0
-                    current_passage_index = 4
-
                 td2 = await TeamDraw.objects.filter(participation=td.participation, round=round2).aget()
                 td2.pool = round2_pools[current_pool_id]
                 td2.passage_index = current_passage_index
-                current_pool_id += 1
+                if len(round2_pools) == 1:
-                if current_pool_id == len(round2_pools):
+                    # Exchange first and last team if there is only one pool
-                    current_pool_id = 0
+                    if i == 0 or i == len(tds) - 1:
-                    current_passage_index += 1
+                        td2.passage_index = len(tds) - 1 - i
+                current_passage_index += 1
                 await td2.asave()
 
+                valid_jokers = []
+                # A joker is valid if it was not in the same pool in the first round
+                # as a team that is already in the current pool in the second round
+                for joker in jokers:
+                    async for td2 in round2_pools[current_pool_id].teamdraw_set.all():
+                        if await joker.pool.teamdraw_set.filter(participation_id=td2.participation_id).aexists():
+                            break
+                    else:
+                        valid_jokers.append(joker)
+
+                # We can add a joker if there is exactly enough free space in the current pool
+                if valid_jokers and current_passage_index + len(valid_jokers) == td2.pool.size:
+                    for joker in valid_jokers:
+                        tds_copy.remove(joker)
+                        jokers.remove(joker)
+                        td2_joker = await TeamDraw.objects.filter(participation_id=joker.participation_id,
+                                                                  round=round2).aget()
+                        td2_joker.pool = round2_pools[current_pool_id]
+                        td2_joker.passage_index = current_passage_index
+                        current_passage_index += 1
+                        await td2_joker.asave()
+                    jokers = []
+
+                    current_passage_index = 0
+                    current_pool_id += 1
+
+                if current_passage_index == round2_pools[current_pool_id].size:
+                    current_passage_index = 0
+                    current_pool_id += 1
+
         # The current pool is the first pool of the current (first) round
         pool = await Pool.objects.filter(round=self.tournament.draw.current_round, letter=1).aget()
         self.tournament.draw.current_round.current_pool = pool
@@ -465,8 +505,9 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
         msg = "Les résultats des dés sont les suivants : "
         msg += ", ".join(f"<strong>{td.participation.team.trigram}</strong> ({td.passage_dice})" for td in tds)
         msg += ". L'ordre de passage et les compositions des différentes poules sont affiché⋅es sur le côté. "
-        msg += "Attention : les ordres de passage sont déterminés à partir des scores des dés, mais ne sont pas "
+        msg += "Les ordres de passage pour le premier tour sont déterminés à partir des scores des dés, "
-        msg += "directement l'ordre croissant des dés, afin d'avoir des poules mélangées."
+        msg += "dans l'ordre croissant. Pour le deuxième tour, les ordres de passage sont déterminés à partir "
+        msg += "des ordres de passage du premier tour."
         self.tournament.draw.last_message = msg
         await self.tournament.draw.asave()
 
@@ -599,6 +640,7 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
                     and isinstance(kwargs['problem'], int) and (1 <= kwargs['problem'] <= len(settings.PROBLEMS)):
                 # Admins can force the draw
                 problem = int(kwargs['problem'])
+                break
 
             # Check that the user didn't already accept this problem for the first round
             # if this is the second round
@@ -899,7 +941,7 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
             if already_refused:
                 msg += "Cela n'ajoute pas de pénalité."
             else:
-                msg += "Cela ajoute une pénalité de 0.5 sur le coefficient de l'oral de la défense."
+                msg += "Cela ajoute une pénalité de 25&nbsp;% sur le coefficient de l'oral de la défense."
         self.tournament.draw.last_message = msg
         await self.tournament.draw.asave()
 
@@ -953,15 +995,19 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
         if not await Draw.objects.filter(tournament=self.tournament).aexists():
             return await self.alert(_("The draw has not started yet."), 'danger')
 
+        await self.channel_layer.group_send(f"volunteer-{self.tournament.id}",
+                                            {'tid': self.tournament_id, 'type': 'draw.export_visibility',
+                                             'visible': False})
+
         # Export each exportable pool
         async for r in self.tournament.draw.round_set.all():
             async for pool in r.pool_set.all():
                 if await pool.is_exportable():
                     await pool.export()
 
-        await self.channel_layer.group_send(f"volunteer-{self.tournament.id}",
+        # Update Google Sheets final sheet
-                                            {'tid': self.tournament_id, 'type': 'draw.export_visibility',
+        if os.getenv('GOOGLE_PRIVATE_KEY_ID', None):
-                                             'visible': False})
+            await sync_to_async(self.tournament.update_ranking_spreadsheet)()
 
     @ensure_orga
     async def continue_final(self, **kwargs):
@@ -977,7 +1023,8 @@ class DrawConsumer(AsyncJsonWebsocketConsumer):
         r2 = await self.tournament.draw.round_set.filter(number=2).aget()
         self.tournament.draw.current_round = r2
         msg = "Le tirage au sort pour le tour 2 va commencer. " \
-              "L'ordre de passage est déterminé à partir du classement du premier tour."
+              "L'ordre de passage est déterminé à partir du classement du premier tour, " \
+              "de sorte à mélanger les équipes entre les deux jours."
         self.tournament.draw.last_message = msg
         await self.tournament.draw.asave()
 

draw/migrations/0003_alter_teamdraw_options.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.0.3 on 2024-04-22 22:11
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("draw", "0002_alter_teamdraw_purposed"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="teamdraw",
+            options={
+                "ordering": (
+                    "round__draw__tournament__name",
+                    "round__number",
+                    "pool__letter",
+                    "passage_index",
+                    "choice_dice",
+                    "passage_dice",
+                ),
+                "verbose_name": "team draw",
+                "verbose_name_plural": "team draws",
+            },
+        ),
+    ]

draw/models.py

@@ -1,6 +1,8 @@
 # Copyright (C) 2023 by Animath
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+import os
+
 from asgiref.sync import sync_to_async
 from django.conf import settings
 from django.core.validators import MaxValueValidator, MinValueValidator
@@ -89,6 +91,7 @@ class Draw(models.Model):
             return 'WAITING_DRAW_PROBLEM'
         else:
             return 'WAITING_CHOOSE_PROBLEM'
+    get_state.short_description = _('State')
 
     @property
     def information(self):
@@ -145,7 +148,7 @@ class Draw(models.Model):
                     # The problem can be rejected
                     s += "Elle peut décider d'accepter ou de refuser ce problème. "
                     if len(td.rejected) >= len(settings.PROBLEMS) - 5:
-                        s += "Refuser ce problème ajoutera une nouvelle pénalité de 0.5 sur le coefficient de l'oral de la défense."
+                        s += "Refuser ce problème ajoutera une nouvelle pénalité de 25 % sur le coefficient de l'oral de la défense."
                     else:
                         s += f"Il reste {len(settings.PROBLEMS) - 5 - len(td.rejected)} refus sans pénalité."
             case 'WAITING_FINAL':
@@ -289,7 +292,7 @@ class Pool(models.Model):
         """
         Returns a query set ordered by passage index of all team draws in this pool.
         """
-        return self.teamdraw_set.order_by('passage_index').all()
+        return self.teamdraw_set.all()
 
     @property
     def trigrams(self) -> list[str]:
@@ -346,7 +349,7 @@ class Pool(models.Model):
         Translates this Pool instance in a :model:`participation.Pool` instance, with the passage orders.
         """
         # Create the pool
-        self.associated_pool = await PPool.objects.acreate(
+        self.associated_pool, _created = await PPool.objects.aget_or_create(
             tournament=self.round.draw.tournament,
             round=self.round.number,
             letter=self.letter,
@@ -358,6 +361,17 @@ class Pool(models.Model):
                                                        .prefetch_related('participation')])
         await self.asave()
 
+        pool2 = None
+        if self.size == 5:
+            pool2, _created = await PPool.objects.aget_or_create(
+                tournament=self.round.draw.tournament,
+                round=self.round.number,
+                letter=self.letter,
+                room=2,
+            )
+            await pool2.participations.aset([td.participation async for td in self.team_draws
+                                             .prefetch_related('participation')])
+
         # Define the passage matrix according to the number of teams
         table = []
         if self.size == 3:
@@ -377,26 +391,34 @@ class Pool(models.Model):
             table = [
                 [0, 2, 3],
                 [1, 3, 4],
-                [2, 0, 1],
+                [2, 4, 0],
-                [3, 4, 0],
+                [3, 0, 1],
                 [4, 1, 2],
             ]
 
         for i, line in enumerate(table):
+            passage_pool = self.associated_pool
+            passage_position = i + 1
+            if self.size == 5:
+                # In 5-teams pools, we may create some passages in the second room
+                if i % 2 == 1:
+                    passage_pool = pool2
+                passage_position = 1 + i // 2
+
             # Create the passage
-            passage = await Passage.objects.acreate(
+            await Passage.objects.acreate(
-                pool=self.associated_pool,
+                pool=passage_pool,
-                position=i + 1,
+                position=passage_position,
                 solution_number=tds[line[0]].accepted,
                 defender=tds[line[0]].participation,
                 opponent=tds[line[1]].participation,
                 reporter=tds[line[2]].participation,
                 defender_penalties=tds[line[0]].penalty_int,
             )
-            if self.size == 4:
+
-                # Add observer for 4-teams pools
+        # Update Google Sheets
-                passage.observer = tds[line[3]].participation
+        if os.getenv('GOOGLE_PRIVATE_KEY_ID', None):
-                await passage.asave()
+            await sync_to_async(self.associated_pool.update_spreadsheet)()
 
         return self.associated_pool
 
@@ -510,9 +532,9 @@ class TeamDraw(models.Model):
     @property
     def penalty(self):
         """
-        The penalty multiplier on the defender oral, which is a malus of 0.5 for each penalty.
+        The penalty multiplier on the defender oral, in percentage, which is a malus of 25% for each penalty.
         """
-        return 0.5 * self.penalty_int
+        return 25 * self.penalty_int
 
     def __str__(self):
         return str(format_lazy(_("Draw of the team {trigram} for the pool {letter}{number}"),
@@ -523,4 +545,5 @@ class TeamDraw(models.Model):
     class Meta:
         verbose_name = _('team draw')
         verbose_name_plural = _('team draws')
-        ordering = ('round__draw__tournament__name', 'round__number', 'pool__letter', 'passage_index',)
+        ordering = ('round__draw__tournament__name', 'round__number', 'pool__letter', 'passage_index',
+                    'choice_dice', 'passage_dice',)

draw/routing.py

@@ -1,10 +0,0 @@
-# Copyright (C) 2023 by Animath
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from django.urls import path
-
-from . import consumers
-
-websocket_urlpatterns = [
-    path("ws/draw/", consumers.DrawConsumer.as_asgi()),
-]

draw/static/tfjm/js/draw.js

@@ -40,6 +40,20 @@ function drawDice(tid, trigram = null, result = null) {
     socket.send(JSON.stringify({'tid': tid, 'type': 'dice', 'trigram': trigram, 'result': result}))
 }
 
+/**
+ * Fetch the requested dice from the buttons and request to draw it.
+ * Only available for debug purposes and for admins.
+ * @param tid The tournament id
+ */
+function drawDebugDice(tid) {
+    let dice_10 = parseInt(document.querySelector(`input[name="debug-dice-${tid}-10"]:checked`).value)
+    let dice_1 = parseInt(document.querySelector(`input[name="debug-dice-${tid}-1"]:checked`).value)
+    let result = (dice_10 + dice_1) || 100
+    let team_div = document.querySelector(`div[id="dices-${tid}"] > div > div[class*="text-bg-warning"]`)
+    let team = team_div.getAttribute("data-team")
+    drawDice(tid, team, result)
+}
+
 /**
  * Request to draw a new problem.
  * @param tid The tournament id
@@ -203,6 +217,14 @@ document.addEventListener('DOMContentLoaded', () => {
             elem.classList.add('text-bg-success')
             elem.innerText = `${trigram} 🎲 ${result}`
         }
+
+        let nextTeam = document.querySelector(` div[id="dices-${tid}"] > div > div[class*="text-bg-warning"]`).getAttribute("data-team")
+        if (nextTeam) {
+            // If there is one team that does not have launched its dice, then we update the debug section
+            let debugSpan = document.getElementById(`debug-dice-${tid}-team`)
+            if (debugSpan)
+                debugSpan.innerText = nextTeam
+        }
     }
 
     /**
@@ -212,10 +234,15 @@ document.addEventListener('DOMContentLoaded', () => {
      */
     function updateDiceVisibility(tid, visible) {
         let div = document.getElementById(`launch-dice-${tid}`)
-        if (visible)
+        let div_debug = document.getElementById(`debug-dice-form-${tid}`)
+        if (visible) {
             div.classList.remove('d-none')
-        else
+            div_debug.classList.remove('d-none')
+        }
+        else {
             div.classList.add('d-none')
+            div_debug.classList.add('d-none')
+        }
     }
 
     /**
@@ -225,10 +252,15 @@ document.addEventListener('DOMContentLoaded', () => {
      */
     function updateBoxVisibility(tid, visible) {
         let div = document.getElementById(`draw-problem-${tid}`)
-        if (visible)
+        let div_debug = document.getElementById(`debug-problem-form-${tid}`)
+        if (visible) {
             div.classList.remove('d-none')
-        else
+            div_debug.classList.remove('d-none')
+        }
+        else {
             div.classList.add('d-none')
+            div_debug.classList.add('d-none')
+        }
     }
 
     /**
@@ -582,6 +614,11 @@ document.addEventListener('DOMContentLoaded', () => {
         let teamLi = document.getElementById(`recap-${tid}-round-${round}-team-${team}`)
         if (teamLi !== null)
             teamLi.classList.add('list-group-item-info')
+
+        let debugSpan = document.getElementById(`debug-problem-${tid}-team`)
+        if (debugSpan && team) {
+            debugSpan.innerText = team
+        }
     }
 
     /**
@@ -622,14 +659,14 @@ document.addEventListener('DOMContentLoaded', () => {
 
         let penaltyDiv = document.getElementById(`recap-${tid}-round-${round}-team-${team}-penalty`)
         if (rejected.length > problems_count - 5) {
-            // If more than P - 5 problems were rejected, add a penalty of 0.5 of the coefficient of the oral defender
+            // If more than P - 5 problems were rejected, add a penalty of 25% of the coefficient of the oral defender
             if (penaltyDiv === null) {
                 penaltyDiv = document.createElement('div')
                 penaltyDiv.id = `recap-${tid}-round-${round}-team-${team}-penalty`
                 penaltyDiv.classList.add('badge', 'rounded-pill', 'text-bg-info')
                 recapDiv.parentNode.append(penaltyDiv)
             }
-            penaltyDiv.textContent = `❌ ${0.5 * (rejected.length - (problems_count - 5))}`
+            penaltyDiv.textContent = `❌ ${25 * (rejected.length - (problems_count - 5))} %`
         } else {
             // Eventually remove this div
             if (penaltyDiv !== null)
@@ -736,7 +773,7 @@ document.addEventListener('DOMContentLoaded', () => {
         }
     }
 
-    function setupSocket() {
+    function setupSocket(nextDelay = 1000) {
         // Open a global websocket
         socket = new WebSocket(
             (document.location.protocol === 'https:' ? 'wss' : 'ws') + '://' + window.location.host + '/ws/draw/'
@@ -753,7 +790,7 @@ document.addEventListener('DOMContentLoaded', () => {
         // Manage errors
         socket.addEventListener('close', e => {
             console.error('Chat socket closed unexpectedly, restarting…')
-            setupSocket()
+            setTimeout(() => setupSocket(2 * nextDelay), nextDelay)
         })
 
         // When the socket is opened, set the language in order to receive alerts in the good language

draw/templates/draw/index.html

@@ -2,6 +2,7 @@
 
 {% load static %}
 {% load i18n %}
+{% load pipeline %}
 
 {% block content %}
     {# The navbar to select the tournament #}
@@ -40,5 +41,5 @@
     {{ problems|length|json_script:'problems_count' }}
 
     {# This script contains all data for the draw management #}
-    <script src="{% static 'draw.js' %}"></script>
+    {% javascript 'draw' %}
 {% endblock %}

draw/templates/draw/tournament_content.html

@@ -37,6 +37,7 @@
                     {% for td in tournament.draw.current_round.team_draws %}
                         <div class="col-md-1" style="order: {{ forloop.counter }};">
                             <div id="dice-{{ tournament.id }}-{{ td.participation.team.trigram }}"
+                                 data-team="{{ td.participation.team.trigram }}"
                                  class="badge rounded-pill text-bg-{% if td.last_dice %}success{% else %}warning{% endif %}"
                                  {% if request.user.registration.is_volunteer %}
                                  {# Volunteers can click on dices to launch the dice of a team #}
@@ -99,7 +100,7 @@
                                                                 {# If needed, add the penalty of the team #}
                                                                 <div id="recap-{{ tournament.id }}-round-{{ round.number }}-team-{{ td.participation.team.trigram }}-penalty"
                                                                      class="badge rounded-pill text-bg-info">
-                                                                    ❌ {{ td.penalty }}
+                                                                    ❌ {{ td.penalty }} %
                                                                 </div>
                                                             {% endif %}
                                                         </li>
@@ -186,6 +187,66 @@
                         {% endif %}
                     {% endif %}
                 </div>
+
+                {% if user.registration.is_admin %}
+                    <div class="card my-3">
+                        <div class="card-header">
+                            <div style="cursor: pointer;" data-bs-toggle="collapse" data-bs-target="#debug-draw-{{ tournament.id }}-body"
+                                aria-controls="debug-draw-{{ tournament.id }}-body" aria-expanded="false">
+                                <h4>{% trans "Debug draw" %}</h4>
+                            </div>
+                        </div>
+                        <div class="card-body collapse" id="debug-draw-{{ tournament.id }}-body">
+                            <div id="debug-dice-form-{{ tournament.id }}" {% if tournament.draw.get_state != 'DICE_SELECT_POULES' and tournament.draw.get_state != 'DICE_ORDER_POULE' %}class="d-none"{% endif %}>
+                                <h5>
+                                    {% trans "Draw dice for" %}
+                                    <span id="debug-dice-{{ tournament.id }}-team">
+                                        {% regroup tournament.draw.current_round.team_draws by last_dice as td_dices %}
+                                        {% for group in td_dices %}
+                                            {% if group.grouper is None %}
+                                                {{ group }}
+                                                {% with group.list|first as td %}
+                                                    {{ td.participation.team.trigram }}
+                                                {% endwith %}
+                                            {% endif %}
+                                        {% endfor %}
+                                    </span>
+                                </h5>
+                                <div class="btn-group w-100" role="group">
+                                    {% for i in range_100 %}
+                                        <input type="radio" class="btn-check" name="debug-dice-{{ tournament.id }}-10" id="debug-dice-{{ tournament.id }}-{{ i|stringformat:"02d" }}" value="{{ i }}" {% if i == 0 %}checked{% endif %}>
+                                        <label class="btn btn-outline-warning" for="debug-dice-{{ tournament.id }}-{{ i|stringformat:"02d" }}">{{ i|stringformat:"02d" }}</label>
+                                    {% endfor %}
+                                </div>
+                                <div class="btn-group w-100" role="group">
+                                    {% for i in range_10 %}
+                                        <input type="radio" class="btn-check" name="debug-dice-{{ tournament.id }}-1" id="debug-dice-{{ tournament.id }}-{{ i }}" value="{{ i }}" {% if i == 0 %}checked{% endif %}>
+                                        <label class="btn btn-outline-warning" for="debug-dice-{{ tournament.id }}-{{ i }}">{{ i }}</label>
+                                    {% endfor %}
+                                </div>
+
+                                <div class="my-2 text-center">
+                                    <button class="btn btn-success" onclick="drawDebugDice({{ tournament.id }})">
+                                        {% trans "Draw dice" %} 🎲
+                                    </button>
+                                </div>
+                            </div>
+                            <div id="debug-problem-form-{{ tournament.id }}" {% if tournament.draw.get_state != 'WAITING_DRAW_PROBLEM' %}class="d-none"{% endif %}>
+                                <h5>
+                                    {% trans "Draw problem for" %}
+                                    <span id="debug-problem-{{ tournament.id }}-team">{{ tournament.draw.current_round.current_pool.current_team.participation.team.trigram }}</span>
+                                </h5>
+                                <div class="btn-group w-100" role="group">
+                                    {% for problem in problems %}
+                                        <button class="btn btn-outline-info" id="debug-problem-{{ tournament.id }}-{{ forloop.counter }}" onclick="drawProblem({{ tournament.id }}, {{ forloop.counter }})">
+                                            {% trans "Pb." %} {{ forloop.counter }}
+                                        </button>
+                                    {% endfor %}
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                {% endif %}
             </div>
         </div>
 
@@ -284,14 +345,14 @@
                                                             {% if forloop.counter == 1 %}
                                                                 <td class="text-center">Déf</td>
                                                                 <td></td>
-                                                                <td class="text-center">Opp</td>
                                                                 <td class="text-center">Rap</td>
+                                                                <td class="text-center">Opp</td>
                                                                 <td></td>
                                                             {% elif forloop.counter == 2 %}
                                                                 <td></td>
                                                                 <td class="text-center">Déf</td>
-                                                                <td class="text-center">Rap</td>
                                                                 <td></td>
+                                                                <td class="text-center">Rap</td>
                                                                 <td class="text-center">Opp</td>
                                                             {% elif forloop.counter == 3 %}
                                                                 <td class="text-center">Opp</td>
@@ -308,10 +369,9 @@
                                                             {% elif forloop.counter == 5 %}
                                                                 <td></td>
                                                                 <td class="text-center">Rap</td>
-                                                                <td></td>
                                                                 <td class="text-center">Opp</td>
-                                                                <td class="text-center">Déf</td>
                                                                 <td></td>
+                                                                <td class="text-center">Déf</td>
                                                             {% endif %}
                                                         {% endif %}
                                                     </tr>

draw/tests.py

@@ -14,8 +14,8 @@ from django.contrib.sites.models import Site
 from django.test import TestCase
 from django.urls import reverse
 from participation.models import Team, Tournament
+from tfjm import routing as websocket_routing
 
-from . import routing
 from .models import Draw, Pool, Round, TeamDraw
 
 
@@ -55,7 +55,7 @@ class TestDraw(TestCase):
 
         # Connect to Websocket
         headers = [(b'cookie', self.async_client.cookies.output(header='', sep='; ').encode())]
-        communicator = WebsocketCommunicator(AuthMiddlewareStack(URLRouter(routing.websocket_urlpatterns)),
+        communicator = WebsocketCommunicator(AuthMiddlewareStack(URLRouter(websocket_routing.websocket_urlpatterns)),
                                              "/ws/draw/", headers)
         connected, subprotocol = await communicator.connect()
         self.assertTrue(connected)
@@ -75,7 +75,7 @@ class TestDraw(TestCase):
         self.assertFalse(await Draw.objects.filter(tournament=self.tournament).aexists())
 
         # Now start the draw
-        await communicator.send_json_to({'tid': tid, 'type': 'start_draw', 'fmt': '3+4+5'})
+        await communicator.send_json_to({'tid': tid, 'type': 'start_draw', 'fmt': '4+5+3'})
 
         # Receive data after the start
         self.assertEqual((await communicator.receive_json_from())['type'], 'alert')
@@ -93,7 +93,7 @@ class TestDraw(TestCase):
                          {'tid': tid, 'type': 'dice_visibility', 'visible': True})
         self.assertEqual((await communicator.receive_json_from())['type'], 'alert')
         self.assertEqual(await communicator.receive_json_from(),
-                         {'tid': tid, 'type': 'draw_start', 'fmt': [5, 4, 3],
+                         {'tid': tid, 'type': 'draw_start', 'fmt': [3, 4, 5],
                           'trigrams': ['AAA', 'BBB', 'CCC', 'DDD', 'EEE', 'FFF',
                                        'GGG', 'HHH', 'III', 'JJJ', 'KKK', 'LLL']})
         self.assertEqual((await communicator.receive_json_from())['type'], 'set_info')
@@ -181,8 +181,8 @@ class TestDraw(TestCase):
             .aget(number=1, draw=draw)
         p = r.current_pool
         self.assertEqual(p.letter, 1)
-        self.assertEqual(p.size, 5)
+        self.assertEqual(p.size, 3)
-        self.assertEqual(await p.teamdraw_set.acount(), 5)
+        self.assertEqual(await p.teamdraw_set.acount(), 3)
         self.assertEqual(p.current_team, None)
 
         # Render page
@@ -292,7 +292,7 @@ class TestDraw(TestCase):
         self.assertIsNone(td.purposed)
         self.assertEqual(td.rejected, [purposed])
 
-        for i in range(4):
+        for i in range(2):
             # Next team
             p: Pool = await Pool.objects.prefetch_related('current_team__participation__team').aget(round=r, letter=1)
             td = p.current_team
@@ -411,8 +411,6 @@ class TestDraw(TestCase):
         td: TeamDraw = await TeamDraw.objects.prefetch_related('participation__team').aget(pk=td.pk)
         self.assertIsNone(td.purposed)
 
-        # Reorder the pool since there are 5 teams
-        self.assertEqual((await communicator.receive_json_from())['type'], 'reorder_poule')
         self.assertEqual(await communicator.receive_json_from(),
                          {'tid': tid, 'type': 'dice_visibility', 'visible': True})
         self.assertEqual((await communicator.receive_json_from())['type'], 'set_info')
@@ -510,8 +508,8 @@ class TestDraw(TestCase):
             .aget(number=1, draw=draw)
         p = r.current_pool
         self.assertEqual(p.letter, 3)
-        self.assertEqual(p.size, 3)
+        self.assertEqual(p.size, 5)
-        self.assertEqual(await p.teamdraw_set.acount(), 3)
+        self.assertEqual(await p.teamdraw_set.acount(), 5)
         self.assertEqual(p.current_team, None)
         self.assertEqual(await communicator.receive_json_from(),
                          {'tid': tid, 'type': 'set_active', 'round': 1, 'poule': 'C', 'team': None})
@@ -532,7 +530,7 @@ class TestDraw(TestCase):
 
         self.assertEqual((await communicator.receive_json_from())['type'], 'set_info')
 
-        for i in range(3):
+        for i in range(5):
             # Next team
             p: Pool = await Pool.objects.prefetch_related('current_team__participation__team').aget(round=r, letter=3)
             td = p.current_team
@@ -562,10 +560,11 @@ class TestDraw(TestCase):
             self.assertIsNotNone(td.purposed)
             self.assertIn(td.purposed, range(1, len(settings.PROBLEMS) + 1))
             # Lower problems are already accepted
-            self.assertGreaterEqual(td.purposed, i + 1)
+            self.assertGreaterEqual(td.purposed, 1 + i // 2)
 
-            # Assume that this is the problem is i for the team i
+            # Assume that this is the problem is i / 2 for the team i (there are 5 teams)
-            td.purposed = i + 1
+            # We force to have duplicates
+            td.purposed = 1 + i // 2
             await td.asave()
 
             # Render page
@@ -577,11 +576,11 @@ class TestDraw(TestCase):
             self.assertEqual(await communicator.receive_json_from(),
                              {'tid': tid, 'type': 'buttons_visibility', 'visible': False})
             self.assertEqual(await communicator.receive_json_from(),
-                             {'tid': tid, 'type': 'set_problem', 'round': 1, 'team': trigram, 'problem': i + 1})
+                             {'tid': tid, 'type': 'set_problem', 'round': 1, 'team': trigram, 'problem': 1 + i // 2})
             td: TeamDraw = await TeamDraw.objects.prefetch_related('participation__team').aget(pk=td.pk)
             self.assertIsNone(td.purposed)
-            self.assertEqual(td.accepted, i + 1)
+            self.assertEqual(td.accepted, 1 + i // 2)
-            if i == 2:
+            if i == 4:
                 break
             self.assertEqual(await communicator.receive_json_from(),
                              {'tid': tid, 'type': 'box_visibility', 'visible': True})
@@ -591,6 +590,9 @@ class TestDraw(TestCase):
             resp = await self.async_client.get(reverse('draw:index'))
             self.assertEqual(resp.status_code, 200)
 
+        # Reorder the pool since there are 5 teams
+        self.assertEqual((await communicator.receive_json_from())['type'], 'reorder_poule')
+
         # Start round 2
         draw: Draw = await Draw.objects.prefetch_related(
             'current_round__current_pool__current_team__participation__team').aget(tournament=self.tournament)
@@ -624,7 +626,7 @@ class TestDraw(TestCase):
                 .aget(draw=draw, number=2)
             p = r.current_pool
             self.assertEqual(p.letter, i + 1)
-            self.assertEqual(p.size, 5 - i)
+            self.assertEqual(p.size, i + 3)
 
             self.assertEqual(await communicator.receive_json_from(),
                              {'tid': tid, 'type': 'set_active', 'round': 2, 'poule': chr(65 + i), 'team': None})
@@ -642,7 +644,7 @@ class TestDraw(TestCase):
             resp = await communicator.receive_json_from()
             self.assertEqual(resp['type'], 'set_info')
 
-            for j in range(5 - i):
+            for j in range(3 + i):
                 # Next team
                 p: Pool = await Pool.objects.prefetch_related('current_team__participation__team').aget(round=r,
                                                                                                         letter=i + 1)
@@ -685,13 +687,13 @@ class TestDraw(TestCase):
                 self.assertEqual((await communicator.receive_json_from())['type'], 'set_problem')
                 td: TeamDraw = await TeamDraw.objects.prefetch_related('participation__team').aget(pk=td.pk)
                 self.assertIsNone(td.purposed)
-                if j == 4 - i:
+                if j == 2 + i:
                     break
                 self.assertEqual(await communicator.receive_json_from(),
                                  {'tid': tid, 'type': 'box_visibility', 'visible': True})
                 self.assertEqual((await communicator.receive_json_from())['type'], 'set_info')
 
-            if i == 0:
+            if i == 2:
                 # Reorder the pool since there are 5 teams
                 self.assertEqual((await communicator.receive_json_from())['type'], 'reorder_poule')
             if i < 2:
@@ -738,20 +740,20 @@ class TestDraw(TestCase):
         draw = Draw.objects.create(tournament=self.tournament)
         r1 = Round.objects.create(draw=draw, number=1)
         r2 = Round.objects.create(draw=draw, number=2)
-        p11 = Pool.objects.create(round=r1, letter=1, size=5)
+        p11 = Pool.objects.create(round=r1, letter=1, size=3)
         p12 = Pool.objects.create(round=r1, letter=2, size=4)
-        p13 = Pool.objects.create(round=r1, letter=3, size=3)
+        p13 = Pool.objects.create(round=r1, letter=3, size=5)
-        p21 = Pool.objects.create(round=r2, letter=1, size=5)
+        p21 = Pool.objects.create(round=r2, letter=1, size=3)
         p22 = Pool.objects.create(round=r2, letter=2, size=4)
-        p23 = Pool.objects.create(round=r2, letter=3, size=3)
+        p23 = Pool.objects.create(round=r2, letter=3, size=5)
         tds = []
         for i, team in enumerate(self.teams):
             tds.append(TeamDraw.objects.create(participation=team.participation,
                                                round=r1,
-                                               pool=p11 if i < 5 else p12 if i < 9 else p13))
+                                               pool=p11 if i < 3 else p12 if i < 7 else p13))
             tds.append(TeamDraw.objects.create(participation=team.participation,
                                                round=r2,
-                                               pool=p21) if i < 5 else p22 if i < 9 else p23)
+                                               pool=p21) if i < 3 else p22 if i < 7 else p23)
 
         p11.current_team = tds[0]
         p11.save()

draw/views.py

@@ -40,4 +40,7 @@ class DisplayView(LoginRequiredMixin, TemplateView):
         context['tournaments_simplified'] = [{'id': t.id, 'name': t.name} for t in tournaments]
         context['problems'] = settings.PROBLEMS
 
+        context['range_100'] = range(0, 100, 10)
+        context['range_10'] = range(0, 10, 1)
+
         return context

entrypoint.sh

@@ -3,7 +3,6 @@
 crond -l 0
 
 python manage.py migrate
-python manage.py loaddata initial
 python manage.py update_index
 
 nginx

participation/admin.py

@@ -7,11 +7,74 @@ from django.utils.translation import gettext_lazy as _
 from .models import Note, Participation, Passage, Pool, Solution, Synthesis, Team, Tournament, Tweak
 
 
+class ParticipationInline(admin.StackedInline):
+    model = Participation
+    extra = 0
+    autocomplete_fields = ('team', 'tournament',)
+    show_change_link = True
+
+
+class ParticipationTabularInline(admin.TabularInline):
+    model = Participation
+    extra = 0
+    fields = ('team', 'valid', 'final',)
+    readonly_fields = ('team',)
+    ordering = ('final', 'valid', 'team__trigram',)
+    autocomplete_fields = ('tournament',)
+    show_change_link = True
+
+
+class SolutionInline(admin.TabularInline):
+    model = Solution
+    extra = 0
+    ordering = ('problem',)
+    autocomplete_fields = ('participation',)
+    show_change_link = True
+
+
+class SynthesisInline(admin.TabularInline):
+    model = Synthesis
+    extra = 0
+    ordering = ('passage__solution_number', 'type',)
+    autocomplete_fields = ('passage',)
+    show_change_link = True
+
+
+class PoolInline(admin.TabularInline):
+    model = Pool
+    extra = 0
+    autocomplete_fields = ('tournament', 'participations', 'jury_president', 'juries',)
+    show_change_link = True
+
+
+class PassageInline(admin.TabularInline):
+    model = Passage
+    extra = 0
+    ordering = ('position',)
+    autocomplete_fields = ('defender', 'opponent', 'reporter',)
+    show_change_link = True
+
+
+class NoteInline(admin.TabularInline):
+    model = Note
+    extra = 0
+    autocomplete_fields = ('jury',)
+    show_change_link = True
+
+
+class TweakInline(admin.TabularInline):
+    model = Tweak
+    extra = 0
+    autocomplete_fields = ('participation', 'pool',)
+    show_change_link = True
+
+
 @admin.register(Team)
 class TeamAdmin(admin.ModelAdmin):
     list_display = ('name', 'trigram', 'tournament', 'valid', 'final',)
     search_fields = ('name', 'trigram',)
     list_filter = ('participation__valid', 'participation__tournament', 'participation__final',)
+    inlines = (ParticipationInline,)
 
     @admin.display(description=_("tournament"))
     def tournament(self, record):
@@ -30,16 +93,18 @@ class TeamAdmin(admin.ModelAdmin):
 class ParticipationAdmin(admin.ModelAdmin):
     list_display = ('team', 'tournament', 'valid', 'final',)
     search_fields = ('team__name', 'team__trigram',)
-    list_filter = ('valid',)
+    list_filter = ('valid', 'tournament',)
     autocomplete_fields = ('team', 'tournament',)
+    inlines = (SolutionInline, SynthesisInline,)
 
 
 @admin.register(Pool)
 class PoolAdmin(admin.ModelAdmin):
-    list_display = ('__str__', 'tournament', 'round', 'letter', 'teams',)
+    list_display = ('__str__', 'tournament', 'round', 'letter', 'room', 'teams', 'jury_president',)
-    list_filter = ('tournament', 'round', 'letter',)
+    list_filter = ('tournament', 'round', 'letter', 'room',)
     search_fields = ('participations__team__name', 'participations__team__trigram',)
-    autocomplete_fields = ('tournament', 'participations', 'juries',)
+    autocomplete_fields = ('tournament', 'participations', 'jury_president', 'juries',)
+    inlines = (PassageInline, TweakInline,)
 
     @admin.display(description=_("teams"))
     def teams(self, record: Pool):
@@ -49,28 +114,30 @@ class PoolAdmin(admin.ModelAdmin):
 @admin.register(Passage)
 class PassageAdmin(admin.ModelAdmin):
     list_display = ('__str__', 'defender_trigram', 'solution_number', 'opponent_trigram', 'reporter_trigram',
-                    'pool_abbr', 'tournament')
+                    'pool_abbr', 'position', 'tournament')
     list_filter = ('pool__tournament', 'pool__round', 'pool__letter', 'solution_number',)
     search_fields = ('pool__participations__team__name', 'pool__participations__team__trigram',)
-    autocomplete_fields = ('pool', 'defender', 'opponent', 'reporter', 'observer',)
+    ordering = ('pool__tournament', 'pool__round', 'pool__letter', 'position',)
+    autocomplete_fields = ('pool', 'defender', 'opponent', 'reporter',)
+    inlines = (NoteInline,)
 
-    @admin.display(description=_("defender"))
+    @admin.display(description=_("defender"), ordering='defender__team__trigram')
     def defender_trigram(self, record: Passage):
         return record.defender.team.trigram
 
-    @admin.display(description=_("opponent"))
+    @admin.display(description=_("opponent"), ordering='opponent__team__trigram')
     def opponent_trigram(self, record: Passage):
         return record.opponent.team.trigram
 
-    @admin.display(description=_("reporter"))
+    @admin.display(description=_("reporter"), ordering='reporter__team__trigram')
     def reporter_trigram(self, record: Passage):
         return record.reporter.team.trigram
 
-    @admin.display(description=_("pool"))
+    @admin.display(description=_("pool"), ordering='pool__letter')
     def pool_abbr(self, record):
-        return f"{record.pool.get_letter_display()}{record.pool.round}"
+        return f"{record.pool.short_name}"
 
-    @admin.display(description=_("tournament"))
+    @admin.display(description=_("tournament"), ordering='pool__tournament__name')
     def tournament(self, record: Passage):
         return record.pool.tournament
 
@@ -87,7 +154,7 @@ class NoteAdmin(admin.ModelAdmin):
 
     @admin.display(description=_("pool"))
     def pool(self, record):
-        return record.passage.pool.get_letter_display()
+        return record.passage.pool.short_name
 
 
 @admin.register(Solution)
@@ -124,12 +191,16 @@ class SynthesisAdmin(admin.ModelAdmin):
 
 @admin.register(Tournament)
 class TournamentAdmin(admin.ModelAdmin):
-    list_display = ('name',)
+    list_display = ('name', 'date_start', 'date_end',)
     search_fields = ('name',)
+    ordering = ('date_start', 'name',)
     autocomplete_fields = ('organizers',)
+    inlines = (ParticipationTabularInline, PoolInline,)
 
 
 @admin.register(Tweak)
 class TweakAdmin(admin.ModelAdmin):
     list_display = ('participation', 'pool', 'diff',)
+    list_filter = ('pool__tournament', 'pool__round',)
+    search_fields = ('participation__team__name', 'participation__team__trigram',)
     autocomplete_fields = ('participation', 'pool',)

participation/api/serializers.py

@@ -61,3 +61,9 @@ class TournamentSerializer(serializers.ModelSerializer):
                   'inscription_limit', 'solution_limit', 'solutions_draw', 'syntheses_first_phase_limit',
                   'solutions_available_second_phase', 'syntheses_second_phase_limit',
                   'description', 'organizers', 'final', 'participations',)
+
+
+class TweakSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Team
+        fields = '__all__'

participation/api/urls.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from .views import NoteViewSet, ParticipationViewSet, PassageViewSet, PoolViewSet, \
-    SolutionViewSet, SynthesisViewSet, TeamViewSet, TournamentViewSet
+    SolutionViewSet, SynthesisViewSet, TeamViewSet, TournamentViewSet, TweakViewSet
 
 
 def register_participation_urls(router, path):
@@ -17,3 +17,4 @@ def register_participation_urls(router, path):
     router.register(path + "/synthesis", SynthesisViewSet)
     router.register(path + "/team", TeamViewSet)
     router.register(path + "/tournament", TournamentViewSet)
+    router.register(path + "/tweak", TweakViewSet)

participation/api/views.py

@@ -4,8 +4,8 @@ from django_filters.rest_framework import DjangoFilterBackend
 from rest_framework.viewsets import ModelViewSet
 
 from .serializers import NoteSerializer, ParticipationSerializer, PassageSerializer, PoolSerializer, \
-    SolutionSerializer, SynthesisSerializer, TeamSerializer, TournamentSerializer
+    SolutionSerializer, SynthesisSerializer, TeamSerializer, TournamentSerializer, TweakSerializer
-from ..models import Note, Participation, Passage, Pool, Solution, Synthesis, Team, Tournament
+from ..models import Note, Participation, Passage, Pool, Solution, Synthesis, Team, Tournament, Tweak
 
 
 class NoteViewSet(ModelViewSet):
@@ -67,3 +67,11 @@ class TournamentViewSet(ModelViewSet):
                         'inscription_limit', 'solution_limit', 'solutions_draw', 'syntheses_first_phase_limit',
                         'solutions_available_second_phase', 'syntheses_second_phase_limit',
                         'description', 'organizers', 'final', ]
+
+
+class TweakViewSet(ModelViewSet):
+    queryset = Tweak.objects.all()
+    serializer_class = TweakSerializer
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['pool', 'pool__tournament', 'pool__tournament__name', 'participation',
+                        'participation__team__trigram', 'diff', ]

participation/apps.py

@@ -12,8 +12,9 @@ class ParticipationConfig(AppConfig):
     name = 'participation'
 
     def ready(self):
-        from participation.signals import create_notes, create_team_participation, update_mailing_list
+        from participation import signals
-        pre_save.connect(update_mailing_list, "participation.Team")
+        pre_save.connect(signals.update_mailing_list, "participation.Team")
-        post_save.connect(create_team_participation, "participation.Team")
+        post_save.connect(signals.create_team_participation, "participation.Team")
-        post_save.connect(create_notes, "participation.Passage")
+        post_save.connect(signals.create_payments, "participation.Participation")
-        post_save.connect(create_notes, "participation.Pool")
+        post_save.connect(signals.create_notes, "participation.Passage")
+        post_save.connect(signals.create_notes, "participation.Pool")

participation/forms.py

@@ -1,22 +1,19 @@
 # Copyright (C) 2020 by Animath
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import csv
 from io import StringIO
 import re
-from typing import Iterable
 
-from crispy_forms.bootstrap import InlineField
 from crispy_forms.helper import FormHelper
-from crispy_forms.layout import Div, Fieldset, Submit
+from crispy_forms.layout import Div, Field, Submit
 from django import forms
 from django.contrib.auth.models import User
 from django.core.exceptions import ValidationError
 from django.core.validators import FileExtensionValidator
-from django.db.models import CharField, Value
-from django.db.models.functions import Concat
 from django.utils.translation import gettext_lazy as _
+import pandas
 from pypdf import PdfReader
+from registration.models import VolunteerRegistration
 
 from .models import Note, Participation, Passage, Pool, Solution, Synthesis, Team, Tournament
 
@@ -55,6 +52,10 @@ class JoinTeamForm(forms.ModelForm):
         access_code = self.cleaned_data["access_code"]
         if not Team.objects.filter(access_code=access_code).exists():
             raise ValidationError(_("No team was found with this access code."))
+        else:
+            team = Team.objects.get(access_code=access_code)
+            if team.participation.valid is not None:
+                raise ValidationError(_("The team is already validated or the validation is pending."))
         return access_code
 
     def clean(self):
@@ -79,7 +80,7 @@ class ParticipationForm(forms.ModelForm):
 
 
 class MotivationLetterForm(forms.ModelForm):
-    def clean_file(self):
+    def clean_motivation_letter(self):
         if "motivation_letter" in self.files:
             file = self.files["motivation_letter"]
             if file.size > 2e6:
@@ -126,7 +127,7 @@ class ValidateParticipationForm(forms.Form):
 class TournamentForm(forms.ModelForm):
     class Meta:
         model = Tournament
-        fields = '__all__'
+        exclude = ('notes_sheet_id', )
         widgets = {
             'date_start': forms.DateInput(attrs={'type': 'date'}, format='%Y-%m-%d'),
             'date_end': forms.DateInput(attrs={'type': 'date'}, format='%Y-%m-%d'),
@@ -175,8 +176,13 @@ class SolutionForm(forms.ModelForm):
 class PoolForm(forms.ModelForm):
     class Meta:
         model = Pool
-        fields = ('tournament', 'round', 'letter', 'bbb_url', 'results_available', 'juries',)
+        fields = ('tournament', 'round', 'letter', 'bbb_url', 'results_available', 'jury_president', 'juries',)
         widgets = {
+            "jury_president": forms.Select(attrs={
+                'class': 'selectpicker',
+                'data-live-search': 'true',
+                'data-live-search-normalize': 'true',
+            }),
             "juries": forms.SelectMultiple(attrs={
                 'class': 'selectpicker',
                 'data-live-search': 'true',
@@ -185,47 +191,31 @@ class PoolForm(forms.ModelForm):
         }
 
 
-class PoolTeamsForm(forms.ModelForm):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.fields["participations"].queryset = self.instance.tournament.participations.all()
-
-    class Meta:
-        model = Pool
-        fields = ('participations',)
-        widgets = {
-            "participations": forms.SelectMultiple(attrs={
-                'class': 'selectpicker',
-                'data-live-search': 'true',
-                'data-live-search-normalize': 'true',
-                'data-width': 'fit',
-            }),
-        }
-
-
 class AddJuryForm(forms.ModelForm):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.fields['first_name'].required = True
+        self.fields['last_name'].required = True
+        self.fields['email'].required = True
         self.helper = FormHelper()
         self.helper.form_class = 'form-inline'
-        self.helper.layout = Fieldset(
+        self.helper.layout = Div(
-            _("Add new jury"),
             Div(
                 Div(
-                    InlineField('first_name', autofocus="autofocus"),
+                    Field('email', autofocus="autofocus", list="juries-email"),
-                    css_class='col-xl-3',
+                    css_class='col-md-5 px-1',
                 ),
                 Div(
-                    InlineField('last_name'),
+                    Field('first_name', list="juries-first-name"),
-                    css_class='col-xl-3',
+                    css_class='col-md-3 px-1',
                 ),
                 Div(
-                    InlineField('email'),
+                    Field('last_name', list="juries-last-name"),
-                    css_class='col-xl-5',
+                    css_class='col-md-3 px-1',
                 ),
                 Div(
                     Submit('submit', _("Add")),
-                    css_class='col-xl-1',
+                    css_class='col-md-1 py-md-4 px-1',
                 ),
                 css_class='row',
             )
@@ -237,7 +227,10 @@ class AddJuryForm(forms.ModelForm):
         """
         email = self.data["email"]
         if User.objects.filter(email=email).exists():
-            self.add_error("email", _("This email address is already used."))
+            self.instance = User.objects.get(email=email)
+            if self.instance.registration.participates:
+                self.add_error(None, _("This user already exists, but is a participant."))
+                return
         return email
 
     class Meta:
@@ -247,79 +240,82 @@ class AddJuryForm(forms.ModelForm):
 
 class UploadNotesForm(forms.Form):
     file = forms.FileField(
-        label=_("CSV file:"),
+        label=_("Spreadsheet file:"),
-        validators=[FileExtensionValidator(allowed_extensions=["csv"])],
+        validators=[FileExtensionValidator(allowed_extensions=["csv", "ods"])],
     )
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.fields['file'].widget.attrs['accept'] = 'text/csv'
+        self.fields['file'].widget.attrs['accept'] = 'text/csv,application/vnd.oasis.opendocument.spreadsheet'
 
     def clean(self):
         cleaned_data = super().clean()
 
         if 'file' in cleaned_data:
             file = cleaned_data['file']
-            with file:
+            if file.name.endswith('.csv'):
-                try:
+                with file:
-                    data: bytes = file.read()
                     try:
-                        content = data.decode()
+                        data: bytes = file.read()
+                        try:
+                            content = data.decode()
+                        except UnicodeDecodeError:
+                            # This is not UTF-8, grrrr
+                            content = data.decode('latin1')
+
+                        table = pandas.read_csv(StringIO(content), sep=None, header=None)
+                        self.process(table, cleaned_data)
                     except UnicodeDecodeError:
-                        # This is not UTF-8, grrrr
+                        self.add_error('file', _("This file contains non-UTF-8 and non-ISO-8859-1 content. "
-                        content = data.decode('latin1')
+                                                 "Please send your sheet as a CSV file."))
-                    csvfile = csv.reader(StringIO(content))
+            elif file.name.endswith('.ods'):
-                    self.process(csvfile, cleaned_data)
+                table = pandas.read_excel(file, header=None, engine='odf')
-                except UnicodeDecodeError:
+                self.process(table, cleaned_data)
-                    self.add_error('file', _("This file contains non-UTF-8 and non-ISO-8859-1 content. "
-                                             "Please send your sheet as a CSV file."))
 
         return cleaned_data
 
-    def process(self, csvfile: Iterable[str], cleaned_data: dict):
+    def process(self, df: pandas.DataFrame, cleaned_data: dict):
         parsed_notes = {}
-        valid_lengths = [1 + 6 * 3, 1 + 7 * 4, 1 + 6 * 5]  # Per pool sizes
         pool_size = 0
         line_length = 0
-        for line in csvfile:
+        for line in df.values.tolist():
-            line = [s.strip() for s in line if s]
+            # Remove NaN
+            line = [s for s in line if s == s]
+            # Strip cases
+            line = [str(s).strip() for s in line if str(s)]
             if line and line[0] == 'Problème':
                 pool_size = len(line) - 1
-                if pool_size < 3 or pool_size > 5:
+                line_length = 2 + 6 * pool_size
-                    self.add_error('file', _("Can't determine the pool size. Are you sure your file is correct?"))
-                    return
-                line_length = valid_lengths[pool_size - 3]
                 continue
 
             if pool_size == 0 or len(line) < line_length:
                 continue
 
             name = line[0]
-            if name.lower() in ["rôle", "juré", "moyenne", "coefficient", "sous-total", "équipe", "equipe"]:
+            if name.lower() in ["rôle", "juré⋅e", "juré?e", "moyenne", "coefficient", "sous-total", "équipe", "equipe"]:
                 continue
-            notes = line[1:line_length]
+            notes = line[2:line_length]
+            print(name, notes)
             if not all(s.isnumeric() or s[0] == '-' and s[1:].isnumeric() for s in notes):
                 continue
-            notes = list(map(int, notes))
+            notes = list(map(lambda x: int(float(x)), notes))
+            print(notes)
 
-            max_notes = pool_size * ([20, 16, 9, 10, 9, 10] + ([4] if pool_size == 4 else []))
+            max_notes = pool_size * [20, 20, 10, 10, 10, 10]
             for n, max_n in zip(notes, max_notes):
                 if n > max_n:
                     self.add_error('file',
                                    _("The following note is higher of the maximum expected value:")
                                    + str(n) + " > " + str(max_n))
 
-            # Search by "{first_name} {last_name}"
+            # Search by volunteer id
-            jury = User.objects.annotate(full_name=Concat('first_name', Value(' '), 'last_name',
+            jury = VolunteerRegistration.objects.filter(pk=int(float(line[1])))
-                                                          output_field=CharField())) \
-                .filter(full_name=name.replace('’', '\''), registration__volunteerregistration__isnull=False)
             if jury.count() != 1:
-                self.add_error('file', _("The following user was not found:") + " " + name)
+                raise ValidationError({'file': _("The following user was not found:") + " " + name})
-                continue
             jury = jury.get()
+            parsed_notes[jury] = notes
 
-            vr = jury.registration
+        print(parsed_notes)
-            parsed_notes[vr] = notes
 
         cleaned_data['parsed_notes'] = parsed_notes
 
@@ -340,7 +336,7 @@ class PassageForm(forms.ModelForm):
 
     class Meta:
         model = Passage
-        fields = ('position', 'solution_number', 'defender', 'opponent', 'reporter', 'observer', 'defender_penalties',)
+        fields = ('position', 'solution_number', 'defender', 'opponent', 'reporter', 'defender_penalties',)
 
 
 class SynthesisForm(forms.ModelForm):
@@ -371,4 +367,4 @@ class NoteForm(forms.ModelForm):
     class Meta:
         model = Note
         fields = ('defender_writing', 'defender_oral', 'opponent_writing',
-                  'opponent_oral', 'reporter_writing', 'reporter_oral', 'observer_oral', )
+                  'opponent_oral', 'reporter_writing', 'reporter_oral', )

participation/management/commands/check_hello_asso.py

@@ -1,87 +0,0 @@
-# Copyright (C) 2020 by Animath
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import os
-
-from django.contrib.auth.models import User
-from django.core.management import BaseCommand
-from django.db.models import Q
-import requests
-
-
-class Command(BaseCommand):
-    def handle(self, *args, **options):  # noqa: C901
-        # Get access token
-        response = requests.post('https://api.helloasso.com/oauth2/token', headers={
-            'Content-Type': 'application/x-www-form-urlencoded',
-        }, data={
-            'client_id': os.getenv('HELLOASSO_CLIENT_ID', ''),
-            'client_secret': os.getenv('HELLOASSO_CLIENT_SECRET', ''),
-            'grant_type': 'client_credentials',
-        }).json()
-
-        token = response['access_token']
-
-        organization = "animath"
-        form_slug = "tfjm-2023-tournois-regionaux"
-        from_date = "2000-01-01"
-        url = f"https://api.helloasso.com/v5/organizations/{organization}/forms/Event/{form_slug}/payments" \
-              f"?from={from_date}&pageIndex=1&pageSize=100&retrieveOfflineDonations=false"
-        headers = {
-            "Accept": "application/json",
-            "Authorization": f"Bearer {token}",
-        }
-        http_response = requests.get(url, headers=headers)
-        response = http_response.json()
-
-        if http_response.status_code != 200:
-            message = response["message"]
-            self.stderr.write(f"Error while querying Hello Asso: {message}")
-            return
-
-        for payment in response["data"]:
-            if payment["state"] != "Authorized":
-                continue
-
-            payer = payment["payer"]
-            email = payer["email"]
-            last_name = payer["lastName"]
-            first_name = payer["firstName"]
-            base_filter = Q(
-                registration__participantregistration__isnull=False,
-                registration__participantregistration__team__isnull=False,
-                registration__participantregistration__team__participation__valid=True,
-            )
-            qs = User.objects.filter(
-                    base_filter,
-                    email=email,
-            )
-            if not qs.exists():
-                qs = User.objects.filter(
-                        base_filter,
-                        last_name__icontains=last_name,
-                )
-                if qs.count() >= 2:
-                    qs = qs.filter(first_name__icontains=first_name)
-            if not qs.exists():
-                self.stderr.write(f"Warning: a payment was found by {first_name} {last_name} ({email}), "
-                                  "but this user is unknown.")
-                continue
-            if qs.count() > 1:
-                self.stderr.write(f"Warning: a payment was found by {first_name} {last_name} ({email}), "
-                                  f"but there are {qs.count()} matching users.")
-                continue
-            user = qs.get()
-            if not user.registration.participates:
-                self.stderr.write(f"Warning: a payment was found by the email address {email}, "
-                                  "but this user is not a participant.")
-                continue
-            payment_obj = user.registration.payment
-            payment_obj.valid = True
-            payment_obj.type = "helloasso"
-            payment_obj.additional_information = f"Identifiant de transation : {payment['id']}\n" \
-                                                 f"Date : {payment['date']}\n" \
-                                                 f"Reçu : {payment['paymentReceiptUrl']}\n" \
-                                                 f"Montant : {payment['amount'] / 100:.2f} €"
-            payment_obj.save()
-            self.stdout.write(f"{payment_obj} is validated")

participation/management/commands/export_results.py

@@ -17,8 +17,8 @@ class Command(BaseCommand):
             self.w("")
             self.w("")
 
-    def w(self, msg):
+    def w(self, msg, prefix="", suffix=""):
-        self.stdout.write(msg)
+        self.stdout.write(f"{prefix}{msg}{suffix}")
 
     def handle_tournament(self, tournament):
         name = tournament.name
@@ -40,7 +40,7 @@ class Command(BaseCommand):
         if tournament.final:
             self.w(f"<p>La finale a eu lieu le weekend du {date_start} au {date_end} et a été remporté par l'équipe "
                    f"<em>{notes[0][0].team.name}</em> suivie de l'équipe <em>{notes[1][0].team.name}</em>. "
-                   f"Les deux premières équipes sont sélectionnées pour représenter la France lors de l'ITYM.</p>")
+                   f"Les deux premières équipes sont sélectionnées pour représenter la France lors de l'ETEAM.</p>")
         else:
             self.w(f"<p>Le tournoi de {name} a eu lieu le weekend du {date_start} au {date_end} et a été remporté par "
                    f"l'équipe <em>{notes[0][0].team.name}</em>.</p>")
@@ -52,32 +52,29 @@ class Command(BaseCommand):
         self.w("<table>")
         self.w("<thead>")
         self.w("<tr>")
-        self.w("\t<th>Équipe</th>")
+        self.w("    <th>Équipe</th>")
-        self.w("\t<th>Score Tour 1</th>")
+        self.w("    <th>Score Tour 1</th>")
-        self.w("\t<th>Score Tour 2</th>")
+        self.w("    <th>Score Tour 2</th>")
-        self.w("\t<th>Total</th>")
+        self.w("    <th>Total</th>")
-        self.w("\t<th class=\"has-text-align-center\">Prix</th>")
+        self.w("    <th class=\"has-text-align-center\">Prix</th>")
         self.w("</tr>")
         self.w("</thead>")
         self.w("<tbody>")
         for i, (participation, note) in enumerate(notes):
             self.w("<tr>")
-            if i < (2 if len(notes) >= 7 else 1):
+            bold = (not tournament.final and participation.final) or (tournament.final and i < 2)
-                self.w(f"\t<th>{participation.team.name} ({participation.team.trigram})</td>")
+            if bold:
+                prefix, suffix = "    <td><strong>", "</strong></td>"
             else:
-                self.w(f"\t<td>{participation.team.name} ({participation.team.trigram})</td>")
+                prefix, suffix = "    <td>", "</td>"
-            for pool in tournament.pools.filter(participations=participation).all():
+            self.w(f"{participation.team.name} ({participation.team.trigram})", prefix, suffix)
-                pool_note = pool.average(participation)
+            for tournament_round in [1, 2]:
-                self.w(f"\t<td>{pool_note:.01f}</td>")
+                pool_note = sum(pool.average(participation)
-            self.w(f"\t<td>{note:.01f}</td>")
+                                for pool in tournament.pools.filter(participations=participation,
-            if i == 0:
+                                                                    round=tournament_round).all())
-                self.w("\t<td class=\"has-text-align-center\">1<sup>er</sup> prix</td>")
+                self.w(f"{pool_note:.01f}", prefix, suffix)
-            elif i < (5 if tournament.final else 3):
+            self.w(f"{note:.01f}", prefix, suffix)
-                self.w(f"\t<td class=\"has-text-align-center\">{i + 1}<sup>ème</sup> prix</td>")
+            self.w(participation.mention_final if tournament.final else participation.mention, prefix, suffix)
-            elif i < 2 * len(notes) / 3:
-                self.w("\t<td class=\"has-text-align-center\">Mention très honorable</td>")
-            else:
-                self.w("\t<td class=\"has-text-align-center\">Mention honorable</td>")
             self.w("</tr>")
         self.w("</tbody>")
         self.w("</table>")

participation/management/commands/fix_sympa_lists.py

@@ -22,11 +22,11 @@ class Command(BaseCommand):
                           "Liste de diffusion pour contacter toutes les equipes non validees du TFJM2.",
                           "education", raise_error=False)
 
-        sympa.create_list("admins", "Administrateurs du TFJM2", "hotline",
+        sympa.create_list("admins", "Administrateur⋅rices du TFJM2", "hotline",
-                          "Liste de diffusion pour contacter tous les administrateurs du TFJM2.",
+                          "Liste de diffusion pour contacter toustes les administrateur.rices du TFJM2.",
                           "education", raise_error=False)
         sympa.create_list("organisateurs", "Organisateurs du TFJM2", "hotline",
-                          "Liste de diffusion pour contacter tous les organisateurs du TFJM2.",
+                          "Liste de diffusion pour contacter toustes les organisateur.rices du TFJM2.",
                           "education", raise_error=False)
         sympa.create_list("jurys", "Jurys du TFJM2", "hotline",
                           "Liste de diffusion pour contacter tous les jurys du TFJM2.",

participation/management/commands/generate_seconds_sheet.py

@@ -0,0 +1,149 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.conf import settings
+from django.core.management import BaseCommand
+from django.utils.translation import activate
+import gspread
+from gspread.utils import a1_range_to_grid_range, MergeType
+
+from ...models import Passage, Tournament
+
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        activate('fr')
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        try:
+            spreadsheet = gc.open("Tableau des deuxièmes", folder_id=settings.NOTES_DRIVE_FOLDER_ID)
+        except gspread.SpreadsheetNotFound:
+            spreadsheet = gc.create("Tableau des deuxièmes", folder_id=settings.NOTES_DRIVE_FOLDER_ID)
+            spreadsheet.update_locale("fr_FR")
+            spreadsheet.share(None, "anyone", "writer", with_link=True)
+
+        sheet = spreadsheet.sheet1
+
+        header1 = ["Tournoi", "Équipe 2", "Tour 1", "", "", "", "", "", "", "", "Tour 2", "", "", "", "", "", "", "",
+                   "Score total", "Score équipe 1", "Score équipe 3"]
+        header2 = ["", ""] + 2 * ["PJ", "Problème", "Défenseur⋅se", "", "Opposant⋅e", "", "Rapporteur⋅rice", ""]
+        header2 += ["", "", ""]
+        header3 = ["", ""] + 2 * (["", ""] + 3 * ["Écrit", "Oral"]) + ["", "", ""]
+        lines = [header1, header2, header3]
+        nb_tournaments = Tournament.objects.filter(final=False).count()
+        for tournament in Tournament.objects.filter(final=False).all():
+            line = [tournament.name]
+            lines.append(line)
+
+            notes = dict()
+            for participation in tournament.participations.filter(valid=True).all():
+                note = sum(pool.average(participation)
+                           for pool in tournament.pools.filter(participations=participation).all())
+                if note:
+                    notes[participation] = note
+
+            if not notes:
+                continue
+
+            sorted_notes = sorted(notes.items(), key=lambda x: x[1], reverse=True)
+
+            team1, score1 = sorted_notes[0]
+            team2, score2 = sorted_notes[1]
+            team3, score3 = sorted_notes[2]
+
+            pool1 = tournament.pools.filter(round=1, participations=team2).first()
+            defender_passage_1 = Passage.objects.get(pool__tournament=tournament, pool__round=1, defender=team2)
+            opponent_passage_1 = Passage.objects.get(pool__tournament=tournament, pool__round=1, opponent=team2)
+            reporter_passage_1 = Passage.objects.get(pool__tournament=tournament, pool__round=1, reporter=team2)
+            pool2 = tournament.pools.filter(round=2, participations=team2).first()
+            defender_passage_2 = Passage.objects.get(pool__tournament=tournament, pool__round=2, defender=team2)
+            opponent_passage_2 = Passage.objects.get(pool__tournament=tournament, pool__round=2, opponent=team2)
+            reporter_passage_2 = Passage.objects.get(pool__tournament=tournament, pool__round=2, reporter=team2)
+
+            line.append(team2.team.trigram)
+            line.append(str(pool1.jury_president or ""))
+            line.append(f"Pb. {defender_passage_1.solution_number}")
+            line.extend([defender_passage_1.average_defender_writing, defender_passage_1.average_defender_oral,
+                         opponent_passage_1.average_opponent_writing, opponent_passage_1.average_opponent_oral,
+                         reporter_passage_1.average_reporter_writing, reporter_passage_1.average_reporter_oral])
+            line.append(str(pool2.jury_president or ""))
+            line.append(f"Pb. {defender_passage_2.solution_number}")
+            line.extend([defender_passage_2.average_defender_writing, defender_passage_2.average_defender_oral,
+                         opponent_passage_2.average_opponent_writing, opponent_passage_2.average_opponent_oral,
+                         reporter_passage_2.average_reporter_writing, reporter_passage_2.average_reporter_oral])
+            line.extend([score2, f"{score1:.1f} ({team1.team.trigram})",
+                         f"{score3:.1f} ({team3.team.trigram})"])
+
+        sheet.update(lines)
+
+        format_requests = []
+        merge_cells = ["A1:A3", "B1:B3", "C1:J1", "K1:R1", "E2:F2", "G2:H2", "I2:J2", "M2:N2", "O2:P2", "Q2:R2",
+                       "C2:C3", "D2:D3", "K2:K3", "L2:L3", "S1:S3", "T1:T3", "U1:U3"]
+        format_requests.append({"unmergeCells": {"range": a1_range_to_grid_range("A1:AF", sheet.id)}})
+        for name in merge_cells:
+            grid_range = a1_range_to_grid_range(name, sheet.id)
+            format_requests.append({"mergeCells": {"mergeType": MergeType.merge_all, "range": grid_range}})
+
+        bold_ranges = [("A1:AF", False), ("A1:U3", True), (f"A4:A{3 + nb_tournaments}", True)]
+        for bold_range, bold in bold_ranges:
+            format_requests.append({
+                "repeatCell": {
+                    "range": a1_range_to_grid_range(bold_range, sheet.id),
+                    "cell": {"userEnteredFormat": {"textFormat": {"bold": bold}}},
+                    "fields": "userEnteredFormat(textFormat)",
+                }
+            })
+
+        border_ranges = [("A1:AF", "0000"),
+                         (f"A1:U{3 + nb_tournaments}", "1111")]
+        sides_names = ['top', 'bottom', 'left', 'right']
+        styles = ["NONE", "SOLID", "SOLID_MEDIUM", "SOLID_THICK", "DOUBLE"]
+        for border_range, sides in border_ranges:
+            borders = {}
+            for side_name, side in zip(sides_names, sides):
+                borders[side_name] = {"style": styles[int(side)]}
+            format_requests.append({
+                "repeatCell": {
+                    "range": a1_range_to_grid_range(border_range, sheet.id),
+                    "cell": {
+                        "userEnteredFormat": {
+                            "borders": borders,
+                            "horizontalAlignment": "CENTER",
+                        },
+                    },
+                    "fields": "userEnteredFormat(borders,horizontalAlignment)",
+                }
+            })
+
+        column_widths = [("A", 120), ("B", 80), ("C", 180), ("D", 80)] + [(chr(ord("E") + i), 60) for i in range(6)]
+        column_widths += [("K", 180), ("L", 80)] + [(chr(ord("M") + i), 60) for i in range(6)]
+        column_widths += [("S", 100), ("T", 120), ("U", 120)]
+        for column, width in column_widths:
+            grid_range = a1_range_to_grid_range(column, sheet.id)
+            format_requests.append({
+                "updateDimensionProperties": {
+                    "range": {
+                        "sheetId": sheet.id,
+                        "dimension": "COLUMNS",
+                        "startIndex": grid_range['startColumnIndex'],
+                        "endIndex": grid_range['endColumnIndex'],
+                    },
+                    "properties": {
+                        "pixelSize": width,
+                    },
+                    "fields": "pixelSize",
+                }
+            })
+
+        # Set number format, display only one decimal
+        number_format_ranges = [f"E4:J{3 + nb_tournaments}", f"M4:S{3 + nb_tournaments}"]
+        for number_format_range in number_format_ranges:
+            format_requests.append({
+                "repeatCell": {
+                    "range": a1_range_to_grid_range(number_format_range, sheet.id),
+                    "cell": {"userEnteredFormat": {"numberFormat": {"type": "NUMBER", "pattern": "0.0"}}},
+                    "fields": "userEnteredFormat.numberFormat",
+                }
+            })
+
+        body = {"requests": format_requests}
+        sheet.client.batch_update(spreadsheet.id, body)

participation/management/commands/parse_notation_sheets.py

@@ -0,0 +1,56 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+from time import sleep
+
+from django.core.management import BaseCommand
+from participation.models import Tournament
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--tournament', '-t', help="Tournament name to update (if not set, all tournaments will be updated)",
+        )
+        parser.add_argument(
+            '--round', '-r', type=int, help="Round number to update (if not set, all rounds will be updated)",
+        )
+        parser.add_argument(
+            '--letter', '-l', help="Letter of the pool to update (if not set, all pools will be updated)",
+        )
+
+    def handle(self, *args, **options):
+        tournaments = Tournament.objects.all() if not options['tournament'] \
+            else Tournament.objects.filter(name=options['tournament']).all()
+
+        for tournament in tournaments:
+            if options['verbosity'] >= 1:
+                self.stdout.write(f"Parsing notation sheet for {tournament}")
+
+            if not tournament.notes_sheet_id:
+                if options['verbosity'] >= 1:
+                    self.stdout.write(
+                        self.style.WARNING(f"No spreadsheet found for {tournament}. Please create it first"))
+                continue
+
+            pools = tournament.pools.all()
+            if options['round']:
+                pools = pools.filter(round=options['round'])
+            if options['letter']:
+                pools = pools.filter(letter=ord(options['letter']) - 64)
+            for pool in pools.all():
+                if options['verbosity'] >= 1:
+                    self.stdout.write(f"Parsing notation sheet for pool {pool.short_name} for {tournament}")
+                try:
+                    pool.parse_spreadsheet()
+                except Exception as e:
+                    if options['verbosity'] >= 1:
+                        self.stderr.write(
+                            self.style.ERROR(f"Error while parsing pool {pool.short_name} for {tournament.name}: {e}"))
+                finally:
+                    sleep(3)  # Three calls = 3s sleep
+
+            try:
+                tournament.parse_tweaks_spreadsheets()
+            except Exception as e:
+                if options['verbosity'] >= 1:
+                    self.stderr.write(self.style.ERROR(f"Error while parsing tweaks for {tournament.name}: {e}"))

participation/management/commands/renew_gdrive_notifications.py

@@ -0,0 +1,61 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from hashlib import sha1
+
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.core.management import BaseCommand
+from django.urls import reverse
+from django.utils import timezone
+from django.utils.timezone import localtime
+import gspread
+
+from ...models import Tournament
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--tournament', '-t', help="Tournament name to update (if not set, all tournaments will be updated)",
+        )
+
+    def handle(self, *args, **options):
+        tournaments = Tournament.objects.all() if not options['tournament'] \
+            else Tournament.objects.filter(name=options['tournament']).all()
+
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        http_client = gc.http_client
+        http_client.login()
+
+        site = Site.objects.get(pk=settings.SITE_ID)
+
+        now = localtime(timezone.now())
+        tomorrow = now + timezone.timedelta(days=1)
+        tomorrow -= timezone.timedelta(hours=now.hour, minutes=now.minute, seconds=now.second,
+                                       microseconds=now.microsecond)
+
+        for tournament in tournaments:
+            if options['verbosity'] >= 1:
+                self.stdout.write(f"Renewing Google Drive notifications for {tournament}")
+
+            if not tournament.notes_sheet_id:
+                if options['verbosity'] >= 1:
+                    self.stdout.write(
+                        self.style.WARNING(f"No spreadsheet found for {tournament}. Please create it first"))
+                continue
+
+            channel_id = sha1(f"{tournament.name}-{now.date()}-{site.domain}".encode()).hexdigest()
+            url = f"https://www.googleapis.com/drive/v3/files/{tournament.notes_sheet_id}/watch?supportsAllDrives=true"
+            notif_path = reverse('participation:tournament_gsheet_notifications', args=[tournament.pk])
+            notif_url = f"https://{site.domain}{notif_path}"
+            body = {
+                "id": channel_id,
+                "type": "web_hook",
+                "address": notif_url,
+                "expiration": str(int(1000 * tomorrow.timestamp())),
+            }
+            try:
+                http_client.request(method="POST", endpoint=url, json=body).raise_for_status()
+            except Exception as e:
+                self.stderr.write(self.style.ERROR(f"Error while renewing notifications for {tournament.name}: {e}"))

participation/management/commands/update_notation_sheets.py

@@ -0,0 +1,39 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.core.management import BaseCommand
+from participation.models import Tournament
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--tournament', '-t', help="Tournament name to update (if not set, all tournaments will be updated)",
+        )
+        parser.add_argument(
+            '--round', '-r', type=int, help="Round number to update (if not set, all rounds will be updated)",
+        )
+        parser.add_argument(
+            '--letter', '-l', help="Letter of the pool to update (if not set, all pools will be updated)",
+        )
+
+    def handle(self, *args, **options):
+        tournaments = Tournament.objects.all() if not options['tournament'] \
+            else Tournament.objects.filter(name=options['tournament']).all()
+
+        for tournament in tournaments:
+            if options['verbosity'] >= 1:
+                self.stdout.write(f"Updating notation sheet for {tournament}")
+            tournament.create_spreadsheet()
+
+            pools = tournament.pools.all()
+            if options['round']:
+                pools = pools.filter(round=options['round'])
+            if options['letter']:
+                pools = pools.filter(letter=ord(options['letter']) - 64)
+            for pool in pools.all():
+                if options['verbosity'] >= 1:
+                    self.stdout.write(f"Updating notation sheet for pool {pool.short_name} for {tournament}")
+                pool.update_spreadsheet()
+
+            tournament.update_ranking_spreadsheet()

participation/migrations/0009_pool_jury_president.py

@@ -0,0 +1,27 @@
+# Generated by Django 5.0.2 on 2024-03-24 14:31
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("participation", "0008_alter_participation_options"),
+        ("registration", "0012_payment_token_alter_payment_type"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="pool",
+            name="jury_president",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="pools_presided",
+                to="registration.volunteerregistration",
+                verbose_name="president of the jury",
+            ),
+        ),
+    ]

participation/migrations/0010_tournament_notes_sheet_id_alter_note_defender_oral_and_more.py

@@ -0,0 +1,93 @@
+# Generated by Django 5.0.3 on 2024-03-29 22:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("participation", "0009_pool_jury_president"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="tournament",
+            name="notes_sheet_id",
+            field=models.CharField(
+                blank=True, default="", max_length=64, verbose_name="Google Sheet ID"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="note",
+            name="defender_oral",
+            field=models.PositiveSmallIntegerField(
+                choices=[
+                    (0, 0),
+                    (1, 1),
+                    (2, 2),
+                    (3, 3),
+                    (4, 4),
+                    (5, 5),
+                    (6, 6),
+                    (7, 7),
+                    (8, 8),
+                    (9, 9),
+                    (10, 10),
+                    (11, 11),
+                    (12, 12),
+                    (13, 13),
+                    (14, 14),
+                    (15, 15),
+                    (16, 16),
+                    (17, 17),
+                    (18, 18),
+                    (19, 19),
+                    (20, 20),
+                ],
+                default=0,
+                verbose_name="defender oral note",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="note",
+            name="opponent_writing",
+            field=models.PositiveSmallIntegerField(
+                choices=[
+                    (0, 0),
+                    (1, 1),
+                    (2, 2),
+                    (3, 3),
+                    (4, 4),
+                    (5, 5),
+                    (6, 6),
+                    (7, 7),
+                    (8, 8),
+                    (9, 9),
+                    (10, 10),
+                ],
+                default=0,
+                verbose_name="opponent writing note",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="note",
+            name="reporter_writing",
+            field=models.PositiveSmallIntegerField(
+                choices=[
+                    (0, 0),
+                    (1, 1),
+                    (2, 2),
+                    (3, 3),
+                    (4, 4),
+                    (5, 5),
+                    (6, 6),
+                    (7, 7),
+                    (8, 8),
+                    (9, 9),
+                    (10, 10),
+                ],
+                default=0,
+                verbose_name="reporter writing note",
+            ),
+        ),
+    ]

participation/migrations/0011_remove_note_observer_oral_remove_passage_observer.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.0.3 on 2024-04-16 21:59
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        (
+            "participation",
+            "0010_tournament_notes_sheet_id_alter_note_defender_oral_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="note",
+            name="observer_oral",
+        ),
+        migrations.RemoveField(
+            model_name="passage",
+            name="observer",
+        ),
+    ]

participation/migrations/0012_participation_mention_participation_mention_final.py

@@ -0,0 +1,27 @@
+# Generated by Django 5.0.3 on 2024-04-16 22:17
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("participation", "0011_remove_note_observer_oral_remove_passage_observer"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="participation",
+            name="mention",
+            field=models.CharField(
+                blank=True, default="", max_length=255, verbose_name="mention"
+            ),
+        ),
+        migrations.AddField(
+            model_name="participation",
+            name="mention_final",
+            field=models.CharField(
+                blank=True, default="", max_length=255, verbose_name="mention (final)"
+            ),
+        ),
+    ]

participation/migrations/0013_alter_pool_options_pool_room.py

@@ -0,0 +1,31 @@
+# Generated by Django 5.0.3 on 2024-04-17 20:50
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("participation", "0012_participation_mention_participation_mention_final"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="pool",
+            options={
+                "ordering": ("round", "letter", "room"),
+                "verbose_name": "pool",
+                "verbose_name_plural": "pools",
+            },
+        ),
+        migrations.AddField(
+            model_name="pool",
+            name="room",
+            field=models.PositiveSmallIntegerField(
+                choices=[(1, "Room 1"), (2, "Room 2")],
+                default=1,
+                help_text="For 5-teams pools only",
+                verbose_name="room",
+            ),
+        ),
+    ]

participation/signals.py

@@ -2,7 +2,8 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 from typing import Union
 
-from participation.models import Note, Participation, Passage, Pool, Team
+from participation.models import Note, Participation, Passage, Pool, Team, Tournament
+from registration.models import Payment
 from tfjm.lists import get_sympa_client
 
 
@@ -36,6 +37,50 @@ def update_mailing_list(instance: Team, raw, **_):
                                              f"{coach.user.first_name} {coach.user.last_name}")
 
 
+def create_payments(instance: Participation, created, raw, **_):
+    """
+    When a participation got created, create an associated payment.
+    """
+    if instance.valid and not raw:
+        for student in instance.team.students.all():
+            payment_qs = Payment.objects.filter(registrations=student, final=False)
+            if payment_qs.exists():
+                payment = payment_qs.get()
+            else:
+                payment = Payment.objects.create()
+                payment.registrations.add(student)
+                payment.save()
+            payment.amount = instance.tournament.price
+            if payment.amount == 0:
+                payment.type = "free"
+                payment.valid = True
+            payment.save()
+
+        if instance.final:
+            for student in instance.team.students.all():
+                payment_qs = Payment.objects.filter(registrations=student, final=True)
+                if payment_qs.exists():
+                    payment = payment_qs.get()
+                else:
+                    payment = Payment.objects.create(final=True)
+                    payment.registrations.add(student)
+
+                    payment_regional = Payment.objects.get(registrations=student, final=False)
+                    if payment_regional.type == 'scholarship':
+                        payment.type = 'scholarship'
+                        with open(payment_regional.receipt.path, 'rb') as f:
+                            payment.receipt.save(payment_regional.receipt.name, f)
+                        payment.additional_information = payment_regional.additional_information
+                        payment.fee = 0
+                        payment.valid = payment_regional.valid
+                    payment.save()
+                payment.amount = Tournament.final_tournament().price
+                if payment.amount == 0:
+                    payment.type = "free"
+                    payment.valid = True
+                payment.save()
+
+
 def create_notes(instance: Union[Passage, Pool], raw, **_):
     if not raw:
         if isinstance(instance, Pool):

participation/tables.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from django.utils import formats
+from django.utils.safestring import mark_safe
 from django.utils.text import format_lazy
 from django.utils.translation import gettext_lazy as _
 import django_tables2 as tables
@@ -90,7 +91,7 @@ class PoolTable(tables.Table):
     )
 
     def render_letter(self, record):
-        return format_lazy(_("Pool {letter}{round}"), letter=record.get_letter_display(), round=record.round)
+        return format_lazy(_("Pool {code}"), code=record.short_name)
 
     def render_teams(self, record):
         return ", ".join(participation.team.trigram for participation in record.participations.all()) \
@@ -137,10 +138,21 @@ class NoteTable(tables.Table):
         }
     )
 
+    update = tables.Column(
+        verbose_name=_("Update"),
+        accessor="id",
+        empty_values=(),
+    )
+
+    def render_update(self, record):
+        return mark_safe(f'<button class="btn btn-info" data-bs-toggle="modal" '
+                         f'data-bs-target="#{record.modal_name}Modal">'
+                         f'{_("Update")}</button>')
+
     class Meta:
         attrs = {
             'class': 'table table-condensed table-striped text-center',
         }
         model = Note
         fields = ('jury', 'defender_writing', 'defender_oral', 'opponent_writing', 'opponent_oral',
-                  'reporter_writing', 'reporter_oral', 'observer_oral',)
+                  'reporter_writing', 'reporter_oral', 'update',)

participation/templates/participation/chat.html

@@ -1,13 +0,0 @@
-{% extends "base.html" %}
-
-{% load i18n %}
-
-{% block content %}
-    <div class="alert alert-warning">
-    {% blocktrans trimmed %}
-        The chat feature is now out of usage. If you feel that having a chat
-        feature between participants is important, for example to build a
-        team, please contact us.
-    {% endblocktrans %}
-    </div>
-{% endblock %}

participation/templates/participation/mails/team_validated.html

@@ -5,16 +5,42 @@
     <title>Équipe validée – TFJM²</title>
 </head>
 <body>
-Bonjour,<br/>
+<p>
-<br/>
+    Bonjour {{ registration }},
-Félicitations ! Votre équipe « {{ team.name }} » ({{ team.trigram }}) est désormais validée ! Vous êtes désormais apte
+</p>
-à travailler sur vos problèmes. Vous pourrez ensuite envoyer vos solutions sur la plateforme.<br>
+<p>
-Les organisateurs vous adressent ce message :<br/>
+    Félicitations ! Votre équipe « {{ team.name }} » ({{ team.trigram }}) est désormais validée ! Vous êtes désormais
-<br/>
+    apte à travailler sur vos problèmes. Vous pourrez ensuite envoyer vos solutions sur la plateforme.
-{{ message }}<br />
+</p>
-<br/>
+
-Cordialement,<br/>
+{% if payment %}
-<br/>
+    <p>
-Le comité d'organisation du TFJM²
+        Vous devez désormais vous acquitter de vos frais de participation, de {{ payment.amount }} € par élève.
+        Vous pouvez payer par carte bancaire ou par virement bancaire. Vous trouverez les informations
+        sur <a href="https://{{ domain }}{% url 'registration:update_payment' pk=payment.pk %}">la page de paiement</a>.
+        Si vous disposez d'une bourse, l'inscription est gratuite, mais vous devez soumettre un justificatif
+        sur la même page.
+    </p>
+{% elif registration.is_coach and team.participation.tournament.price %}
+    <p>
+        Votre équipe doit désormais s'acquitter des frais de participation de {{ team.participation.tournament.price }} €
+        par élève (les encadrant⋅es sont exonéré⋅es). Les élèves qui disposent d'une bourse sont exonéré⋅es de ces frais.
+        Vous pouvez suivre l'état des paiements sur
+        <a href="https://{{ domain }}{% url 'participation:team_detail' pk=team.pk %}">la page de votre équipe</a>.
+    </p>
+{% endif %}
+
+{% if message %}
+    <p>
+        Les organisateur⋅ices vous adressent ce message :
+    </p>
+    <p>
+        {{ message }}
+    </p>
+{% endif %}
+
+<p>
+    Le comité d'organisation du TFJM²
+</p>
 </body>
 </html>

participation/templates/participation/mails/team_validated.txt

@@ -1,12 +1,23 @@
-Bonjour,
+Bonjour {{ registration }},
 
 Félicitations ! Votre équipe « {{ team.name }} » ({{ team.trigram }}) est désormais validée ! Vous êtes désormais apte
 à travailler sur vos problèmes. Vous pourrez ensuite envoyer vos solutions sur la plateforme.
-
+{% if team.participation.amount %}
-Les organisateurs vous adressent ce message :
+Vous devez désormais vous acquitter de vos frais de participation, de {{ team.participation.amount }} €.
+Vous pouvez payer par carte bancaire ou par virement bancaire. Vous trouverez les informations
+sur la page de paiement que vous pouvez retrouver sur votre compte :
+https://{{ domain }}{% url 'registration:my_account_detail' %}
+Si vous disposez d'une bourse, l'inscription est gratuite, mais vous devez soumettre un justificatif
+sur la même page.
+{% elif registration.is_coach and team.participation.tournament.price %}
+Votre équipe doit désormais s'acquitter des frais de participation de {{ team.participation.tournament.price }} €
+par élève (les encadrant⋅es sont exonéré⋅es). Les élèves qui disposent d'une bourse sont exonéré⋅es de ces frais.
+Vous pouvez suivre l'état des paiements sur la page de votre équipe :
+https://{{ domain }}{% url 'participation:team_detail' pk=team.pk %}
+{% endif %}
+{% if message %}
+Les organisateurices vous adressent ce message :
 
 {{ message }}
-
+{% endif %}
-Cordialement,
-
 Le comité d'organisation du TFJM²

participation/templates/participation/note_form.html

@@ -5,6 +5,9 @@
 {% block content %}
     <form method="post">
         <div id="form-content">
+            <h4>{% trans "Notes of" %} {{ note.jury }}</h4>
+            <h5>{% trans "Defense of" %} {{ note.passage.defender.team.trigram }}, {% trans "Pb." %} {{ note.passage.solution_number }}</h5>
+            <hr>
             {% csrf_token %}
             {{ form|crispy }}
         </div>

participation/templates/participation/participation_detail.html

@@ -30,6 +30,12 @@
                         {% empty %}
                             <li>{% trans "No solution was uploaded yet." %}</li>
                         {% endfor %}
+                        <li>
+                            <a href="{% url "participation:participation_solutions" team_id=participation.team_id %}"
+                               class="btn btn-sm btn-info">
+                                <i class="fas fa-archive"></i> {% trans "Download as ZIP" %}
+                            </a>
+                        </li>
                     </ul>
                 </dd>
 

participation/templates/participation/passage_detail.html

@@ -6,7 +6,16 @@
 {% trans "any" as any %}
     <div class="card bg-body shadow">
         <div class="card-header text-center">
-            <h4>{{ passage }}</h4>
+            <h4>
+                {{ passage }}
+                {% if user.registration.is_admin or user.registration in passage.pool.tournament.organizers.all %}
+                    <button class="btn btn-sm btn-secondary"
+                            data-bs-toggle="modal" data-bs-target="#updatePassageModal">
+                        <i class="fas fa-edit"></i>
+                        {% trans "Update" %}
+                    </button>
+                {% endif %}
+            </h4>
         </div>
         <div class="card-body">
             <dl class="row">
@@ -25,11 +34,6 @@
                 <dt class="col-sm-3">{% trans "Reporter:" %}</dt>
                 <dd class="col-sm-9"><a href="{{ passage.reporter.get_absolute_url }}">{{ passage.reporter.team }}</a></dd>
 
-                {% if passage.observer %}
-                    <dt class="col-sm-3">{% trans "Observer:" %}</dt>
-                    <dd class="col-sm-9"><a href="{{ passage.observer.get_absolute_url }}">{{ passage.observer.team }}</a></dd>
-                {% endif %}
-
                 <dt class="col-sm-3">{% trans "Defended solution:" %}</dt>
                 <dd class="col-sm-9"><a href="{{ passage.defended_solution.file.url }}">{{ passage.defended_solution }}</a></dd>
 
@@ -49,9 +53,8 @@
         {% if notes is not None %}
             <div class="card-footer text-center">
                 {% if my_note is not None %}
-                    <button class="btn btn-info" data-bs-toggle="modal" data-bs-target="#updateNotesModal">{% trans "Update notes" %}</button>
+                    <button class="btn btn-info" data-bs-toggle="modal" data-bs-target="#{{ my_note.modal_name }}Modal">{% trans "Update notes" %}</button>
                 {% endif %}
-                <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#updatePassageModal">{% trans "Update" %}</button>
             </div>
         {% elif user.registration.participates %}
             <div class="card-footer text-center">
@@ -70,46 +73,63 @@
         <div class="card bg-body shadow">
             <div class="card-body">
                 <dl class="row">
-                    <dt class="col-sm-8">{% trans "Average points for the defender writing:" %}</dt>
+                    <dt class="col-sm-8">
+                        {% trans "Average points for the defender writing" %}
+                        ({{ passage.defender.team.trigram }}) :
+                    </dt>
                     <dd class="col-sm-4">{{ passage.average_defender_writing|floatformat }}/20</dd>
 
-                    <dt class="col-sm-8">{% trans "Average points for the defender oral:" %}</dt>
+                    <dt class="col-sm-8">
-                    <dd class="col-sm-4">{{ passage.average_defender_oral|floatformat }}/16</dd>
+                        {% trans "Average points for the defender oral" %}
+                        ({{ passage.defender.team.trigram }}) :
+                    </dt>
+                    <dd class="col-sm-4">{{ passage.average_defender_oral|floatformat }}/20</dd>
 
-                    <dt class="col-sm-8">{% trans "Average points for the opponent writing:" %}</dt>
+                    <dt class="col-sm-8">
-                    <dd class="col-sm-4">{{ passage.average_opponent_writing|floatformat }}/9</dd>
+                        {% trans "Average points for the opponent writing" %}
+                        ({{ passage.opponent.team.trigram }}) :
+                    </dt>
+                    <dd class="col-sm-4">{{ passage.average_opponent_writing|floatformat }}/10</dd>
 
-                    <dt class="col-sm-8">{% trans "Average points for the opponent oral:" %}</dt>
+                    <dt class="col-sm-8">
+                        {% trans "Average points for the opponent oral" %}
+                        ({{ passage.opponent.team.trigram }}) :
+                    </dt>
                     <dd class="col-sm-4">{{ passage.average_opponent_oral|floatformat }}/10</dd>
 
-                    <dt class="col-sm-8">{% trans "Average points for the reporter writing:" %}</dt>
+                    <dt class="col-sm-8">
-                    <dd class="col-sm-4">{{ passage.average_reporter_writing|floatformat }}/9</dd>
+                        {% trans "Average points for the reporter writing" %}
+                        ({{ passage.reporter.team.trigram }}) :
+                    </dt>
+                    <dd class="col-sm-4">{{ passage.average_reporter_writing|floatformat }}/10</dd>
 
-                    <dt class="col-sm-8">{% trans "Average points for the reporter oral:" %}</dt>
+                    <dt class="col-sm-8">
+                        {% trans "Average points for the reporter oral" %}
+                        ({{ passage.reporter.team.trigram }}) :
+                    </dt>
                     <dd class="col-sm-4">{{ passage.average_reporter_oral|floatformat }}/10</dd>
-
-                    {% if passage.observer %}
-                        <dt class="col-sm-8">{% trans "Average points for the observer oral:" %}</dt>
-                        <dd class="col-sm-4">{{ passage.average_observer|floatformat }}/4</dd>
-                    {% endif %}
                 </dl>
 
                 <hr>
 
                 <dl class="row">
-                    <dt class="col-sm-8">{% trans "Defender points:" %}</dt>
+                    <dt class="col-sm-8">
+                        {% trans "Defender points" %}
+                        ({{ passage.defender.team.trigram }}) :
+                    </dt>
                     <dd class="col-sm-4">{{ passage.average_defender|floatformat }}/52</dd>
 
-                    <dt class="col-sm-8">{% trans "Opponent points:" %}</dt>
+                    <dt class="col-sm-8">
+                        {% trans "Opponent points" %}
+                        ({{ passage.opponent.team.trigram }}) :
+                    </dt>
                     <dd class="col-sm-4">{{ passage.average_opponent|floatformat }}/29</dd>
 
-                    <dt class="col-sm-8">{% trans "Reporter points:" %}</dt>
+                    <dt class="col-sm-8">
+                        {% trans "Reporter points" %}
+                        ({{ passage.reporter.team.trigram }}) :
+                    </dt>
                     <dd class="col-sm-4">{{ passage.average_reporter|floatformat }}/19</dd>
-
-                    {% if passage.observer %}
-                        <dt class="col-sm-8">{% trans "Observer points:" %}</dt>
-                        <dd class="col-sm-4">{{ passage.average_observer|floatformat }}/4</dd>
-                    {% endif %}
                 </dl>
             </div>
         </div>
@@ -121,12 +141,12 @@
         {% url "participation:passage_update" pk=passage.pk as modal_action %}
         {% include "base_modal.html" with modal_id="updatePassage" %}
 
-        {% if my_note is not None %}
+        {% for note in notes.data %}
             {% trans "Update notes" as modal_title %}
             {% trans "Update" as modal_button %}
-            {% url "participation:update_notes" pk=my_note.pk as modal_action %}
+            {% url "participation:update_notes" pk=note.pk as modal_action %}
-            {% include "base_modal.html" with modal_id="updateNotes" %}
+            {% include "base_modal.html" with modal_id=note.modal_name %}
-        {% endif %}
+        {% endfor %}
     {% elif user.registration.participates %}
         {% trans "Upload synthesis" as modal_title %}
         {% trans "Upload" as modal_button %}
@@ -141,9 +161,9 @@
             {% if notes is not None %}
                 initModal("updatePassage", "{% url "participation:passage_update" pk=passage.pk %}")
 
-                {% if my_note is not None %}
+              {% for note in notes.data %}
-                    initModal("updateNotes", "{% url "participation:update_notes" pk=my_note.pk %}")
+                initModal("{{ note.modal_name }}", "{% url "participation:update_notes" pk=note.pk %}")
-                {% endif %}
+            {% endfor %}
             {% elif user.registration.participates %}
                 initModal("uploadSynthesis", "{% url "participation:upload_synthesis" pk=passage.pk %}")
             {% endif %}

participation/templates/participation/pool_add_jurys.html

@@ -1,47 +0,0 @@
-{% extends "base.html" %}
-
-{% load crispy_forms_tags %}
-{% load i18n %}
-
-{% block content %}
-    <div class="alert alert-info">
-        <p>
-            {% trans "You can here register juries for the pool." %}
-            {% trans "Be careful: this form register new users. To add existing users into the jury, please use this form:" %}
-            <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#updatePoolModal">{% trans "Update pool" %}</button>
-        </p>
-        <p>
-            {% trans "For now, the registered juries for the tournament are:" %}
-            <ul>
-                {% for jury in pool.juries.all %}
-                    <li>{{ jury.user.first_name }} {{ jury.user.last_name }} (<a class="alert-link" href="mailto:{{ jury.user.email }}">{{ jury.user.email }}</a>)</li>
-                {% empty %}
-                    <li><i>{% trans "There is no jury yet." %}</i></li>
-                {% endfor %}
-            </ul>
-        </p>
-    </div>
-    {% crispy form %}
-
-    <hr>
-
-    <div class="row text-center">
-    <a href="{% url 'participation:pool_detail' pk=pool.pk %}" class="btn btn-secondary">
-        <i class="fas fa-arrow-left"></i> {% trans "Back to pool detail" %}
-    </a>
-    </div>
-
-    {% trans "Update pool" as modal_title %}
-    {% trans "Update" as modal_button %}
-    {% url "participation:pool_update" pk=pool.pk as modal_action %}
-    {% include "base_modal.html" with modal_id="updatePool" %}
-{% endblock %}
-
-{% block extrajavascript %}
-    <script>
-        document.addEventListener('DOMContentLoaded', () => {
-            initModal("updatePool", "{% url "participation:pool_update" pk=pool.pk %}")
-        })
-    </script>
-{% endblock %}
-

participation/templates/participation/pool_detail.html

@@ -5,7 +5,15 @@
 {% block content %}
     <div class="card bg-body shadow">
         <div class="card-header text-center">
-            <h4>{{ pool }}</h4>
+            <h4>
+                {{ pool }}
+                {% if user.registration.is_admin or user.registration in pool.tournament.organizers.all %}
+                    <button class="btn btn-sm btn-secondary" data-bs-toggle="modal" data-bs-target="#updatePoolModal">
+                        <i class="fas fa-edit"></i>
+                        {% trans "Update" %}
+                    </button>
+                {% endif %}
+            </h4>
         </div>
         <div class="card-body">
             <dl class="row">
@@ -17,6 +25,11 @@
 
                 <dt class="col-sm-3">{% trans "Letter:" %}</dt>
                 <dd class="col-sm-9">{{ pool.get_letter_display }}</dd>
+            
+                {% if pool.participations.count == 5 %}
+                    <dt class="col-sm-3">{% trans "Room:" %}</dt>
+                    <dd class="col-sm-9">{{ pool.get_room_display }}</dd>
+                {% endif %}
 
                 <dt class="col-sm-3">{% trans "Teams:" %}</dt>
                 <dd class="col-sm-9">
@@ -28,8 +41,8 @@
                 <dt class="col-sm-3">{% trans "Juries:" %}</dt>
                 <dd class="col-sm-9">
                     {{ pool.juries.all|join:", " }}
-                    <a class="badge rounded-pill text-bg-info" href="{% url 'participation:pool_add_jurys' pk=pool.pk %}">
+                    <a class="badge rounded-pill text-bg-info" href="{% url 'participation:pool_jury' pk=pool.pk %}">
-                        <i class="fas fa-plus"></i> {% trans "Add jurys" %}
+                        <i class="fas fa-plus"></i> {% trans "Edit jury" %}
                     </a>
                 </dd>
 
@@ -38,7 +51,7 @@
                     {% for passage in pool.passages.all %}
                         <a href="{{ passage.defended_solution.file.url }}">{{ passage.defender.team.trigram }} — {{ passage.get_solution_number_display }}</a>{% if not forloop.last %}, {% endif %}
                     {% endfor %}
-                    <a href="{% url 'participation:pool_download_solutions' pk=pool.pk %}" class="badge rounded-pill text-bg-secondary">
+                    <a href="{% url 'participation:pool_download_solutions' pool_id=pool.id %}" class="badge rounded-pill text-bg-secondary">
                         <i class="fas fa-download"></i> {% trans "Download all" %}
                     </a>
                 </dd>
@@ -57,13 +70,45 @@
                             </li>
                         {% endfor %}
                     </ul>
-                    <a href="{% url 'participation:pool_download_syntheses' pk=pool.pk %}" class="badge rounded-pill text-bg-secondary">
+                    <a href="{% url 'participation:pool_download_syntheses' pool_id=pool.id %}" class="badge rounded-pill text-bg-secondary">
                         <i class="fas fa-download"></i> {% trans "Download all" %}
                     </a>
                 </dd>
 
-                <dt class="col-sm-3">{% trans "BigBlueButton link:" %}</dt>
+                {% if pool.bbb_url %}
-                <dd class="col-sm-9">{{ pool.bbb_url|urlize }}</dd>
+                    <dt class="col-sm-3">{% trans "BigBlueButton link:" %}</dt>
+                    <dd class="col-sm-9">{{ pool.bbb_url|urlize }}</dd>
+                {% endif %}
+
+                {% if user.registration.is_admin or user.registration.is_volunteer %}
+                    {% if user.registration.is_admin or user.registration in pool.tournament.organizers.all or user.registration == pool.jury_president %}
+                        <dt class="col-sm-3">{% trans "Notation sheets:" %}</dt>
+                        <dd class="col-sm-9">
+                            <div class="btn-group">
+                                <a class="btn btn-sm btn-info" href="{% url 'participation:pool_scale_note_sheet' pk=pool.pk %}">
+                                    <i class="fas fa-download"></i>
+                                    {% trans "Download the scale sheet" %}
+                                </a>
+                                <a class="btn btn-sm btn-info" href="{% url 'participation:pool_final_note_sheet' pk=pool.pk %}">
+                                    <i class="fas fa-download"></i>
+                                    {% trans "Download the final notation sheet" %}
+                                </a>
+                                <a class="btn btn-sm btn-info" href="{% url 'participation:pool_notation_sheets' pool_id=pool.id %}">
+                                    <i class="fas fa-archive"></i>
+                                    {% trans "Download all notation sheets" %}
+                                </a>
+                            </div>
+                        </dd>
+
+                        <dt class="col-sm-3">{% trans "Google Sheets Spreadsheet:" %}</dt>
+                        <dd class="col-sm-9">
+                            <a class="btn btn-sm btn-success" href="https://docs.google.com/spreadsheets/d/{{ pool.tournament.notes_sheet_id }}/edit">
+                                <i class="fas fa-table"></i>
+                                {% trans "Go to the Google Sheets page of the pool" %}
+                            </a>
+                        </dd>
+                    {% endif %}
+                {% endif %}
             </dl>
 
             <div class="card bg-body shadow">
@@ -77,40 +122,24 @@
                         {% endfor %}
                     </ul>
                 </div>
-                {% if user.registration.is_volunteer %}
+                {% if user.registration.is_admin or user.registration.is_volunteer %}
-                    <div class="card-footer text-center">
+                    {% if user.registration.is_admin or user.registration in pool.tournament.organizers.all or user.registration == pool.jury_president %}
-                        <div class="btn-group">
+                        <div class="card-footer text-center">
-                            <a class="btn btn-info" href="{% url 'participation:pool_scale_note_sheet' pk=pool.pk %}">
+                            <div class="btn btn-group">
-                                {% trans "Download the scale sheet" %}{% if pool.passages.count == 5 %} — {% trans "Room" %} 1{% endif %}
+                                <button class="btn btn-sm btn-primary" data-bs-toggle="modal" data-bs-target="#uploadNotesModal">
-                            </a>
+                                    <i class="fas fa-upload"></i>
-                            {% if pool.passages.count == 5 %}
+                                    {% trans "Upload notes from a spreadsheet file" %}
-                                <a class="btn btn-info" href="{% url 'participation:pool_scale_note_sheet' pk=pool.pk %}?page=2">
+                                </button>
-                                    {% trans "Room" %} 2
+                                <a class="btn btn-sm btn-info" href="{% url 'participation:pool_notes_template' pk=pool.pk %}">
+                                    <i class="fas fa-download"></i>
+                                    {% trans "Download notation spreadsheet" %}
                                 </a>
-                            {% endif %}
+                            </div>
                         </div>
-                        <div class="btn-group">
+                    {% endif %}
-                            <a class="btn btn-info" href="{% url 'participation:pool_final_note_sheet' pk=pool.pk %}">
-                                {% trans "Download the final notation sheet" %}{% if pool.passages.count == 5 %} — {% trans "Room" %} 1{% endif %}
-                            </a>
-                            {% if pool.passages.count == 5 %}
-                                <a class="btn btn-info" href="{% url 'participation:pool_final_note_sheet' pk=pool.pk %}?page=2">
-                                    {% trans "Room" %} 2
-                                </a>
-                            {% endif %}
-                        </div>
-                        <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#uploadNotesModal">{% trans "Upload notes from a CSV file" %}</button>
-                    </div>
                 {% endif %}
             </div>
         </div>
-        {% if user.registration.is_volunteer %}
-            <div class="card-footer text-center">
-                <button class="btn btn-success" data-bs-toggle="modal" data-bs-target="#addPassageModal">{% trans "Add passage" %}</button>
-                <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#updatePoolModal">{% trans "Update" %}</button>
-                <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#updateTeamsModal">{% trans "Update teams" %}</button>
-            </div>
-        {% endif %}
     </div>
 
     <hr>
@@ -119,21 +148,11 @@
 
     {% render_table passages %}
 
-    {% trans "Add passage" as modal_title %}
-    {% trans "Add" as modal_button %}
-    {% url "participation:passage_create" pk=pool.pk as modal_action %}
-    {% include "base_modal.html" with modal_id="addPassage" modal_button_type="success" %}
-
     {% trans "Update pool" as modal_title %}
     {% trans "Update" as modal_button %}
     {% url "participation:pool_update" pk=pool.pk as modal_action %}
     {% include "base_modal.html" with modal_id="updatePool" %}
 
-    {% trans "Update teams" as modal_title %}
-    {% trans "Update" as modal_button %}
-    {% url "participation:pool_update_teams" pk=pool.pk as modal_action %}
-    {% include "base_modal.html" with modal_id="updateTeams" %}
-
     {% trans "Upload notes" as modal_title %}
     {% trans "Upload" as modal_button %}
     {% url "participation:pool_upload_notes" pk=pool.pk as modal_action %}
@@ -144,8 +163,6 @@
     <script>
         document.addEventListener('DOMContentLoaded', () => {
             initModal("updatePool", "{% url "participation:pool_update" pk=pool.pk %}")
-            initModal("updateTeams", "{% url "participation:pool_update_teams" pk=pool.pk %}")
-            initModal("addPassage", "{% url "participation:passage_create" pk=pool.pk %}")
             initModal("uploadNotes", "{% url "participation:pool_upload_notes" pk=pool.pk %}")
         })
     </script>

participation/templates/participation/pool_jury.html

@@ -0,0 +1,141 @@
+{% extends "base.html" %}
+
+{% load crispy_forms_tags crispy_forms_filters %}
+{% load i18n %}
+
+{% block content %}
+    <div class="alert alert-info">
+        <p>
+            {% blocktrans trimmed %}
+            On this page, you can manage the juries of the pool. You can add a new jury by entering the email address
+            of the jury. If the jury is not registered, the account will be created automatically. If the jury already
+            exists, its account will be autocompleted and directly linked to the pool.
+            {% endblocktrans %}
+        </p>
+    
+        <p>
+            {% blocktrans trimmed %}
+            On this page, you can also define the president of the jury, who will have the right to see all solutions
+            and if necessary define the notes of other jury members.
+            {% endblocktrans %}
+        </p>
+    </div>
+
+    <hr>
+
+    {% for jury in pool.juries.all %}
+        <div class="row my-3 px-0">
+            <div class="col-md-5 px-1">
+                <input type="email" class="form-control" value="{{ jury.user.email }}" disabled>
+            </div>
+            <div class="col-md-3 px-1">
+                <input type="text" class="form-control" value="{{ jury.user.first_name }}" disabled>
+            </div>
+            <div class="col-md-3 px-1">
+                <input type="text" class="form-control" value="{{ jury.user.last_name }}" disabled>
+            </div>
+            <div class="col-md-1 px-1">
+                <div class="btn-group-vertical btn-group-sm">
+                    {% if jury == pool.jury_president %}
+                        <button class="btn btn-success">
+                            <i class="fas fa-crown"></i> {% trans "PoJ" %}
+                        </button>
+                    {% else %}
+                        <a href="{% url 'participation:pool_preside' pk=pool.pk jury_id=jury.id %}"
+                                class="btn btn-warning">
+                            <i class="fas fa-crown"></i> {% trans "Preside" %}
+                        </a>
+                    {% endif %}
+                    <a href="{% url 'participation:pool_remove_jury' pk=pool.pk jury_id=jury.id %}"
+                            class="btn btn-danger">
+                        <i class="fas fa-trash"></i> {% trans "Remove" %}
+                    </a>
+                </div>
+            </div>
+        </div>
+    {% endfor %}
+
+    {{ form|as_crispy_errors }}
+    {% crispy form %}
+
+    <datalist id="juries-email">
+    </datalist>
+
+    <datalist id="juries-first-name">
+    </datalist>
+
+    <datalist id="juries-last-name">
+    </datalist>
+
+    <hr>
+
+    <div class="row text-center">
+        <a href="{% url 'participation:pool_detail' pk=pool.pk %}" class="btn btn-secondary">
+            <i class="fas fa-arrow-left"></i> {% trans "Back to pool detail" %}
+        </a>
+    </div>
+{% endblock %}
+
+{% block extrajavascript %}
+    <script>
+        const emailField = document.getElementById('id_email')
+        const firstNameField = document.getElementById('id_first_name')
+        const lastNameField = document.getElementById('id_last_name')
+
+        const juriesEmailList = document.getElementById('juries-email')
+        const juriesFirstNameList = document.getElementById('juries-first-name')
+        const juriesLastNameList = document.getElementById('juries-last-name')
+
+        function updateJuries(filter) {
+            fetch(`/api/registration/volunteers/?search=${filter}`)
+                .then(response => response.json())
+                .then(response => response.results)
+                .then(data => {
+                    juriesEmailList.innerHTML = ''
+                    juriesFirstNameList.innerHTML = ''
+                    juriesLastNameList.innerHTML = ''
+
+                    data.forEach(jury => {
+                        const optionEmail = document.createElement('option')
+                        optionEmail.value = jury.email
+                        optionEmail.setAttribute('data-id', jury.id)
+                        optionEmail.text = `${jury.first_name} ${jury.last_name} (${jury.email})`
+                        juriesEmailList.appendChild(optionEmail)
+
+                        const optionFirstName = document.createElement('option')
+                        optionFirstName.value = jury.first_name
+                        optionFirstName.setAttribute('data-id', jury.id)
+                        optionFirstName.text = `${jury.first_name} ${jury.last_name} (${jury.email})`
+                        juriesFirstNameList.appendChild(optionFirstName)
+
+                        const optionLastName = document.createElement('option')
+                        optionLastName.value = jury.last_name
+                        optionLastName.setAttribute('data-id', jury.id)
+                        optionLastName.text = `${jury.first_name} ${jury.last_name} (${jury.email})`
+                        juriesLastNameList.appendChild(optionLastName)
+                    })
+                })
+        }
+
+        emailField.addEventListener('input', event => {
+            let emailOption = document.querySelector(`datalist[id="juries-email"] > option[value="${event.target.value}"]`)
+            if (emailOption) {
+                let id = emailOption.getAttribute('data-id')
+                let firstNameOption = document.querySelector(`datalist[id="juries-first-name"] > option[data-id="${id}"]`)
+                let lastNameOption = document.querySelector(`datalist[id="juries-last-name"] > option[data-id="${id}"]`)
+                if (firstNameOption && lastNameOption) {
+                    firstNameField.value = firstNameOption.value
+                    lastNameField.value = lastNameOption.value
+                }
+            }
+            updateJuries(event.target.value)
+        })
+        firstNameField.addEventListener('input', event => {
+            updateJuries(event.target.value)
+        })
+        lastNameField.addEventListener('input', event => {
+            updateJuries(event.target.value)
+        })
+    </script>
+{% endblock %}
+

participation/templates/participation/team_detail.html

@@ -10,19 +10,19 @@
         </div>
     <div class="card-body">
         <dl class="row">
-            <dt class="col-sm-6 text-end">{% trans "Name:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Name:" %}</dt>
             <dd class="col-sm-6">{{ team.name }}</dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Trigram:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Trigram:" %}</dt>
             <dd class="col-sm-6">{{ team.trigram }}</dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Email:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Email:" %}</dt>
             <dd class="col-sm-6"><a href="mailto:{{ team.email }}">{{ team.email }}</a></dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Access code:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Access code:" %}</dt>
             <dd class="col-sm-6">{{ team.access_code }}</dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Coaches:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Coaches:" %}</dt>
             <dd class="col-sm-6">
                 {% for coach in team.coaches.all %}
                     <a href="{% url "registration:user_detail" pk=coach.user.pk %}">{{ coach }}</a>{% if not forloop.last %},{% endif %}
@@ -31,7 +31,7 @@
                 {% endfor %}
             </dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Participants:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Participants:" %}</dt>
             <dd class="col-sm-6">
                 {% for student in team.students.all %}
                     <a href="{% url "registration:user_detail" pk=student.user.pk %}">{{ student }}</a>{% if not forloop.last %},{% endif %}
@@ -40,7 +40,7 @@
                 {% endfor %}
             </dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Tournament:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Tournament:" %}</dt>
             <dd class="col-sm-6">
                 {% if team.participation.tournament %}
                     <a href="{% url "participation:tournament_detail" pk=team.participation.tournament.pk %}">{{ team.participation.tournament }}</a>
@@ -49,7 +49,7 @@
                 {% endif %}
             </dd>
 
-            <dt class="col-sm-6 text-end">{% trans "Photo authorizations:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Photo authorizations:" %}</dt>
             <dd class="col-sm-6">
                 {% for participant in team.participants.all %}
                     {% if participant.photo_authorization %}
@@ -60,8 +60,21 @@
                 {% endfor %}
             </dd>
 
+            {% if team.participation.final %}
+                <dt class="col-sm-6 text-sm-end">{% trans "Photo authorizations (final):" %}</dt>
+                <dd class="col-sm-6">
+                    {% for participant in team.participants.all %}
+                        {% if participant.photo_authorization_final %}
+                            <a href="{{ participant.photo_authorization_final.url }}">{{ participant }}</a>{% if not forloop.last %},{% endif %}
+                        {% else %}
+                            {{ participant }} ({% trans "Not uploaded yet" %}){% if not forloop.last %},{% endif %}
+                        {% endif %}
+                    {% endfor %}
+                </dd>
+            {% endif %}
+
             {% if not team.participation.tournament.remote  %}
-                <dt class="col-sm-6 text-end">{% trans "Health sheets:" %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans "Health sheets:" %}</dt>
                 <dd class="col-sm-6">
                     {% for student in team.students.all %}
                         {% if student.under_18 %}
@@ -74,7 +87,7 @@
                     {% endfor %}
                 </dd>
 
-                <dt class="col-sm-6 text-end">{% trans "Vaccine sheets:" %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans "Vaccine sheets:" %}</dt>
                 <dd class="col-sm-6">
                     {% for student in team.students.all %}
                         {% if student.under_18 %}
@@ -87,7 +100,7 @@
                     {% endfor %}
                 </dd>
 
-                <dt class="col-sm-6 text-end">{% trans "Parental authorizations:" %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans "Parental authorizations:" %}</dt>
                 <dd class="col-sm-6">
                     {% for student in team.students.all %}
                         {% if student.under_18 %}
@@ -99,9 +112,24 @@
                         {% endif %}
                     {% endfor %}
                 </dd>
+
+                {% if team.participation.final %}
+                    <dt class="col-sm-6 text-sm-end">{% trans "Parental authorizations (final):" %}</dt>
+                    <dd class="col-sm-6">
+                        {% for student in team.students.all %}
+                            {% if student.under_18_final %}
+                                {% if student.parental_authorization_final %}
+                                    <a href="{{ student.parental_authorization_final.url }}">{{ student }}</a>{% if not forloop.last %},{% endif %}
+                                {% else %}
+                                    {{ student }} ({% trans "Not uploaded yet" %}){% if not forloop.last %},{% endif %}
+                                {% endif %}
+                            {% endif %}
+                        {% endfor %}
+                    </dd>
+                {% endif %}
             {% endif %}
 
-            <dt class="col-sm-6 text-end">{% trans "Motivation letter:" %}</dt>
+            <dt class="col-sm-6 text-sm-end">{% trans "Motivation letter:" %}</dt>
             <dd class="col-sm-6">
                 {% if team.motivation_letter %}
                     <a href="{{ team.motivation_letter.url }}">{% trans "Download" %}</a>
@@ -112,17 +140,40 @@
                     <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#uploadMotivationLetterModal">{% trans "Replace" %}</button>
                 {% endif %}
             </dd>
-        </dl>
 
         {% if user.registration.is_volunteer %}
             {% if user.registration in self.team.participation.tournament.organizers or user.registration.is_admin %}
                 <div class="text-center">
-                    <a class="btn btn-info" href="{% url "participation:team_authorizations" pk=team.pk %}">
+                    <a class="btn btn-info" href="{% url "participation:team_authorizations" team_id=team.id %}">
                         <i class="fas fa-file-archive"></i> {% trans "Download all submitted authorizations" %}
                     </a>
                 </div>
             {% endif %}
         {% endif %}
+
+        {% if team.participation.valid %}
+            <hr class="my-3">
+            {% for student in team.students.all %}
+                {% for payment in student.payments.all %}
+                    <dt class="col-sm-6 text-sm-end">
+                        {% trans "Payment of" %} {{ student }}
+                        {% if payment.grouped %}({% trans "grouped" %}){% endif %}
+                        {% if payment.final %} ({% trans "final" %}){% endif %} :
+                    </dt>
+                    <dd class="col-sm-6">
+                        Valide : {{ payment.valid|yesno }}
+                        {% if payment.valid is False or user.registration.is_volunteer %}
+                            {% if user.registration in payment.registrations.all or user.registration.is_coach or user.registration.is_volunteer %}
+                                <a href="{% url "registration:update_payment" pk=payment.pk %}" class="btn btn-secondary">
+                                    <i class="fas fa-money-bill-wave"></i> {% trans "Update payment" %}
+                                </a>
+                            {% endif %}
+                        {% endif %}
+                    </dd>
+                {% endfor %}
+            {% endfor %}
+        {% endif %}
+        </dl>
     </div>
     <div class="card-footer text-center">
         <button class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#updateTeamModal">{% trans "Update" %}</button>

participation/templates/participation/tex/bareme.tex

@@ -1,4 +1,4 @@
-\documentclass[12pt,a4paper,landscape]{article}
+\documentclass[11pt,a4paper,landscape]{article}
 
 \usepackage[T1]{fontenc}
 \usepackage[utf8x]{inputenc}
@@ -22,7 +22,7 @@
 \addtolength{\textwidth}{4cm}
 \setlength{\parindent}{0mm}
 
-\geometry{left=1.6cm,right=1.6cm,top=1.2cm,bottom=2cm}
+\geometry{left=1.6cm,right=1.6cm,top=1.2cm,bottom=1.2cm}
 
 \newcommand{\tfjm}{$\mathbb{TFJM}^2$}
 \pagestyle{empty}
@@ -49,78 +49,75 @@
 \vspace{6mm}
 
 %%%%%%%%%%%%%%%%%%%%%DEFENSEUR
-\begin{tabular}{|c|p{20mm}|p{11cm}|c{% for passage in passages.all %}|p{2cm}{% endfor %}|}\hline
+\begin{tabular}{|c|p{24mm}|p{11cm}|c|{% for passage in passages.all %}p{2cm}|{% endfor %}}\hline
-\multicolumn{4}{|l|}{Læ {\bf D\'efenseur\textperiodcentered{}se} \normalsize pr\'esente les id\'ees et r\'esultats principaux pour la solution du probl\`eme.} {% for passage in passages.all %}& Passage {{ forloop.counter }} {% endfor %}\\ \hline \hline
+\multicolumn{4}{|l|}{Læ {\bf D\'efenseur\textperiodcentered{}se} \normalsize pr\'esente les id\'ees et r\'esultats principaux pour la solution du probl\`eme.} {% for passage in passages.all %}& P.{{ forloop.counter }} - {{ passage.defender.team.trigram }} {% endfor %}\\ \hline \hline
+
 %ECRIT
-\multirow{6}{3mm}{\centering \bf\'E\\ C\\ R\\ I\\ T} & \multirow{3}{20mm}{Partie scientifique} & Profondeur des r\'esultats d\'emontr\'es & [0,5] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+\multirow{6}{3mm}{\centering \bf\'E\\ C\\ R\\ I\\ T} & \multirow{3}{20mm}{Partie scientifique} & Profondeur et difficulté des éléments présentés & [0,6] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Originalit\'e et pertinence des preuves& [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& Présence, exactitude et justesse des démonstrations et algorithmes & [0,6] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Exactitude et justesse des d\'emonstrations, algorithmes, etc. & [0,7] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Pertinence, efficacité et élégance & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-&\multirow{2}{20mm}{Forme} & Pr\'esentation (lisibilit\'e, etc.) & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&\multirow{3}{20mm}{Forme}& Clarté du raisonnement (explications, exemples, illustrations, schémas, etc.) & [0,3]{{ esp|safe }} \\ \cline{3-{{ passages.count|add:4 }}}
-&& Clart\'e du raisonnement : facile \`a comprendre ou compl\`etement obscur ? & [0,3]{{ esp|safe }} \\ \cline{2-{{ passages.count|add:4 }}}
+&& Présentation (lisibilité, respect du format, etc.) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
 &\multicolumn{3}{|l|}{\bf TOTAL \'ECRIT (/20)} {{ esp|safe }} \\ \hline \hline
+
 %ORAL
-\multirow{8}{3mm}{\centering\bf O\\ R\\ A\\ L} & \multirow{4}{20mm}{Partie scientifique} & Compr\'ehension du mat\'eriel, connaissance des sujets math\'ematiques correspondants \emph{lors de la pr\'esentation} & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+\multirow{8}{3mm}{\centering\bf O\\ R\\ A\\ L} & \multirow{4}{20mm}{Présentation orale} & Compréhension du matériel présenté, connaissance et maîtrise des sujets mathématiques utilisés \emph{lors de la présentation} & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& P\'edagogie, notamment clart\'e, exactitude et justesse des d\'emonstrations \emph{lors de la pr\'esentation} & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& Pertinence des choix (démonstrations, exemples, profondeur au regard de la solution écrite) & [0,4] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Capacit\'e \`a r\'eagir aux questions et remarques de l'Opposant\textperiodcentered{}e et de læ Rapporteur\textperiodcentered{}e & [0,4] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& Pédagogie et clarté du discours (explications, illustrations, etc.) & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Capacit\'e \`a r\'eagir aux questions et remarques du jury & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Brieveté et propreté de la présentation & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-&\multirow{3}{20mm}{Forme} & Bri\`evet\'e  et propret\'e de la pr\'esentation & [0,2] {{ esp|safe }} \\ \cline{3-{{ passages.count|add:4 }}}
+&\multirow{2}{20mm}{Débats} & Réponses correctes aux questions posées & [0,5] {{ esp|safe }} \\ \cline{3-{{ passages.count|add:4 }}}
-&& Capacit\'e de faire avancer le d\'ebat & [0,2] {{ esp|safe }} \\ \cline{3-{{ passages.count|add:4 }}}
+&& Capacité de faire avancer le débat (expliquer les limites de ses connaissances, des conjectures, rechercher en direct, etc.) & [0,4] {{ esp|safe }} \\ \cline{2-{{ passages.count|add:4 }}}
-&& \emph{Conformit\'e} entre la pr\'esentation et le mat\'eriel \'ecrit & [--5,0] {{ esp|safe }} \\ \cline{2-{{ passages.count|add:4 }}}
+&\multirow{2}{20mm}{Malus} & Attitude irrespectueuse ? & [--6,0] {{ esp|safe }} \\ \cline{3-{{ passages.count|add:4 }}}
-&\multicolumn{3}{|l|}{\bf TOTAL ORAL (/16)} {{ esp|safe }} \\ \hline
+&& Non-conformité de la présentation avec le matériel écrit ? & [--6,0] {{ esp|safe }} \\ \cline{2-{{ passages.count|add:4 }}}
+&\multicolumn{3}{|l|}{\bf TOTAL ORAL (/20)} {{ esp|safe }} \\ \hline
 
 \end{tabular}
 
 \newpage
 
 %%%%%%%%%%%%%%%%%OPPOSANT
-\begin{tabular}{|c|p{20mm}|p{11cm}|c{% for passage in passages.all %}|p{2cm}{% endfor %}|}\hline
+\begin{tabular}{|c|p{24mm}|p{11cm}|c{% for passage in passages.all %}|p{2cm}{% endfor %}|}\hline
 \multicolumn{4}{|l|}{L' {\bf Opposant\textperiodcentered{}e} \normalsize fournit une analyse critique de la solution et de la pr\'esentation.}
-{% for passage in passages.all %}& Passage {{ forloop.counter }} {% endfor %} \\ \hline \hline
+{% for passage in passages.all %}& P.{{ forloop.counter }} - {{ passage.opponent.team.trigram }} {% endfor %} \\ \hline \hline
+
 %ECRIT
-\multirow{4}{3mm}{\centering\bf\'E\\ C\\ R\\ I\\ T} &\multirow{2}{20mm}{Partie scientifique} & Compr\'ehension du probl\`eme, savoir \'evaluer la qualit\'e g\'en\'erale de la solution & [0,4] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+\multirow{4}{3mm}{\centering\bf\'E\\ C\\ R\\ I\\ T} &\multirow{3}{20mm}{Partie scientifique} & Recul et esprit critique par rapport à la solution proposée & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Rep\'erer les erreurs et leur importance & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Validité des erreurs et points positifs soulevés & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-& Forme & Pr\'esentation (lisibilit\'e, etc.) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Repérer les erreurs et points positifs les plus importants et les hiérarchiser & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-&\multicolumn{3}{|l|}{\bf TOTAL \'ECRIT (/9)} {{ esp|safe }} \\ \hline \hline
+& Forme & Pr\'esentation (lisibilité, respect du format, etc.) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&\multicolumn{3}{|l|}{\bf TOTAL \'ECRIT (/10)} {{ esp|safe }} \\ \hline \hline
+
 %ORAL
-\multirow{6}{3mm}{\centering\bf O\\ R\\ A\\ L} & \multirow{3}{20mm}{Partie scientifique} & Compr\'ehension du probl\`eme, savoir \'evaluer la qualit\'e g\'en\'erale de la pr\'esentation de læ D\'efenseur\textperiodcentered{}se
+\multirow{6}{3mm}{\centering\bf O\\ R\\ A\\ L} & \multirow{3}{20mm}{Questions et discours de l'opposant\textperiodcentered{}e} & Pertinence des questions (importance des sujets abordés, des points soulevés) & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-& [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& Gestion de l'échange (formulation des questions, réaction aux réponses, articulation entre les questions, gestion du temps) & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Rep\'erer les erreurs et leur importance & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& Capacité à évaluer la qualité de la prestation de læ Défenseur⋅se (présentation et réponses à l'Opposant⋅e) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-&& Pertinence des questions & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Réponses aux questions de læ Rapporteur\textperiodcentered{}rice et du jury (fond et capacité à faire avancer le débat) & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-& Forme & M\`ene un d\'ebat de fa\c con comp\'etente et propre. & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+& Malus & Attitude irrespectueuse ? & [-3,0] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
 &\multicolumn{3}{|l|}{\bf TOTAL ORAL (/10)} {{ esp|safe }}\\ \hline
 \end{tabular}
 
 \vfill
 
-%%%%%%%%%%%%%%%%%%%%%%RAPPORTEUR
+%%%%%%%%%%%%%%%%%%%%%%RAPPORTEUR.RICE
-\begin{tabular}{|c|p{20mm}|p{11cm}|c{% for passage in passages.all %}|p{2cm}{% endfor %}|}\hline
+\begin{tabular}{|c|p{24mm}|p{11cm}|c{% for passage in passages.all %}|p{2cm}{% endfor %}|}\hline
-\multicolumn{4}{|l|}{Læ {\bf Rapporteur\textperiodcentered{}e} \normalsize \'evalue le d\'ebat entre læ D\'efenseur\textperiodcentered{}se et l'Opposant\textperiodcentered{}e.} {% for passage in passages.all %}& Passage {{ forloop.counter }} {% endfor %}\\ \hline \hline
+\multicolumn{4}{|l|}{Læ {\bf Rapporteur\textperiodcentered{}rice} \normalsize \'evalue le d\'ebat entre læ D\'efenseur\textperiodcentered{}se et l'Opposant\textperiodcentered{}e.} {% for passage in passages.all %}& P.{{ forloop.counter }} - {{ passage.reporter.team.trigram }} {% endfor %}\\ \hline \hline
+
 %ECRIT
-\multirow{4}{3mm}{\centering\bf\'E\\ C\\ R\\ I\\ T} &\multirow{2}{20mm}{Partie scientifique} & Compr\'ehension du probl\`eme, savoir \'evaluer la qualit\'e g\'en\'erale de la solution & [0,4] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+\multirow{4}{3mm}{\centering\bf\'E\\ C\\ R\\ I\\ T} &\multirow{3}{20mm}{Partie scientifique} & Recul et esprit critique par rapport à la solution proposée & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-& & Rep\'erer les erreurs et leur importance & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Validité des erreurs et points positifs soulevés & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-& Forme & Pr\'esentation (lisibilit\'e, etc.) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Repérer les erreurs et points positifs les plus importants et les hiérarchiser & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-&\multicolumn{3}{|l|}{\bf TOTAL \'ECRIT (/9)} {{ esp|safe }}\\ \hline \hline
+& Forme & Présentation (lisibilité, respect du format, etc.) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&\multicolumn{3}{|l|}{\bf TOTAL \'ECRIT (/10)} {{ esp|safe }}\\ \hline \hline
+
 %ORAL
-\multirow{6}{3mm}{\centering\bf O\\ R\\ A\\ L} &\multirow{4}{20mm}{Partie scientifique} & Compr\'ehension du probl\`eme, savoir \'evaluer la qualit\'e g\'en\'erale de la pr\'esentation de læ D\'efenseur\textperiodcentered{}se & [0,1] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+\multirow{6}{3mm}{\centering\bf O\\ R\\ A\\ L} & \multirow{3}{20mm}{Questions et discours de læ rapporteur\textperiodcentered{}rice} & \footnotesize Faire prendre de la hauteur au débat (par les sujets abordés, la pertinence des questions posées, les points soulevés, gestion du temps) & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Savoir \'evaluer la qualit\'e g\'en\'erale du d\'ebat & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& \footnotesize Créer un échange constructif entre les participants (formulation des questions, réaction aux réponses, articulation entre les questions, circulation de la parole) & [0,3] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
-&& Rep\'erer les points importants non abord\'es & [0,2] {{ esp|safe }}\\ \cline{3-{{ passages.count|add:4 }}}
+&& Capacité à évaluer la qualité des échanges (Défenseur⋅se-Opposant⋅e et à trois) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-&& Pertinence des questions & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+&& Réponses aux questions de læ Rapporteur\textperiodcentered{}rice et du jury (fond et capacité à faire avancer le débat) & [0,2] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-& Forme & M\`ene un d\'ebat de fa\c con comp\'etente et propre. & [0,3] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
+& Malus & Attitude irrespectueuse ? & [-3,0] {{ esp|safe }}\\ \cline{2-{{ passages.count|add:4 }}}
-& \multicolumn{3}{|l|}{\bf TOTAL ORAL (/10)} {{ esp|safe }}\\ \hline
+&\multicolumn{3}{|l|}{\bf TOTAL ORAL (/10)} {{ esp|safe }}\\ \hline
 \end{tabular}
 
 \vfill
 
-{% if passages.count == 4 %}
-%%%%%%% INTERVENTION EXCEPTIONNELLE
-\begin{tabular}{|c|p{11cm}|c|p{2cm}|p{2cm}|p{2cm}|p{2cm}|}\hline
-\multicolumn{3}{|l|}{L'{\bf Intervention exceptionnelle} \normalsize permet de signaler une erreur grave omise par tous.} {% for passage in passages.all %}& Passage {{ forloop.counter }} {% endfor %}\\ \hline \hline
-%ORAL
-\multirow{1}{3mm}{\centering\bf O\\ R\\ A\\ L}
-& Toute intervention exceptionnelle non pertinente est sanctionn\'ee par une note n\'egative, l'absence d'intervention re\c coit un z\'ero forfaitaire. \phantom{pour avoir oral en entier dans la} \phantom{colonne il} \phantom{faut blablater un peu}& [-4,4] {{ esp|safe }}\\ \hline
-\end{tabular}
-{% endif %}
-
-
-
 \end{document}

participation/templates/participation/tex/finale.tex

@@ -37,52 +37,36 @@
 
 \Large {\bf \tfjmedition$^{e}$ Tournoi Fran\c cais des Jeunes Math\'ematiciennes et Math\'ematiciens \tfjm}\\
 \vspace{3mm}
-Tour {{ pool.round }} \;-- Poule {{ pool.get_letter_display }}{{ page }} \;-- {% if pool.round == 1 %}{{ pool.tournament.date_start }}{% else %}{{ pool.tournament.date_end }}{% endif %}
+Tour {{ pool.round }} \;-- Poule {{ pool.get_letter_display }}{% if pool.participations.count == 5 %} \;-- {{ pool.get_room_display }}{% endif %} \;-- {% if pool.round == 1 %}{{ pool.tournament.date_start }}{% else %}{{ pool.tournament.date_end }}{% endif %}
 
 
 \vspace{15mm}
 
 
-\begin{tabular}{|p{35mm}{% for passage in passages.all %}{% if passages.count == 3 %}|p{3cm}|p{3cm}{% else %}|p{2.5cm}|p{2.5cm}{% endif %}{% endfor %}|}\hline
+\begin{tabular}{|p{40mm}{% for passage in passages.all %}{% if passages.count == 3 %}|p{3cm}|p{3cm}{% else %}|p{2.5cm}|p{2.5cm}{% endif %}{% endfor %}|}\hline
-\multirow{2}{35mm}{\LARGE R\^ole} {% for passage in passages.all %}& \multicolumn{2}{c|}{ \Large Probl\`eme {{ passage.solution_number }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
+\multirow{2}{40mm}{\LARGE R\^ole} {% for passage in passages.all %}& \multicolumn{2}{c|}{ \Large Probl\`eme {{ passage.solution_number }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
 {% for passage in passages.all %}& \hspace{4mm} {\Large \'ECRIT} & \hspace{4mm} {\Large ORAL}{% endfor %} \\ \hline
 \multirow{2}{35mm}{\LARGE D\'efenseur\textperiodcentered{}se} {% for passage in passages.all %}& \multicolumn{2}{c|}{\Large {{ passage.defender.team.trigram }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
 {% for passage in passages.all %}
 & \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 20$
-& \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 16$
+& \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 20$
 {% endfor %} & \hline
 \multirow{2}{35mm}{\LARGE Opposant\textperiodcentered{}e} {% for passage in passages.all %}& \multicolumn{2}{c|}{\Large {{ passage.opponent.team.trigram }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
 {% for passage in passages.all %}
-& \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 9$
+& \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 10$
 & \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 10$
 {% endfor %} & \hline
-\multirow{2}{35mm}{\LARGE Rapporteur\textperiodcentered{}e} {% for passage in passages.all %}& \multicolumn{2}{c|}{\Large {{ passage.reporter.team.trigram }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
+\multirow{2}{35mm}{\LARGE Rapporteur\textperiodcentered{}rice} {% for passage in passages.all %}& \multicolumn{2}{c|}{\Large {{ passage.reporter.team.trigram }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
 {% for passage in passages.all %}
-& \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 9$
+& \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 10$
 & \phantom{asd asd} \phantom{asd asd} \centering \normalsize$0\leq x\leq 10$
 {% endfor %} & \hline
-{% if passages.count == 4 %}
-\multirow{4}{35mm}{\Large Intervention exceptionnelle}{% for passage in passages.all %} & \multicolumn{2}{c|}{\Large {{ passage.observer.team.trigram }}}{% endfor %} \\ \cline{2-{{ passages.count|add:passages.count|add:1 }}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}\\
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}
-& \multicolumn{2}{c|}{\phantom{asd asd} \phantom{asd asd}}\\
-& \multicolumn{2}{c|}{\centering \normalsize$-4\leq x\leq 4$}
-& \multicolumn{2}{c|}{\centering \normalsize$-4\leq x\leq 4$}
-& \multicolumn{2}{c|}{\centering \normalsize$-4\leq x\leq 4$}
-& \multicolumn{2}{c|}{\centering \normalsize$-4\leq x\leq 4$} & \hline
-{% endif %}
-
 \end{tabular}
 
 \vspace{15mm}
 
 \LARGE Nom jur\'e\textperiodcentered{}e :
-{% if is_jury %}\underline{ {{ user.first_name|safe }} {{ user.last_name|safe }} }{% else %}\underline{\phantom{Phrase suffisamment longue pour le nom}}{% endif %}
+{% if jury %}\underline{ {{ jury.user.first_name|safe }} {{ jury.user.last_name|safe }} }{% else %}\underline{\phantom{Phrase suffisamment longue pour le nom}}{% endif %}
 $\qquad$ Signature : \underline{\phantom{Phrase moins longue}}
 
 \newpage

participation/templates/participation/tournament_detail.html

@@ -9,60 +9,62 @@
         </div>
         <div class="card-body">
             <dl class="row">
-                <dt class="col-xl-6 text-end">{% trans 'organizers'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'organizers'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.organizers.all|join:", " }}</dd>
+                <dd class="col-sm-6">{{ tournament.organizers.all|join:", " }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'size'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'size'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.max_teams }}</dd>
+                <dd class="col-sm-6">{{ tournament.max_teams }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'place'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'place'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.place }}</dd>
+                <dd class="col-sm-6">{{ tournament.place }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'price'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'price'|capfirst %}</dt>
-                <dd class="col-xl-6">{% if tournament.price %}{{ tournament.price }} €{% else %}{% trans "Free" %}{% endif %}</dd>
+                <dd class="col-sm-6">{% if tournament.price %}{{ tournament.price }} €{% else %}{% trans "Free" %}{% endif %}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'remote'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'remote'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.remote|yesno }}</dd>
+                <dd class="col-sm-6">{{ tournament.remote|yesno }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'dates'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'dates'|capfirst %}</dt>
-                <dd class="col-xl-6">{% trans "From" %} {{ tournament.date_start }} {% trans "to" %} {{ tournament.date_end }}</dd>
+                <dd class="col-sm-6">{% trans "From" %} {{ tournament.date_start }} {% trans "to" %} {{ tournament.date_end }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'date of registration closing'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'date of registration closing'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.inscription_limit }}</dd>
+                <dd class="col-sm-6">{{ tournament.inscription_limit }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'date of maximal solution submission'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'date of maximal solution submission'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.solution_limit }}</dd>
+                <dd class="col-sm-6">{{ tournament.solution_limit }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'date of the random draw'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'date of the random draw'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.solutions_draw }}</dd>
+                <dd class="col-sm-6">{{ tournament.solutions_draw }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'date of maximal syntheses submission for the first round'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'date of maximal syntheses submission for the first round'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.syntheses_first_phase_limit }}</dd>
+                <dd class="col-sm-6">{{ tournament.syntheses_first_phase_limit }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'date when solutions of round 2 are available'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'date when solutions of round 2 are available'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.solutions_available_second_phase }}</dd>
+                <dd class="col-sm-6">{{ tournament.solutions_available_second_phase }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'date of maximal syntheses submission for the second round'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'date of maximal syntheses submission for the second round'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.syntheses_second_phase_limit }}</dd>
+                <dd class="col-sm-6">{{ tournament.syntheses_second_phase_limit }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'description'|capfirst %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'description'|capfirst %}</dt>
-                <dd class="col-xl-6">{{ tournament.description }}</dd>
+                <dd class="col-sm-6">{{ tournament.description }}</dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'To contact organizers' %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'To contact organizers' %}</dt>
-                <dd class="col-xl-6"><a href="mailto:{{ tournament.organizers_email }}">{{ tournament.organizers_email }}</a></dd>
+                <dd class="col-sm-6"><a href="mailto:{{ tournament.organizers_email }}">{{ tournament.organizers_email }}</a></dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'To contact juries' %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'To contact juries' %}</dt>
-                <dd class="col-xl-6"><a href="mailto:{{ tournament.jurys_email }}">{{ tournament.jurys_email }}</a></dd>
+                <dd class="col-sm-6"><a href="mailto:{{ tournament.jurys_email }}">{{ tournament.jurys_email }}</a></dd>
 
-                <dt class="col-xl-6 text-end">{% trans 'To contact valid teams' %}</dt>
+                <dt class="col-sm-6 text-sm-end">{% trans 'To contact valid teams' %}</dt>
-                <dd class="col-xl-6"><a href="mailto:{{ tournament.teams_email }}">{{ tournament.teams_email }}</a></dd>
+                <dd class="col-sm-6"><a href="mailto:{{ tournament.teams_email }}">{{ tournament.teams_email }}</a></dd>
             </dl>
         </div>
 
         {% if user.registration.is_admin or user.registration in tournament.organizers.all %}
             <div class="card-footer text-center">
-                <a href="{% url "participation:tournament_update" pk=tournament.pk %}"><button class="btn btn-secondary">{% trans "Edit tournament" %}</button></a>
+                <a class="btn btn-secondary" href="{% url "participation:tournament_update" pk=tournament.pk %}">
-                <a href="{% url "participation:tournament_csv" pk=tournament.pk %}"><button class="btn btn-success">{% trans "Export as CSV" %}</button></a>
+                    <i class="fas fa-edit"></i>
+                    {% trans "Edit tournament" %}
+                </a>
             </div>
         {% endif %}
     </div>
@@ -73,6 +75,14 @@
     <div id="teams_table">
         {% render_table teams %}
     </div>
+    
+    {% if user.registration.is_admin or user.registration in tournament.organizers.all %}
+        <div class="text-center">
+            <a href="{% url "participation:tournament_payments" pk=tournament.pk %}" class="btn btn-secondary">
+                <i class="fas fa-money-bill-wave"></i> {% trans "Access to payments list" %}
+            </a>
+        </div>
+    {% endif %}
 
     {% if pools.data %}
         <hr>
@@ -83,12 +93,6 @@
         </div>
     {% endif %}
 
-    {% if user.registration.is_admin %}
-        <div class="d-grid">
-            <button class="btn gap-0 btn-success" data-bs-toggle="modal" data-bs-target="#addPoolModal">{% trans "Add new pool" %}</button>
-        </div>
-    {% endif %}
-
     {% if notes %}
         <hr>
 
@@ -99,27 +103,159 @@
             <div class="card-body">
                 <ul>
                     {% for participation, note in notes %}
-                        <li><strong>{{ participation.team }} :</strong> {{ note|floatformat }}</li>
+                        <li>
+                            <strong>{{ participation.team }} :</strong> {{ note|floatformat }}
+                            {% if available_notes_2 or user.registration.is_volunteer %}
+                                {% if not tournament.final and participation.mention %}
+                                    — {{ participation.mention }}
+                                {% endif %}
+                                {% if tournament.final and participation.mention_final %}
+                                    — {{ participation.mention_final }}
+                                {% endif %}
+                             {% endif %}
+                            {% if participation.final and not tournament.final %}
+                                <span class="badge badge-sm text-bg-warning">
+                                    <i class="fas fa-medal"></i>
+                                    {% trans "Selected for final tournament" %}
+                                </span>
+                            {% endif %}
+                            {% if user.registration.is_admin or user.registration in tournament.organizers.all %}
+                                {% if team_selectable_for_final == participation %}
+                                    <a href="{% url 'participation:select_team_final' pk=tournament.pk participation_id=participation.pk %}"
+                                       class="badge badge-sm text-bg-success">
+                                        <i class="fas fa-medal"></i>
+                                        {% trans "Select for final tournament" %}
+                                    </a>
+                                {% endif %}
+                            {% endif %}
+                        </li>
                     {% endfor %}
                 </ul>
             </div>
+            {% if user.registration.is_admin or user.registration in tournament.organizers.all %}
+                <div class="card-footer text-center">
+                    <div class="btn-group">
+                        <a href="{% url 'participation:tournament_harmonize' pk=tournament.pk round=1 %}" class="btn btn-secondary">
+                            <i class="fas fa-ranking-star"></i>
+                            {% trans "Harmonize" %} - {% trans "Day" %} 1
+                        </a>
+                        <a href="{% url 'participation:tournament_harmonize' pk=tournament.pk round=2 %}" class="btn btn-secondary">
+                            <i class="fas fa-ranking-star"></i>
+                            {% trans "Harmonize" %} - {% trans "Day" %} 2
+                        </a>
+                    </div>
+                </div>
+                <div class="card-footer text-center">
+                    <div class="btn-group">
+                        {% if not available_notes_1 %}
+                            <a href="{% url 'participation:tournament_publish_notes' pk=tournament.pk round=1 %}" class="btn btn-sm btn-info">
+                                <i class="fas fa-eye"></i>
+                                {% trans "Publish notes for first round" %}
+                            </a>
+                        {% else %}
+                            <a href="{% url 'participation:tournament_publish_notes' pk=tournament.pk round=1 %}?hide" class="btn btn-sm btn-danger">
+                                <i class="fas fa-eye-slash"></i>
+                                {% trans "Unpublish notes for first round" %}
+                            </a>
+                        {% endif %}
+                        {% if not available_notes_2 %}
+                            <a href="{% url 'participation:tournament_publish_notes' pk=tournament.pk round=2 %}" class="btn btn-sm btn-info">
+                                <i class="fas fa-eye"></i>
+                                {% trans "Publish notes for second round" %}
+                            </a>
+                        {% else %}
+                            <a href="{% url 'participation:tournament_publish_notes' pk=tournament.pk round=2 %}?hide" class="btn btn-sm btn-danger">
+                                <i class="fas fa-eye-slash"></i>
+                                {% trans "Unpublish notes for second round" %}
+                            </a>
+                        {% endif %}
+                    </div>
+                </div>
+            {% endif %}
+        </div>
+    {% endif %}
+
+    {% if user.registration.is_admin or user.registration in tournament.organizers.all %}
+        <hr>
+
+        <h3>{% trans "Files available for download" %}</h3>
+
+        <div class="alert alert-warning fade show files-to-download-collapse" id="files-to-download-popup">
+            <h4>IMPORTANT</h4>
+
+            <p>
+                Les fichiers accessibles ci-dessous peuvent contenir des informations personnelles.
+                Par conformité avec le droit européen et par respect de la confidentialité des données
+                des participant⋅es, vous ne devez utiliser ces données que dans un cadre strictement
+                nécessaire en lien avec l'organisation du tournoi.
+            </p>
+
+            <p>
+                De plus, il est de votre responsabilité de supprimer ces fichiers une fois que vous
+                n'en avez plus besoin, notamment à la fin du tournoi.
+            </p>
+
+            <p class="text-center">
+                <button class="btn btn-warning" data-bs-toggle="collapse" href=".files-to-download-collapse"
+                        role="button" aria-expanded="false" aria-controls="files-to-download files-to-download-popup">
+                    Je m'engage à ne pas divulguer les données des participant⋅es
+                    et de les supprimer à l'issue du tournoi
+                </button>
+            </p>
+        </div>
+
+        <div class="card bg-body shadow fade collapse files-to-download-collapse" id="files-to-download">
+            <div class="card-body">
+                <ul>
+                    <li>
+                        <a href="{% url "participation:tournament_csv" pk=tournament.pk %}">
+                            Tableur de données des participant⋅es des équipes validées
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_csv" pk=tournament.pk %}?all">
+                            Tableur de données des participant⋅es de toutes les équipes
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_authorizations" tournament_id=tournament.id %}">
+                            Archive de toutes les autorisations triées par équipe et par personne
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_solutions" tournament_id=tournament.id %}">
+                            Archive de toutes les solutions envoyées triées par équipe
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_solutions" tournament_id=tournament.id %}?sort_by=problem">
+                            Archive de toutes les solutions envoyées triées par problème
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_solutions" tournament_id=tournament.id %}?sort_by=pool">
+                            Archive de toutes les solutions envoyées triées par poule
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_syntheses" tournament_id=tournament.id %}?sort_by=pool">
+                            Archive de toutes les notes de synthèse triées par poule et par passage
+                        </a>
+                    </li>
+                    <li>
+                        <a href="https://docs.google.com/spreadsheets/d/{{ tournament.notes_sheet_id }}/edit">
+                            <i class="fas fa-table"></i>
+                            Tableur de notes sur Google Sheets
+                        </a>
+                    </li>
+                    <li>
+                        <a href="{% url "participation:tournament_notation_sheets" tournament_id=tournament.id %}">
+                            Archive de toutes les feuilles de notes à imprimer triées par poule
+                        </a>
+                    </li>
+                </ul>
+            </div>
         </div>
     {% endif %}
 
-    {% if user.registration.is_admin %}
-        {% trans "Add pool" as modal_title %}
-        {% trans "Add" as modal_button %}
-        {% url "participation:pool_create" as modal_action %}
-        {% include "base_modal.html" with modal_id="addPool" %}
-    {% endif %}
-{% endblock %}
-
-{% block extrajavascript %}
-    <script>
-        document.addEventListener('DOMContentLoaded', () => {
-            {% if user.registration.is_admin %}
-                initModal("addPool", "{% url "participation:pool_create" %}")
-            {% endif %}
-        });
-    </script>
 {% endblock %}

participation/templates/participation/tournament_harmonize.html

@@ -0,0 +1,52 @@
+{% extends "base.html" %}
+
+{% load i18n %}
+
+{% block  content %}
+	<div class="card bg-body shadow">
+        <div class="card-header text-center">
+            <h5>{% trans "Ranking" %}</h5>
+        </div>
+        <div class="card-body">
+            <table class="table table-striped text-center">
+                <thead>
+                    <tr>
+                        <th>{% trans "Rank" %}</th>
+                        <th>{% trans "team"|capfirst %}</th>
+                        <th>{% trans "Note" %}</th>
+                        <th>{% trans "Including bonus / malus" %}</th>
+                        <th>{% trans "Add bonus / malus" %}</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for participation, note in notes %}
+                        <tr>
+                            <td>{{ forloop.counter }}</td>
+                            <td>{{ participation.team }}</td>
+                            <td>{{ note.note|floatformat }}</td>
+                            <td>{% if note.tweak >= 0 %}+{% endif %}{{ note.tweak }}</td>
+                            <td>
+                                <div class="btn-group">
+                                    <a href="{% url 'participation:tournament_harmonize_note' pk=tournament.pk round=round action="add" trigram=participation.team.trigram %}"
+                                       class="btn btn-sm btn-success">
+                                        +1
+                                    </a>
+                                    <a href="{% url 'participation:tournament_harmonize_note' pk=tournament.pk round=round action="remove" trigram=participation.team.trigram %}"
+                                       class="btn btn-sm btn-danger">
+                                        -1
+                                    </a>
+                                </div>
+                            </td>
+                        </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+        <div class="card-footer text-center">
+            <a class="btn btn-secondary" href="{% url 'participation:tournament_detail' pk=tournament.pk %}">
+                <i class="fas fa-arrow-left-long"></i>
+                {% trans "Back to tournament page" %}
+            </a>
+        </div>
+    </div>
+{% endblock %}

participation/templates/participation/tournament_payments.html

@@ -0,0 +1,11 @@
+{% extends "base.html" %}
+
+{% load django_tables2 i18n %}
+
+{% block content %}
+    {% render_table table %}
+
+    <a href="{% url "participation:tournament_detail" pk=tournament.pk %}" class="btn btn-primary">
+        <i class="fas fa-long-arrow-alt-left"></i> {% trans "Back to tournament page" %}
+    </a>
+{% endblock %}

participation/templates/participation/upload_notes.html

@@ -6,9 +6,16 @@
 {% block content %}
     <form method="post" enctype="multipart/form-data">
         <div id="form-content">
+            <div class="alert alert-warning">
+                {% url 'participation:pool_jury' pk=pool.jury as jury_url %}
+                {% blocktrans trimmed with jury_url=jury_url %}
+                    Rows that are full of zeros are ignored.
+                    Unknown juries are not considered.
+                {% endblocktrans %}
+            </div>
             <div class="alert alert-info">
                 <a class="alert-link" href="{% url "participation:pool_notes_template" pk=pool.pk %}">
-                {% trans "Download empty notation sheet" %}
+                    {% trans "Download empty notation sheet" %}
                 </a>
             </div>
             {% csrf_token %}

participation/templates/participation/upload_synthesis.html

@@ -7,9 +7,10 @@
         <div id="form-content">
             <div class="alert alert-info">
                 {% trans "Templates:" %}
-                <a class="alert-link" href="{% static "Fiche_synthèse.pdf" %}"> PDF</a> —
+                <a class="alert-link" href="{% static "tfjm/Fiche_synthèse.pdf" %}"> PDF</a> —
-                <a class="alert-link" href="{% static "Fiche_synthèse.tex" %}"> TEX</a> —
+                <a class="alert-link" href="{% static "tfjm/Fiche_synthèse.tex" %}"> TEX</a> —
-                <a class="alert-link" href="{% static "Fiche_synthèse.docx" %}" title="{% trans "Warning: non-free format" %}"> DOCX</a>
+                <a class="alert-link" href="{% static "tfjm/Fiche_synthèse.odt" %}"> ODT</a> —
+                <a class="alert-link" href="{% static "tfjm/Fiche_synthèse.docx" %}" title="{% trans "Warning: non-free format" %}"> DOCX</a>
             </div>
             {% csrf_token %}
             {{ form|crispy }}

participation/tests.py

@@ -4,10 +4,12 @@
 from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.sites.models import Site
+from django.core import mail
+from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.management import call_command
-from django.test import TestCase
+from django.test import LiveServerTestCase, override_settings, TestCase
 from django.urls import reverse
-from registration.models import CoachRegistration, StudentRegistration
+from registration.models import CoachRegistration, Payment, StudentRegistration
 
 from .models import Participation, Team, Tournament
 
@@ -515,6 +517,616 @@ class TestStudentParticipation(TestCase):
         self.assertEqual(resp.status_code, 403)
 
 
+class TestPayment(TestCase):
+    """
+    Tests that are relative to a payment
+    """
+
+    def setUp(self):
+        self.superuser = User.objects.create_superuser(
+            username="admin",
+            email="admin@example.com",
+            password="admin",
+        )
+        self.tournament = Tournament.objects.create(
+            name="France",
+            place="Here",
+            price=21,
+        )
+        self.team = Team.objects.create(
+            name="Super team",
+            trigram="AAA",
+            access_code="azerty",
+        )
+        self.user = User.objects.create(
+            first_name="Toto",
+            last_name="Toto",
+            email="toto@example.com",
+            password="toto",
+        )
+        StudentRegistration.objects.create(
+            user=self.user,
+            team=self.team,
+            student_class=12,
+            address="1 Rue de Rivoli",
+            zip_code=75001,
+            city="Paris",
+            school="Earth",
+            give_contact_to_animath=True,
+            email_confirmed=True,
+        )
+        self.second_user = User.objects.create(
+            first_name="Lalala",
+            last_name="Lalala",
+            email="lalala@example.com",
+            password="lalala",
+        )
+        StudentRegistration.objects.create(
+            user=self.second_user,
+            team=self.team,
+            student_class=11,
+            address="1 Rue de Rivoli",
+            zip_code=75001,
+            city="Paris",
+            school="Moon",
+            give_contact_to_animath=True,
+            email_confirmed=True,
+        )
+        self.coach = User.objects.create(
+            first_name="Coach",
+            last_name="Coach",
+            email="coach@example.com",
+            password="coach",
+        )
+        CoachRegistration.objects.create(
+            user=self.coach,
+            team=self.team,
+            address="1 Rue de Rivoli",
+            zip_code=75001,
+            city="Paris",
+        )
+
+        self.team.participation.tournament = self.tournament
+        self.team.participation.valid = True
+        self.team.participation.save()
+        self.client.force_login(self.user)
+
+    def test_check_payments_exists(self):
+        """
+        Check that users in a validated team have an invalid payment, but not for the final,
+        and that coaches are not concerned.
+        """
+        self.assertTrue(Payment.objects.filter(final=False, valid=False, type='',
+                                               registrations=self.user.registration).exists())
+        self.assertTrue(Payment.objects.filter(final=False, valid=False, type='',
+                                               registrations=self.second_user.registration).exists())
+        self.assertFalse(Payment.objects.filter(final=False, valid=False, type='',
+                                                registrations=self.coach.registration).exists())
+
+        self.assertFalse(Payment.objects.filter(final=True, valid=False, type='',
+                                                registrations=self.user.registration).exists())
+        self.assertFalse(Payment.objects.filter(final=True, valid=False, type='',
+                                                registrations=self.second_user.registration).exists())
+        self.assertFalse(Payment.objects.filter(final=True, valid=False, type='',
+                                                registrations=self.coach.registration).exists())
+
+    def test_load_payment_page(self):
+        """
+        Ensure that the payment page loads correctly.
+        """
+        response = self.client.get(reverse('participation:team_detail', args=(self.team.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.get(reverse('registration:user_detail', args=(self.user.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.get(reverse('participation:tournament_payments', args=(self.tournament.pk,)))
+        self.assertEqual(response.status_code, 403)
+
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+    def test_bank_transfer_payment(self):
+        """
+        Try to send a bank transfer.
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "bank_transfer",
+                                          'additional_information': "This is a bank transfer"})
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'receipt',
+                             ["This field is required.", "You must upload your receipt."])
+        payment.refresh_from_db()
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+
+        # README is not a valid PDF file
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "bank_transfer",
+                                          'additional_information': "This is a bank transfer",
+                                          'receipt': open("README.md", "rb")})
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'receipt',
+                             ["The uploaded file must be a PDF, PNG of JPEG file."])
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+
+        # Don't send too large files
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "bank_transfer",
+                                          'additional_information': "This is a bank transfer",
+                                          'receipt': SimpleUploadedFile(
+                                              "file.pdf",
+                                              content=int(0).to_bytes(2000001, "big"),
+                                              content_type="application/pdf"),
+                                          })
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'receipt',
+                             ["The uploaded file size must be under 2 Mo."])
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "bank_transfer",
+                                          'additional_information': "This is a bank transfer",
+                                          'receipt': open("tfjm/static/Fiche_sanitaire.pdf", "rb")})
+        self.assertRedirects(response, reverse('participation:team_detail', args=(self.team.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertIsNone(payment.valid)
+        self.assertEqual(payment.type, "bank_transfer")
+        self.assertEqual(payment.additional_information, "This is a bank transfer")
+        self.assertIsNotNone(payment.receipt)
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+    def test_scholarship(self):
+        """
+        Try to don't pay because of a scholarship.
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "scholarship",
+                                          'additional_information': "I don't have to pay because I have a scholarship"})
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'receipt',
+                             ["This field is required.", "You must upload your receipt."])
+        payment.refresh_from_db()
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+        self.assertEqual(payment.amount, self.tournament.price)
+
+        # README is not a valid PDF file
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "scholarship",
+                                          'additional_information': "I don't have to pay because I have a scholarship",
+                                          'receipt': open("README.md", "rb")})
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'receipt',
+                             ["The uploaded file must be a PDF, PNG of JPEG file."])
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+        self.assertEqual(payment.amount, self.tournament.price)
+
+        # Don't send too large files
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "scholarship",
+                                          'additional_information': "I don't have to pay because I have a scholarship",
+                                          'receipt': SimpleUploadedFile(
+                                              "file.pdf",
+                                              content=int(0).to_bytes(2000001, "big"),
+                                              content_type="application/pdf"),
+                                          })
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'receipt',
+                             ["The uploaded file size must be under 2 Mo."])
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+        self.assertEqual(payment.amount, self.tournament.price)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "scholarship",
+                                          'additional_information': "I don't have to pay because I have a scholarship",
+                                          'receipt': open("tfjm/static/Fiche_sanitaire.pdf", "rb")})
+        self.assertRedirects(response, reverse('participation:team_detail', args=(self.team.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertIsNone(payment.valid)
+        self.assertEqual(payment.type, "scholarship")
+        self.assertEqual(payment.additional_information, "I don't have to pay because I have a scholarship")
+        self.assertIsNotNone(payment.receipt)
+        self.assertEqual(payment.amount, 0)
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+    def test_other(self):
+        """
+        Try to send a different type of payment.
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "other"})
+        self.assertEqual(response.status_code, 200)
+        self.assertFormError(response.context['form'], 'additional_information',
+                             ["This field is required."])
+        payment.refresh_from_db()
+        self.assertFalse(payment.valid)
+        self.assertEqual(payment.type, "")
+        self.assertEqual(payment.amount, self.tournament.price)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'type': "other",
+                                          'additional_information': "Why should I pay"})
+        self.assertRedirects(response, reverse('participation:team_detail', args=(self.team.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertIsNone(payment.valid)
+        self.assertEqual(payment.type, "other")
+        self.assertEqual(payment.additional_information, "Why should I pay")
+        self.assertIsNotNone(payment.receipt)
+        self.assertEqual(payment.amount, self.tournament.price)
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+    def test_group(self):
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        self.assertFalse(payment.grouped)
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.get(reverse('registration:update_payment_group_mode', args=(payment.pk,)))
+        self.assertRedirects(response, reverse('registration:update_payment', args=(payment.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertTrue(payment.grouped)
+        self.assertEqual(Payment.objects.count(), 1)
+        self.assertIn(self.user.registration, payment.registrations.all())
+        self.assertIn(self.second_user.registration, payment.registrations.all())
+        self.assertEqual(payment.amount, 2 * self.tournament.price)
+
+    def test_ungroup(self):
+        """
+        Test to ungroup payments
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        self.client.get(reverse('registration:update_payment_group_mode', args=(payment.pk,)))
+        payment.refresh_from_db()
+        self.assertTrue(payment.grouped)
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.get(reverse('registration:update_payment_group_mode', args=(payment.pk,)))
+        self.assertRedirects(response, reverse('registration:update_payment', args=(payment.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertFalse(payment.grouped)
+        self.assertEqual(Payment.objects.count(), 2)
+        self.assertIn(self.user.registration, payment.registrations.all())
+        self.assertNotIn(self.second_user.registration, payment.registrations.all())
+        self.assertEqual(payment.amount, self.tournament.price)
+
+    def test_group_forbidden(self):
+        """
+        Payment grouping is forbidden if at least one payment is already valid.
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        payment.valid = True
+        payment.save()
+        payment2 = Payment.objects.get(registrations=self.second_user.registration, final=False)
+        response = self.client.get(reverse('registration:update_payment_group_mode', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 403)
+
+        response = self.client.get(reverse('registration:update_payment_group_mode', args=(payment2.pk,)))
+        self.assertEqual(response.status_code, 403)
+
+    def test_validate_payment(self):
+        """
+        Try to validate a payment.
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        payment.type = "other"
+        payment.valid = None
+        payment.save()
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'valid': True})
+        self.assertEqual(response.status_code, 403)
+        self.assertFalse(payment.valid)
+
+        self.client.force_login(self.superuser)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'valid': True})
+        self.assertRedirects(response, reverse('participation:team_detail', args=(self.team.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertTrue(payment.valid)
+
+    def test_invalidate_payment(self):
+        """
+        Try to invalidate a payment.
+        """
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        payment.type = "other"
+        payment.valid = None
+        payment.save()
+
+        response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+        self.assertEqual(response.status_code, 200)
+
+        self.client.force_login(self.superuser)
+
+        response = self.client.post(reverse('registration:update_payment', args=(payment.pk,)),
+                                    data={'valid': False})
+        self.assertRedirects(response, reverse('participation:team_detail', args=(self.team.pk,)), 302, 200)
+        payment.refresh_from_db()
+        self.assertFalse(payment.valid)
+
+    def test_payment_reminder(self):
+        """
+        Check that the payment reminder command works correctly.
+        """
+        self.assertEqual(len(mail.outbox), 0)
+
+        call_command('remind_payments')
+        self.assertEqual(len(mail.outbox), 2)
+        self.assertEqual(mail.outbox[0].subject, "[TFJM²] Rappel pour votre paiement")
+
+        payment = Payment.objects.get(registrations=self.user.registration, final=False)
+        payment2 = Payment.objects.get(registrations=self.second_user.registration, final=False)
+        payment.type = 'other'
+        payment.valid = True
+        payment.save()
+        payment2.type = 'bank_transfer'
+        payment2.valid = None
+        payment2.save()
+
+        mail.outbox = []
+        call_command('remind_payments')
+        self.assertEqual(len(mail.outbox), 0)
+
+
+@override_settings(HELLOASSO_TEST_ENDPOINT=True, ROOT_URLCONF="tfjm.helloasso.test_urls")
+class TestHelloAssoPayment(LiveServerTestCase):
+    """
+    Tests that are relative to a HelloAsso
+    """
+
+    def setUp(self):
+        self.superuser = User.objects.create_superuser(
+            username="admin",
+            email="admin@example.com",
+            password="admin",
+        )
+        self.tournament = Tournament.objects.create(
+            name="France",
+            place="Here",
+            price=21,
+        )
+        self.team = Team.objects.create(
+            name="Super team",
+            trigram="AAA",
+            access_code="azerty",
+        )
+        self.user = User.objects.create(
+            first_name="Toto",
+            last_name="Toto",
+            email="toto@example.com",
+            password="toto",
+        )
+        StudentRegistration.objects.create(
+            user=self.user,
+            team=self.team,
+            student_class=12,
+            address="1 Rue de Rivoli",
+            zip_code=75001,
+            city="Paris",
+            school="Earth",
+            give_contact_to_animath=True,
+            email_confirmed=True,
+        )
+        self.coach = User.objects.create(
+            first_name="Coach",
+            last_name="Coach",
+            email="coach@example.com",
+            password="coach",
+        )
+        CoachRegistration.objects.create(
+            user=self.coach,
+            team=self.team,
+            address="1 Rue de Rivoli",
+            zip_code=75001,
+            city="Paris",
+        )
+
+        self.team.participation.tournament = self.tournament
+        self.team.participation.valid = True
+        self.team.participation.save()
+        self.client.force_login(self.user)
+
+        Site.objects.update(domain=self.live_server_url.replace("http://", ""))
+
+    def test_create_checkout_intent(self):
+        with self.settings(HELLOASSO_TEST_ENDPOINT_URL=self.live_server_url):
+            payment = Payment.objects.get(registrations=self.user.registration, final=False)
+            checkout_intent = payment.create_checkout_intent()
+
+            self.assertIsNotNone(checkout_intent)
+            self.assertEqual(checkout_intent['metadata'], {
+                'payment_id': payment.pk,
+                'users': [
+                    {
+                        'user_id': self.user.pk,
+                        'first_name': self.user.first_name,
+                        'last_name': self.user.last_name,
+                        'email': self.user.email,
+                    }
+                ],
+                'final': False,
+                'tournament_id': self.tournament.pk,
+            })
+            self.assertNotIn('order', checkout_intent)
+
+            checkout_intent_fetched = payment.get_checkout_intent()
+            self.assertEqual(checkout_intent, checkout_intent_fetched)
+
+            # Don't create a new checkout intent if one already exists
+            checkout_intent_new = payment.create_checkout_intent()
+            self.assertEqual(checkout_intent, checkout_intent_new)
+
+            payment.refresh_from_db()
+            self.assertEqual(payment.checkout_intent_id, checkout_intent['id'])
+            self.assertFalse(payment.valid)
+
+    def test_helloasso_payment_success(self):
+        """
+        Simulates the redirection to Hello Asso and the return for a successful payment.
+        """
+        with self.settings(HELLOASSO_TEST_ENDPOINT_URL=self.live_server_url):
+            payment = Payment.objects.get(registrations=self.user.registration, final=False)
+            self.assertIsNone(payment.checkout_intent_id)
+            self.assertFalse(payment.valid)
+
+            response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+            self.assertEqual(response.status_code, 200)
+
+            response = self.client.get(reverse('registration:payment_hello_asso', args=(payment.pk,)),
+                                       follow=True)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.redirect_chain[-1],
+                             (reverse('participation:team_detail', args=(self.team.pk,)), 302))
+            self.assertIn("type=return", response.redirect_chain[1][0])
+            self.assertIn("code=succeeded", response.redirect_chain[1][0])
+
+            payment.refresh_from_db()
+            self.assertIsNotNone(payment.checkout_intent_id)
+            self.assertTrue(payment.valid)
+
+            checkout_intent = payment.get_checkout_intent()
+            self.assertIn('order', checkout_intent)
+
+    def test_helloasso_payment_refused(self):
+        """
+        Simulates the redirection to Hello Asso and the return for a refused payment.
+        """
+        with self.settings(HELLOASSO_TEST_ENDPOINT_URL=self.live_server_url):
+            payment = Payment.objects.get(registrations=self.user.registration, final=False)
+            checkout_intent = payment.create_checkout_intent()
+            self.assertFalse(payment.valid)
+
+            response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+            self.assertEqual(response.status_code, 200)
+
+            response = self.client.get(checkout_intent['redirectUrl'] + "?refused", follow=True)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.redirect_chain[-1],
+                             (reverse('registration:update_payment', args=(payment.pk,)), 302))
+            self.assertIn("type=return", response.redirect_chain[0][0])
+            self.assertIn("code=refused", response.redirect_chain[0][0])
+
+            payment.refresh_from_db()
+            self.assertFalse(payment.valid)
+
+            checkout_intent = payment.get_checkout_intent()
+            self.assertNotIn('order', checkout_intent)
+
+    def test_helloasso_payment_error(self):
+        """
+        Simulates the redirection to Hello Asso and the return for an errored payment.
+        """
+        with self.settings(HELLOASSO_TEST_ENDPOINT_URL=self.live_server_url):
+            payment = Payment.objects.get(registrations=self.user.registration, final=False)
+            checkout_intent = payment.create_checkout_intent()
+            self.assertFalse(payment.valid)
+
+            response = self.client.get(reverse('registration:update_payment', args=(payment.pk,)))
+            self.assertEqual(response.status_code, 200)
+
+            response = self.client.get(checkout_intent['redirectUrl'] + "?error", follow=True)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.redirect_chain[-1],
+                             (reverse('registration:update_payment', args=(payment.pk,)), 302))
+            self.assertIn("type=error", response.redirect_chain[0][0])
+            self.assertIn("error=", response.redirect_chain[0][0])
+
+            payment.refresh_from_db()
+            self.assertFalse(payment.valid)
+
+            checkout_intent = payment.get_checkout_intent()
+            self.assertNotIn('order', checkout_intent)
+
+    def test_anonymous_payment(self):
+        """
+        Test to make a successful payment from an anonymous user, authenticated by token.
+        """
+        self.client.logout()
+
+        with self.settings(HELLOASSO_TEST_ENDPOINT_URL=self.live_server_url):
+            payment = Payment.objects.get(registrations=self.user.registration, final=False)
+            self.assertIsNone(payment.checkout_intent_id)
+            self.assertFalse(payment.valid)
+
+            response = self.client.get(reverse('registration:payment_hello_asso', args=(payment.pk,)),
+                                       follow=True)
+            self.assertRedirects(response,
+                                 f"{reverse('login')}?next="
+                                 f"{reverse('registration:payment_hello_asso', args=(payment.pk,))}")
+
+            response = self.client.get(
+                reverse('registration:payment_hello_asso', args=(payment.pk,)) + "?token=" + payment.token,
+                follow=True)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.redirect_chain[-1], (reverse('index'), 302))
+            self.assertIn("type=return", response.redirect_chain[1][0])
+            self.assertIn("code=succeeded", response.redirect_chain[1][0])
+
+            payment.refresh_from_db()
+            self.assertIsNotNone(payment.checkout_intent_id)
+            self.assertTrue(payment.valid)
+
+            checkout_intent = payment.get_checkout_intent()
+            self.assertIn('order', checkout_intent)
+
+    def test_hello_asso_payment_verification(self):
+        """
+        Check that a payment that is pending verification can be verified.
+        """
+        with self.settings(HELLOASSO_TEST_ENDPOINT_URL=self.live_server_url):
+            payment = Payment.objects.get(registrations=self.user.registration, final=False)
+            self.assertFalse(payment.valid)
+
+            call_command('check_hello_asso')
+            payment.refresh_from_db()
+            self.assertFalse(payment.valid)
+
+            self.client.get(reverse('registration:payment_hello_asso', args=(payment.pk,)),
+                            follow=True)
+
+            payment.refresh_from_db()
+            payment.valid = None
+            payment.additional_information = ""
+            payment.save()
+            self.assertIsNone(payment.valid)
+
+            call_command('check_hello_asso')
+            payment.refresh_from_db()
+            self.assertTrue(payment.valid)
+            self.assertTrue(payment.additional_information)
+
+
 class TestAdmin(TestCase):
     def setUp(self) -> None:
         self.user = User.objects.create_superuser(

participation/urls.py

@@ -2,15 +2,17 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from django.urls import path
-from django.views.generic import TemplateView
 
-from .views import CreateTeamView, FinalNotationSheetTemplateView, JoinTeamView, MyParticipationDetailView, \
+from .views import CreateTeamView, FinalNotationSheetTemplateView, GSheetNotificationsView, JoinTeamView, \
-    MyTeamDetailView, NoteUpdateView, ParticipationDetailView, PassageCreateView, PassageDetailView, \
+    MyParticipationDetailView, MyTeamDetailView, NotationSheetsArchiveView, NoteUpdateView, ParticipationDetailView, \
-    PassageUpdateView, PoolAddJurysView, PoolCreateView, PoolDetailView, PoolDownloadView, PoolNotesTemplateView, \
+    PassageDetailView, PassageUpdateView, PoolCreateView, PoolDetailView, PoolJuryView, PoolNotesTemplateView, \
-    PoolUpdateTeamsView, PoolUpdateView, PoolUploadNotesView, ScaleNotationSheetTemplateView, SolutionUploadView, \
+    PoolPresideJuryView, PoolRemoveJuryView, PoolUpdateView, PoolUploadNotesView, \
-    SynthesisUploadView, TeamAuthorizationsView, TeamDetailView, TeamLeaveView, TeamListView, TeamUpdateView, \
+    ScaleNotationSheetTemplateView, SelectTeamFinalView, \
+    SolutionsDownloadView, SolutionUploadView, SynthesisUploadView, \
+    TeamAuthorizationsView, TeamDetailView, TeamLeaveView, TeamListView, TeamUpdateView, \
     TeamUploadMotivationLetterView, TournamentCreateView, TournamentDetailView, TournamentExportCSVView, \
-    TournamentListView, TournamentUpdateView
+    TournamentHarmonizeNoteView, TournamentHarmonizeView, TournamentListView, TournamentPaymentsView, \
+    TournamentPublishNotesView, TournamentUpdateView
 
 
 app_name = "participation"
@@ -24,31 +26,51 @@ urlpatterns = [
     path("team/<int:pk>/update/", TeamUpdateView.as_view(), name="update_team"),
     path("team/<int:pk>/upload-motivation-letter/", TeamUploadMotivationLetterView.as_view(),
          name="upload_team_motivation_letter"),
-    path("team/<int:pk>/authorizations/", TeamAuthorizationsView.as_view(), name="team_authorizations"),
+    path("team/<int:team_id>/authorizations/", TeamAuthorizationsView.as_view(), name="team_authorizations"),
     path("team/leave/", TeamLeaveView.as_view(), name="team_leave"),
     path("detail/", MyParticipationDetailView.as_view(), name="my_participation_detail"),
     path("detail/<int:pk>/", ParticipationDetailView.as_view(), name="participation_detail"),
     path("detail/<int:pk>/solution/", SolutionUploadView.as_view(), name="upload_solution"),
+    path("detail/<int:team_id>/solutions/", SolutionsDownloadView.as_view(), name="participation_solutions"),
     path("tournament/", TournamentListView.as_view(), name="tournament_list"),
     path("tournament/create/", TournamentCreateView.as_view(), name="tournament_create"),
     path("tournament/<int:pk>/", TournamentDetailView.as_view(), name="tournament_detail"),
     path("tournament/<int:pk>/update/", TournamentUpdateView.as_view(), name="tournament_update"),
+    path("tournament/<int:pk>/payments/", TournamentPaymentsView.as_view(), name="tournament_payments"),
     path("tournament/<int:pk>/csv/", TournamentExportCSVView.as_view(), name="tournament_csv"),
+    path("tournament/<int:tournament_id>/authorizations/", TeamAuthorizationsView.as_view(),
+         name="tournament_authorizations"),
+    path("tournament/<int:tournament_id>/solutions/", SolutionsDownloadView.as_view(),
+         name="tournament_solutions"),
+    path("tournament/<int:tournament_id>/syntheses/", SolutionsDownloadView.as_view(),
+         name="tournament_syntheses"),
+    path("tournament/<int:tournament_id>/notation/sheets/", NotationSheetsArchiveView.as_view(),
+         name="tournament_notation_sheets"),
+    path("tournament/<int:pk>/notation/notifications/", GSheetNotificationsView.as_view(),
+         name="tournament_gsheet_notifications"),
+    path("tournament/<int:pk>/publish-notes/<int:round>/", TournamentPublishNotesView.as_view(),
+         name="tournament_publish_notes"),
+    path("tournament/<int:pk>/harmonize/<int:round>/", TournamentHarmonizeView.as_view(),
+         name="tournament_harmonize"),
+    path("tournament/<int:pk>/harmonize/<int:round>/<str:action>/<str:trigram>/", TournamentHarmonizeNoteView.as_view(),
+         name="tournament_harmonize_note"),
+    path("tournament/<int:pk>/select-final/<int:participation_id>/", SelectTeamFinalView.as_view(),
+         name="select_team_final"),
     path("pools/create/", PoolCreateView.as_view(), name="pool_create"),
     path("pools/<int:pk>/", PoolDetailView.as_view(), name="pool_detail"),
     path("pools/<int:pk>/update/", PoolUpdateView.as_view(), name="pool_update"),
-    path("pools/<int:pk>/solutions/", PoolDownloadView.as_view(), name="pool_download_solutions"),
+    path("pools/<int:pool_id>/solutions/", SolutionsDownloadView.as_view(), name="pool_download_solutions"),
-    path("pools/<int:pk>/syntheses/", PoolDownloadView.as_view(), name="pool_download_syntheses"),
+    path("pools/<int:pool_id>/syntheses/", SolutionsDownloadView.as_view(), name="pool_download_syntheses"),
     path("pools/<int:pk>/notation/scale/", ScaleNotationSheetTemplateView.as_view(), name="pool_scale_note_sheet"),
     path("pools/<int:pk>/notation/final/", FinalNotationSheetTemplateView.as_view(), name="pool_final_note_sheet"),
-    path("pools/<int:pk>/update-teams/", PoolUpdateTeamsView.as_view(), name="pool_update_teams"),
+    path("pools/<int:pool_id>/notation/sheets/", NotationSheetsArchiveView.as_view(), name="pool_notation_sheets"),
-    path("pools/<int:pk>/add-jurys/", PoolAddJurysView.as_view(), name="pool_add_jurys"),
+    path("pools/<int:pk>/jury/", PoolJuryView.as_view(), name="pool_jury"),
+    path("pools/<int:pk>/jury/remove/<int:jury_id>/", PoolRemoveJuryView.as_view(), name="pool_remove_jury"),
+    path("pools/<int:pk>/jury/preside/<int:jury_id>/", PoolPresideJuryView.as_view(), name="pool_preside"),
     path("pools/<int:pk>/upload-notes/", PoolUploadNotesView.as_view(), name="pool_upload_notes"),
     path("pools/<int:pk>/upload-notes/template/", PoolNotesTemplateView.as_view(), name="pool_notes_template"),
-    path("pools/passages/add/<int:pk>/", PassageCreateView.as_view(), name="passage_create"),
     path("pools/passages/<int:pk>/", PassageDetailView.as_view(), name="passage_detail"),
     path("pools/passages/<int:pk>/update/", PassageUpdateView.as_view(), name="passage_update"),
     path("pools/passages/<int:pk>/solution/", SynthesisUploadView.as_view(), name="upload_synthesis"),
     path("pools/passages/notes/<int:pk>/", NoteUpdateView.as_view(), name="update_notes"),
-    path("chat/", TemplateView.as_view(template_name="participation/chat.html"), name="chat")
 ]

registration/admin.py

@@ -3,13 +3,45 @@
 
 from django.contrib import admin
 from django.contrib.admin import ModelAdmin
+from django.contrib.auth.admin import UserAdmin
+from django.contrib.auth.models import User
 from django.utils.translation import gettext_lazy as _
-from polymorphic.admin import PolymorphicChildModelAdmin, PolymorphicChildModelFilter, PolymorphicParentModelAdmin
+from polymorphic.admin import PolymorphicChildModelAdmin, PolymorphicChildModelFilter, PolymorphicInlineSupportMixin, \
+    PolymorphicParentModelAdmin, StackedPolymorphicInline
 
 from .models import CoachRegistration, ParticipantRegistration, Payment, Registration, \
     StudentRegistration, VolunteerRegistration
 
 
+class RegistrationInline(StackedPolymorphicInline):
+    class StudentRegistrationInline(StackedPolymorphicInline.Child):
+        model = StudentRegistration
+        autocomplete_fields = ('team',)
+        show_change_link = True
+
+    class CoachRegistrationInline(StackedPolymorphicInline.Child):
+        model = CoachRegistration
+        autocomplete_fields = ('team',)
+        show_change_link = True
+
+    class VolunteerRegistrationInline(StackedPolymorphicInline.Child):
+        model = VolunteerRegistration
+        show_change_link = True
+
+    model = Registration
+    child_inlines = (
+        StudentRegistrationInline,
+        CoachRegistrationInline,
+        VolunteerRegistrationInline,
+    )
+
+
+class PaymentInline(admin.TabularInline):
+    model = Payment
+    extra = 0
+    autocomplete_fields = ('registrations',)
+
+
 @admin.register(Registration)
 class RegistrationAdmin(PolymorphicParentModelAdmin):
     child_models = (StudentRegistration, CoachRegistration, VolunteerRegistration,)
@@ -97,11 +129,34 @@ class VolunteerRegistrationAdmin(PolymorphicChildModelAdmin):
 
 @admin.register(Payment)
 class PaymentAdmin(ModelAdmin):
-    list_display = ('registration', 'registration_type', 'type', 'valid', )
+    list_display = ('concerned_people', 'tournament', 'team', 'grouped', 'type', 'amount', 'final', 'valid', )
-    search_fields = ('registration__user__last_name', 'registration__user__first_name', 'registration__user__email',)
+    search_fields = ('registrations__user__last_name', 'registrations__user__first_name', 'registrations__user__email',
-    list_filter = ('registration__team__participation__valid', 'type', 'type', 'valid',)
+                     'registrations__team__name', 'registrations__team__participation__team__trigram',)
-    autocomplete_fields = ('registration',)
+    list_filter = ('registrations__team__participation__valid', 'type',
+                   'grouped', 'valid', 'registrations__team__participation__tournament', 'final',)
+    autocomplete_fields = ('registrations',)
+    actions = ('mark_as_valid', 'mark_as_pending', 'mark_as_invalid',)
 
-    @admin.display(description=_('registration type'), ordering='registration__polymorphic_ctype')
+    @admin.display(description=_('concerned people'))
-    def registration_type(self, record: Payment):
+    def concerned_people(self, record: Payment):
-        return record.registration.get_real_instance().type
+        return ", ".join(f"{reg.user.first_name} {reg.user.last_name}" for reg in record.registrations.all())
+
+    @admin.action(description=_('Mark as valid'))
+    def mark_as_valid(self, request, queryset):
+        queryset.update(valid=True)
+
+    @admin.action(description=_('Mark as pending'))
+    def mark_as_pending(self, request, queryset):
+        queryset.update(valid=None)
+
+    @admin.action(description=_('Mark as invalid'))
+    def mark_as_invalid(self, request, queryset):
+        queryset.update(valid=False)
+
+
+admin.site.unregister(User)
+
+
+@admin.register(User)
+class UserCustomAdmin(PolymorphicInlineSupportMixin, UserAdmin):
+    inlines = [RegistrationInline]

registration/api/serializers.py

@@ -1,11 +1,12 @@
 # Copyright (C) 2020 by Animath
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+from django.contrib.auth.models import User
 from rest_framework import serializers
 from rest_polymorphic.serializers import PolymorphicSerializer
 
 from ..models import CoachRegistration, ParticipantRegistration, \
-    StudentRegistration, VolunteerRegistration
+    Payment, StudentRegistration, VolunteerRegistration
 
 
 class CoachSerializer(serializers.ModelSerializer):
@@ -38,3 +39,15 @@ class RegistrationSerializer(PolymorphicSerializer):
         StudentRegistration: StudentSerializer,
         VolunteerRegistration: VolunteerSerializer,
     }
+
+
+class PaymentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Payment
+        fields = '__all__'
+
+
+class BasicUserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ['id', 'first_name', 'last_name', 'email', ]

registration/api/urls.py

@@ -1,11 +1,13 @@
 # Copyright (C) 2020 by Animath
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from .views import RegistrationViewSet
+from .views import PaymentViewSet, RegistrationViewSet, VolunteersViewSet
 
 
 def register_registration_urls(router, path):
     """
     Configure router for registration REST API.
     """
+    router.register(path + "/payment", PaymentViewSet)
     router.register(path + "/registration", RegistrationViewSet)
+    router.register(path + "/volunteers", VolunteersViewSet)

registration/api/views.py

@@ -1,11 +1,14 @@
 # Copyright (C) 2020 by Animath
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+from django.contrib.auth.models import User
 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.viewsets import ModelViewSet
+from rest_framework.filters import SearchFilter
+from rest_framework.permissions import BasePermission, IsAdminUser, IsAuthenticated, SAFE_METHODS
+from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
 
-from .serializers import RegistrationSerializer
+from .serializers import BasicUserSerializer, PaymentSerializer, RegistrationSerializer
-from ..models import Registration
+from ..models import Payment, Registration
 
 
 class RegistrationViewSet(ModelViewSet):
@@ -13,3 +16,25 @@ class RegistrationViewSet(ModelViewSet):
     serializer_class = RegistrationSerializer
     filter_backends = [DjangoFilterBackend]
     filterset_fields = ['user', 'participantregistration__team', ]
+
+
+class PaymentViewSet(ModelViewSet):
+    queryset = Payment.objects.all()
+    serializer_class = PaymentSerializer
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['registrations', 'grouped', 'amount', 'final', 'type', 'valid', ]
+
+
+class IsTournamentOrganizer(BasePermission):
+    def has_permission(self, request, view):
+        reg = request.user.registration
+        return request.method in SAFE_METHODS and reg.is_volunteer and reg.organized_tournaments.exists()
+
+
+class VolunteersViewSet(ReadOnlyModelViewSet):
+    queryset = User.objects.filter(registration__volunteerregistration__isnull=False)
+    serializer_class = BasicUserSerializer
+    permission_classes = [IsAdminUser | (IsAuthenticated & IsTournamentOrganizer)]
+    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filterset_fields = ['first_name', 'last_name', 'email', ]
+    search_fields = ['$first_name', '$last_name', '$email', ]

registration/apps.py

@@ -12,11 +12,8 @@ class RegistrationConfig(AppConfig):
     name = 'registration'
 
     def ready(self):
-        from registration.signals import create_admin_registration, create_payment, \
+        from registration import signals
-            set_username, send_email_link
+        pre_save.connect(signals.set_username, 'auth.User')
-        pre_save.connect(set_username, "auth.User")
+        pre_save.connect(signals.send_email_link, 'auth.User')
-        pre_save.connect(send_email_link, "auth.User")
+        pre_save.connect(signals.update_payment_amount, 'registration.Payment')
-        post_save.connect(create_admin_registration, "auth.User")
+        post_save.connect(signals.create_admin_registration, 'auth.User')
-        post_save.connect(create_payment, "registration.Registration")
-        post_save.connect(create_payment, "registration.StudentRegistration")
-        post_save.connect(create_payment, "registration.CoachRegistration")

registration/forms.py

@@ -133,6 +133,28 @@ class PhotoAuthorizationForm(forms.ModelForm):
         fields = ('photo_authorization',)
 
 
+class PhotoAuthorizationFinalForm(forms.ModelForm):
+    """
+    Form to send a photo authorization.
+    """
+    def clean_photo_authorization_final(self):
+        if "photo_authorization_final" in self.files:
+            file = self.files["photo_authorization_final"]
+            if file.size > 2e6:
+                raise ValidationError(_("The uploaded file size must be under 2 Mo."))
+            if file.content_type not in ["application/pdf", "image/png", "image/jpeg"]:
+                raise ValidationError(_("The uploaded file must be a PDF, PNG of JPEG file."))
+            return self.cleaned_data["photo_authorization_final"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["photo_authorization_final"].widget = FileInput()
+
+    class Meta:
+        model = ParticipantRegistration
+        fields = ('photo_authorization_final',)
+
+
 class HealthSheetForm(forms.ModelForm):
     """
     Form to send a health sheet.
@@ -199,6 +221,28 @@ class ParentalAuthorizationForm(forms.ModelForm):
         fields = ('parental_authorization',)
 
 
+class ParentalAuthorizationFinalForm(forms.ModelForm):
+    """
+    Form to send a parental authorization.
+    """
+    def clean_parental_authorization(self):
+        if "parental_authorization_final" in self.files:
+            file = self.files["parental_authorization_final"]
+            if file.size > 2e6:
+                raise ValidationError(_("The uploaded file size must be under 2 Mo."))
+            if file.content_type not in ["application/pdf", "image/png", "image/jpeg"]:
+                raise ValidationError(_("The uploaded file must be a PDF, PNG of JPEG file."))
+            return self.cleaned_data["parental_authorization"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["parental_authorization_final"].widget = FileInput()
+
+    class Meta:
+        model = StudentRegistration
+        fields = ('parental_authorization_final',)
+
+
 class CoachRegistrationForm(forms.ModelForm):
     """
     A coach can tell its professional activity.
@@ -219,33 +263,68 @@ class VolunteerRegistrationForm(forms.ModelForm):
         fields = ('professional_activity', 'admin', 'give_contact_to_animath', 'email_confirmed',)
 
 
-class PaymentForm(forms.ModelForm):
+class PaymentAdminForm(forms.ModelForm):
     """
     Indicate payment information
     """
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.fields["valid"].widget.choices[0] = ('unknown', _("Pending"))
+        payment_type = kwargs.get('data', {}).get('type', "")
+        self.fields['receipt'].required = payment_type in ["scholarship", "bank_transfer"]
+        self.fields['additional_information'].required = payment_type in ["other"]
 
-    def clean_scholarship_file(self):
+    def clean_receipt(self):
-        print(self.files)
+        if "receipt" in self.files:
-        if "scholarship_file" in self.files:
+            file = self.files["receipt"]
-            file = self.files["scholarship_file"]
             if file.size > 2e6:
                 raise ValidationError(_("The uploaded file size must be under 2 Mo."))
             if file.content_type not in ["application/pdf", "image/png", "image/jpeg"]:
                 raise ValidationError(_("The uploaded file must be a PDF, PNG of JPEG file."))
-            return self.cleaned_data["scholarship_file"]
+            return self.cleaned_data["receipt"]
 
     def clean(self):
         cleaned_data = super().clean()
 
-        if "type" in cleaned_data and cleaned_data["type"] == "scholarship" \
+        if "type" in cleaned_data and cleaned_data['type'] in ["scholarship", "bank_transfer"] \
-                and "scholarship_file" not in self.files and not self.instance.scholarship_file:
+                and "receipt" not in self.files and not self.instance.receipt:
-            self.add_error("scholarship_file", _("You must upload your scholarship attestation."))
+            self.add_error("receipt", _("You must upload your receipt."))
 
         return cleaned_data
 
     class Meta:
         model = Payment
-        fields = ('type', 'scholarship_file', 'additional_information', 'valid',)
+        fields = ('type', 'receipt', 'additional_information', 'valid',)
+
+
+class PaymentForm(forms.ModelForm):
+    """
+    Indicate payment information
+    """
+    def __init__(self, payment_type, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields['type'].widget = forms.HiddenInput(attrs={'value': payment_type})
+        self.fields['receipt'].required = payment_type in ["scholarship", "bank_transfer"]
+        self.fields['additional_information'].required = payment_type in ["other"]
+
+    def clean_receipt(self):
+        if "receipt" in self.files:
+            file = self.files["receipt"]
+            if file.size > 2e6:
+                raise ValidationError(_("The uploaded file size must be under 2 Mo."))
+            if file.content_type not in ["application/pdf", "image/png", "image/jpeg"]:
+                raise ValidationError(_("The uploaded file must be a PDF, PNG of JPEG file."))
+            return self.cleaned_data["receipt"]
+
+    def clean(self):
+        cleaned_data = super().clean()
+
+        if "type" in cleaned_data and cleaned_data['type'] in ["scholarship", "bank_transfer"] \
+                and "receipt" not in self.files and not self.instance.receipt:
+            self.add_error("receipt", _("You must upload your receipt."))
+
+        return cleaned_data
+
+    class Meta:
+        model = Payment
+        fields = ('type', 'receipt', 'additional_information',)

registration/management/commands/check_hello_asso.py

@@ -0,0 +1,25 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import json
+
+from django.core.management import BaseCommand
+
+from ...models import Payment
+
+
+class Command(BaseCommand):
+    """
+    This command checks if the initiated Hello Asso payments are validated or not.
+    """
+    help = "Vérifie si les paiements Hello Asso initiés sont validés ou non. Si oui, valide les inscriptions."
+
+    def handle(self, *args, **options):
+        for payment in Payment.objects.exclude(valid=True).filter(checkout_intent_id__isnull=False).all():
+            checkout_intent = payment.get_checkout_intent()
+            if checkout_intent is not None and 'order' in checkout_intent:
+                payment.type = 'helloasso'
+                payment.valid = True
+                payment.additional_information = json.dumps(checkout_intent['order'])
+                payment.save()
+                payment.send_helloasso_payment_confirmation_mail()

registration/management/commands/remind_payments.py

@@ -0,0 +1,17 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.core.management import BaseCommand
+
+from ...models import Payment
+
+
+class Command(BaseCommand):
+    """
+    This command sends a mail to each participant who has not yet paid.
+    """
+    help = "Envoie un mail de rappel à toustes les participant⋅es qui n'ont pas encore payé ou déclaré de paiement."
+
+    def handle(self, *args, **options):
+        for payment in Payment.objects.filter(valid=False).filter(registrations__team__participation__valid=True).all():
+            payment.send_remind_mail()

registration/migrations/0001_initial.py

@@ -113,7 +113,7 @@ class Migration(migrations.Migration):
             fields=[
                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                 ('type', models.CharField(blank=True, choices=[('', 'No payment'), ('helloasso', 'Hello Asso'), ('scholarship', 'Scholarship'), ('bank_transfer', 'Bank transfer'), ('other', 'Other (please indicate)'), ('free', 'The tournament is free')], default='', max_length=16, verbose_name='type')),
-                ('scholarship_file', models.FileField(blank=True, default='', help_text='only if you have a scholarship.', upload_to=registration.models.get_scholarship_filename, verbose_name='scholarship file')),
+                ('scholarship_file', models.FileField(blank=True, default='', help_text='only if you have a scholarship.', upload_to=registration.models.get_receipt_filename, verbose_name='scholarship file')),
                 ('additional_information', models.TextField(blank=True, default='', help_text='To help us to find your payment.', verbose_name='additional information')),
                 ('valid', models.BooleanField(default=False, null=True, verbose_name='valid')),
                 ('registration', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='payment', to='registration.participantregistration', verbose_name='registration')),

registration/migrations/0011_remove_payment_registration_and_more.py

@@ -0,0 +1,76 @@
+# Generated by Django 5.0.1 on 2024-02-12 20:40
+
+import registration.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("registration", "0010_coachregistration_last_degree"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="payment",
+            name="registration",
+        ),
+        migrations.RemoveField(
+            model_name="payment",
+            name="scholarship_file",
+        ),
+        migrations.AddField(
+            model_name="payment",
+            name="amount",
+            field=models.PositiveSmallIntegerField(
+                default=0,
+                help_text="Corresponds to the total required amount to pay, in euros.",
+                verbose_name="total amount",
+            ),
+        ),
+        migrations.AddField(
+            model_name="payment",
+            name="checkout_intent_id",
+            field=models.IntegerField(
+                blank=True,
+                default=None,
+                null=True,
+                verbose_name="Hello Asso checkout intent ID",
+            ),
+        ),
+        migrations.AddField(
+            model_name="payment",
+            name="final",
+            field=models.BooleanField(
+                default=False, verbose_name="for final tournament"
+            ),
+        ),
+        migrations.AddField(
+            model_name="payment",
+            name="grouped",
+            field=models.BooleanField(
+                default=False,
+                help_text="If set to true, then one payment is made for the full team, for example if the school pays for all.",
+                verbose_name="grouped",
+            ),
+        ),
+        migrations.AddField(
+            model_name="payment",
+            name="receipt",
+            field=models.FileField(
+                blank=True,
+                default="",
+                help_text="only if you have a scholarship or if you chose a bank transfer.",
+                upload_to=registration.models.get_receipt_filename,
+                verbose_name="receipt",
+            ),
+        ),
+        migrations.AddField(
+            model_name="payment",
+            name="registrations",
+            field=models.ManyToManyField(
+                related_name="payments",
+                to="registration.participantregistration",
+                verbose_name="registrations",
+            ),
+        ),
+    ]

registration/migrations/0012_payment_token_alter_payment_type.py

@@ -0,0 +1,41 @@
+# Generated by Django 5.0.1 on 2024-02-20 22:48
+
+import registration.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("registration", "0011_remove_payment_registration_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="payment",
+            name="token",
+            field=models.CharField(
+                default=registration.models.get_random_token,
+                help_text="A token to authorize external users to make this payment.",
+                max_length=32,
+                verbose_name="token",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="payment",
+            name="type",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("", "No payment"),
+                    ("helloasso", "Credit card"),
+                    ("scholarship", "Scholarship"),
+                    ("bank_transfer", "Bank transfer"),
+                    ("other", "Other (please indicate)"),
+                    ("free", "The tournament is free"),
+                ],
+                default="",
+                max_length=16,
+                verbose_name="type",
+            ),
+        ),
+    ]