Remove mailing list feature

Merge pull request #1507 from ae-utbm/edt-save
Add user timetable saving
2026-10-24 19:29:32 +00:00 · 2026-10-24 14:32:09 +02:00 · 2026-10-24 01:09:43 +02:00 · 2026-10-23 20:53:47 +02:00 · 2026-10-23 16:27:33 +02:00 · 2026-10-23 16:08:40 +02:00
55 changed files with 1140 additions and 1571 deletions
@@ -31,20 +31,10 @@ from django.forms.models import ModelChoiceField, ModelChoiceIterator
 from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
-from club.models import (
+from club.models import Club, ClubLink, ClubRole, Membership
    Club,
    ClubLink,
    ClubRole,
    Mailing,
    MailingSubscription,
    Membership,
 )
 from core.models import User
 from core.views.forms import SelectDateTime
-from core.views.widgets.ajax_select import (
+from core.views.widgets.ajax_select import AutoCompleteSelectUser
    AutoCompleteSelectMultipleUser,
    AutoCompleteSelectUser,
 )
 from counter.models import Counter, Selling
 from counter.schemas import SaleFilterSchema
@@ -131,107 +121,6 @@ class ClubAdminEditForm(ClubEditForm):
        fields = ["name", "parent", "is_active", *ClubEditForm.Meta.fields]
 class MailingForm(forms.Form):
    """Form handling mailing lists right."""
    ACTION_NEW_MAILING = 1
    ACTION_NEW_SUBSCRIPTION = 2
    ACTION_REMOVE_SUBSCRIPTION = 3
    subscription_users = forms.ModelMultipleChoiceField(
        label=_("Users to add"),
        help_text=_("Search users to add (one or more)."),
        required=False,
        widget=AutoCompleteSelectMultipleUser,
        queryset=User.objects.all(),
    )
    def __init__(self, club_id, user_id, mailings, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["action"] = forms.TypedChoiceField(
            choices=(
                (self.ACTION_NEW_MAILING, _("New Mailing")),
                (self.ACTION_NEW_SUBSCRIPTION, _("Subscribe")),
                (self.ACTION_REMOVE_SUBSCRIPTION, _("Remove")),
            ),
            coerce=int,
            label=_("Action"),
            initial=1,
            required=True,
            widget=forms.HiddenInput(),
        )
        # Generate bulk removal forms, they are never required
        for mailing in mailings:
            self.fields["removal_" + str(mailing.id)] = forms.ModelMultipleChoiceField(
                mailing.subscriptions.all(),
                label=_("Remove"),
                required=False,
                widget=forms.CheckboxSelectMultiple,
            )
        # Include fields for handling mailing creation
        mailing_fields = ("email",)
        self.fields.update(forms.fields_for_model(Mailing, fields=mailing_fields))
        for field in mailing_fields:
            self.fields["mailing_" + field] = self.fields.pop(field)
            self.fields["mailing_" + field].required = False
        # Include fields for handling subscription creation
        subscription_fields = ("mailing", "email")
        self.fields.update(
            forms.fields_for_model(MailingSubscription, fields=subscription_fields)
        )
        for field in subscription_fields:
            self.fields["subscription_" + field] = self.fields.pop(field)
            self.fields["subscription_" + field].required = False
        self.fields["subscription_mailing"].queryset = Mailing.objects.filter(
            club__id=club_id, is_moderated=True
        )
    def check_required(self, cleaned_data, field):
        """If the given field doesn't exist or has no value, add a required error on it."""
        if not cleaned_data.get(field, None):
            self.add_error(field, _("This field is required"))
    def clean_subscription_users(self):
        """Convert given users into real users and check their validity."""
        cleaned_data = super().clean()
        users = []
        for user in cleaned_data["subscription_users"]:
            if not user.email:
                raise forms.ValidationError(
                    _("One of the selected users doesn't have an email address"),
                    code="invalid",
                )
            users.append(user)
        return users
    def clean(self):
        cleaned_data = super().clean()
        if "action" not in cleaned_data:
            # If there is no action provided, we can stop here
            raise forms.ValidationError(_("An action is required"), code="invalid")
        if cleaned_data["action"] == self.ACTION_NEW_MAILING:
            self.check_required(cleaned_data, "mailing_email")
        if cleaned_data["action"] == self.ACTION_NEW_SUBSCRIPTION:
            self.check_required(cleaned_data, "subscription_mailing")
            if not cleaned_data.get(
                "subscription_users", None
            ) and not cleaned_data.get("subscription_email", None):
                raise forms.ValidationError(
                    _("You must specify at least an user or an email address"),
                    code="invalid",
                )
        return cleaned_data
 class SellingsForm(forms.Form):
    begin_date = forms.DateTimeField(
        label=_("Begin date"), widget=SelectDateTime, required=False
@@ -0,0 +1,16 @@
 # Generated by Django 5.2.17 on 2026-10-15 13:13
 from django.db import migrations
 class Migration(migrations.Migration):
    dependencies = [("club", "0018_clubrole_linked_groups")]
    operations = [
        migrations.AlterUniqueTogether(
            name="mailingsubscription", unique_together=None
        ),
        migrations.RemoveField(model_name="mailingsubscription", name="user"),
        migrations.DeleteModel(name="Mailing"),
        migrations.DeleteModel(name="MailingSubscription"),
    ]
@@ -28,8 +28,7 @@ from functools import reduce
 from typing import Iterable, Self
 from django.conf import settings
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.core.exceptions import ValidationError
 from django.core.validators import RegexValidator, validate_email
 from django.db import ProgrammingError, models, transaction
 from django.db.models import Exists, F, OuterRef, Q
 from django.urls import reverse
@@ -41,7 +40,7 @@ from django.utils.translation import gettext_lazy as _
 from ordered_model.models import OrderedModel
 from core.fields import ResizedImageField
-from core.models import Group, Notification, Page, SithFile, User
+from core.models import Group, Page, SithFile, User
 class ClubQuerySet(models.QuerySet):
@@ -238,7 +237,7 @@ class Club(models.Model):
    def can_be_edited_by(self, user: User) -> bool:
        """Method to see if that object can be edited by the given user."""
-        return self.has_rights_in_club(user)
+        return user.has_perm("club.change_club") or self.has_rights_in_club(user)
    def can_roles_be_edited_by(self, user: User) -> bool:
        """Return True if the given user can edit the roles of this club"""
@@ -633,169 +632,6 @@ class Membership(models.Model):
        return User.groups.through.objects.bulk_create(groups, ignore_conflicts=True)
 class Mailing(models.Model):
    """A Mailing list for a club.
    Warning:
        Remember that mailing lists should be validated by UTBM.
    """
    club = models.ForeignKey(
        Club,
        verbose_name=_("Club"),
        related_name="mailings",
        null=False,
        blank=False,
        on_delete=models.CASCADE,
    )
    email = models.CharField(
        _("Email address"),
        unique=True,
        null=False,
        blank=False,
        max_length=256,
        validators=[
            RegexValidator(
                validate_email.user_regex,
                _("Enter a valid address. Only the root of the address is needed."),
            )
        ],
    )
    is_moderated = models.BooleanField(_("is moderated"), default=False)
    moderator = models.ForeignKey(
        User,
        related_name="moderated_mailings",
        verbose_name=_("moderator"),
        null=True,
        on_delete=models.CASCADE,
    )
    def __str__(self):
        return "%s - %s" % (self.club, self.email_full)
    def save(self, *args, **kwargs):
        if not self.is_moderated:
            unread_notif_subquery = Notification.objects.filter(
                user=OuterRef("pk"), type="MAILING_MODERATION", viewed=False
            )
            for user in User.objects.filter(
                ~Exists(unread_notif_subquery),
                groups__id__in=[settings.SITH_GROUP_COM_ADMIN_ID],
            ):
                Notification(
                    user=user,
                    url=reverse("com:mailing_admin"),
                    type="MAILING_MODERATION",
                ).save(*args, **kwargs)
        super().save(*args, **kwargs)
    def clean(self):
        if Mailing.objects.filter(email=self.email).exists():
            raise ValidationError(_("This mailing list already exists."))
        if self.can_moderate(self.moderator):
            self.is_moderated = True
        else:
            self.moderator = None
        super().clean()
    @property
    def email_full(self):
        return self.email + "@" + settings.SITH_MAILING_DOMAIN
    def can_moderate(self, user):
        return user.is_root or user.is_com_admin
    def is_owned_by(self, user):
        if user.is_anonymous:
            return False
        return user.is_root or user.is_com_admin
    def can_view(self, user):
        return self.club.has_rights_in_club(user)
    def can_be_edited_by(self, user):
        return self.club.has_rights_in_club(user)
    def delete(self, *args, **kwargs):
        self.subscriptions.all().delete()
        super().delete()
    def fetch_format(self):
        destination = "".join(s.fetch_format() for s in self.subscriptions.all())
        return f"{self.email}: {destination}"
 class MailingSubscription(models.Model):
    """Link between user and mailing list."""
    mailing = models.ForeignKey(
        Mailing,
        verbose_name=_("Mailing"),
        related_name="subscriptions",
        null=False,
        blank=False,
        on_delete=models.CASCADE,
    )
    user = models.ForeignKey(
        User,
        verbose_name=_("User"),
        related_name="mailing_subscriptions",
        null=True,
        blank=True,
        on_delete=models.CASCADE,
    )
    email = models.EmailField(_("Email address"), blank=False, null=False)
    class Meta:
        unique_together = (("user", "email", "mailing"),)
    def __str__(self):
        return "(%s) - %s : %s" % (self.mailing, self.get_username, self.email)
    def clean(self):
        if not self.user and not self.email:
            raise ValidationError(_("At least user or email is required"))
        try:
            if self.user and not self.email:
                self.email = self.user.email
                if MailingSubscription.objects.filter(
                    mailing=self.mailing, email=self.email
                ).exists():
                    raise ValidationError(
                        _("This email is already suscribed in this mailing")
                    )
        except ObjectDoesNotExist:
            pass
        super().clean()
    def is_owned_by(self, user):
        if user.is_anonymous:
            return False
        return (
            self.mailing.club.has_rights_in_club(user)
            or user.is_root
            or self.user.is_com_admin
        )
    def can_be_edited_by(self, user):
        return self.user is not None and user.id == self.user.id
    @cached_property
    def get_email(self):
        if self.user and not self.email:
            return self.user.email
        return self.email
    @cached_property
    def get_username(self):
        if self.user:
            return str(self.user)
        return _("Unregistered user")
    def fetch_format(self):
        return self.get_email + " "
 class LinkType(models.Model):
    """A link type, in order to group links and give them icons.
@@ -26,6 +26,15 @@
 {% endblock %}
 {% block content %}
  {% if user.is_authenticated and user.can_edit(club) %}
    <a
      href="{{ url("core:page_edit", page_name=club.page.get_full_name()) }}"
      class="btn btn-blue margin-bottom"
    >
      <i class="fa fa-pen-to-square"></i> {% trans %}Edit{% endtrans %}
    </a>
  {% endif %}
  <h3>{{ club.name }}</h3>
  <div id="club-detail" {% if links %}class="has-links"{% endif %}>
    <div id="club-attributes">
@@ -15,9 +15,6 @@
          {% trans %}Post in the Weekmail{% endtrans %}
        </a>
      </li>
      {% if object.can_roles_be_edited_by(user) %}
        <li><a href="{{ url("club:club_roles", club_id=object.id) }}"></a></li>
      {% endif %}
      {% if object.trombi %}
        <li> <a href="{{ url('trombi:detail', trombi_id=object.trombi.id) }}">{% trans %}Edit Trombi{% endtrans %}</a></li>
      {% else %}
@@ -1,108 +0,0 @@
 {% extends "core/base.jinja" %}
 {% from 'core/macros.jinja' import select_all_checkbox %}
 {% block title %}
  {% trans %}Mailing lists{% endtrans %}
 {% endblock %}
 {% block content %}
  <b>{% trans %}Remember : mailing lists need to be moderated, if your new created list is not shown wait until moderation takes action{% endtrans %}</b>
  {% if mailings_not_moderated %}
    <p>{% trans %}Mailing lists waiting for moderation{% endtrans %}</p>
    <ul>
      {% for mailing in mailings_not_moderated %}
        <li>{{ mailing.email_full }}<a href="{{ url('club:mailing_delete', mailing_id=mailing.id) }}"> - {% trans %}Delete{% endtrans %}</a></li>
      {% endfor %}
    </ul>
  {% endif %}
  {% if mailings_moderated %}
    {% for mailing in mailings_moderated %}
      <h2>{% trans %}Mailing{% endtrans %} {{ mailing.email_full }}
        {%- if user.is_owner(mailing) -%}
          <a href="{{ url('club:mailing_delete', mailing_id=mailing.id) }}"> - {% trans %}Delete{% endtrans %}</a>
        {%- endif -%}
      </h2>
      <form method="GET" action="{{ url('club:mailing_generate', mailing_id=mailing.id) }}" style="display:inline-block;">
        <input type="submit" name="generateMalingList" value="{% trans %}Generate mailing list{% endtrans %}">
      </form>
      {% set form_mailing_removal = form["removal_" + mailing.id|string] %}
      {% if form_mailing_removal.field.choices %}
        {% set ms = dict(mailing.subscriptions.all() | groupby('id')) %}
        <form action="{{ url('club:mailing', club_id=club.id) }}" id="{{ form_mailing_removal.auto_id }}" method="post" enctype="multipart/form-data">
          <p style="margin-bottom: 1em;">{{ select_all_checkbox(form_mailing_removal.auto_id) }}</p>
          {% csrf_token %}
          <input hidden type="number" name="{{ form.action.name }}" value="{{ form_actions.REMOVE_SUBSCRIPTION }}" />
          <table>
            <thead>
              <tr>
                <td>{% trans %}User{% endtrans %}</td>
                <td>{% trans %}Email{% endtrans %}</td>
                <td>{% trans %}Delete{% endtrans %}</td>
              </tr>
            </thead>
            <tbody>
              {% for widget in form_mailing_removal.subwidgets %}
                {% set user = ms[widget.data.value.value][0] %}
                <tr>
                  <td>{{ user.get_username }}</td>
                  <td>{{ user.get_email }}</td>
                  <td>{{ widget.tag() }}</td>
                </tr>
              {% endfor %}
            </tbody>
          </table>
          {{ form_mailing_removal.errors }}
          <p><input type="submit" value="{% trans %}Remove from mailing list{% endtrans %}" /></p>
        </form>
      {% else %}
        <p><b>{% trans %}There is no subscriber for this mailing list{% endtrans %}</b></p>
      {% endif %}
    {% endfor %}
  {% else %}
    <p>{% trans %}No mailing list existing for this club{% endtrans %}</p>
  {% endif %}
  <p>{{ form.non_field_errors() }}</p>
  {% if mailings_moderated %}
    <h2>{% trans %}New member{% endtrans %}</h2>
    <form action="{{ url('club:mailing', club_id=club.id) }}" method="post" enctype="multipart/form-data">
      {% csrf_token %}
      <p>
        {{ form.subscription_mailing.errors }}
        <label for="{{ form.subscription_mailing.id_for_label }}">{{ form.subscription_mailing.label }}</label>
        {{ form.subscription_mailing }}
      </p>
      <p>
        {{ form.subscription_users.errors }}
        <label for="{{ form.subscription_users.id_for_label }}">{{ form.subscription_users.label }}</label>
        {{ form.subscription_users }}
        <span class="helptext">{{ form.subscription_users.help_text }}</span>
      </p>
      <p>
        {{ form.subscription_email.errors }}
        <label for="{{ form.subscription_email.id_for_label }}">{{ form.subscription_email.label }}</label>
        {{ form.subscription_email }}
      </p>
      <input hidden type="number" name="{{ form.action.name }}" value="{{ form_actions.NEW_SUBSCRIPTION }}" />
      <p><input type="submit" value="{% trans %}Add to mailing list{% endtrans %}" /></p>
    </form>
  {% endif %}
  <h2>{% trans %}New mailing{% endtrans %}</h2>
  <form action="{{ url('club:mailing', club_id=club.id) }}" method="post" enctype="multipart/form-data">
    {% csrf_token %}
    <p>
      {{ form.mailing_email.errors }}
      <label for="{{ form.mailing_email.id_for_label }}">{{ form.mailing_email.label }}</label>
      {{ form.mailing_email }}
    </p>
    <input hidden type="number" name="{{ form.action.name }}" value="{{ form_actions.NEW_MALING }}" />
    <p><input type="submit" value="{% trans %}Create mailing list{% endtrans %}" /></p>
  </form>
 {% endblock %}
@@ -1,328 +0,0 @@
 from django.conf import settings
 from django.test import TestCase
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.translation import gettext as _
 from model_bakery import baker
 from club.forms import MailingForm
 from club.models import Club, ClubRole, Mailing, Membership
 from core.models import User
 class TestMailingForm(TestCase):
    """Perform validation tests for MailingForm."""
    @classmethod
    def setUpTestData(cls):
        cls.skia = User.objects.get(username="skia")
        cls.rbatsbak = User.objects.get(username="rbatsbak")
        cls.krophil = User.objects.get(username="krophil")
        cls.comunity = User.objects.get(username="comunity")
        cls.root = User.objects.get(username="root")
        cls.club = Club.objects.get(id=settings.SITH_PDF_CLUB_ID)
        cls.mail_url = reverse("club:mailing", kwargs={"club_id": cls.club.id})
        Membership(
            user=cls.rbatsbak,
            club=cls.club,
            start_date=timezone.now(),
            role=baker.make(ClubRole, club=cls.club, is_board=True),
        ).save()
    def test_mailing_list_add_no_moderation(self):
        # Test with Communication admin
        self.client.force_login(self.comunity)
        response = self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "foyer"},
        )
        self.assertRedirects(response, self.mail_url)
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        assert "Liste de diffusion foyer@utbm.fr" in response.text
        # Test with Root
        self.client.force_login(self.root)
        self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        assert "Liste de diffusion mde@utbm.fr" in response.text
    def test_mailing_list_add_moderation(self):
        self.client.force_login(self.rbatsbak)
        self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "Liste de diffusion mde@utbm.fr" not in content
        assert "<p>Listes de diffusions en attente de modération</p>" in content
        assert "<li>mde@utbm.fr" in content
    def test_mailing_list_forbidden(self):
        # With anonymous user
        response = self.client.get(self.mail_url)
        self.assertContains(response, "", status_code=403)
        # With user not in club
        self.client.force_login(self.krophil)
        response = self.client.get(self.mail_url)
        assert response.status_code == 403
    def test_add_new_subscription_fail_not_moderated(self):
        self.client.force_login(self.rbatsbak)
        self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
        )
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": self.skia.id,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        assert "skia@git.an" not in response.text
    def test_add_new_subscription_success(self):
        # Prepare mailing list
        self.client.force_login(self.comunity)
        self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
        )
        # Add single user
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": self.skia.id,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        assert "skia@git.an" in response.text
        # Add multiple users
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": (self.comunity.id, self.rbatsbak.id),
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "richard@git.an" in content
        assert "comunity@git.an" in content
        assert "skia@git.an" in content
        # Add arbitrary email
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_email": "arbitrary@git.an",
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "richard@git.an" in content
        assert "comunity@git.an" in content
        assert "skia@git.an" in content
        assert "arbitrary@git.an" in content
        # Add user and arbitrary email
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_email": "more.arbitrary@git.an",
                "subscription_users": self.krophil.id,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "richard@git.an" in content
        assert "comunity@git.an" in content
        assert "skia@git.an" in content
        assert "arbitrary@git.an" in content
        assert "more.arbitrary@git.an" in content
        assert "krophil@git.an" in content
    def test_add_new_subscription_fail_form_errors(self):
        # Prepare mailing list
        self.client.force_login(self.comunity)
        self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
        )
        # Neither email or email is specified
        response = self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        assert response.status_code
        self.assertInHTML(
            _("You must specify at least an user or an email address"),
            response.text,
        )
        # No mailing specified
        response = self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": self.krophil.id,
            },
        )
        assert response.status_code == 200
        assert _("This field is required") in response.text
        # One of the selected users doesn't exist
        response = self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": [789],
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        assert response.status_code == 200
        self.assertInHTML(
            _("You must specify at least an user or an email address"),
            response.text,
        )
        # An user has no email address
        self.krophil.email = ""
        self.krophil.save()
        response = self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": self.krophil.id,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        assert response.status_code == 200
        self.assertInHTML(
            _("One of the selected users doesn't have an email address"),
            response.text,
        )
        self.krophil.email = "krophil@git.an"
        self.krophil.save()
        # An user is added twice
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": self.krophil.id,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        response = self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": self.krophil.id,
                "subscription_mailing": Mailing.objects.get(email="mde").id,
            },
        )
        assert response.status_code == 200
        self.assertInHTML(
            _("This email is already suscribed in this mailing"),
            response.text,
        )
    def test_remove_subscription_success(self):
        # Prepare mailing list
        self.client.force_login(self.comunity)
        self.client.post(
            self.mail_url,
            {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
        )
        mde = Mailing.objects.get(email="mde")
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                "subscription_users": (
                    self.comunity.id,
                    self.rbatsbak.id,
                    self.krophil.id,
                ),
                "subscription_mailing": mde.id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "comunity@git.an" in content
        assert "richard@git.an" in content
        assert "krophil@git.an" in content
        # Delete one user
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_REMOVE_SUBSCRIPTION,
                "removal_%d" % mde.id: mde.subscriptions.get(user=self.krophil).id,
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "comunity@git.an" in content
        assert "richard@git.an" in content
        assert "krophil@git.an" not in content
        # Delete multiple users
        self.client.post(
            self.mail_url,
            {
                "action": MailingForm.ACTION_REMOVE_SUBSCRIPTION,
                "removal_%d" % mde.id: [
                    user.id
                    for user in mde.subscriptions.filter(
                        user__in=[self.rbatsbak, self.comunity]
                    ).all()
                ],
            },
        )
        response = self.client.get(self.mail_url)
        assert response.status_code == 200
        content = response.text
        assert "comunity@git.an" not in content
        assert "richard@git.an" not in content
        assert "krophil@git.an" not in content
@@ -1,8 +1,9 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
 import pytest
 from aemark import markdown
 from bs4 import BeautifulSoup
 from django.contrib.auth.models import Permission
 from django.urls import reverse
 from model_bakery import baker
 from pytest_django.asserts import assertHTMLEqual, assertRedirects
@@ -16,13 +17,20 @@ if TYPE_CHECKING:
@pytest.mark.django_db
-def test_page_display_on_club_main_page(client: Client):
+@pytest.mark.parametrize("user_factory", [lambda: None, subscriber_user.make])
 def test_page_display_on_club_main_page(
    client: Client, user_factory: Callable[[], User | None]
 ):
    """Test the club Page is properly displayed on the club main view"""
    club = baker.make(Club)
    # create another previous revision, to test that we display the most recent one
    baker.make(PageRev, page=club.page, revision=1)
    content = "# foo\nLorem ipsum dolor sit amet"
-    baker.make(PageRev, page=club.page, revision=1, content=content)
+    baker.make(PageRev, page=club.page, revision=2, content=content)
    res = client.get(reverse("club:club_view", kwargs={"club_id": club.id}))
    if user := user_factory():
        client.force_login(user)
    res = client.get(reverse("club:club_view", kwargs={"club_id": club.id}))
    assert res.status_code == 200
    soup = BeautifulSoup(res.text, "lxml")
    detail_html = soup.find(id="club-page").find(class_="markdown")
@@ -30,20 +38,60 @@ def test_page_display_on_club_main_page(client: Client):
@pytest.mark.django_db
-def test_club_main_page_without_content(client: Client):
+@pytest.mark.parametrize(
-    """Test the club view works, even if the club page is empty"""
+    ("user_factory", "can_view_tabs", "can_view_edit_button"),
    [
        (lambda _: None, False, False),
        (lambda _: baker.make(User), False, False),
        (lambda _: subscriber_user.make(), True, False),
        (
            # admin user
            lambda _: subscriber_user.make(
                user_permissions=[Permission.objects.get(codename="change_club")]
            ),
            True,
            True,
        ),
        (
            # club board member
            lambda club: (
                baker.make(
                    Membership,
                    club=club,
                    role=baker.make(ClubRole, is_board=True),
                    user=subscriber_user.make(),
                ).user
            ),
            True,
            True,
        ),
    ],
    ids=["anonymous", "public", "subscriber", "admin", "club board"],
 )
@pytest.mark.django_db
 def test_club_main_page_displayed_elements(
    client: Client, user_factory, can_view_tabs, can_view_edit_button
 ):
    """Test that the appropriate elements are displayed depending on user status."""
    club = baker.make(Club)
-    club.page.revisions.all().delete()
+    if user := user_factory(club):
        client.force_login(user)
    res = client.get(reverse("club:club_view", kwargs={"club_id": club.id}))
    assert res.status_code == 200
    soup = BeautifulSoup(res.text, "lxml")
-    detail_html = soup.find(id="club-page")
+    tabs = soup.find(class_="tool_bar")
-    assert detail_html.find_all("markdown") == []
+    assert tabs is not None if can_view_tabs else tabs is None
    edit_btn = soup.find(
        "a",
        href=reverse("core:page_edit", kwargs={"page_name": club.page.get_full_name()}),
    )
    assert edit_btn is not None if can_view_edit_button else edit_btn is None
@pytest.mark.django_db
 def test_page_revision(client: Client):
    """Test that accessing a previous revision of the club page works."""
    club = baker.make(Club)
    revisions = baker.make(
        PageRev, page=club.page, _quantity=3, content=iter(["foo", "bar", "baz"])
@@ -29,7 +29,6 @@ from club.views import (
    ClubCreateView,
    ClubEditView,
    ClubListView,
    ClubMailingView,
    ClubMembersView,
    ClubOldMembersView,
    ClubPageEditView,
@@ -43,9 +42,6 @@ from club.views import (
    ClubSellingView,
    ClubToolsView,
    ClubView,
    MailingAutoGenerationView,
    MailingDeleteView,
    MailingSubscriptionDeleteView,
    MembershipDeleteView,
    MembershipSetOldView,
    PosterCreateView,
@@ -96,22 +92,6 @@ urlpatterns = [
        "<int:club_id>/sellings/csv/", ClubSellingCSVView.as_view(), name="sellings_csv"
    ),
    path("<int:club_id>/tools/", ClubToolsView.as_view(), name="tools"),
    path("<int:club_id>/mailing/", ClubMailingView.as_view(), name="mailing"),
    path(
        "<int:mailing_id>/mailing/generate/",
        MailingAutoGenerationView.as_view(),
        name="mailing_generate",
    ),
    path(
        "<int:mailing_id>/mailing/delete/",
        MailingDeleteView.as_view(),
        name="mailing_delete",
    ),
    path(
        "<int:mailing_subscription_id>/mailing/delete/subscription/",
        MailingSubscriptionDeleteView.as_view(),
        name="mailing_subscription_delete",
    ),
    path(
        "membership/<int:membership_id>/set_old/",
        MembershipSetOldView.as_view(),
@@ -34,7 +34,6 @@ from django.contrib.auth.mixins import (
    UserPassesTestMixin,
 )
 from django.contrib.messages.views import SuccessMessageMixin
 from django.core.exceptions import NON_FIELD_ERRORS, PermissionDenied, ValidationError
 from django.core.paginator import InvalidPage, Paginator
 from django.db.models import F, Prefetch, Q, Sum
 from django.db.models.functions import Length
@@ -59,7 +58,6 @@ from club.forms import (
    ClubRoleFormSet,
    ClubSearchForm,
    JoinClubForm,
    MailingForm,
    SellingsForm,
 )
 from club.models import (
@@ -67,8 +65,6 @@ from club.models import (
    ClubLink,
    ClubRole,
    LinkType,
    Mailing,
    MailingSubscription,
    Membership,
 )
 from com.models import Poster
@@ -106,42 +102,35 @@ class ClubTabsMixin(TabedViewMixin):
        return self.object.get_display_name()
    def get_list_of_tabs(self):
        if not self.request.user.has_perm("club.view_club"):
            # The user will still be able to see the club main page,
            # but nothing else.
            # It's useless to display a tab with only one item, so return nothing.
            return []
        tab_list = [
            {
                "url": reverse("club:club_view", kwargs={"club_id": self.object.id}),
                "slug": "infos",
                "name": _("Infos"),
-            }
+            },
            {
                "url": reverse("club:club_members", kwargs={"club_id": self.object.id}),
                "slug": "members",
                "name": _("Members"),
            },
            {
                "url": reverse(
                    "club:club_old_members", kwargs={"club_id": self.object.id}
                ),
                "slug": "elderlies",
                "name": _("Old members"),
            },
            {
                "url": reverse("club:club_hist", kwargs={"club_id": self.object.id}),
                "slug": "history",
                "name": _("History"),
            },
        ]
        if self.request.user.has_perm("club.view_club"):
            tab_list.extend(
                [
                    {
                        "url": reverse(
                            "club:club_members", kwargs={"club_id": self.object.id}
                        ),
                        "slug": "members",
                        "name": _("Members"),
                    },
                    {
                        "url": reverse(
                            "club:club_old_members", kwargs={"club_id": self.object.id}
                        ),
                        "slug": "elderlies",
                        "name": _("Old members"),
                    },
                ]
            )
            if self.object.page:
                tab_list.append(
                    {
                        "url": reverse(
                            "club:club_hist", kwargs={"club_id": self.object.id}
                        ),
                        "slug": "history",
                        "name": _("History"),
                    }
                )
        if self.request.user.can_edit(self.object):
            tab_list.extend(
                [
@@ -159,21 +148,6 @@ class ClubTabsMixin(TabedViewMixin):
                        "slug": "edit",
                        "name": _("Edit"),
                    },
                ]
            )
            if self.object.page and self.request.user.can_edit(self.object.page):
                tab_list.append(
                    {
                        "url": reverse(
                            "core:page_edit",
                            kwargs={"page_name": self.object.page.get_full_name()},
                        ),
                        "slug": "page_edit",
                        "name": _("Edit club page"),
                    }
                )
            tab_list.extend(
                [
                    {
                        "url": reverse(
                            "club:club_sellings", kwargs={"club_id": self.object.id}
@@ -181,13 +155,6 @@ class ClubTabsMixin(TabedViewMixin):
                        "slug": "sellings",
                        "name": _("Sellings"),
                    },
                    {
                        "url": reverse(
                            "club:mailing", kwargs={"club_id": self.object.id}
                        ),
                        "slug": "mailing",
                        "name": _("Mailing list"),
                    },
                    {
                        "url": reverse(
                            "club:poster_list", kwargs={"club_id": self.object.id}
@@ -742,166 +709,6 @@ class MembershipDeleteView(PermissionRequiredMixin, DeleteView):
        return reverse_lazy("core:user_clubs", kwargs={"user_id": self.object.user_id})
 class ClubMailingView(ClubTabsMixin, CanEditMixin, DetailFormView):
    """A list of mailing for a given club."""
    model = Club
    form_class = MailingForm
    pk_url_kwarg = "club_id"
    template_name = "club/mailing.jinja"
    current_tab = "mailing"
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs["club_id"] = self.object.id
        kwargs["user_id"] = self.request.user.id
        kwargs["mailings"] = self.object.mailings.all()
        return kwargs
    def get_context_data(self, **kwargs):
        kwargs = super().get_context_data(**kwargs)
        mailings = list(self.object.mailings.all())
        kwargs["club"] = self.object
        kwargs["user"] = self.request.user
        kwargs["mailings"] = mailings
        kwargs["mailings_moderated"] = [m for m in mailings if m.is_moderated]
        kwargs["mailings_not_moderated"] = [m for m in mailings if not m.is_moderated]
        kwargs["form_actions"] = {
            "NEW_MALING": self.form_class.ACTION_NEW_MAILING,
            "NEW_SUBSCRIPTION": self.form_class.ACTION_NEW_SUBSCRIPTION,
            "REMOVE_SUBSCRIPTION": self.form_class.ACTION_REMOVE_SUBSCRIPTION,
        }
        return kwargs
    def add_new_mailing(self, cleaned_data) -> ValidationError | None:
        """Create a new mailing list from the form."""
        mailing = Mailing(
            club=self.object,
            email=cleaned_data["mailing_email"],
            moderator=self.request.user,
            is_moderated=False,
        )
        try:
            mailing.clean()
        except ValidationError as validation_error:
            return validation_error
        mailing.save()
        return None
    def add_new_subscription(self, cleaned_data) -> ValidationError | None:
        """Add mailing subscriptions for each user given and/or for the specified email in form."""
        users_to_save = []
        for user in cleaned_data["subscription_users"]:
            sub = MailingSubscription(
                mailing=cleaned_data["subscription_mailing"], user=user
            )
            try:
                sub.clean()
            except ValidationError as validation_error:
                return validation_error
            sub.save()
            users_to_save.append(sub)
        if cleaned_data["subscription_email"]:
            sub = MailingSubscription(
                mailing=cleaned_data["subscription_mailing"],
                email=cleaned_data["subscription_email"],
            )
        try:
            sub.clean()
        except ValidationError as validation_error:
            return validation_error
        sub.save()
        # Save users after we are sure there is no error
        for user in users_to_save:
            user.save()
        return None
    def remove_subscription(self, cleaned_data):
        """Remove specified users from a mailing list."""
        fields = [
            val for key, val in cleaned_data.items() if key.startswith("removal_")
        ]
        for field in fields:
            for sub in field:
                sub.delete()
    def form_valid(self, form):
        resp = super().form_valid(form)
        cleaned_data = form.clean()
        error = None
        if cleaned_data["action"] == self.form_class.ACTION_NEW_MAILING:
            error = self.add_new_mailing(cleaned_data)
        if cleaned_data["action"] == self.form_class.ACTION_NEW_SUBSCRIPTION:
            error = self.add_new_subscription(cleaned_data)
        if cleaned_data["action"] == self.form_class.ACTION_REMOVE_SUBSCRIPTION:
            self.remove_subscription(cleaned_data)
        if error:
            form.add_error(NON_FIELD_ERRORS, error)
            return self.form_invalid(form)
        return resp
    def get_success_url(self, **kwargs):
        return reverse("club:mailing", kwargs={"club_id": self.object.id})
 class MailingDeleteView(CanEditMixin, DeleteView):
    model = Mailing
    template_name = "core/delete_confirm.jinja"
    pk_url_kwarg = "mailing_id"
    redirect_page = None
    def dispatch(self, request, *args, **kwargs):
        self.club_id = self.get_object().club.id
        return super().dispatch(request, *args, **kwargs)
    def get_success_url(self, **kwargs):
        if self.redirect_page:
            return reverse_lazy(self.redirect_page)
        else:
            return reverse_lazy("club:mailing", kwargs={"club_id": self.club_id})
 class MailingSubscriptionDeleteView(CanEditMixin, DeleteView):
    model = MailingSubscription
    template_name = "core/delete_confirm.jinja"
    pk_url_kwarg = "mailing_subscription_id"
    def dispatch(self, request, *args, **kwargs):
        self.club_id = self.get_object().mailing.club.id
        return super().dispatch(request, *args, **kwargs)
    def get_success_url(self, **kwargs):
        return reverse_lazy("club:mailing", kwargs={"club_id": self.club_id})
 class MailingAutoGenerationView(View):
    def dispatch(self, request, *args, **kwargs):
        self.mailing = get_object_or_404(Mailing, pk=kwargs["mailing_id"])
        if not request.user.can_edit(self.mailing):
            raise PermissionDenied
        return super().dispatch(request, *args, **kwargs)
    def get(self, request, *args, **kwargs):
        club = self.mailing.club
        self.mailing.subscriptions.all().delete()
        members = club.members.ongoing().filter(role__is_board=True)
        for member in members.all():
            MailingSubscription(user=member.user, mailing=self.mailing).save()
        return redirect("club:mailing", club_id=club.id)
 class PosterListView(
    PermissionOrClubBoardRequiredMixin, ClubTabsMixin, PosterListBaseView
 ):
@@ -259,10 +259,7 @@ class Weekmail(models.Model):
        return f"Weekmail {self.id} (sent: {self.sent}) - {self.title}"
    def send(self):
-        """Send the weekmail to all users with the receive weekmail option opt-in.
+        """Send the weekmail to all users with the receive weekmail option opt-in."""
        Also send the weekmail to the mailing list in settings.SITH_COM_EMAIL.
        """
        dest = [
            i[0]
            for i in Preferences.objects.filter(receive_weekmail=True).values_list(
@@ -1,45 +0,0 @@
 {% extends "core/base.jinja" %}
 {% block title %}
  {% trans %}Mailing lists administration{% endtrans %}
 {% endblock %}
 {% macro display_mailings(list) %}
  <table>
    <tr>
      <th>{% trans %}Email{% endtrans %}</th>
      <th>{% trans %}Club{%endtrans%}</th>
      <th>{% trans %}Actions{% endtrans %}</th>
    </tr>
    {% for mailing in list %}
      <tr>
        <td>{{ mailing.email_full }}</td>
        <td><a href="{{ url('club:mailing', club_id=mailing.club.id) }}">{{ mailing.club }}</a></td>
        <td>
          <a href="{{ url('com:mailing_delete', mailing_id=mailing.id) }}">{% trans %}Delete{% endtrans %}</a> - {% if not mailing.is_moderated %}<a href="{{ url('com:mailing_moderate', mailing_id=mailing.id) }}">{% trans %}Moderate{% endtrans %}</a>{% else %}{% trans user=mailing.moderator %}Moderated by {{ user }}{% endtrans %}{% endif %}
        </td>
      </tr>
    {% endfor %}
  </table>
 {% endmacro %}
 {% block content %}
  <h1>{% trans %}This page lists all mailing lists{% endtrans %}</h1>
  {% if has_unmoderated %}
    <h2>{% trans %}Not moderated mailing lists{% endtrans %}</h2>
    {{ display_mailings(unmoderated) }}
  {% endif %}
  <h2>{% trans %}Moderated mailing lists{% endtrans %}</h2>
  {% if has_moderated %}
    {{ display_mailings(moderated) }}
  {% else %}
    <p>{% trans %}No mailing list existing{% endtrans %}</p>
  {% endif %}
 {% endblock %}
@@ -15,12 +15,9 @@
 from django.urls import path
 from club.views import MailingDeleteView
 from com.views import (
    AlertMsgEditView,
    InfoMsgEditView,
    MailingListAdminView,
    MailingModerateView,
    NewsAdminListView,
    NewsCreateView,
    NewsDeleteView,
@@ -82,17 +79,6 @@ urlpatterns = [
        "news/<int:news_id>/moderate/", NewsModerateView.as_view(), name="news_moderate"
    ),
    path("news/<int:news_id>/", NewsDetailView.as_view(), name="news_detail"),
    path("mailings/", MailingListAdminView.as_view(), name="mailing_admin"),
    path(
        "mailings/<int:mailing_id>/moderate/",
        MailingModerateView.as_view(),
        name="mailing_moderate",
    ),
    path(
        "mailings/<int:mailing_id>/delete/",
        MailingDeleteView.as_view(redirect_page="com:mailing_admin"),
        name="mailing_delete",
    ),
    path("poster/", PosterListView.as_view(), name="poster_list"),
    path("poster/create/", PosterCreateView.as_view(), name="poster_create"),
    path("poster/<int:poster_id>/edit/", PosterEditView.as_view(), name="poster_edit"),
@@ -30,11 +30,9 @@ from urllib.parse import urlparse
 from dateutil.relativedelta import relativedelta
 from django.conf import settings
 from django.contrib import messages
-from django.contrib.auth.mixins import (
+from django.contrib.auth.mixins import PermissionRequiredMixin
    PermissionRequiredMixin,
 )
 from django.contrib.syndication.views import Feed
-from django.core.exceptions import PermissionDenied, ValidationError
+from django.core.exceptions import ValidationError
 from django.db.models import Exists, Max, OuterRef, Value
 from django.forms.models import modelform_factory
 from django.http import HttpResponseRedirect
@@ -46,7 +44,7 @@ from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView, TemplateView, View
 from django.views.generic.edit import CreateView, DeleteView, UpdateView
-from club.models import Club, Mailing, Membership
+from club.models import Club, Membership
 from com.forms import NewsDateForm, NewsForm, PosterForm
 from com.ics_calendar import IcsCalendar
 from com.models import News, NewsDate, Poster, Screen, Sith, Weekmail, WeekmailArticle
@@ -86,11 +84,6 @@ class ComTabsMixin(TabedViewMixin):
                "slug": "alert",
                "name": _("Alert message"),
            },
            {
                "url": reverse("com:mailing_admin"),
                "slug": "mailings",
                "name": _("Mailing lists administration"),
            },
            {
                "url": reverse("com:poster_list"),
                "slug": "posters",
@@ -533,37 +526,6 @@ class WeekmailArticleDeleteView(CanEditPropMixin, DeleteView):
    pk_url_kwarg = "article_id"
 class MailingListAdminView(ComTabsMixin, ListView):
    template_name = "com/mailing_admin.jinja"
    model = Mailing
    current_tab = "mailings"
    def dispatch(self, request, *args, **kwargs):
        if not (request.user.is_com_admin or request.user.is_root):
            raise PermissionDenied
        return super().dispatch(request, *args, **kwargs)
    def get_context_data(self, **kwargs):
        kwargs = super().get_context_data(**kwargs)
        kwargs["moderated"] = self.get_queryset().filter(is_moderated=True).all()
        kwargs["unmoderated"] = self.get_queryset().filter(is_moderated=False).all()
        kwargs["has_moderated"] = len(kwargs["moderated"]) > 0
        kwargs["has_unmoderated"] = len(kwargs["unmoderated"]) > 0
        return kwargs
 class MailingModerateView(View):
    def get(self, request, *args, **kwargs):
        mailing = get_object_or_404(Mailing, pk=kwargs["mailing_id"])
        if mailing.can_moderate(request.user):
            mailing.is_moderated = True
            mailing.moderator = request.user
            mailing.save()
            return redirect("com:mailing_admin")
        raise PermissionDenied
 class PosterListBaseView(ListView):
    """List communication posters."""
@@ -1,18 +1,15 @@
 from typing import Annotated, Literal
 from annotated_types import Ge, Le, MinLen
 from django.conf import settings
 from django.db.models import F
 from ninja import File, Query
 from ninja.security import SessionAuth
 from ninja_extra import ControllerBase, api_controller, paginate, route
 from ninja_extra.exceptions import PermissionDenied
 from ninja_extra.pagination import PageNumberPaginationExtra
 from ninja_extra.schemas import PaginatedResponseSchema
 from api.auth import ApiKeyAuth
 from api.permissions import CanAccessLookup, CanView, HasPerm
 from club.models import Mailing
 from core.models import Group, QuickUploadImage, SithFile, User
 from core.schemas import (
    FamilyGodfatherSchema,
@@ -48,19 +45,6 @@ class UploadController(ControllerBase):
        return image
@api_controller("/mailings")
 class MailingListController(ControllerBase):
    @route.get("", response=str)
    def fetch_mailing_lists(self, key: str):
        if key != settings.SITH_MAILING_FETCH_KEY:
            raise PermissionDenied
        mailings = Mailing.objects.filter(
            is_moderated=True, club__is_active=True
        ).prefetch_related("subscriptions")
        data = "\n".join(m.fetch_format() for m in mailings)
        return data
@api_controller("/user")
 class UserController(ControllerBase):
    @route.get("", response=list[UserProfileSchema])
@@ -0,0 +1,22 @@
 # Generated by Django 5.2.17 on 2026-09-24 14:49
 from django.db import migrations, models
 class Migration(migrations.Migration):
    dependencies = [("core", "0051_user_cgu_approved_at")]
    operations = [
        migrations.AddField(
            model_name="preferences",
            name="show_my_timetable",
            field=models.BooleanField(
                default=True,
                help_text=(
                    "Allow subscribers to see your timetable and "
                    "to compare it to theirs (if you have filled it)"
                ),
                verbose_name="show your timetable to others",
            ),
        ),
    ]
@@ -799,6 +799,14 @@ class Preferences(models.Model):
        ),
        default=False,
    )
    show_my_timetable = models.BooleanField(
        _("show your timetable to others"),
        help_text=_(
            "Allow subscribers to see your timetable and "
            "to compare it to theirs (if you have filled it)"
        ),
        default=True,
    )
    notify_on_click = models.BooleanField(
        _("get a notification for every click"), default=False
    )
@@ -60,6 +60,7 @@ const loadEasyMde = (textarea: HTMLTextAreaElement) => {
      });
      easymde.codemirror.replaceSelection("\n");
    },
    previewClass: ["editor-preview", "markdown"], // default class + our own markdown class
    previewRender: (plainText) => markdown(plainText),
    forceSync: true, // Avoid validation error on generic create view
    imageTexts: {
@@ -33,6 +33,15 @@
    padding: 1px 2px;
  }
  /**
   * Some restyling rules for the cases where our own md css
   * conflicts with the easymde editor preview css
   */
  &.editor-preview {
    pre {
      background: unset;
    }
  }
  pre code {
    // code that is not inlined
    margin: 15px;
@@ -29,5 +29,13 @@
    </span>
    {{ form.show_my_stats.errors }}
  </fieldset>
  <fieldset class="form-group">
    {{ form.show_my_timetable }}
    {{ form.show_my_timetable.label_tag() }}
    <span class="helptext">
      {{ form.show_my_timetable.help_text }}
    </span>
    {{ form.show_my_timetable.errors }}
  </fieldset>
  <input type="submit" class="btn btn-blue" value="{% trans %}Save{% endtrans %}">
 </form>
@@ -79,15 +79,5 @@
      {% endfor %}
    </tbody>
  </table>
  {% if
  profile.mailing_subscriptions.exists()
  and (profile.id == user.id or user.is_root or user.is_com_admin)
  %}
  <h4>{% trans %}Subscribed mailing lists{% endtrans %}</h4>
  {% for sub in profile.mailing_subscriptions.all() %}
    <p>{{ sub.mailing.email }} <a href="{{ url('club:mailing_subscription_delete', mailing_subscription_id=sub.id) }}">{% trans %}Unsubscribe{% endtrans %}</a></p>
  {% endfor %}
 {% endif %}
 {% endblock %}
@@ -31,10 +31,10 @@
          {% for sum in purchase_sums %}
            <div>
              <span>{{ sum["counter__name"] }}</span>
-              <span>{{ sum["total"] }} €</span>
+              <span>{{ "%.2f"|format(sum["total"]) }} €</span>
            </div>
          {% endfor %}
-          <div><b>Total : </b><b>{{ total_purchases }} €</b></div>
+          <div><b>Total : </b><b>{{ "%.2f"|format(total_purchases) }} €</b></div>
        </div>
      </div>
    </div>
@@ -133,7 +133,6 @@
              <li><a href="{{ url('com:alert_edit') }}">{% trans %}Edit alert message{% endtrans %}</a></li>
              <li><a href="{{ url('com:info_edit') }}">{% trans %}Edit information message{% endtrans %}</a></li>
              <li><a href="{{ url('core:file_moderation') }}">{% trans %}Moderate files{% endtrans %}</a></li>
              <li><a href="{{ url('com:mailing_admin') }}">{% trans %}Mailing lists administration{% endtrans %}</a></li>
              <li><a href="{{ url('com:poster_list') }}">{% trans %}Posters{% endtrans %}</a></li>
              <li><a href="{{ url('com:screen_list') }}">{% trans %}Screens{% endtrans %}</a></li>
            {% endif %}
@@ -84,6 +84,7 @@ from core.views import (
    notification,
    send_file,
 )
 from timetable.views import UserTimetableView
 register_converter(FourDigitYearConverter, "yyyy")
 register_converter(TwoDigitMonthConverter, "mm")
@@ -184,6 +185,11 @@ urlpatterns = [
        name="user_account_detail",
    ),
    path("user/<int:user_id>/stats/", UserStatsView.as_view(), name="user_stats"),
    path(
        "user/<int:user_id>/edt/",
        UserTimetableView.as_view(),
        name="user_timetable",
    ),
    path(
        "user/<int:user_id>/gift/create/",
        GiftCreateView.as_view(),
@@ -336,10 +336,14 @@ class UserVisibilityForm(forms.ModelForm):
    __preferences_fields = forms.fields_for_model(
        Preferences,
-        ["show_my_stats"],
+        ["show_my_stats", "show_my_timetable"],
-        widgets={"show_my_stats": forms.CheckboxInput(attrs={"class": "switch"})},
+        widgets={
            "show_my_stats": forms.CheckboxInput(attrs={"class": "switch"}),
            "show_my_timetable": forms.CheckboxInput(attrs={"class": "switch"}),
        },
    )
    show_my_stats = __preferences_fields["show_my_stats"]
    show_my_timetable = __preferences_fields["show_my_timetable"]
    def __init__(
        self, *args, initial: dict | None = None, instance: User | None = None, **kwargs
@@ -347,12 +351,16 @@ class UserVisibilityForm(forms.ModelForm):
        if instance:
            initial = initial or {}
            initial["show_my_stats"] = instance.preferences.show_my_stats
            initial["show_my_timetable"] = instance.preferences.show_my_timetable
        super().__init__(*args, initial=initial, instance=instance, **kwargs)
    def save(self, commit=True) -> User:  # noqa: FBT002
        instance = super().save(commit=commit)
        if commit:
            instance.preferences.show_my_stats = self.cleaned_data["show_my_stats"]
            instance.preferences.show_my_timetable = self.cleaned_data[
                "show_my_timetable"
            ]
            instance.preferences.save()
        return instance
@@ -1,6 +1,14 @@
 import copy
 import inspect
-from typing import TYPE_CHECKING, Any, ClassVar, LiteralString, Protocol, Unpack
+from typing import (
    TYPE_CHECKING,
    Any,
    ClassVar,
    LiteralString,
    Protocol,
    TypedDict,
    Unpack,
 )
 from django.core.exceptions import ImproperlyConfigured
 from django.template.loader import render_to_string
@@ -12,11 +20,17 @@ if TYPE_CHECKING:
    from django.utils.safestring import SafeString
 class TabItem(TypedDict):
    url: str
    slug: str
    name: str
 class TabedViewMixin(View):
    """Basic functions for displaying tabs in the template."""
    current_tab: ClassVar[str | None] = None
-    list_of_tabs: ClassVar[list | None] = None
+    list_of_tabs: ClassVar[list[TabItem] | None] = None
    tabs_title: ClassVar[str | None] = None
    def get_tabs_title(self):
@@ -413,7 +413,7 @@ class UserStatsView(UserTabsMixin, UserPassesTestMixin, DetailView):
        kwargs = super().get_context_data(**kwargs)
        kwargs["perm_time"] = list(
-            self.object.permanencies.filter(end__isnull=False, counter__type="BAR")
+            self.object.permanencies.filter(end__isnull=False)
            .values("counter", "counter__name")
            .annotate(total=Sum(F("end") - F("start"), default=timedelta(seconds=0)))
            .order_by("-total")
@@ -422,8 +422,7 @@ class UserStatsView(UserTabsMixin, UserPassesTestMixin, DetailView):
            [perm["total"] for perm in kwargs["perm_time"]], start=timedelta(seconds=0)
        )
        kwargs["purchase_sums"] = list(
-            self.object.customer.buyings.filter(counter__type="BAR")
+            self.object.customer.buyings.values("counter", "counter__name")
            .values("counter", "counter__name")
            .annotate(total=Sum(F("unit_price") * F("quantity")))
            .order_by("-total")
        )
@@ -647,13 +647,6 @@ class Counter(models.Model):
            or user in self.sellers.all()
        )
    def gen_token(self) -> None:
        """Generate a new token for this counter."""
        self.token = "".join(
            random.choice(string.ascii_letters + string.digits) for _ in range(30)
        )
        self.save()
    @cached_property
    def barmen_list(self) -> list[User]:
        """Returns the barman list as list of User."""
@@ -661,10 +654,6 @@ class Counter(models.Model):
            p.user for p in self.permanencies.filter(end=None).select_related("user")
        ]
    def get_random_barman(self) -> User:
        """Return a random user being currently a barman."""
        return random.choice(self.barmen_list)
    def update_activity(self) -> None:
        """Update the barman activity to prevent timeout."""
        self.permanencies.filter(end=None).update(activity=timezone.now())
@@ -83,8 +83,17 @@
 {% endmacro %}
 {% block content %}
  <div class="alert alert-yellow">
    <div class="alert-main">
      {%- trans trimmed -%}
        You can see product details.
        However, you cannot edit it, thus you won't be able
        to submit this form.
      {%- endtrans -%}
    </div>
  </div>
  {% if object %}
-    <h2>{% trans name=object %}Edit product {{ name }}{% endtrans %}</h2>
+    <h2>{{ object }}</h2>
    <p><i>{% trans %}Creation date{% endtrans %} : {{ object.created_at|date }}</i></p>
    <p><i>{% trans %}Last update{% endtrans %} : {{ object.updated_at|date }}</i></p>
  {% else %}
@@ -127,19 +136,17 @@
      {{ form.price_formset.management_form }}
      <div x-ref="formContainer">
        {%- for form in form.price_formset.forms -%}
-          <div>
+          <div>{{ price_form(form) }}</div>
            {{ price_form(form) }}
          </div>
        {%- endfor -%}
      </div>
      <template x-ref="formTemplate">
-        <div>
+        <div>{{ price_form(form.price_formset.empty_form) }}</div>
          {{ price_form(form.price_formset.empty_form) }}
        </div>
      </template>
-      <button class="btn btn-grey" @click.prevent="addForm()">
+      {% if user.has_perm("counter.change_product") %}
-        <i class="fa fa-plus"></i> {% trans %}Add a price{% endtrans %}
+        <button class="btn btn-grey" @click.prevent="addForm()">
-      </button>
+          <i class="fa fa-plus"></i> {% trans %}Add a price{% endtrans %}
        </button>
      {% endif %}
    </div>
    <br />
@@ -165,11 +172,16 @@
      <template x-ref="formTemplate">
        {{ action_form(form.action_formset.empty_form) }}
      </template>
-      <button @click.prevent="addForm()" class="btn btn-grey">
+      {% if user.has_perm("counter.change_product") %}
-        <i class="fa fa-plus"></i>{% trans %}Add action{% endtrans %}
+        <button @click.prevent="addForm()" class="btn btn-grey">
-      </button>
+          <i class="fa fa-plus"></i>{% trans %}Add action{% endtrans %}
        </button>
      {% endif %}
    </div>
    <div class="row gap margin-bottom">{{ form.archived.as_field_group() }}</div>
-    <p><input class="btn btn-blue" type="submit" value="{% trans %}Save{% endtrans %}" /></p>
+
    {% if user.has_perm("counter.change_product") %}
      <p><input class="btn btn-blue" type="submit" value="{% trans %}Save{% endtrans %}" /></p>
    {% endif %}
  </form>
 {% endblock %}
@@ -80,9 +80,11 @@
    <h3 class="margin-bottom">{% trans %}Product list{% endtrans %}</h3>
    <div class="row margin-bottom">
-      <a href="{{ url('counter:new_product') }}" class="btn btn-blue">
+      {% if user.has_perm("counter.add_product") %}
-        {% trans %}New product{% endtrans %} <i class="fa fa-plus"></i>
+        <a href="{{ url('counter:new_product') }}" class="btn btn-blue">
-      </a>
+          {% trans %}New product{% endtrans %} <i class="fa fa-plus"></i>
        </a>
      {% endif %}
      <button
        class="btn btn-blue"
        @click="downloadCsv()"
@@ -13,12 +13,12 @@
 {% endblock %}
 {% block content %}
-  <p>
+  {% if user.has_perm("counter.add_producttype") %}
-    <a href="{{ url('counter:new_product_type') }}" class="btn btn-blue">
+    <a href="{{ url('counter:new_product_type') }}" class="btn btn-blue margin-bottom">
      {% trans %}New product type{% endtrans %}
      <i class="fa fa-plus"></i>
    </a>
-  </p>
+  {% endif %}
  {% if product_types %}
    <aside>
      <p>
@@ -48,7 +48,7 @@ from counter.models import (
    Selling,
 )
 from counter.utils import is_logged_in_counter
-from counter.views.mixins import CounterAdminMixin, CounterAdminTabsMixin
+from counter.views.mixins import CounterAdminTabsMixin
 class CounterListView(CounterAdminTabsMixin, CanViewMixin, ListView):
@@ -84,17 +84,18 @@ class CounterEditView(
        return reverse_lazy("counter:admin", kwargs={"counter_id": self.object.id})
-class CounterEditPropView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
+class CounterEditPropView(CounterAdminTabsMixin, PermissionRequiredMixin, UpdateView):
-    """Edit a counter's main informations (for the counter's admin)."""
+    """Edit a counter's main infos."""
    model = Counter
    form_class = modelform_factory(Counter, fields=["name", "club", "type"])
    pk_url_kwarg = "counter_id"
    template_name = "core/edit.jinja"
    current_tab = "counters"
    permission_required = "counter.change_counter"
-class CounterCreateView(CounterAdminTabsMixin, CounterAdminMixin, CreateView):
+class CounterCreateView(CounterAdminTabsMixin, PermissionRequiredMixin, CreateView):
    """Create a counter (for the admins)."""
    model = Counter
@@ -105,9 +106,10 @@ class CounterCreateView(CounterAdminTabsMixin, CounterAdminMixin, CreateView):
    )
    template_name = "core/create.jinja"
    current_tab = "counters"
    permission_required = "counter.add_counter"
-class CounterDeleteView(CounterAdminTabsMixin, CounterAdminMixin, DeleteView):
+class CounterDeleteView(CounterAdminTabsMixin, PermissionRequiredMixin, DeleteView):
    """Delete a counter (for the admins)."""
    model = Counter
@@ -115,30 +117,33 @@ class CounterDeleteView(CounterAdminTabsMixin, CounterAdminMixin, DeleteView):
    template_name = "core/delete_confirm.jinja"
    success_url = reverse_lazy("counter:admin_list")
    current_tab = "counters"
    permission_required = "counter.delete_counter"
 # Product management
-class ProductTypeListView(CounterAdminTabsMixin, CounterAdminMixin, ListView):
+class ProductTypeListView(CounterAdminTabsMixin, PermissionRequiredMixin, ListView):
    """A list view for the admins."""
    model = ProductType
    template_name = "counter/product_type_list.jinja"
    current_tab = "product_types"
    context_object_name = "product_types"
    permission_required = "counter.view_producttype"
-class ProductTypeCreateView(CounterAdminTabsMixin, CounterAdminMixin, CreateView):
+class ProductTypeCreateView(CounterAdminTabsMixin, PermissionRequiredMixin, CreateView):
    """A create view for the admins."""
    model = ProductType
    fields = ["name", "description", "comment", "icon"]
    template_name = "core/create.jinja"
    current_tab = "products"
    permission_required = "counter.add_producttype"
-class ProductTypeEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
+class ProductTypeEditView(CounterAdminTabsMixin, PermissionRequiredMixin, UpdateView):
    """An edit view for the admins."""
    model = ProductType
@@ -146,23 +151,26 @@ class ProductTypeEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
    fields = ["name", "description", "comment", "icon"]
    pk_url_kwarg = "type_id"
    current_tab = "products"
    permission_required = "counter.change_producttype"
-class ProductListView(CounterAdminTabsMixin, CounterAdminMixin, TemplateView):
+class ProductListView(CounterAdminTabsMixin, PermissionRequiredMixin, TemplateView):
    current_tab = "products"
    template_name = "counter/product_list.jinja"
    permission_required = "counter.view_product"
-class ProductCreateView(CounterAdminTabsMixin, CounterAdminMixin, CreateView):
+class ProductCreateView(CounterAdminTabsMixin, PermissionRequiredMixin, CreateView):
    """A create view for the admins."""
    model = Product
    form_class = ProductForm
    template_name = "counter/product_form.jinja"
    current_tab = "products"
    permission_required = "counter.add_product"
-class ProductEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
+class ProductEditView(CounterAdminTabsMixin, PermissionRequiredMixin, UpdateView):
    """An edit view for the admins."""
    model = Product
@@ -170,6 +178,13 @@ class ProductEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
    pk_url_kwarg = "product_id"
    template_name = "counter/product_form.jinja"
    current_tab = "products"
    permission_required = "counter.change_product"
    def has_permission(self):
        return self.request.user.has_perm("counter.change_product") or (
            self.request.method == "GET"
            and self.request.user.has_perm("counter.view_product")
        )
 class ProductFormulaListView(CounterAdminTabsMixin, PermissionRequiredMixin, ListView):
@@ -299,7 +314,6 @@ class RefillingDeleteView(DeleteView):
    template_name = "core/delete_confirm.jinja"
    def dispatch(self, request, *args, **kwargs):
        """We have here a very particular right handling, we can't inherit from CanEditPropMixin."""
        self.object = self.get_object()
        if timezone.now() - self.object.date <= timedelta(
            minutes=settings.SITH_LAST_OPERATIONS_LIMIT
@@ -324,7 +338,6 @@ class SellingDeleteView(DeleteView):
    template_name = "core/delete_confirm.jinja"
    def dispatch(self, request, *args, **kwargs):
        """We have here a very particular right handling, we can't inherit from CanEditPropMixin."""
        self.object = self.get_object()
        if timezone.now() - self.object.date <= timedelta(
            minutes=settings.SITH_LAST_OPERATIONS_LIMIT
@@ -376,30 +389,31 @@ class CounterStatView(PermissionRequiredMixin, DetailView):
        return kwargs
-class CounterRefillingListView(CounterAdminTabsMixin, CounterAdminMixin, ListView):
+class CounterRefillingListView(
    CounterAdminTabsMixin, PermissionRequiredMixin, ListView
 ):
    """List of refillings on a counter."""
    model = Refilling
    template_name = "counter/refilling_list.jinja"
    current_tab = "counters"
    paginate_by = 30
    permission_required = "counter.view_refilling"
-    def dispatch(self, request, *args, **kwargs):
+    def get_queryset(self):
-        self.counter = get_object_or_404(Counter, pk=kwargs["counter_id"])
+        self.counter = get_object_or_404(Counter, pk=self.kwargs["counter_id"])
-        self.queryset = Refilling.objects.filter(counter__id=self.counter.id)
+        return Refilling.objects.filter(counter=self.counter).order_by("-date")
        return super().dispatch(request, *args, **kwargs)
    def get_context_data(self, **kwargs):
-        kwargs = super().get_context_data(**kwargs)
+        return super().get_context_data(**kwargs) | {"counter": self.counter}
        kwargs["counter"] = self.counter
        return kwargs
-class RefoundAccountView(UserPassesTestMixin, FormView):
+class RefoundAccountView(UserPassesTestMixin, SuccessMessageMixin, FormView):
    """Create a selling with the same amount as the current user money."""
    template_name = "counter/refound_account.jinja"
    form_class = CloseCustomerAccountForm
    success_message = _("%(user)s's AE account has been emptied")
    def test_func(self):
        return self.request.user.is_root or self.request.user.is_in_group(
@@ -12,7 +12,7 @@
 # OR WITHIN THE LOCAL FILE "LICENSE"
 #
 #
-
+from django.contrib.auth.mixins import PermissionRequiredMixin
 from django.http import Http404, HttpResponse
 from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView
@@ -21,28 +21,30 @@ from django.views.generic.edit import CreateView, UpdateView
 from core.auth.mixins import CanViewMixin
 from counter.forms import EticketForm
 from counter.models import Eticket, Selling
-from counter.views.mixins import CounterAdminMixin, CounterAdminTabsMixin
+from counter.views.mixins import CounterAdminTabsMixin
-class EticketListView(CounterAdminTabsMixin, CounterAdminMixin, ListView):
+class EticketListView(CounterAdminTabsMixin, PermissionRequiredMixin, ListView):
    """A list view for the admins."""
    model = Eticket
    template_name = "counter/eticket_list.jinja"
    ordering = ["id"]
    current_tab = "etickets"
    permission_required = "counter.view_eticket"
-class EticketCreateView(CounterAdminTabsMixin, CounterAdminMixin, CreateView):
+class EticketCreateView(CounterAdminTabsMixin, PermissionRequiredMixin, CreateView):
    """Create an eticket."""
    model = Eticket
    template_name = "core/create.jinja"
    form_class = EticketForm
    current_tab = "etickets"
    permission_required = "counter.add_eticket"
-class EticketEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
+class EticketEditView(CounterAdminTabsMixin, PermissionRequiredMixin, UpdateView):
    """Edit an eticket."""
    model = Eticket
@@ -50,6 +52,7 @@ class EticketEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
    form_class = EticketForm
    pk_url_kwarg = "eticket_id"
    current_tab = "etickets"
    permission_required = "counter.change_eticket"
 class EticketPDFView(CanViewMixin, DetailView):
@@ -13,38 +13,13 @@
 #
 #
 from django.conf import settings
 from django.core.exceptions import PermissionDenied
 from django.urls import reverse, reverse_lazy
 from django.utils.translation import gettext_lazy as _
 from django.views.generic.base import View
 from core.views.mixins import TabedViewMixin
 from counter.utils import is_logged_in_counter
 class CounterAdminMixin(View):
    """Protect counter admin section."""
    edit_group = [settings.SITH_GROUP_COUNTER_ADMIN_ID]
    edit_club = []
    def _test_group(self, user):
        return any(user.is_in_group(pk=grp_id) for grp_id in self.edit_group)
    def _test_club(self, user):
        return any(c.can_be_edited_by(user) for c in self.edit_club)
    def dispatch(self, request, *args, **kwargs):
        if not (
            request.user.is_root
            or self._test_group(request.user)
            or self._test_club(request.user)
        ):
            raise PermissionDenied
        return super().dispatch(request, *args, **kwargs)
 class CounterTabsMixin(TabedViewMixin):
    def get_tabs_title(self):
        return self.object
@@ -89,45 +64,70 @@ class CounterTabsMixin(TabedViewMixin):
 class CounterAdminTabsMixin(TabedViewMixin):
    tabs_title = _("Counter administration")
-    list_of_tabs = [
+
-        {
+    def get_list_of_tabs(self):
-            "url": reverse_lazy("counter:admin_list"),
+        user = self.request.user
-            "slug": "counters",
+        res = [
-            "name": _("Counters"),
+            {
-        },
+                "url": reverse_lazy("counter:admin_list"),
-        {
+                "slug": "counters",
-            "url": reverse_lazy("counter:product_list"),
+                "name": _("Counters"),
-            "slug": "products",
+            }
-            "name": _("Products"),
+        ]
-        },
+        if user.has_perm("counter.view_product"):
-        {
+            res.append(
-            "url": reverse_lazy("counter:product_formula_list"),
+                {
-            "slug": "formulas",
+                    "url": reverse_lazy("counter:product_list"),
-            "name": _("Formulas"),
+                    "slug": "products",
-        },
+                    "name": _("Products"),
-        {
+                }
-            "url": reverse_lazy("counter:product_type_list"),
+            )
-            "slug": "product_types",
+        if user.has_perm("counter.view_productformula"):
-            "name": _("Product types"),
+            res.append(
-        },
+                {
-        {
+                    "url": reverse_lazy("counter:product_formula_list"),
-            "url": reverse_lazy("counter:returnable_list"),
+                    "slug": "formulas",
-            "slug": "returnable_products",
+                    "name": _("Formulas"),
-            "name": _("Returnable products"),
+                }
-        },
+            )
-        {
+        if user.has_perm("counter.view_producttype"):
-            "url": reverse_lazy("counter:cash_summary_list"),
+            res.append(
-            "slug": "cash_summary",
+                {
-            "name": _("Cash register summaries"),
+                    "url": reverse_lazy("counter:product_type_list"),
-        },
+                    "slug": "product_types",
-        {
+                    "name": _("Product types"),
-            "url": reverse_lazy("counter:invoices_call"),
+                }
-            "slug": "invoices_call",
+            )
-            "name": _("Invoices call"),
+        if user.has_perm("counter.view_returnableproduct"):
-        },
+            res.append(
-        {
+                {
-            "url": reverse_lazy("counter:eticket_list"),
+                    "url": reverse_lazy("counter:returnable_list"),
-            "slug": "etickets",
+                    "slug": "returnable_products",
-            "name": _("Etickets"),
+                    "name": _("Returnable products"),
-        },
+                }
-    ]
+            )
        if user.has_perm("counter.view_cashregistersummary"):
            res.append(
                {
                    "url": reverse_lazy("counter:cash_summary_list"),
                    "slug": "cash_summary",
                    "name": _("Cash register summaries"),
                }
            )
        if user.has_perm("counter.view_invoicecall"):
            res.append(
                {
                    "url": reverse_lazy("counter:invoices_call"),
                    "slug": "invoices_call",
                    "name": _("Invoices call"),
                }
            )
        if user.has_perm("counter.view_eticket"):
            res.append(
                {
                    "url": reverse_lazy("counter:eticket_list"),
                    "slug": "etickets",
                    "name": _("Etickets"),
                }
            )
        return res
@@ -48,7 +48,7 @@ des scripts complets mais qui restent lisibles,
    ```
    Ok, c'est de la triche, on installe un package externe.
    Mais bon, ça marche, et l'équivalent pur bash
-    serait carrément plus moche.
+    serait un pur enfer.
 === "nu"
@@ -59,20 +59,18 @@ des scripts complets mais qui restent lisibles,
    Nombre de lignes total :
    ```nu
-    ls **/*.py | insert linecount { get name | open | lines | length } | math sum
+    ls **/*.py | par-each { open $in.name | lines | length } | math sum
    ```
    Vous pouvez aussi exlure les lignes vides
    et les les lignes de commentaire :
    ```nu
    ls **/*.py |
-    insert linecount {
+    par-each {
-        get name |
+        open $in.name |
        open |
        lines |
        each { str trim } |
-        filter { |l| not ($l | str starts-with "#") } |  # commentaires
+        where { |l| ($l | str length) > 0 and not ($l | str starts-with "#") } |
        filter { |l| ($l | str length) > 0 } |  # lignes vides
        length
    } |
    math sum
@@ -18,7 +18,8 @@ il n'est pas possible de développer le site sur ce système d'exploitation.
 Heureusement, il existe une alternative qui ne requiert pas de désinstaller votre
 OS ni de mettre un dual boot sur votre ordinateur : `WSL`.
- **Prérequis:** vous devez être sur Windows 10 version 2004 ou ultérieure (build 19041 & versions ultérieures) ou Windows 11.
+- **Prérequis:** vous devez être sur Windows 10 version 2004 ou ultérieure (build 19041 & versions ultérieures) ou
  Windows 11.
 - **Plus d'info:** [docs.microsoft.com](https://docs.microsoft.com/fr-fr/windows/wsl/install)
 ```shell
@@ -43,7 +44,7 @@ il suffit d'utiliser la commande suivante :
 cd /mnt/<la_lettre_du_disque>/vos/fichiers/comme/dhab
 ```
-!!!note
+!!!success
    À ce stade, si vous avez réussi votre installation de `WSL` ou bien qu'il
    était déjà installé, vous pouvez effectuer la mise en place du projet en suivant
@@ -101,10 +102,10 @@ cd /mnt/<la_lettre_du_disque>/vos/fichiers/comme/dhab
        ln -s /usr/bin/valkey-server /usr/bin/redis-server
        ```
 === "macOS"
-    Pour installer les dépendances, il est fortement recommandé d'installer le gestionnaire de paquets `homebrew <https://brew.sh/index_fr>`_.  
+    Pour installer les dépendances, il est fortement recommandé 
    d'installer le gestionnaire de paquets `homebrew <https://brew.sh/index_fr>`_.  
    Il est également nécessaire d'avoir installé xcode
    ```bash    
@@ -116,12 +117,15 @@ cd /mnt/<la_lettre_du_disque>/vos/fichiers/comme/dhab
    !!!note
-        Si vous rencontrez des erreurs lors de votre configuration, n'hésitez pas à vérifier l'état de votre installation homebrew avec :code:`brew doctor`
+        Si vous rencontrez des erreurs lors de votre configuration, 
        n'hésitez pas à vérifier l'état de votre installation homebrew 
        avec :code:`brew doctor`
 !!!note
    Python ne fait pas parti des dépendances puisqu'il est automatiquement
-    installé par uv. Il est cependant parfois nécessaire d'installer les headers Python nécessaire à la compilation de certains paquets.
+    installé par uv. Il est cependant parfois nécessaire d'installer 
    les headers Python nécessaire à la compilation de certains paquets.
 ## Finaliser l'installation
@@ -145,7 +149,6 @@ uv run ./manage.py install_xapian
    de texte à l'écran.
    C'est normal, il ne faut pas avoir peur.
 La modification de la configuration passe par la modification de variables
 d'environnement.
 Ces variables sont stockées dans un fichier `.env`.
@@ -183,11 +186,32 @@ Il suffit ensuite d'utiliser cette commande :
 uv run ./manage.py runserver
 ```
-!!!note
+Le serveur est alors accessible à l'adresse
 [http://localhost:8000](http://localhost:8000) 
 ou bien [http://127.0.0.1:8000/](http://127.0.0.1:8000/).
-    Le serveur est alors accessible à l'adresse
+Pour vous connecter, vous pouvez utiliser un des comptes utilisateur
-    [http://localhost:8000](http://localhost:8000) 
+créés durant l'installation :
-    ou bien [http://127.0.0.1:8000/](http://127.0.0.1:8000/).
+
 | username         | description                                                                |
 |------------------|----------------------------------------------------------------------------|
 | `root`           | super-utilisateur<br/>il peut tout faire et tout voir                      |
 | `subscriber`     | simple cotisant                                                            |
 | `old_subscriber` | ancien cotisant                                                            |
 | `public`         | non-cotisant                                                               |
 | `krophil`        | cotisant<br/>barman Foyer<br/>président du Troll Penché                    |
 | `sli`            | cotisant<br/>VP Troll                                                      |
 | `skia`           | cotisant<br/>barman MDE<br/>membre du bureau AE<br/>ancien membre du Troll |
 | `comunity`       | cotisant<br/>membre du bureau PdF<br/>admin communication                  |
 | `counter`        | cotisant<br/>admin comptoirs                                               |
 | `comptable`      | cotisant<br/>admin comptabilité                                            |
 | `rbatsbak`       | cotisant<br/>membre du Troll                                               |
 En plus de ces dernier, quelques centaines d'utilisateurs
 supplémentaires sont générés procéduralement,
 afin de rajouter un peu de volume de données.
 Tous les utilisateurs ont le mot de passe `plop`.
 !!!note
@@ -346,13 +346,16 @@ class ForumTopicDetailView(CanViewMixin, DetailView):
        return kwargs
-class ForumMessageView(SingleObjectMixin, RedirectView):
+class ForumMessageView(SingleObjectMixin, UserPassesTestMixin, RedirectView):
    model = ForumMessage
    pk_url_kwarg = "message_id"
    permanent = False
-    def get_redirect_url(self, *args, **kwargs):
+    def test_func(self) -> bool:
        self.object = self.get_object()
        return self.request.user.can_view(self.object)
    def get_redirect_url(self, *args, **kwargs):
        return self.object.get_url()
@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-10-02 12:56+0200\n"
+"POT-Creation-Date: 2026-10-19 19:45+0200\n"
 "PO-Revision-Date: 2016-07-18\n"
 "Last-Translator: Maréchal <thomas.girod@utbm.fr\n"
 "Language-Team: AE info <ae.info@utbm.fr>\n"
@@ -192,51 +192,11 @@ msgstr ""
 "arrivée durant l'interaction avec l'application tierce. Veuillez contacter "
 "les responsables de cette dernière."
 #: club/forms.py
 msgid "Users to add"
 msgstr "Utilisateurs à ajouter"
 #: club/forms.py core/views/group.py
 msgid "Search users to add (one or more)."
 msgstr "Recherche les utilisateurs à ajouter (un ou plus)."
 #: club/forms.py
 msgid "New Mailing"
 msgstr "Nouvelle mailing liste"
 #: club/forms.py
 msgid "Subscribe"
 msgstr "S'abonner"
 #: club/forms.py
 msgid "Remove"
 msgstr "Retirer"
 #: club/forms.py counter/forms.py pedagogy/templates/pedagogy/moderation.jinja
 msgid "Action"
 msgstr "Action"
 #: club/forms.py club/tests/test_mailing.py
 msgid "This field is required"
 msgstr "Ce champ est obligatoire"
 #: club/forms.py club/tests/test_mailing.py
 msgid "One of the selected users doesn't have an email address"
 msgstr "Un des utilisateurs sélectionnés n'a pas d'adresse email"
 #: club/forms.py
 msgid "An action is required"
 msgstr "Une action est requise"
 #: club/forms.py club/tests/test_mailing.py
 msgid "You must specify at least an user or an email address"
 msgstr "vous devez spécifier au moins un utilisateur ou une adresse email"
 #: club/forms.py counter/forms.py
 msgid "Begin date"
 msgstr "Date de début"
-#: club/forms.py com/forms.py counter/forms.py subscription/forms.py
+#: club/forms.py com/forms.py counter/forms.py
 msgid "End date"
 msgstr "Date de fin"
@@ -414,60 +374,6 @@ msgstr "rôle"
 msgid "past member"
 msgstr "ancien membre"
 #: club/models.py com/templates/com/mailing_admin.jinja
 #: com/templates/com/news_admin_list.jinja com/templates/com/weekmail.jinja
 #: core/templates/core/user_clubs.jinja
 #: counter/templates/counter/invoices_call.jinja
 #: trombi/templates/trombi/edit_profile.jinja
 #: trombi/templates/trombi/export.jinja
 #: trombi/templates/trombi/user_profile.jinja
 msgid "Club"
 msgstr "Club"
 #: club/models.py
 msgid "Email address"
 msgstr "Adresse email"
 #: club/models.py
 msgid "Enter a valid address. Only the root of the address is needed."
 msgstr ""
 "Entrez une adresse valide. Seule la racine de l'adresse est nécessaire."
 #: club/models.py com/models.py core/models.py
 msgid "is moderated"
 msgstr "est modéré"
 #: club/models.py com/models.py
 msgid "moderator"
 msgstr "modérateur"
 #: club/models.py
 msgid "This mailing list already exists."
 msgstr "Cette liste de diffusion existe déjà."
 #: club/models.py club/templates/club/mailing.jinja
 msgid "Mailing"
 msgstr "Liste de diffusion"
 #: club/models.py club/templates/club/club_members.jinja
 #: club/templates/club/club_old_members.jinja club/templates/club/mailing.jinja
 #: counter/templates/counter/cash_summary_list.jinja
 #: counter/templates/counter/stats.jinja
 msgid "User"
 msgstr "Utilisateur"
 #: club/models.py
 msgid "At least user or email is required"
 msgstr "Au moins un utilisateur ou un email est nécessaire"
 #: club/models.py club/tests/test_mailing.py
 msgid "This email is already suscribed in this mailing"
 msgstr "Cet email est déjà abonné à cette mailing"
 #: club/models.py
 msgid "Unregistered user"
 msgstr "Utilisateur non enregistré"
 #: club/models.py
 msgid "The base url that links with this type must respect"
 msgstr "L'url de base que tous les liens de ce type doivent respecter"
@@ -517,6 +423,22 @@ msgstr "Url dupliquée"
 msgid "This link doesn't match with the url base of its type."
 msgstr "Ce lien ne correspond pas à l'url de base de son type."
 #: club/templates/club/club_detail.jinja club/views.py
 #: com/templates/com/news_admin_list.jinja com/templates/com/poster_list.jinja
 #: com/templates/com/screen_list.jinja com/templates/com/weekmail.jinja
 #: core/templates/core/file.jinja core/templates/core/group_list.jinja
 #: core/templates/core/page/base.jinja core/templates/core/user_tools.jinja
 #: core/views/user.py counter/templates/counter/cash_summary_list.jinja
 #: counter/templates/counter/counter_list.jinja
 #: election/templates/election/election_detail.jinja
 #: forum/templates/forum/macros.jinja
 #: pedagogy/templates/pedagogy/fragments/ue_detail/comments.jinja
 #: pedagogy/templates/pedagogy/guide.jinja sas/templates/sas/album.jinja
 #: trombi/templates/trombi/detail.jinja
 #: trombi/templates/trombi/edit_profile.jinja
 msgid "Edit"
 msgstr "Éditer"
 #: club/templates/club/club_detail.jinja com/templates/com/news_list.jinja
 msgid "Links"
 msgstr "Liens"
@@ -554,6 +476,13 @@ msgstr "Membres du club"
 msgid "Manage roles"
 msgstr "Gérer les rôles"
 #: club/templates/club/club_members.jinja
 #: club/templates/club/club_old_members.jinja
 #: counter/templates/counter/cash_summary_list.jinja
 #: counter/templates/counter/stats.jinja
 msgid "User"
 msgstr "Utilisateur"
 #: club/templates/club/club_members.jinja
 #: club/templates/club/club_old_members.jinja
 #: core/templates/core/user_clubs.jinja
@@ -817,8 +746,7 @@ msgstr "Total"
 msgid "Payment method"
 msgstr "Méthode de paiement"
-#: club/templates/club/club_sellings.jinja club/templates/club/mailing.jinja
+#: club/templates/club/club_sellings.jinja com/templates/com/macros.jinja
 #: com/templates/com/macros.jinja com/templates/com/mailing_admin.jinja
 #: com/templates/com/news_admin_list.jinja com/templates/com/poster_edit.jinja
 #: com/templates/com/screen_edit.jinja com/templates/com/weekmail.jinja
 #: core/templates/core/file_detail.jinja
@@ -944,60 +872,6 @@ msgstr "Ajouter"
 msgid "Join"
 msgstr "Rejoindre"
 #: club/templates/club/mailing.jinja
 msgid "Mailing lists"
 msgstr "Mailing listes"
 #: club/templates/club/mailing.jinja
 msgid ""
 "Remember : mailing lists need to be moderated, if your new created list is "
 "not shown wait until moderation takes action"
 msgstr ""
 "Rappelez vous : les mailing listes doivent être modérées, si votre liste "
 "nouvellement créée n'est pas affichée, attendez jusqu'à ce qu'un modérateur "
 "prenne une décision"
 #: club/templates/club/mailing.jinja
 msgid "Mailing lists waiting for moderation"
 msgstr "Listes de diffusions en attente de modération"
 #: club/templates/club/mailing.jinja
 msgid "Generate mailing list"
 msgstr "Générer la liste de diffusion"
 #: club/templates/club/mailing.jinja com/templates/com/mailing_admin.jinja
 msgid "Email"
 msgstr "Email"
 #: club/templates/club/mailing.jinja
 msgid "Remove from mailing list"
 msgstr "Supprimer de la liste de diffusion"
 #: club/templates/club/mailing.jinja
 msgid "There is no subscriber for this mailing list"
 msgstr "Il n'y a pas d'abonnés dans cette liste de diffusion"
 #: club/templates/club/mailing.jinja
 msgid "No mailing list existing for this club"
 msgstr "Aucune mailing liste n'existe pour ce club"
 #: club/templates/club/mailing.jinja
 #: subscription/templates/subscription/subscription.jinja
 msgid "New member"
 msgstr "Nouveau membre"
 #: club/templates/club/mailing.jinja
 msgid "Add to mailing list"
 msgstr "Ajouter à la mailing liste"
 #: club/templates/club/mailing.jinja
 msgid "New mailing"
 msgstr "Nouvelle liste de diffusion"
 #: club/templates/club/mailing.jinja
 msgid "Create mailing list"
 msgstr "Créer une liste de diffusion"
 #: club/templates/club/pagerev_edit.jinja core/templates/core/page/edit.jinja
 msgid "Edit page"
 msgstr "Éditer la page"
@@ -1019,34 +893,10 @@ msgstr "Historique"
 msgid "Tools"
 msgstr "Outils"
 #: club/views.py com/templates/com/news_admin_list.jinja
 #: com/templates/com/poster_list.jinja com/templates/com/screen_list.jinja
 #: com/templates/com/weekmail.jinja core/templates/core/file.jinja
 #: core/templates/core/group_list.jinja core/templates/core/page/base.jinja
 #: core/templates/core/user_tools.jinja core/views/user.py
 #: counter/templates/counter/cash_summary_list.jinja
 #: counter/templates/counter/counter_list.jinja
 #: election/templates/election/election_detail.jinja
 #: forum/templates/forum/macros.jinja
 #: pedagogy/templates/pedagogy/fragments/ue_detail/comments.jinja
 #: pedagogy/templates/pedagogy/guide.jinja sas/templates/sas/album.jinja
 #: trombi/templates/trombi/detail.jinja
 #: trombi/templates/trombi/edit_profile.jinja
 msgid "Edit"
 msgstr "Éditer"
 #: club/views.py
 msgid "Edit club page"
 msgstr "Éditer la page de club"
 #: club/views.py
 msgid "Sellings"
 msgstr "Vente"
 #: club/views.py
 msgid "Mailing list"
 msgstr "Listes de diffusion"
 #: club/views.py
 msgid "You are now a member of this club."
 msgstr "Vous êtes maintenant membre de ce club."
@@ -1093,7 +943,7 @@ msgstr "Prix d'achat"
 msgid "Format: 16:9 | Resolution: 1920x1080"
 msgstr "Format : 16:9 | Résolution : 1920x1080"
-#: com/forms.py subscription/forms.py
+#: com/forms.py
 msgid "Start date"
 msgstr "Date de début"
@@ -1177,6 +1027,10 @@ msgstr "auteur"
 msgid "is published"
 msgstr "est publié"
 #: com/models.py
 msgid "moderator"
 msgstr "modérateur"
 #: com/models.py
 msgid "news"
 msgstr "nouvelle"
@@ -1237,6 +1091,10 @@ msgstr "fichier"
 msgid "display time"
 msgstr "temps d'affichage"
 #: com/models.py core/models.py
 msgid "is moderated"
 msgstr "est modéré"
 #: com/models.py
 msgid "Begin date should be before end date"
 msgstr "La date de début doit être avant celle de fin"
@@ -1272,46 +1130,6 @@ msgstr "Nouvelle publiée"
 msgid "News deleted"
 msgstr "Nouvelle supprimée"
 #: com/templates/com/mailing_admin.jinja com/views.py
 #: core/templates/core/user_tools.jinja
 msgid "Mailing lists administration"
 msgstr "Administration des mailing listes"
 #: com/templates/com/mailing_admin.jinja
 #: com/templates/com/news_admin_list.jinja com/templates/com/weekmail.jinja
 #: counter/templates/counter/refilling_list.jinja
 msgid "Actions"
 msgstr "Actions"
 #: com/templates/com/mailing_admin.jinja com/templates/com/poster_list.jinja
 #: core/templates/core/file_detail.jinja
 #: core/templates/core/file_moderation.jinja
 #: pedagogy/templates/pedagogy/fragments/ue_detail/comments.jinja
 #: sas/templates/sas/moderation.jinja sas/templates/sas/picture.jinja
 msgid "Moderate"
 msgstr "Modérer"
 #: com/templates/com/mailing_admin.jinja
 #, python-format
 msgid "Moderated by %(user)s"
 msgstr "Modéré par %(user)s"
 #: com/templates/com/mailing_admin.jinja
 msgid "This page lists all mailing lists"
 msgstr "Cette page liste toutes les listes de diffusion"
 #: com/templates/com/mailing_admin.jinja
 msgid "Not moderated mailing lists"
 msgstr "Listes de diffusion non modérées"
 #: com/templates/com/mailing_admin.jinja
 msgid "Moderated mailing lists"
 msgstr "Modérer les listes de diffusion"
 #: com/templates/com/mailing_admin.jinja
 msgid "No mailing list existing"
 msgstr "Aucune liste de diffusion existante"
 #: com/templates/com/news_admin_list.jinja
 msgid "News admin"
 msgstr "Administration des nouvelles"
@@ -1344,6 +1162,15 @@ msgstr "Titre"
 msgid "Summary"
 msgstr "Résumé"
 #: com/templates/com/news_admin_list.jinja com/templates/com/weekmail.jinja
 #: core/templates/core/user_clubs.jinja
 #: counter/templates/counter/invoices_call.jinja
 #: trombi/templates/trombi/edit_profile.jinja
 #: trombi/templates/trombi/export.jinja
 #: trombi/templates/trombi/user_profile.jinja
 msgid "Club"
 msgstr "Club"
 #: com/templates/com/news_admin_list.jinja com/templates/com/weekmail.jinja
 #: forum/templates/forum/forum.jinja sas/models.py
 msgid "Author"
@@ -1358,6 +1185,11 @@ msgstr "Modérateur"
 msgid "Dates"
 msgstr "Dates"
 #: com/templates/com/news_admin_list.jinja com/templates/com/weekmail.jinja
 #: counter/templates/counter/refilling_list.jinja
 msgid "Actions"
 msgstr "Actions"
 #: com/templates/com/news_admin_list.jinja core/templates/core/file.jinja
 #: core/templates/core/page/base.jinja
 msgid "View"
@@ -1518,6 +1350,13 @@ msgstr "Créer"
 msgid "Click to expand"
 msgstr "Cliquez pour agrandir"
 #: com/templates/com/poster_list.jinja core/templates/core/file_detail.jinja
 #: core/templates/core/file_moderation.jinja
 #: pedagogy/templates/pedagogy/fragments/ue_detail/comments.jinja
 #: sas/templates/sas/moderation.jinja sas/templates/sas/picture.jinja
 msgid "Moderate"
 msgstr "Modérer"
 #: com/templates/com/poster_list.jinja
 msgid "No posters"
 msgstr "Aucune affiche"
@@ -2828,14 +2667,6 @@ msgstr "Clubs actuels : "
 msgid "Old club(s) :"
 msgstr "Anciens clubs :"
 #: core/templates/core/user_clubs.jinja
 msgid "Subscribed mailing lists"
 msgstr "Mailing listes abonnées"
 #: core/templates/core/user_clubs.jinja
 msgid "Unsubscribe"
 msgstr "Se désabonner"
 #: core/templates/core/user_detail.jinja
 #, python-format
 msgid "%(user_name)s's profile"
@@ -3317,6 +3148,10 @@ msgstr "%s est déjà votre fillot/fillote"
 msgid "Users to add to group"
 msgstr "Utilisateurs à ajouter au groupe"
 #: core/views/group.py
 msgid "Search users to add (one or more)."
 msgstr "Recherche les utilisateurs à ajouter (un ou plus)."
 #: core/views/group.py
 msgid "Users to remove from group"
 msgstr "Utilisateurs à retirer du groupe"
@@ -3416,6 +3251,10 @@ msgstr ""
 "temps, mais les utilisateurs suivants ont été définis comme les deux : "
 "%(users)s"
 #: counter/forms.py pedagogy/templates/pedagogy/moderation.jinja
 msgid "Action"
 msgstr "Action"
 #: counter/forms.py
 msgid "Date and time of action"
 msgstr "Date et heure de l'action"
@@ -4102,7 +3941,6 @@ msgstr "Nouvelle formule"
 #: counter/templates/counter/fragments/create_student_card.jinja
 #: counter/templates/counter/invoices_call.jinja
 #: sas/templates/sas/picture.jinja
 #: subscription/templates/subscription/stats.jinja
 msgid "Go"
 msgstr "Valider"
@@ -4237,9 +4075,12 @@ msgid "Remove price"
 msgstr "Retirer le prix"
 #: counter/templates/counter/product_form.jinja
-#, python-format
+msgid ""
-msgid "Edit product %(name)s"
+"You can see product details. However, you cannot edit it, thus you won't be "
-msgstr "Édition du produit %(name)s"
+"able to submit this form."
 msgstr ""
 "Vous pouvez voir ce produit. Cependant, vous ne pouvez pas l'éditer ; vous "
 "ne serez donc pas en mesure de soumettre le formulaire."
 #: counter/templates/counter/product_form.jinja
 msgid "Creation date"
@@ -4411,6 +4252,11 @@ msgstr ""
 msgid "returnable product : %(returnable)s -> %(returned)s"
 msgstr "produit consigné : %(returnable)s -> %(returned)s"
 #: counter/views/admin.py
 #, python-format
 msgid "%(user)s's AE account has been emptied"
 msgstr "Le compte de %(user)s a été vidé"
 #: counter/views/cash.py
 msgid "10 cents"
 msgstr "10 centimes"
@@ -5860,10 +5706,6 @@ msgstr "Cursus alternant (-20%)"
 msgid "A new poster needs to be moderated"
 msgstr "Une nouvelle affiche a besoin d'être modérée"
 #: sith/settings.py
 msgid "A new mailing list needs to be moderated"
 msgstr "Une nouvelle mailing list a besoin d'être modérée"
 #: sith/settings.py
 msgid "A new pedagogy comment has been signaled for moderation"
 msgstr ""
@@ -5985,17 +5827,17 @@ msgid "Create another subscription"
 msgstr "Créer une nouvelle cotisation"
 #: subscription/templates/subscription/stats.jinja
-msgid "Total subscriptions"
+msgid "All subscriptions"
-msgstr "Cotisations totales"
+msgstr "Toutes les cotisations"
 #: subscription/templates/subscription/stats.jinja
 msgid "Subscriptions by type"
 msgstr "Cotisations par type"
 #: subscription/templates/subscription/subscription.jinja
 msgid "Existing member"
 msgstr "Membre existant"
 #: subscription/templates/subscription/subscription.jinja
 msgid "New member"
 msgstr "Nouveau membre"
 #: subscription/views.py
 msgid "the groups that can create subscriptions"
 msgstr "les groupes pouvant créer des cotisations"
@@ -621,7 +621,6 @@ with open(
 SITH_NOTIFICATIONS = [
    ("POSTER_MODERATION", _("A new poster needs to be moderated")),
    ("MAILING_MODERATION", _("A new mailing list needs to be moderated")),
    (
        "PEDAGOGY_MODERATION",
        _("A new pedagogy comment has been signaled for moderation"),
@@ -1 +1,17 @@
 # Register your models here.
 from django.contrib import admin
 from timetable.models import Timetable, TimetableSlot
 class TimetableSlotInline(admin.TabularInline):
    model = TimetableSlot
@admin.register(Timetable)
 class TimetableAdmin(admin.ModelAdmin):
    list_display = ("user", "semester")
    search_fields = ("user__nick_name", "user__first_name", "user__last_name")
    autocomplete_fields = ("user",)
    inlines = (TimetableSlotInline,)
    list_select_related = ("user",)
@@ -0,0 +1,37 @@
 from ninja.security import SessionAuth
 from ninja_extra import ControllerBase, api_controller, route
 from ninja_extra.exceptions import PermissionDenied
 from core.utils import get_semester_code
 from timetable.models import Timetable, TimetableSlot
 from timetable.schemas import CreateTimetableSchema, TimetableSchema
@api_controller("/edt", urls_namespace="timetable")
 class TimetableController(ControllerBase):
    @route.put(
        "/{int:user_id}",
        auth=SessionAuth(),
        response={200: TimetableSchema},
        url_name="save",
    )
    def save_timetable(self, user_id: int, data: CreateTimetableSchema):
        user = self.context.request.user
        if not user.has_perm("pedagogy.add_timetable") and not (
            user.has_perm("timetable.add_self_timetable") and user.id == user_id
        ):
            raise PermissionDenied
        timetable, created = Timetable.objects.get_or_create(
            semester=get_semester_code(), user_id=user_id
        )
        if not created:
            timetable.slots.all().delete()
        if user.preferences.show_my_timetable != data.is_viewable:
            user.preferences.show_my_timetable = data.is_viewable
            user.preferences.save()
        slots = TimetableSlot.objects.bulk_create(
            [TimetableSlot(timetable=timetable, **s.model_dump()) for s in data.slots]
        )
        return TimetableSchema(
            id=timetable.id, semester=timetable.semester, slots=slots
        )
@@ -0,0 +1,141 @@
 # Generated by Django 5.2.17 on 2026-10-03 21:43
 import django.core.validators
 import django.db.models.deletion
 from django.conf import settings
 from django.db import migrations, models
 import core.utils
 class Migration(migrations.Migration):
    initial = True
    dependencies = [migrations.swappable_dependency(settings.AUTH_USER_MODEL)]
    operations = [
        migrations.CreateModel(
            name="Timetable",
            fields=[
                (
                    "id",
                    models.BigAutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                (
                    "semester",
                    models.CharField(
                        blank=True,
                        default=core.utils.get_semester_code,
                        validators=[
                            django.core.validators.RegexValidator("(A|P)\\d{2}")
                        ],
                        verbose_name="semester",
                    ),
                ),
                (
                    "user",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        related_name="timetables",
                        to=settings.AUTH_USER_MODEL,
                        verbose_name="user",
                    ),
                ),
            ],
            options={
                "verbose_name": "timetable",
                "verbose_name_plural": "timetables",
                "permissions": [("add_self_timetable", "Can add its own timetable")],
            },
        ),
        migrations.CreateModel(
            name="TimetableSlot",
            fields=[
                (
                    "id",
                    models.BigAutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                (
                    "weekday",
                    models.SmallIntegerField(
                        choices=[
                            (1, "Monday"),
                            (2, "Tuesday"),
                            (3, "Wednesday"),
                            (4, "Thursday"),
                            (5, "Friday"),
                            (6, "Saturday"),
                            (7, "Sunday"),
                        ],
                        verbose_name="weekday",
                    ),
                ),
                (
                    "start_at",
                    models.PositiveSmallIntegerField(
                        validators=[django.core.validators.MaxValueValidator(95)],
                        verbose_name="start at",
                    ),
                ),
                (
                    "end_at",
                    models.PositiveSmallIntegerField(
                        validators=[django.core.validators.MaxValueValidator(95)],
                        verbose_name="end at",
                    ),
                ),
                (
                    "course_type",
                    models.CharField(max_length=12, verbose_name="course type"),
                ),
                ("room", models.CharField(max_length=32, verbose_name="room")),
                ("ue", models.CharField(max_length=32, verbose_name="ue")),
                (
                    "week_group",
                    models.CharField(
                        blank=True,
                        choices=[("A", "A"), ("B", "B")],
                        default="",
                        max_length=1,
                        verbose_name="week group",
                    ),
                ),
                (
                    "timetable",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        related_name="slots",
                        to="timetable.timetable",
                        verbose_name="timetable",
                    ),
                ),
            ],
            options={
                "verbose_name": "timetable slot",
                "verbose_name_plural": "timetable slots",
            },
        ),
        migrations.AddConstraint(
            model_name="timetable",
            constraint=models.UniqueConstraint(
                fields=("user", "semester"), name="timetable_unique_user_semester"
            ),
        ),
        migrations.AddConstraint(
            model_name="timetableslot",
            constraint=models.CheckConstraint(
                condition=models.Q(("end_at__gt", models.F("start_at"))),
                name="timetable_slot_end_after_start",
            ),
        ),
    ]
@@ -1 +1,102 @@
 # Create your models here.
 from datetime import timedelta
 from django.core.validators import MaxValueValidator, RegexValidator
 from django.db import models
 from django.db.models import F, Q
 from django.utils.translation import gettext_lazy as _
 from core.models import User
 from core.utils import get_semester_code
 class Timetable(models.Model):
    user = models.ForeignKey(
        User,
        verbose_name=_("user"),
        related_name="timetables",
        on_delete=models.CASCADE,
    )
    semester = models.CharField(
        _("semester"),
        default=get_semester_code,
        validators=[RegexValidator(r"(A|P)\d{2}")],
        blank=True,
    )
    class Meta:
        verbose_name = _("timetable")
        verbose_name_plural = _("timetables")
        constraints = [
            models.UniqueConstraint(
                fields=("user", "semester"), name="timetable_unique_user_semester"
            )
        ]
        permissions = [("add_self_timetable", "Can add its own timetable")]
    def __str__(self) -> str:
        return f"{self.user} {self.semester}"
 class TimetableSlot(models.Model):
    MINUTES_PER_SLOT = 15
    class WeekDay(models.IntegerChoices):
        MONDAY = 1
        TUESDAY = 2
        WEDNESDAY = 3
        THURSDAY = 4
        FRIDAY = 5
        SATURDAY = 6
        SUNDAY = 7
    class WeekGroup(models.TextChoices):
        A = "A"
        B = "B"
        BOTH = ""
    timetable = models.ForeignKey(
        Timetable,
        verbose_name=_("timetable"),
        related_name="slots",
        on_delete=models.CASCADE,
    )
    weekday = models.SmallIntegerField(_("weekday"), choices=WeekDay)
    # there are 4 * 24 = 96 quarters in a day, and we start counting at 0
    start_at = models.PositiveSmallIntegerField(
        _("start at"), validators=[MaxValueValidator(95)]
    )
    end_at = models.PositiveSmallIntegerField(
        _("end at"), validators=[MaxValueValidator(95)]
    )
    course_type = models.CharField(_("course type"), max_length=12)
    room = models.CharField(_("room"), max_length=32)
    ue = models.CharField(_("ue"), max_length=32)
    week_group = models.CharField(
        _("week group"),
        max_length=1,
        choices=WeekGroup,
        default=WeekGroup.BOTH,
        blank=True,
    )
    class Meta:
        verbose_name = _("timetable slot")
        verbose_name_plural = _("timetable slots")
        constraints = [
            models.CheckConstraint(
                condition=Q(end_at__gt=F("start_at")),
                name="timetable_slot_end_after_start",
            )
        ]
    def __str__(self) -> str:
        return f"{self.start_hour} - {self.end_hour} - {self.get_weekday_display()}"
    @property
    def start_hour(self):
        return timedelta(minutes=self.start_at * self.MINUTES_PER_SLOT)
    @property
    def end_hour(self):
        return timedelta(minutes=self.end_at * self.MINUTES_PER_SLOT)
@@ -0,0 +1,35 @@
 from typing import Annotated
 from annotated_types import Ge, Le
 from ninja import ModelSchema, Schema
 from pydantic import Field
 from timetable.models import Timetable, TimetableSlot
 class TimetableSlotSchema(ModelSchema):
    weekday: TimetableSlot.WeekDay = Field(
        description=(
            f"{TimetableSlot.WeekDay.MONDAY} is monday, "
            f"{TimetableSlot.WeekDay.TUESDAY} is tuesday, etc."
        )
    )
    start_at: Annotated[int, Ge(0), Le(96)]
    end_at: Annotated[int, Ge(0), Le(96)]
    class Meta:
        model = TimetableSlot
        fields = ["start_at", "end_at", "week_group", "ue", "course_type", "room"]
 class CreateTimetableSchema(Schema):
    is_viewable: bool
    slots: list[TimetableSlotSchema]
 class TimetableSchema(ModelSchema):
    slots: list[TimetableSlotSchema]
    class Meta:
        model = Timetable
        fields = ["id", "semester"]
@@ -1,4 +1,6 @@
 import html2canvas from "html2canvas";
 import { AlertMessage } from "#core:utils/alert-message";
 import { type WeekDay as ApiWeekDay, timetableSaveTimetable } from "#openapi";
 // see https://regex101.com/r/QHSaPM/3
 const TIMETABLE_ROW_RE: RegExp =
@@ -76,17 +78,88 @@ function parseSlots(s: string): TimetableSlot[] {
 }
 document.addEventListener("alpine:init", () => {
-  Alpine.data("timetableGenerator", () => ({
+  /**
   * Alpine data that can parse a timetable, save it and export it to png.
   */
  Alpine.data("timetableGenerator", (userId: number) => ({
    content: DEFAULT_TIMETABLE,
-    error: null as { incorrectRow?: string },
+    error: null as { incorrectRow?: string } | null,
    displayedWeekdays: [] as WeekDay[],
    courses: [] as TimetableSlot[],
    edtPublic: false,
    saving: false,
    timetableSavedMessage: new AlertMessage(),
    generate() {
      try {
        this.courses = parseSlots(this.content);
        this.error = null;
      } catch (err) {
        type ParseRowError = { cause: { row: string } };
        this.error = { incorrectRow: (err as ParseRowError)?.cause?.row };
        return;
      }
    },
    async savePng() {
      const elem = document.getElementById("timetable");
      const img = (await html2canvas(elem as HTMLElement)).toDataURL();
      const downloadLink = document.createElement("a");
      downloadLink.href = img;
      downloadLink.download = "edt.png";
      document.body.appendChild(downloadLink);
      downloadLink.click();
      downloadLink.remove();
    },
    async saveSith() {
      this.saving = true;
      const res = await timetableSaveTimetable({
        // biome-ignore lint/style/useNamingConvention: api is snake case
        path: { user_id: userId },
        body: {
          // biome-ignore lint/style/useNamingConvention: api is snake case
          is_viewable: this.edtPublic,
          slots: this.courses.map((c) => ({
            // biome-ignore lint/style/useNamingConvention: api is snake case
            start_at: c.startSlot,
            // biome-ignore lint/style/useNamingConvention: api is snake case
            end_at: c.endSlot,
            weekday: (WEEKDAYS.indexOf(c.weekday) + 1) as ApiWeekDay,
            // biome-ignore lint/style/useNamingConvention: api is snake case
            week_group: c.weekGroup,
            // biome-ignore lint/style/useNamingConvention: api is snake case
            course_type: c.courseType,
            room: c.room,
            ue: c.ueCode,
          })),
        },
      });
      if (res.response?.ok) {
        this.timetableSavedMessage.display(
          gettext("This timetable has been saved in your profile"),
          { success: true },
        );
      } else {
        this.timetableSavedMessage.display(
          interpolate(gettext("Error %d: timetable save failed"), res.response?.status),
          { success: false },
        );
      }
      this.saving = false;
    },
  }));
  /**
   * Alpine data dedicated to timetable display only.
   * It can interact with the `timetableGenerator` data with x-model and x-modelable
   * (for example of this, see timetable/generator.jinja)
   */
  Alpine.data("timetableDisplay", (slots: TimetableSlot[]) => ({
    displayedWeekdays: [] as WeekDay[],
    startSlot: 0,
    endSlot: 0,
-    table: {
+    table: { height: 0, width: 0 },
-      height: 0,
+    slots: slots,
      width: 0,
    },
    colors: {} as Record<string, string>,
    colorPalette: [
@@ -103,18 +176,14 @@ document.addEventListener("alpine:init", () => {
      "#1b5e20",
    ],
-    generate() {
+    init() {
-      try {
+      this.$watch("slots", () => this.display());
-        this.courses = parseSlots(this.content);
+    },
        this.error = null;
      } catch (err) {
        this.error = { incorrectRow: err?.cause?.row };
        return;
      }
    display() {
      // color each UE
      let colorIndex = 0;
-      for (const slot of this.courses) {
+      for (const slot of this.slots) {
        if (!this.colors[slot.ueCode]) {
          this.colors[slot.ueCode] =
            this.colorPalette[colorIndex % this.colorPalette.length];
@@ -123,13 +192,13 @@ document.addEventListener("alpine:init", () => {
      }
      this.displayedWeekdays = WEEKDAYS.filter((day) =>
-        this.courses.some((slot: TimetableSlot) => slot.weekday === day),
+        this.slots.some((slot: TimetableSlot) => slot.weekday === day),
      );
-      this.startSlot = this.courses.reduce(
+      this.startSlot = this.slots.reduce(
        (acc: number, curr: TimetableSlot) => Math.min(acc, curr.startSlot),
        25 * 4,
      );
-      this.endSlot = this.courses.reduce(
+      this.endSlot = this.slots.reduce(
        (acc: number, curr: TimetableSlot) => Math.max(acc, curr.endSlot),
        1,
      );
@@ -138,7 +207,7 @@ document.addEventListener("alpine:init", () => {
    },
    getStyle(slot: TimetableSlot) {
-      const hasWeekGroup = slot.weekGroup !== undefined;
+      const hasWeekGroup = !!slot.weekGroup;
      const width = hasWeekGroup ? SLOT_WIDTH / 2 : SLOT_WIDTH;
      const leftOffset = slot.weekGroup === "B" ? SLOT_WIDTH / 2 : 0;
      return {
@@ -150,15 +219,19 @@ document.addEventListener("alpine:init", () => {
      };
    },
-    getHours(): [string, object][] {
+    /**
     * Return the hours that should be displayed on this timetable,
     * with their `top` placing
     */
    getHours(): [string, { top: `${number}px` }][] {
      let hour: number = Number.parseInt(
-        this.courses
+        this.slots
          .map((c: TimetableSlot) => c.startHour)
          .reduce((res: string, hour: string) => (hour < res ? hour : res), "24:00")
          .split(":")[0],
        10,
      );
-      const res: [string, object][] = [];
+      const res: [string, { top: `${number}px` }][] = [];
      for (let i = 0; i <= this.endSlot - this.startSlot; i += 60 / MINUTES_PER_SLOT) {
        res.push([`${hour}:00`, { top: `${i * SLOT_HEIGHT}px` }]);
        hour += 1;
@@ -169,16 +242,5 @@ document.addEventListener("alpine:init", () => {
    getWidth() {
      return this.displayedWeekdays.length * SLOT_WIDTH + 20;
    },
    async savePng() {
      const elem = document.getElementById("timetable");
      const img = (await html2canvas(elem as HTMLElement)).toDataURL();
      const downloadLink = document.createElement("a");
      downloadLink.href = img;
      downloadLink.download = "edt.png";
      document.body.appendChild(downloadLink);
      downloadLink.click();
      downloadLink.remove();
    },
  }));
 });
@@ -1,6 +1,6 @@
@import "core/static/core/colors";
-#timetable {
+.timetable {
  --hour-side-width: 60px;
  display: block;
@@ -1,11 +1,13 @@
-{% extends 'core/base.jinja' %}
+{% extends "core/base.jinja" %}
 {% from "timetable/macros.jinja" import display_timetable %}
 {%- block additional_css -%}
  <link rel="stylesheet" href="{{ static('timetable/css/generator.scss') }}">
 {%- endblock -%}
 {%- block additional_js -%}
-  <script type="module" src="{{ static('bundled/timetable/generator-index.ts') }}"></script>
+  <script type="module" src="{{ static('bundled/timetable/timetable-index.ts') }}"></script>
 {%- endblock -%}
 {% block title %}
@@ -32,7 +34,7 @@
 {% endblock %}
 {% block content %}
-  <div x-data="timetableGenerator">
+  <div x-data="timetableGenerator({{ user.id }})">
    <form @submit.prevent="generate()">
      <h1>{% trans %}Timetable generator{% endtrans %}</h1>
      <template x-if="error !== null" x-cloak>
@@ -60,44 +62,40 @@
      </div>
      <input type="submit" class="btn btn-blue" value="{% trans %}Generate{% endtrans %}">
    </form>
-    <div
+    {{ display_timetable("courses") }}
-      id="timetable"
+    <template x-if="courses.length > 0">
-      x-show="table.height > 0 && table.width > 0"
+      <section>
-      :style="{width: `${table.width+80}px`, height: `${table.height+40}px`}"
+        {% if user.has_perm("timetable.add_self_timetable") %}
-    >
+          <div id="timetable-save" class="margin-bottom">
-      <div class="header">
+            <h3>{% trans %}Save on your profile{% endtrans %}</h3>
-        <template x-for="weekday in displayedWeekdays">
+            <form>
-          <span x-text="weekday"></span>
+              <fieldset>
-        </template>
+                <input type="checkbox" class="switch" id="edt-public-switch-id" x-model="edtPublic">
-      </div>
+                <label for="edt-public-switch-id">{% trans %}Make this timetable public{% endtrans %}</label>
-      <div class="content">
+                <span class="helptext">
-        <div class="hours" :height="(endSlot - endSlot%4) - (startSlot - startSlot%4)">
+                  {% trans trimmed url=url("core:user_prefs", user_id=user.id) %}
-          <template x-for="[hour, style] in getHours()">
+                    You can change this at any time in <a href="{{ url }}">your preferences</a>
-            <div class="hour" :style="style">
+                  {% endtrans %}
-              <div x-text="hour"></div>
+                </span>
-              <div class="hour-bar" :style="{width: `${getWidth()}px`}"></div>
+              </fieldset>
-            </div>
+              <button class="btn btn-blue" :disabled="saving" @click.prevent="saveSith">
-          </template>
+                {% trans %}Save timetable{% endtrans %}
-        </div>
+              </button>
-        <div class="courses">
+              <p
-          <template x-for="course in courses">
+                class="alert"
-            <div class="slot" :style="getStyle(course)">
+                :class="timetableSavedMessage.success ? 'alert-green' : 'alert-red'"
-              <span class="course-type" x-text="course.courseType"></span>
+                x-show="timetableSavedMessage.open"
-              <span x-text="course.ueCode"></span>
+                x-transition.duration.500ms
-              <span x-text="`${course.startHour} - ${course.endHour}`"></span>
+                x-text="timetableSavedMessage.content"
-              <span x-text="(course.weekGroup ? `\nGroupe ${course.weekGroup}` : '')"></span>
+              ></p>
-              <span x-text="course.room"></span>
+            </form>
-            </div>
+          </div>
-          </template>
+        {% endif %}
-        </div>
+        <h3 class="margin-bottom">{% trans %}Export{% endtrans %}</h3>
-      </div>
+        <button class="margin-bottom btn btn-blue" @click="savePng">
-    </div>
+          {% trans %}Export to PNG{% endtrans %}
-    <button
+        </button>
-      class="margin-bottom btn btn-blue"
+      </section>
-      @click="savePng"
+    </template>
      x-show="table.height > 0 && table.width > 0"
    >
      {% trans %}Save to PNG{% endtrans %}
    </button>
  </div>
 {% endblock content %}
@@ -0,0 +1,46 @@
 {# HTML+AlpineJS to display a timetable
 Args:
    ues: either a JS variable name or an array of object
         satisfying the TimetableSlot interface
    reactive: if True and `ues` is a variable used in an Alpine context,
         then this timetable will react to modifications and
         change its own display
 #}
 {% macro display_timetable(ues) %}
  <div
    x-data="timetableDisplay({{ ues }})"
    x-model="{{ ues }}"
    x-modelable="slots"
    class="timetable"
    x-show="slots.length > 0"
    :style="{width: `${table.width+80}px`, height: `${table.height+40}px`}"
  >
    <div class="header">
      <template x-for="weekday in displayedWeekdays">
        <span x-text="weekday"></span>
      </template>
    </div>
    <div class="content">
      <div class="hours" :height="(endSlot - endSlot%4) - (startSlot - startSlot%4)">
        <template x-for="[hour, style] in getHours()">
          <div class="hour" :style="style">
            <div x-text="hour"></div>
            <div class="hour-bar" :style="{width: `${getWidth()}px`}"></div>
          </div>
        </template>
      </div>
      <div class="courses">
        <template x-for="course in slots">
          <div class="slot" :style="getStyle(course)">
            <span class="course-type" x-text="course.courseType"></span>
            <span x-text="course.ueCode"></span>
            <span x-text="`${course.startHour} - ${course.endHour}`"></span>
            <span x-text="(course.weekGroup ? `\nGroupe ${course.weekGroup}` : '')"></span>
            <span x-text="course.room"></span>
          </div>
        </template>
      </div>
    </div>
  </div>
 {% endmacro %}
@@ -0,0 +1,52 @@
 {% extends "core/base.jinja" %}
 {% from "timetable/macros.jinja" import display_timetable %}
 {%- block additional_css -%}
  <link rel="stylesheet" href="{{ static('timetable/css/generator.scss') }}">
 {%- endblock -%}
 {%- block additional_js -%}
  <script type="module" src="{{ static('bundled/timetable/timetable-index.ts') }}"></script>
 {%- endblock -%}
 {% block content %}
  {% for timetable in timetables %}
    <details
      class="accordion"
      name="{{ timetable.semester }}"
      {% if loop.first %}open{% endif %}
    >
      <summary>{{ timetable.semester }}</summary>
      <div class="accordion-content">
        {{ display_timetable(timetable.semester) }}
      </div>
    </details>
  {% endfor %}
 {% endblock %}
 {%- block script -%}
  {% set weekdays = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"] %}
  <script>
    {%- for timetable in timetables  -%}
      const {{ timetable.semester }} = [
        {%- for slot in timetable.slots.all() -%}
          {
            courseType: "{{ slot.course_type }}",
            room: "{{ slot.room }}",
            startHour: "{{ "%02d:%02d" % (slot.start_hour.seconds // 3600, (slot.start_hour.seconds % 3600 ) // 60) }}",
            endHour: "{{ "%02d:%02d" % (slot.end_hour.seconds // 3600, (slot.end_hour.seconds % 3600 ) // 60) }}",
            startSlot: {{ slot.start_at }},
            endSlot: {{ slot.end_at }},
            ueCode: "{{ slot.ue }}",
            {%- if slot.week_group -%}
              weekGroup: "{{ slot.week_group }}",
            {%- endif -%}
            weekday: "{{ weekdays[slot.weekday] }}"
          },
        {%- endfor -%}
      ];
    {%- endfor -%}
  </script>
 {%- endblock -%}
@@ -1 +0,0 @@
 # Create your tests here.
@@ -0,0 +1,20 @@
 from django.test import TestCase
 from django.urls import reverse
 from core.baker_recipes import subscriber_user
 from timetable.models import TimetableSlot
 class TestSaveTimetable(TestCase):
    @classmethod
    def setUpTestData(cls) -> None:
        cls.user = subscriber_user.make()
        cls.payload = {
            "is_viewable": True,
            "slots": [
                {"weekday": TimetableSlot.WeekDay.MONDAY, "start_at": 32, "end_at": 40},
                {"weekday": TimetableSlot.WeekDay.MONDAY, "start_at": 41, "end_at": 49},
                {"weekday": TimetableSlot.WeekDay.FRIDAY, "start_at": 52, "end_at": 64},
            ],
        }
        cls.url = reverse("api:timetable:save", kwargs={"user_id": cls.user.id})
@@ -0,0 +1,31 @@
 from typing import TYPE_CHECKING
 import pytest
 from bs4 import BeautifulSoup
 from django.contrib.auth.models import Permission
 from django.urls import reverse
 from model_bakery import baker
 from core.models import User
 if TYPE_CHECKING:
    from django.test import Client
@pytest.mark.django_db
@pytest.mark.parametrize("can_save", [True, False])
 def test_generator_ok(client: Client, can_save):
    user = baker.make(User)
    if can_save:
        user.user_permissions.add(Permission.objects.get(codename="add_self_timetable"))
    client.force_login(user)
    res = client.get(reverse("timetable:generator"))
    assert res.status_code == 200
    soup = BeautifulSoup(res.text, "lxml")
    elem = soup.find(id="timetable-save")
    if can_save:
        assert elem is not None
    else:
        assert elem is None
@@ -1,5 +1,8 @@
 from django.urls import path
-from timetable.views import GeneratorView
+from timetable.views import GeneratorView, UserTimetableView
-urlpatterns = [path("", GeneratorView.as_view(), name="generator")]
+urlpatterns = [
    path("", GeneratorView.as_view(), name="generator"),
    path("user/<int:user_id>", UserTimetableView.as_view(), name="user_timetable"),
 ]
@@ -1,6 +1,54 @@
-# Create your views here.
+from django.contrib.auth.mixins import UserPassesTestMixin
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 from django.views.generic import TemplateView
 from django.views.generic.detail import DetailView
 from core.models import User
 from core.views import TabedViewMixin
-class GeneratorView(TemplateView):
+class TimetableTabsMixin(TabedViewMixin):
    tabs_title = _("Timetables")
    def get_list_of_tabs(self):
        res = [
            {
                "url": reverse("timetable:generator"),
                "slug": "generator",
                "name": _("Generator"),
            }
        ]
        if self.request.user.timetables.exists():
            res.append(
                {
                    "url": reverse(
                        "core:user_timetable", kwargs={"user_id": self.request.user.id}
                    ),
                    "slug": "saved",
                    "name": _("My timetables"),
                }
            )
        return res
 class GeneratorView(TimetableTabsMixin, TemplateView):
    template_name = "timetable/generator.jinja"
    current_tab = "generator"
 class UserTimetableView(UserPassesTestMixin, TimetableTabsMixin, DetailView):
    model = User
    pk_url_kwarg = "user_id"
    template_name = "timetable/user_timetable.jinja"
    current_tab = "saved"
    def test_func(self) -> bool | None:
        return self.request.user.id == self.kwargs[
            "user_id"
        ] or self.request.user.has_perm("timetable.view_timetable")
    def get_context_data(self, **kwargs):
        return super().get_context_data(**kwargs) | {
            "timetables": list(self.object.timetables.prefetch_related("slots"))
        }
Author	SHA1	Message	Date
imperosol	f1213f2cc9	Remove mailing list feature	2026-10-24 14:32:09 +02:00
thomas girod	32c30da0fc	Merge pull request #1507 from ae-utbm/edt-save Add user timetable saving	2026-10-24 01:09:43 +02:00
thomas girod	d3f3b18660	Merge pull request #1519 from ae-utbm/page-edit-link Move the club page edit link to the club main page	2026-10-23 20:53:47 +02:00
thomas girod	e50b1fd71e	Merge pull request #1525 from ae-utbm/show-all-counters-in-stats Show all counters in user stats view	2026-10-23 16:27:33 +02:00
imperosol	78376eaca4	don't restict user counter stats to bar counters	2026-10-23 16:08:40 +02:00
thomas girod	8d56c72054	Merge pull request #1524 from ae-utbm/remove-gentoken remove unused Counter methods	2026-10-22 19:10:47 +02:00
imperosol	a794f02a8d	remove unused Counter methods `Counter.gen_token` et `Counter.get_random_barman` étaient utilisés avant la refonte du système de connexion des barmen (PR #1413), mais on a oublié de les retirer.	2026-10-22 11:56:04 +02:00
imperosol	cb0a2f866d	`TimetableTabMixin`	2026-10-22 11:39:52 +02:00
imperosol	4b4c5a73b6	add tests	2026-10-22 11:39:52 +02:00
imperosol	b37b98b932	view to see a user's timetables	2026-10-22 11:39:52 +02:00
imperosol	ed888834d6	split timetable parsing and display	2026-10-22 11:39:52 +02:00
imperosol	0657888076	User timetable save	2026-10-22 11:39:52 +02:00
imperosol	3f135777cd	add `show_my_timetable` to VisibilityForm	2026-10-22 11:39:51 +02:00
imperosol	73ebe9c674	add timetable visibility to UserVisibilityForm	2026-10-22 11:39:51 +02:00
imperosol	816cbe3a2c	api to save timetable	2026-10-22 11:39:51 +02:00
imperosol	a33a4da143	add models	2026-10-22 11:39:51 +02:00
imperosol	2c77ed3c54	add tests	2026-10-22 11:25:40 +02:00
imperosol	3312a6214e	move the club page edit link to the club main page	2026-10-22 10:07:26 +02:00
thomas girod	87533a7327	Merge pull request #1521 from ae-utbm/account-dump-msg Add success message when refunding AE account	2026-10-21 16:35:05 +02:00
imperosol	2db46e3958	add success message when refunding AE account	2026-10-21 16:34:12 +02:00
thomas girod	f2469873fd	Merge pull request #1522 from ae-utbm/md-smallfix fix: add back `.markdown` on EasyMde preview editor	2026-10-20 18:38:19 +02:00
imperosol	68c05b5b1d	fix: add back `.markdown` on EasyMde preview editor A l'origine, l'API retournait le markdown encapsulé dans une div avec la class `.markdown`. Quand on est passé sur notre propre lib WASM pour faire la preview entièrement côté front, on a oublié ce détail. En même temps, on résout ici un petit glitch d'affichage qui fait qu'on avait le background des blocs de codes qui se mettait en dessous de notre propre style.	2026-10-20 12:52:20 +02:00
thomas girod	2d492e0157	Merge pull request #1511 from ae-utbm/counter-admin-mixin remove `CounterAdminMixin`	2026-10-14 20:13:43 +02:00
thomas girod	67cfcb66b6	Merge pull request #1512 from ae-utbm/docs-populate Small documentation fixes	2026-10-13 11:32:02 +02:00
thomas girod	b560c6860b	Merge pull request #1510 from ae-utbm/forum-message-403 short-circuit `ForumMessageView` redirection on 403	2026-10-13 00:12:07 +02:00
imperosol	15c5a37c99	docs: fix nushell scripts	2026-10-12 14:08:12 +02:00
imperosol	07648f596e	docs: describe populated user accounts	2026-10-12 13:51:18 +02:00
imperosol	0c6594b3cd	remove `CounterAdminMixin`	2026-10-09 21:59:37 +02:00
imperosol	22b510e25b	short-circuit `ForumMessageView` redirection on 403 Quand on accède à cette vue, on est immédiatement redirigé vers le topic correspondant (quitte à se faire 403 une fois arrivé là). Comme la redirection est une opération qui a un cout, on peut gagner du temps en mettant un PermissionDenied directement (d'autant plus que les bots aiment beaucoup rechercher les messages du forum, et qu'ils se font systématiquement 403)	2026-10-09 16:09:54 +02:00