docs: more details on AI guideline rationals

.github/auto_assign.yml

@@ -6,7 +6,7 @@ addAssignees: author
 
 # A list of team reviewers to be added to pull requests (GitHub team slug)
 reviewers:
-  - ae-utbm/developpeurs
+  - ae-utbm/sith-3-developers
 
 # Number of reviewers has no impact on GitHub teams
 # Set 0 to add all the reviewers (default: 0)

.github/dependabot.yml

@@ -16,16 +16,7 @@ multi-ecosystem-groups:
 
 updates:
   - package-ecosystem: "uv"
-    patterns: ["*"]
     multi-ecosystem-group: "common"
 
   - package-ecosystem: "npm"
-    patterns: ["*"]
     multi-ecosystem-group: "common"
-    groups:
-      # npm supports production and development groups, but not uv
-      # cf. https://docs.github.com/en/code-security/dependabot/working-with-dependabot/dependabot-options-reference#dependency-type-groups
-      main-deps:
-        dependency-type: "production"
-      dev-deps:
-        dependency-type: "development"

club/forms.py

@@ -26,16 +26,12 @@ from django import forms
 from django.conf import settings
 from django.db.models import Exists, OuterRef, Q
 from django.db.models.functions import Lower
-from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 
 from club.models import Club, Mailing, MailingSubscription, Membership
 from core.models import User
-from core.views.forms import SelectDateTime
+from core.views.forms import SelectDate, SelectDateTime
-from core.views.widgets.ajax_select import (
+from core.views.widgets.ajax_select import AutoCompleteSelectMultipleUser
-    AutoCompleteSelectMultipleUser,
-    AutoCompleteSelectUser,
-)
 from counter.models import Counter, Selling
 
 
@@ -192,113 +188,105 @@ class SellingsForm(forms.Form):
         )
 
 
-class ClubOldMemberForm(forms.Form):
+class ClubMemberForm(forms.Form):
-    members_old = forms.ModelMultipleChoiceField(
+    """Form handling the members of a club."""
-        Membership.objects.none(),
-        label=_("Mark as old"),
-        widget=forms.CheckboxSelectMultiple,
-        required=False,
-    )
-
-    def __init__(self, *args, user: User, club: Club, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.fields["members_old"].queryset = (
-            Membership.objects.ongoing().filter(club=club).editable_by(user)
-        )
-
-
-class ClubMemberForm(forms.ModelForm):
-    """Form to add a member to the club, as a board member."""
 
     error_css_class = "error"
     required_css_class = "required"
 
-    class Meta:
+    users = forms.ModelMultipleChoiceField(
-        model = Membership
+        label=_("Users to add"),
-        fields = ["role", "description"]
+        help_text=_("Search users to add (one or more)."),
+        required=False,
+        widget=AutoCompleteSelectMultipleUser,
+        queryset=User.objects.all(),
+    )
 
-    def __init__(self, *args, club: Club, request_user: User, **kwargs):
+    def __init__(self, *args, **kwargs):
-        self.club = club
+        self.club = kwargs.pop("club")
-        self.request_user = request_user
+        self.request_user = kwargs.pop("request_user")
+        self.club_members = kwargs.pop("club_members", None)
+        if not self.club_members:
+            self.club_members = self.club.members.ongoing().order_by("-role").all()
         self.request_user_membership = self.club.get_membership_for(self.request_user)
         super().__init__(*args, **kwargs)
-        self.fields["role"].required = True
-        self.fields["role"].choices = [
-            (value, name)
-            for value, name in settings.SITH_CLUB_ROLES.items()
-            if value <= self.max_available_role
-        ]
-        self.instance.club = club
 
-    @property
+        # Using a ModelForm binds too much the form with the model and we don't want that
-    def max_available_role(self):
+        # We want the view to process the model creation since they are multiple users
-        """The greatest role that will be obtainable with this form."""
+        # We also want the form to handle bulk deletion
-        # this is unreachable, because it will be overridden by subclasses
+        self.fields.update(
-        return -1  # pragma: no cover
+            forms.fields_for_model(
+                Membership,
+                fields=("role", "start_date", "description"),
+                widgets={"start_date": SelectDate},
+            )
+        )
 
+        # Role is required only if users is specified
+        self.fields["role"].required = False
 
-class ClubAddMemberForm(ClubMemberForm):
+        # Start date and description are never really required
-    """Form to add a member to the club, as a board member."""
+        self.fields["start_date"].required = False
+        self.fields["description"].required = False
 
-    class Meta(ClubMemberForm.Meta):
+        self.fields["users_old"] = forms.ModelMultipleChoiceField(
-        fields = ["user", *ClubMemberForm.Meta.fields]
+            User.objects.filter(
-        widgets = {"user": AutoCompleteSelectUser}
+                id__in=[
+                    ms.user.id
+                    for ms in self.club_members
+                    if ms.can_be_edited_by(self.request_user)
+                ]
+            ).all(),
+            label=_("Mark as old"),
+            required=False,
+            widget=forms.CheckboxSelectMultiple,
+        )
+        if not self.request_user.is_root:
+            self.fields.pop("start_date")
 
-    @cached_property
+    def clean_users(self):
-    def max_available_role(self):
+        """Check that the user is not trying to add an user already in the club.
-        """The greatest role that will be obtainable with this form.
-
-        Admins and the club president can attribute any role.
-        Board members can attribute roles lower than their own.
-        Other users cannot attribute roles with this form
-        """
-        if self.request_user.has_perm("club.add_subscription"):
-            return settings.SITH_CLUB_ROLES_ID["President"]
-        membership = self.request_user_membership
-        if membership is None or membership.role <= settings.SITH_MAXIMUM_FREE_ROLE:
-            return -1
-        if membership.role == settings.SITH_CLUB_ROLES_ID["President"]:
-            return membership.role
-        return membership.role - 1
-
-    def clean_user(self):
-        """Check that the user is not trying to add a user already in the club.
 
         Also check that the user is valid and has a valid subscription.
         """
-        user = self.cleaned_data["user"]
+        cleaned_data = super().clean()
-        if not user.is_subscribed:
+        users = []
-            raise forms.ValidationError(
+        for user in cleaned_data["users"]:
-                _("User must be subscriber to take part to a club"), code="invalid"
+            if not user.is_subscribed:
-            )
+                raise forms.ValidationError(
-        if self.club.get_membership_for(user):
+                    _("User must be subscriber to take part to a club"), code="invalid"
-            raise forms.ValidationError(
+                )
-                _("You can not add the same user twice"), code="invalid"
+            if self.club.get_membership_for(user):
-            )
+                raise forms.ValidationError(
-        return user
+                    _("You can not add the same user twice"), code="invalid"
-
+                )
-
+            users.append(user)
-class JoinClubForm(ClubMemberForm):
+        return users
-    """Form to join a club."""
-
-    def __init__(self, *args, club: Club, request_user: User, **kwargs):
-        super().__init__(*args, club=club, request_user=request_user, **kwargs)
-        # this form doesn't manage the user who will join the club,
-        # so we must set this here to avoid errors
-        self.instance.user = self.request_user
-
-    @cached_property
-    def max_available_role(self):
-        return settings.SITH_MAXIMUM_FREE_ROLE
 
     def clean(self):
-        """Check that the user is subscribed and isn't already in the club."""
+        """Check user rights for adding an user."""
-        if not self.request_user.is_subscribed:
+        cleaned_data = super().clean()
-            raise forms.ValidationError(
+
-                _("You must be subscribed to join a club"), code="invalid"
+        if "start_date" in cleaned_data and not cleaned_data["start_date"]:
-            )
+            # Drop start_date if allowed to edition but not specified
-        if self.club.get_membership_for(self.request_user):
+            cleaned_data.pop("start_date")
-            raise forms.ValidationError(
+
-                _("You are already a member of this club"), code="invalid"
+        if not cleaned_data.get("users"):
-            )
+            # No user to add equals no check needed
-        return super().clean()
+            return cleaned_data
+
+        if cleaned_data.get("role", "") == "":
+            # Role is required if users exists
+            self.add_error("role", _("You should specify a role"))
+            return cleaned_data
+
+        request_user = self.request_user
+        membership = self.request_user_membership
+        if not (
+            cleaned_data["role"] <= settings.SITH_MAXIMUM_FREE_ROLE
+            or (membership is not None and membership.role >= cleaned_data["role"])
+            or request_user.is_board_member
+            or request_user.is_root
+        ):
+            raise forms.ValidationError(_("You do not have the permission to do that"))
+        return cleaned_data

club/migrations/0012_club_board_group_club_members_group.py

@@ -34,10 +34,12 @@ def migrate_meta_groups(apps: StateApps, schema_editor):
     clubs = list(Club.objects.all())
     for club in clubs:
         club.board_group = meta_groups.get_or_create(
-            name=f"{club.unix_name}-bureau", defaults={"is_meta": True}
+            name=club.unix_name + settings.SITH_BOARD_SUFFIX,
+            defaults={"is_meta": True},
         )[0]
         club.members_group = meta_groups.get_or_create(
-            name=f"{club.unix_name}-membres", defaults={"is_meta": True}
+            name=club.unix_name + settings.SITH_MEMBER_SUFFIX,
+            defaults={"is_meta": True},
         )[0]
         club.save()
         club.refresh_from_db()

club/models.py

@@ -30,8 +30,7 @@ from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.core.validators import RegexValidator, validate_email
 from django.db import models, transaction
-from django.db.models import Exists, F, OuterRef, Q, Value
+from django.db.models import Exists, F, OuterRef, Q
-from django.db.models.functions import Greatest
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.functional import cached_property
@@ -43,13 +42,6 @@ from core.fields import ResizedImageField
 from core.models import Group, Notification, Page, SithFile, User
 
 
-class ClubQuerySet(models.QuerySet):
-    def having_board_member(self, user: User) -> Self:
-        """Filter all club in which the given user is a board member."""
-        active_memberships = user.memberships.board().ongoing()
-        return self.filter(Exists(active_memberships.filter(club=OuterRef("pk"))))
-
-
 class Club(models.Model):
     """The Club class, made as a tree to allow nice tidy organization."""
 
@@ -99,8 +91,6 @@ class Club(models.Model):
         Group, related_name="club_board", on_delete=models.PROTECT
     )
 
-    objects = ClubQuerySet.as_manager()
-
     class Meta:
         ordering = ["name"]
 
@@ -210,6 +200,10 @@ class Club(models.Model):
         """Method to see if that object can be edited by the given user."""
         return self.has_rights_in_club(user)
 
+    def can_be_viewed_by(self, user: User) -> bool:
+        """Method to see if that object can be seen by the given user."""
+        return user.was_subscribed
+
     def get_membership_for(self, user: User) -> Membership | None:
         """Return the current membership the given user.
 
@@ -249,44 +243,6 @@ class MembershipQuerySet(models.QuerySet):
         """
         return self.filter(role__gt=settings.SITH_MAXIMUM_FREE_ROLE)
 
-    def editable_by(self, user: User) -> Self:
-        """Filter Memberships that this user can edit.
-
-        Users with the `club.change_membership` permission can edit all Membership.
-        The other users can edit :
-        - their own membership
-        - if they are board members, ongoing memberships with a role lower than their own
-
-        For example, let's suppose the following users :
-        - A : board member
-        - B : board member
-        - C : simple member
-        - D : curious
-        - E : old member
-
-        A will be able to edit the memberships of A, C and D ;
-        C and D will be able to edit only their own membership ;
-        nobody will be able to edit E's membership.
-        """
-        if user.has_perm("club.change_membership"):
-            return self.all()
-        return self.filter(
-            Q(user=user)
-            | Exists(
-                Membership.objects.filter(
-                    Q(
-                        role__gt=Greatest(
-                            OuterRef("role"), Value(settings.SITH_MAXIMUM_FREE_ROLE)
-                        )
-                    ),
-                    user=user,
-                    end_date=None,
-                    club=OuterRef("club"),
-                )
-            ),
-            end_date=None,
-        )
-
     def update(self, **kwargs) -> int:
         """Refresh the cache and edit group ownership.
 
@@ -363,12 +319,16 @@ class Membership(models.Model):
         User,
         verbose_name=_("user"),
         related_name="memberships",
+        null=False,
+        blank=False,
         on_delete=models.CASCADE,
     )
     club = models.ForeignKey(
         Club,
         verbose_name=_("club"),
         related_name="members",
+        null=False,
+        blank=False,
         on_delete=models.CASCADE,
     )
     start_date = models.DateField(_("start date"), default=timezone.now)

club/static/club/members.scss

@@ -1,24 +0,0 @@
-#club_members_table {
-  tbody label {
-    margin: 0;
-    padding: 0;
-  }
-}
-
-#add_club_members_form {
-  fieldset {
-    display: flex;
-    flex-direction: row;
-    column-gap: 2em;
-    row-gap: 1em;
-    flex-wrap: wrap;
-
-    @media (max-width: 1100px) {
-      justify-content: space-evenly;
-    }
-
-    .errorlist {
-      max-width: 300px;
-    }
-  }
-}

club/templates/club/club_members.jinja

@@ -1,33 +1,15 @@
 {% extends "core/base.jinja" %}
 {% from 'core/macros.jinja' import user_profile_link, select_all_checkbox %}
 
-{% block additional_js %}
-  <script type="module" src="{{ static("bundled/core/components/ajax-select-index.ts") }}"></script>
-{% endblock %}
-{% block additional_css %}
-  <link rel="stylesheet" href="{{ static("bundled/core/components/ajax-select-index.css") }}">
-  <link rel="stylesheet" href="{{ static("club/members.scss") }}">
-{% endblock %}
-
 {% block content %}
-  {% block notifications %}
-    {# Notifications are moved a little bit below #}
-  {% endblock %}
-
   <h2>{% trans %}Club members{% endtrans %}</h2>
-
-  {% if add_member_fragment %}
-    <br />
-    {{ add_member_fragment }}
-    <br />
-  {% endif %}
-  {% include "core/base/notifications.jinja" %}
   {% if members %}
-    <form action="{{ url('club:club_members', club_id=club.id) }}" id="members_old" method="post">
+    <form action="{{ url('club:club_members', club_id=club.id) }}" id="users_old" method="post">
       {% csrf_token %}
-      {% if can_end_membership %}
+      {% set users_old = dict(form.users_old | groupby("choice_label")) %}
-        {{ select_all_checkbox("members_old") }}
+      {% if users_old %}
-        <br />
+        {{ select_all_checkbox("users_old") }}
+        <p></p>
       {% endif %}
       <table id="club_members_table">
         <thead>
@@ -36,7 +18,7 @@
             <td>{% trans %}Role{% endtrans %}</td>
             <td>{% trans %}Description{% endtrans %}</td>
             <td>{% trans %}Since{% endtrans %}</td>
-            {% if can_end_membership %}
+            {% if users_old %}
               <td>{% trans %}Mark as old{% endtrans %}</td>
             {% endif %}
           </tr>
@@ -48,24 +30,20 @@
               <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
               <td>{{ m.description }}</td>
               <td>{{ m.start_date }}</td>
-              {%- if can_end_membership -%}
+              {% if users_old %}
                 <td>
-                  {%- if m.is_editable -%}
+                  {% set user_old = users_old[m.user.get_display_name()] %}
-                    <label for="id_members_old_{{ loop.index }}"></label>
+                  {% if user_old %}
-                    <input
+                    {{ user_old[0].tag() }}
-                      type="checkbox"
+                  {% endif %}
-                      name="members_old"
-                      value="{{ m.id }}"
-                      id="id_members_old_{{ loop.index }}"
-                    >
-                  {%- endif -%}
                 </td>
-              {%- endif -%}
+              {% endif %}
             </tr>
           {% endfor %}
         </tbody>
       </table>
-      {% if can_end_membership %}
+      {{ form.users_old.errors }}
+      {% if users_old %}
         <p></p>
         <input type="submit" name="submit" value="{% trans %}Mark as old{% endtrans %}">
       {% endif %}
@@ -73,4 +51,32 @@
   {% else %}
     <p>{% trans %}There are no members in this club.{% endtrans %}</p>
   {% endif %}
+  <form action="{{ url('club:club_members', club_id=club.id) }}" id="add_users" method="post">
+    {% csrf_token %}
+    {{ form.non_field_errors() }}
+    <p>
+      {{ form.users.errors }}
+      <label for="{{ form.users.id_for_label }}">{{ form.users.label }} :</label>
+      {{ form.users }}
+      <span class="helptext">{{ form.users.help_text }}</span>
+    </p>
+    <p>
+      {{ form.role.errors }}
+      <label for="{{ form.role.id_for_label }}">{{ form.role.label }} :</label>
+      {{ form.role }}
+    </p>
+    {% if form.start_date %}
+      <p>
+        {{ form.start_date.errors }}
+        <label for="{{ form.start_date.id_for_label }}">{{ form.start_date.label }} :</label>
+        {{ form.start_date }}
+      </p>
+    {% endif %}
+    <p>
+      {{ form.description.errors }}
+      <label for="{{ form.description.id_for_label }}">{{ form.description.label }} :</label>
+      {{ form.description }}
+    </p>
+    <p><input type="submit" value="{% trans %}Add{% endtrans %}" /></p>
+  </form>
 {% endblock %}

club/templates/club/club_old_members.jinja

@@ -5,22 +5,20 @@
   <h2>{% trans %}Club old members{% endtrans %}</h2>
   <table>
     <thead>
-      <tr>
+      <td>{% trans %}User{% endtrans %}</td>
-        <td>{% trans %}User{% endtrans %}</td>
+      <td>{% trans %}Role{% endtrans %}</td>
-        <td>{% trans %}Role{% endtrans %}</td>
+      <td>{% trans %}Description{% endtrans %}</td>
-        <td>{% trans %}Description{% endtrans %}</td>
+      <td>{% trans %}From{% endtrans %}</td>
-        <td>{% trans %}From{% endtrans %}</td>
+      <td>{% trans %}To{% endtrans %}</td>
-        <td>{% trans %}To{% endtrans %}</td>
-      </tr>
     </thead>
     <tbody>
-      {% for member in old_members %}
+      {% for m in club.members.exclude(end_date=None).order_by('-role', 'description', '-end_date').all() %}
         <tr>
-          <td>{{ user_profile_link(member.user) }}</td>
+          <td>{{ user_profile_link(m.user) }}</td>
-          <td>{{ settings.SITH_CLUB_ROLES[member.role] }}</td>
+          <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
-          <td>{{ member.description }}</td>
+          <td>{{ m.description }}</td>
-          <td>{{ member.start_date }}</td>
+          <td>{{ m.start_date }}</td>
-          <td>{{ member.end_date }}</td>
+          <td>{{ m.end_date }}</td>
         </tr>
       {% endfor %}
     </tbody>

club/templates/club/club_sellings.jinja

@@ -83,10 +83,9 @@ TODO : rewrite the pagination used in this template an Alpine one
   </table>
   <script type="text/javascript">
     function formPagination(link){
-      const form = document.getElementById("form")
+      $("form").attr("action", link.href);
-      form.action = link.href;
       link.href = "javascript:void(0)"; // block link action
-      form.submit();
+      $("form").submit();
     }
   </script>
   {{ paginate(paginated_result, paginator, "formPagination(this)") }}

club/templates/club/fragments/add_member.jinja

@@ -1,46 +0,0 @@
-<section id="member-fragment-container">
-  {% if form.user %}
-    <h4>{% trans %}Add a new member{% endtrans %}</h4>
-  {% else %}
-    <h4>{% trans %}Join club{% endtrans %}</h4>
-  {% endif %}
-
-  <form
-    hx-post="{{ url('club:club_new_members', club_id=club.id) }}"
-    hx-disabled-elt="find input[type='submit']"
-    hx-swap="outerHTML"
-    hx-target="#member-fragment-container"
-    id="add_club_members_form"
-  >
-    {% csrf_token %}
-    {{ form.non_field_errors() }}
-    <fieldset>
-      {% if form.user %}
-        <div>
-          {{ form.user.label_tag() }}
-          <span class="helptext">{{ form.user.help_text }}</span>
-          {{ form.user }}
-          {{ form.user.errors }}
-        </div>
-      {% endif %}
-      <div>
-        {{ form.role.label_tag() }}
-        {{ form.role }}
-        {{ form.role.errors }}
-      </div>
-      <div>
-        {{ form.description.label_tag() }}
-        {{ form.description }}
-        {{ form.description.errors }}
-      </div>
-    </fieldset>
-    <button type="submit" class="btn btn-blue">
-      <i class="fa fa-user-plus"></i>
-      {%- if form.user -%}
-        {% trans %}Add{% endtrans %}
-      {%- else -%}
-        {% trans %}Join{% endtrans %}
-      {%- endif -%}
-    </button>
-  </form>
-</section>

club/tests/base.py

@@ -43,9 +43,6 @@ class TestClub(TestCase):
 
         cls.ae = Club.objects.get(pk=settings.SITH_MAIN_CLUB_ID)
         cls.club = baker.make(Club)
-        cls.new_members_url = reverse(
-            "club:club_new_members", kwargs={"club_id": cls.club.id}
-        )
         cls.members_url = reverse("club:club_members", kwargs={"club_id": cls.club.id})
         a_month_ago = now() - timedelta(days=30)
         yesterday = now() - timedelta(days=1)

club/tests/test_club.py

@@ -1,27 +0,0 @@
-from datetime import timedelta
-
-import pytest
-from django.utils.timezone import localdate
-from model_bakery import baker
-from model_bakery.recipe import Recipe
-
-from club.models import Club, Membership
-from core.baker_recipes import subscriber_user
-
-
-@pytest.mark.django_db
-def test_club_queryset_having_board_member():
-    clubs = baker.make(Club, _quantity=5)
-    user = subscriber_user.make()
-    membership_recipe = Recipe(
-        Membership, user=user, start_date=localdate() - timedelta(days=3)
-    )
-    membership_recipe.make(club=clubs[0], role=1)
-    membership_recipe.make(club=clubs[1], role=3)
-    membership_recipe.make(club=clubs[2], role=7)
-    membership_recipe.make(
-        club=clubs[3], role=3, end_date=localdate() - timedelta(days=1)
-    )
-
-    club_ids = Club.objects.having_board_member(user).values_list("id", flat=True)
-    assert set(club_ids) == {clubs[1].id, clubs[2].id}

club/tests/test_membership.py

@@ -1,20 +1,13 @@
-from collections.abc import Callable
-from datetime import timedelta
-
-import pytest
 from bs4 import BeautifulSoup
 from django.conf import settings
-from django.contrib.auth.models import Permission
 from django.core.cache import cache
 from django.db.models import Max
-from django.test import TestCase
 from django.urls import reverse
 from django.utils.timezone import localdate, localtime, now
 from model_bakery import baker
-from pytest_django.asserts import assertRedirects
 
-from club.forms import ClubAddMemberForm, JoinClubForm
+from club.forms import ClubMemberForm
-from club.models import Club, Membership
+from club.models import Membership
 from club.tests.base import TestClub
 from core.baker_recipes import subscriber_user
 from core.models import AnonymousUser, User
@@ -144,38 +137,6 @@ class TestMembershipQuerySet(TestClub):
         assert set(user.groups.all()).isdisjoint(club_groups)
 
 
-class TestMembershipEditableBy(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        Membership.objects.all().delete()
-        cls.club_a, cls.club_b = baker.make(Club, _quantity=2)
-        cls.memberships = [
-            *baker.make(
-                Membership, role=iter([7, 3, 3, 1]), club=cls.club_a, _quantity=4
-            ),
-            *baker.make(
-                Membership, role=iter([7, 3, 3, 1]), club=cls.club_b, _quantity=4
-            ),
-        ]
-
-    def test_admin_user(self):
-        perm = Permission.objects.get(codename="change_membership")
-        user = baker.make(User, user_permissions=[perm])
-        qs = Membership.objects.editable_by(user).values_list("id", flat=True)
-        assert set(qs) == set(Membership.objects.values_list("id", flat=True))
-
-    def test_simple_subscriber_user(self):
-        user = subscriber_user.make()
-        assert not Membership.objects.editable_by(user).exists()
-
-    def test_board_member(self):
-        # a board member can end lower memberships and its own one
-        user = self.memberships[2].user
-        qs = Membership.objects.editable_by(user).values_list("id", flat=True)
-        expected = {self.memberships[2].id, self.memberships[3].id}
-        assert set(qs) == expected
-
-
 class TestMembership(TestClub):
     def assert_membership_started_today(self, user: User, role: int):
         """Assert that the given membership is active and started today."""
@@ -190,7 +151,7 @@ class TestMembership(TestClub):
 
     def assert_membership_ended_today(self, user: User):
         """Assert that the given user have a membership which ended today."""
-        today = localdate()
+        today = localtime(now()).date()
         assert user.memberships.filter(club=self.club, end_date=today).exists()
         assert self.club.get_membership_for(user) is None
 
@@ -199,9 +160,7 @@ class TestMembership(TestClub):
         cannot see the page.
         """
         response = self.client.post(self.members_url)
-        assertRedirects(
+        assert response.status_code == 403
-            response, reverse("core:login", query={"next": self.members_url})
-        )
 
         self.client.force_login(self.public)
         response = self.client.post(self.members_url)
@@ -212,9 +171,7 @@ class TestMembership(TestClub):
         information are displayed.
         """
         self.client.force_login(self.simple_board_member)
-        response = self.client.get(
+        response = self.client.get(self.members_url)
-            reverse("club:club_members", kwargs={"club_id": self.club.id})
-        )
         assert response.status_code == 200
         soup = BeautifulSoup(response.text, "lxml")
         table = soup.find("table", id="club_members_table")
@@ -240,45 +197,59 @@ class TestMembership(TestClub):
             assert cols[2].text == membership.description
             assert cols[3].text == str(membership.start_date)
 
-            if membership.role < 3 or membership.user_id == self.simple_board_member.id:
+            if membership.role <= 3:  # 3 is the role of simple_board_member
-                # 3 is the role of simple_board_member
                 form_input = cols[4].find("input")
                 expected_attrs = {
                     "type": "checkbox",
-                    "name": "members_old",
+                    "name": "users_old",
-                    "value": str(membership.id),
+                    "value": str(user.id),
                 }
                 assert form_input.attrs.items() >= expected_attrs.items()
             else:
                 assert cols[4].find_all() == []
 
     def test_root_add_one_club_member(self):
-        """Test that root users can add members to clubs"""
+        """Test that root users can add members to clubs, one at a time."""
         self.client.force_login(self.root)
         response = self.client.post(
-            self.new_members_url, {"user": self.subscriber.id, "role": 3}
+            self.members_url,
-        )
+            {"users": [self.subscriber.id], "role": 3},
-        assert response.status_code == 200
-        assert response.headers.get("HX-Redirect", "") == reverse(
-            "club:club_members", kwargs={"club_id": self.club.id}
         )
+        self.assertRedirects(response, self.members_url)
         self.subscriber.refresh_from_db()
         self.assert_membership_started_today(self.subscriber, role=3)
 
+    def test_root_add_multiple_club_member(self):
+        """Test that root users can add multiple members at once to clubs."""
+        self.client.force_login(self.root)
+        response = self.client.post(
+            self.members_url,
+            {
+                "users": (self.subscriber.id, self.krophil.id),
+                "role": 3,
+            },
+        )
+        self.assertRedirects(response, self.members_url)
+        self.subscriber.refresh_from_db()
+        self.assert_membership_started_today(self.subscriber, role=3)
+        self.assert_membership_started_today(self.krophil, role=3)
+
     def test_add_unauthorized_members(self):
         """Test that users who are not currently subscribed
         cannot be members of clubs.
         """
         for user in self.public, self.old_subscriber:
-            form = ClubAddMemberForm(
+            form = ClubMemberForm(
-                data={"user": user.id, "role": 1},
+                data={"users": [user.id], "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
 
             assert not form.is_valid()
             assert form.errors == {
-                "user": ["L'utilisateur doit être cotisant pour faire partie d'un club"]
+                "users": [
+                    "L'utilisateur doit être cotisant pour faire partie d'un club"
+                ]
             }
 
     def test_add_members_already_members(self):
@@ -310,16 +281,16 @@ class TestMembership(TestClub):
         nb_memberships = self.club.members.count()
         max_id = User.objects.aggregate(id=Max("id"))["id"]
         for members in [max_id + 1], [max_id + 1, self.subscriber.id]:
-            form = ClubAddMemberForm(
+            form = ClubMemberForm(
-                data={"user": members, "role": 1},
+                data={"users": members, "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
             assert not form.is_valid()
             assert form.errors == {
-                "user": [
+                "users": [
                     "Sélectionnez un choix valide. "
-                    "Ce choix ne fait pas partie de ceux disponibles."
+                    f"{max_id + 1} n\u2019en fait pas partie."
                 ]
             }
         self.club.refresh_from_db()
@@ -332,12 +303,10 @@ class TestMembership(TestClub):
         nb_subscriber_memberships = self.subscriber.memberships.count()
         self.client.force_login(president)
         response = self.client.post(
-            self.new_members_url, {"user": self.subscriber.id, "role": 9}
+            self.members_url,
-        )
+            {"users": self.subscriber.id, "role": 9},
-        assert response.status_code == 200
-        assert response.headers.get("HX-Redirect", "") == reverse(
-            "club:club_members", kwargs={"club_id": self.club.id}
         )
+        self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
         self.subscriber.refresh_from_db()
         assert self.club.members.count() == nb_club_membership + 1
@@ -348,8 +317,8 @@ class TestMembership(TestClub):
         """Test that a member of the club member cannot create
         a membership with a greater role than its own.
         """
-        form = ClubAddMemberForm(
+        form = ClubMemberForm(
-            data={"user": self.subscriber.id, "role": 10},
+            data={"users": [self.subscriber.id], "role": 10},
             request_user=self.simple_board_member,
             club=self.club,
         )
@@ -357,7 +326,7 @@ class TestMembership(TestClub):
 
         assert not form.is_valid()
         assert form.errors == {
-            "role": ["Sélectionnez un choix valide. 10 n\u2019en fait pas partie."]
+            "__all__": ["Vous n'avez pas la permission de faire cela"]
         }
         self.club.refresh_from_db()
         assert nb_memberships == self.club.members.count()
@@ -365,53 +334,23 @@ class TestMembership(TestClub):
 
     def test_add_member_without_role(self):
         """Test that trying to add members without specifying their role fails."""
-        form = ClubAddMemberForm(
+        self.client.force_login(self.root)
-            data={"user": self.subscriber.id}, request_user=self.root, club=self.club
+        form = ClubMemberForm(
-        )
+            data={"users": [self.subscriber.id]},
-
+            request_user=self.simple_board_member,
-        assert not form.is_valid()
-        assert form.errors == {"role": ["Ce champ est obligatoire."]}
-
-    def test_add_member_already_there(self):
-        form = ClubAddMemberForm(
-            data={"user": self.simple_board_member, "role": 3},
-            request_user=self.root,
             club=self.club,
         )
+
         assert not form.is_valid()
-        assert form.errors == {
+        assert form.errors == {"role": ["Vous devez choisir un rôle"]}
-            "user": ["Vous ne pouvez pas ajouter deux fois le même utilisateur"]
-        }
-
-    def test_add_other_member_forbidden(self):
-        non_member = subscriber_user.make()
-        simple_member = baker.make(Membership, club=self.club, role=1).user
-        for user in non_member, simple_member:
-            form = ClubAddMemberForm(
-                data={"user": subscriber_user.make(), "role": 1},
-                request_user=user,
-                club=self.club,
-            )
-            assert not form.is_valid()
-            assert form.errors == {
-                "role": ["Sélectionnez un choix valide. 1 n\u2019en fait pas partie."]
-            }
-
-    def test_simple_members_dont_see_form_anymore(self):
-        """Test that simple club members don't see the form to add members"""
-        user = subscriber_user.make()
-        baker.make(Membership, club=self.club, user=user, role=1)
-        self.client.force_login(user)
-        res = self.client.get(self.members_url)
-        assert res.status_code == 200
-        soup = BeautifulSoup(res.text, "lxml")
-        assert not soup.find(id="add_club_members_form")
 
     def test_end_membership_self(self):
         """Test that a member can end its own membership."""
         self.client.force_login(self.simple_board_member)
-        membership = self.club.members.get(end_date=None, user=self.simple_board_member)
+        self.client.post(
-        self.client.post(self.members_url, {"members_old": [membership.id]})
+            self.members_url,
+            {"users_old": self.simple_board_member.id},
+        )
         self.simple_board_member.refresh_from_db()
         self.assert_membership_ended_today(self.simple_board_member)
 
@@ -419,13 +358,15 @@ class TestMembership(TestClub):
         """Test that board members of the club can end memberships
         of users with lower roles.
         """
-        # reminder : simple_board_member has role 3
+        # remainder : simple_board_member has role 3, president has role 10, richard has role 1
         self.client.force_login(self.simple_board_member)
-        membership = baker.make(Membership, club=self.club, role=2, end_date=None)
+        response = self.client.post(
-        response = self.client.post(self.members_url, {"members_old": [membership.id]})
+            self.members_url,
+            {"users_old": self.richard.id},
+        )
         self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
-        self.assert_membership_ended_today(membership.user)
+        self.assert_membership_ended_today(self.richard)
 
     def test_end_membership_higher_role(self):
         """Test that board members of the club cannot end memberships
@@ -433,30 +374,46 @@ class TestMembership(TestClub):
         """
         membership = self.president.memberships.filter(club=self.club).first()
         self.client.force_login(self.simple_board_member)
-        self.client.post(self.members_url, {"members_old": [membership.id]})
+        self.client.post(
+            self.members_url,
+            {"users_old": self.president.id},
+        )
         self.club.refresh_from_db()
         new_membership = self.club.get_membership_for(self.president)
         assert new_membership is not None
         assert new_membership == membership
 
-        membership.refresh_from_db()
+        membership = self.president.memberships.filter(club=self.club).first()
         assert membership.end_date is None
 
-    def test_end_membership_with_permission(self):
+    def test_end_membership_as_main_club_board(self):
-        """Test that users with permission can end any membership."""
+        """Test that board members of the main club can end the membership
+        of anyone.
+        """
         # make subscriber a board member
+        subscriber = subscriber_user.make()
+        Membership.objects.create(club=self.ae, user=subscriber, role=3)
+
         nb_memberships = self.club.members.ongoing().count()
-        self.client.force_login(
+        self.client.force_login(subscriber)
-            subscriber_user.make(
-                user_permissions=[Permission.objects.get(codename="change_membership")]
-            )
-        )
-        president_membership = self.club.president
         response = self.client.post(
-            self.members_url, {"members_old": [president_membership.id]}
+            self.members_url,
+            {"users_old": self.president.id},
         )
         self.assertRedirects(response, self.members_url)
-        self.assert_membership_ended_today(president_membership.user)
+        self.assert_membership_ended_today(self.president)
+        assert self.club.members.ongoing().count() == nb_memberships - 1
+
+    def test_end_membership_as_root(self):
+        """Test that root users can end the membership of anyone."""
+        nb_memberships = self.club.members.ongoing().count()
+        self.client.force_login(self.root)
+        response = self.client.post(
+            self.members_url,
+            {"users_old": [self.president.id]},
+        )
+        self.assertRedirects(response, self.members_url)
+        self.assert_membership_ended_today(self.president)
         assert self.club.members.ongoing().count() == nb_memberships - 1
 
     def test_end_membership_as_foreigner(self):
@@ -464,11 +421,14 @@ class TestMembership(TestClub):
         nb_memberships = self.club.members.count()
         membership = self.richard.memberships.filter(club=self.club).first()
         self.client.force_login(self.subscriber)
-        self.client.post(self.members_url, {"members_old": [self.richard.id]})
+        self.client.post(
+            self.members_url,
+            {"users_old": [self.richard.id]},
+        )
         # nothing should have changed
-        membership.refresh_from_db()
+        new_mem = self.club.get_membership_for(self.richard)
         assert self.club.members.count() == nb_memberships
-        assert membership.end_date is None
+        assert membership == new_mem
 
     def test_remove_from_club_group(self):
         """Test that when a membership ends, the user is removed from club groups."""
@@ -530,85 +490,3 @@ class TestMembership(TestClub):
         new_board = set(self.club.board_group.users.values_list("id", flat=True))
         assert new_members == initial_members
         assert new_board == initial_board
-
-
-@pytest.mark.django_db
-class TestJoinClub:
-    @pytest.fixture(autouse=True)
-    def clear_cache(self):
-        cache.clear()
-
-    @pytest.mark.parametrize(
-        ("user_factory", "role", "errors"),
-        [
-            (
-                subscriber_user.make,
-                2,
-                {
-                    "role": [
-                        "Sélectionnez un choix valide. 2 n\u2019en fait pas partie."
-                    ]
-                },
-            ),
-            (
-                lambda: baker.make(User),
-                1,
-                {"__all__": ["Vous devez être cotisant pour faire partie d'un club"]},
-            ),
-        ],
-    )
-    def test_join_club_errors(
-        self, user_factory: Callable[[], User], role: int, errors: dict
-    ):
-        club = baker.make(Club)
-        user = user_factory()
-        form = JoinClubForm(club=club, request_user=user, data={"role": role})
-        assert not form.is_valid()
-        assert form.errors == errors
-
-    def test_user_already_in_club(self):
-        club = baker.make(Club)
-        user = subscriber_user.make()
-        baker.make(Membership, user=user, club=club)
-        form = JoinClubForm(club=club, request_user=user, data={"role": 1})
-        assert not form.is_valid()
-        assert form.errors == {"__all__": ["Vous êtes déjà membre de ce club."]}
-
-    def test_ok(self):
-        club = baker.make(Club)
-        user = subscriber_user.make()
-        form = JoinClubForm(club=club, request_user=user, data={"role": 1})
-        assert form.is_valid()
-        form.save()
-        assert Membership.objects.ongoing().filter(user=user, club=club).exists()
-
-
-class TestOldMembersView(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        club = baker.make(Club)
-        roles = [1, 1, 1, 2, 2, 4, 4, 5, 7, 9, 10]
-        cls.memberships = baker.make(
-            Membership,
-            role=iter(roles),
-            club=club,
-            start_date=now() - timedelta(days=14),
-            end_date=now() - timedelta(days=7),
-            _quantity=len(roles),
-            _bulk_create=True,
-        )
-        cls.url = reverse("club:club_old_members", kwargs={"club_id": club.id})
-
-    def test_ok(self):
-        user = subscriber_user.make()
-        self.client.force_login(user)
-        res = self.client.get(self.url)
-        assert res.status_code == 200
-
-    def test_access_forbidden(self):
-        res = self.client.get(self.url)
-        assertRedirects(res, reverse("core:login", query={"next": self.url}))
-
-        self.client.force_login(baker.make(User))
-        res = self.client.get(self.url)
-        assert res.status_code == 403

club/tests/test_posters.py

@@ -1,35 +0,0 @@
-import pytest
-from django.test import Client
-from django.urls import reverse
-from model_bakery import baker
-
-from club.models import Club
-from com.models import Poster
-from core.baker_recipes import subscriber_user
-
-
-@pytest.mark.django_db
-@pytest.mark.parametrize("route_url", ["club:poster_list", "club:poster_create"])
-def test_access(client: Client, route_url):
-    club = baker.make(Club)
-    user = subscriber_user.make()
-    url = reverse(route_url, kwargs={"club_id": club.id})
-
-    client.force_login(user)
-    assert client.get(url).status_code == 403
-    club.board_group.users.add(user)
-    assert client.get(url).status_code == 200
-
-
-@pytest.mark.django_db
-@pytest.mark.parametrize("route_url", ["club:poster_edit", "club:poster_delete"])
-def test_access_specific_poster(client: Client, route_url):
-    club = baker.make(Club)
-    user = subscriber_user.make()
-    poster = baker.make(Poster)
-    url = reverse(route_url, kwargs={"club_id": club.id, "poster_id": poster.id})
-
-    client.force_login(user)
-    assert client.get(url).status_code == 403
-    club.board_group.users.add(user)
-    assert client.get(url).status_code == 200

club/urls.py

@@ -25,7 +25,6 @@
 from django.urls import path
 
 from club.views import (
-    ClubAddMembersFragment,
     ClubCreateView,
     ClubEditView,
     ClubListView,
@@ -61,11 +60,6 @@ urlpatterns = [
     path("<int:club_id>/edit/", ClubEditView.as_view(), name="club_edit"),
     path("<int:club_id>/edit/page/", ClubPageEditView.as_view(), name="club_edit_page"),
     path("<int:club_id>/members/", ClubMembersView.as_view(), name="club_members"),
-    path(
-        "fragment/<int:club_id>/members/",
-        ClubAddMembersFragment.as_view(),
-        name="club_new_members",
-    ),
     path(
         "<int:club_id>/elderlies/",
         ClubOldMembersView.as_view(),

club/views.py

@@ -23,14 +23,12 @@
 #
 
 import csv
-from typing import Any
 
 from django.conf import settings
 from django.contrib.auth.mixins import PermissionRequiredMixin
-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 Q, Sum
+from django.db.models import Sum
 from django.http import (
     Http404,
     HttpResponseRedirect,
@@ -39,52 +37,38 @@ from django.http import (
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse, reverse_lazy
 from django.utils import timezone
-from django.utils.safestring import SafeString
+from django.utils.functional import cached_property
-from django.utils.timezone import now
 from django.utils.translation import gettext as _t
 from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView, View
 from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
 from club.forms import (
-    ClubAddMemberForm,
     ClubAdminEditForm,
     ClubEditForm,
-    ClubOldMemberForm,
+    ClubMemberForm,
-    JoinClubForm,
     MailingForm,
     SellingsForm,
 )
-from club.models import (
+from club.models import Club, Mailing, MailingSubscription, Membership
-    Club,
-    Mailing,
-    MailingSubscription,
-    Membership,
-)
-from com.models import Poster
 from com.views import (
     PosterCreateBaseView,
     PosterDeleteBaseView,
     PosterEditBaseView,
     PosterListBaseView,
 )
-from core.auth.mixins import (
+from core.auth.mixins import CanCreateMixin, CanEditMixin, CanViewMixin
-    CanEditMixin,
-)
 from core.models import PageRev
-from core.views import DetailFormView, PageEditViewBase, UseFragmentsMixin
+from core.views import DetailFormView, PageEditViewBase
-from core.views.mixins import FragmentMixin, FragmentRenderer, TabedViewMixin
+from core.views.mixins import TabedViewMixin
 from counter.models import Selling
 
 
 class ClubTabsMixin(TabedViewMixin):
     def get_tabs_title(self):
-        if not hasattr(self, "object") or not self.object:
+        obj = self.get_object()
-            self.object = self.get_object()
+        if isinstance(obj, PageRev):
-        if isinstance(self.object, PageRev):
+            self.object = obj.page.club
-            self.object = self.object.page.club
-        elif isinstance(self.object, Poster):
-            self.object = self.object.club
         return self.object.get_display_name()
 
     def get_list_of_tabs(self):
@@ -95,7 +79,7 @@ class ClubTabsMixin(TabedViewMixin):
                 "name": _("Infos"),
             }
         ]
-        if self.request.user.has_perm("club.view_club"):
+        if self.request.user.can_view(self.object):
             tab_list.extend(
                 [
                     {
@@ -114,16 +98,16 @@ class ClubTabsMixin(TabedViewMixin):
                     },
                 ]
             )
-            if self.object.page:
+        if self.object.page:
-                tab_list.append(
+            tab_list.append(
-                    {
+                {
-                        "url": reverse(
+                    "url": reverse(
-                            "club:club_hist", kwargs={"club_id": self.object.id}
+                        "club:club_hist", kwargs={"club_id": self.object.id}
-                        ),
+                    ),
-                        "slug": "history",
+                    "slug": "history",
-                        "name": _("History"),
+                    "name": _("History"),
-                    }
+                }
-                )
+            )
         if self.request.user.can_edit(self.object):
             tab_list.extend(
                 [
@@ -175,7 +159,7 @@ class ClubTabsMixin(TabedViewMixin):
                             "club:poster_list", kwargs={"club_id": self.object.id}
                         ),
                         "slug": "posters",
-                        "name": _("Posters"),
+                        "name": _("Posters list"),
                     },
                 ]
             )
@@ -244,14 +228,13 @@ class ClubPageEditView(ClubTabsMixin, PageEditViewBase):
         return reverse_lazy("club:club_view", kwargs={"club_id": self.club.id})
 
 
-class ClubPageHistView(ClubTabsMixin, PermissionRequiredMixin, DetailView):
+class ClubPageHistView(ClubTabsMixin, CanViewMixin, DetailView):
     """Modification hostory of the page."""
 
     model = Club
     pk_url_kwarg = "club_id"
     template_name = "club/page_history.jinja"
     current_tab = "history"
-    permission_required = "club.view_club"
 
 
 class ClubToolsView(ClubTabsMixin, CanEditMixin, DetailView):
@@ -263,121 +246,57 @@ class ClubToolsView(ClubTabsMixin, CanEditMixin, DetailView):
     current_tab = "tools"
 
 
-class ClubAddMembersFragment(
+class ClubMembersView(ClubTabsMixin, CanViewMixin, DetailFormView):
-    FragmentMixin, PermissionRequiredMixin, SuccessMessageMixin, CreateView
-):
-    template_name = "club/fragments/add_member.jinja"
-    model = Membership
-    object = None
-    reload_on_redirect = True
-    permission_required = "club.view_club"
-
-    def dispatch(self, *args, **kwargs):
-        self.club = get_object_or_404(Club, pk=kwargs.get("club_id"))
-        return super().dispatch(*args, **kwargs)
-
-    def get_form_class(self):
-        user = self.request.user
-        if user.has_perm("club.add_membership") or self.club.get_membership_for(user):
-            return ClubAddMemberForm
-        return JoinClubForm
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "request_user": self.request.user,
-            "club": self.club,
-        }
-
-    def render_fragment(self, request, **kwargs) -> SafeString:
-        self.club = kwargs.get("club")
-        return super().render_fragment(request, **kwargs)
-
-    def get_success_url(self):
-        return reverse("club:club_members", kwargs={"club_id": self.club.id})
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
-
-    def get_success_message(self, cleaned_data):
-        if "user" not in cleaned_data or cleaned_data["user"] == self.request.user:
-            return _("You are now a member of this club.")
-        return _("%(user)s has been added to club.") % cleaned_data
-
-
-class ClubMembersView(
-    ClubTabsMixin, UseFragmentsMixin, PermissionRequiredMixin, DetailFormView
-):
     """View of a club's members."""
 
     model = Club
     pk_url_kwarg = "club_id"
-    form_class = ClubOldMemberForm
+    form_class = ClubMemberForm
     template_name = "club/club_members.jinja"
     current_tab = "members"
-    permission_required = "club.view_club"
 
-    def get_fragments(self) -> dict[str, type[FragmentMixin] | FragmentRenderer]:
+    @cached_property
-        membership = self.object.get_membership_for(self.request.user)
+    def members(self) -> list[Membership]:
-        if (
+        return list(self.object.members.ongoing().order_by("-role"))
-            membership
-            and membership.role <= settings.SITH_MAXIMUM_FREE_ROLE
-            and not self.request.user.has_perm("club.add_membership")
-        ):
-            # Simple club members won't see the form anymore.
-            # Even if they saw it, they couldn't add anyone to the club anyway
-            return {}
-        return {"add_member_fragment": ClubAddMembersFragment}
-
-    def get_fragment_data(self) -> dict[str, Any]:
-        return {"add_member_fragment": {"club": self.object}}
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
+        kwargs = super().get_form_kwargs()
-            "user": self.request.user,
+        kwargs["request_user"] = self.request.user
-            "club": self.object,
+        kwargs["club"] = self.object
-        }
+        kwargs["club_members"] = self.members
+        return kwargs
 
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)
-        editable = list(
+        kwargs["members"] = self.members
-            kwargs["form"].fields["members_old"].queryset.values_list("id", flat=True)
-        )
-        kwargs["members"] = list(
-            self.object.members.ongoing()
-            .annotate(is_editable=Q(id__in=editable))
-            .order_by("-role")
-            .select_related("user")
-        )
-        kwargs["can_end_membership"] = len(editable) > 0
         return kwargs
 
     def form_valid(self, form):
-        for membership in form.cleaned_data.get("members_old"):
+        """Check user rights."""
-            membership.end_date = now()
+        resp = super().form_valid(form)
+
+        data = form.clean()
+        users = data.pop("users", [])
+        users_old = data.pop("users_old", [])
+        for user in users:
+            Membership(club=self.object, user=user, **data).save()
+        for user in users_old:
+            membership = self.object.get_membership_for(user)
+            membership.end_date = timezone.now()
             membership.save()
-        return super().form_valid(form)
+        return resp
 
     def get_success_url(self, **kwargs):
         return self.request.path
 
 
-class ClubOldMembersView(ClubTabsMixin, PermissionRequiredMixin, DetailView):
+class ClubOldMembersView(ClubTabsMixin, CanViewMixin, DetailView):
     """Old members of a club."""
 
     model = Club
     pk_url_kwarg = "club_id"
     template_name = "club/club_old_members.jinja"
     current_tab = "elderlies"
-    permission_required = "club.view_club"
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "old_members": (
-                self.object.members.exclude(end_date=None)
-                .order_by("-role", "description", "-end_date")
-                .select_related("user")
-            )
-        }
 
 
 class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
@@ -418,7 +337,7 @@ class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
         form = self.get_form()
         if form.is_valid():
             if not len([v for v in form.cleaned_data.values() if v is not None]):
-                qs = Selling.objects.none()
+                qs = Selling.objects.filter(id=-1)
             if form.cleaned_data["begin_date"]:
                 qs = qs.filter(date__gte=form.cleaned_data["begin_date"])
             if form.cleaned_data["end_date"]:
@@ -436,9 +355,7 @@ class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
             if len(selected_products) > 0:
                 qs = qs.filter(product__in=selected_products)
 
-            kwargs["result"] = qs.select_related(
+            kwargs["result"] = qs.all().order_by("-id")
-                "counter", "counter__club", "customer", "customer__user", "seller"
-            ).order_by("-id")
             kwargs["total"] = sum([s.quantity * s.unit_price for s in kwargs["result"]])
             total_quantity = qs.all().aggregate(Sum("quantity"))
             if total_quantity["quantity__sum"]:
@@ -769,45 +686,48 @@ class MailingAutoGenerationView(View):
         return redirect("club:mailing", club_id=club.id)
 
 
-class PosterListView(ClubTabsMixin, PosterListBaseView):
+class PosterListView(ClubTabsMixin, PosterListBaseView, CanViewMixin):
     """List communication posters."""
 
-    current_tab = "posters"
-    extra_context = {"app": "club"}
-
-    def get_queryset(self):
-        return super().get_queryset().filter(club=self.club.id)
-
     def get_object(self):
         return self.club
 
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "club"
+        kwargs["club"] = self.club
+        return kwargs
 
-class PosterCreateView(ClubTabsMixin, PosterCreateBaseView):
+
+class PosterCreateView(PosterCreateBaseView, CanCreateMixin):
     """Create communication poster."""
 
-    current_tab = "posters"
+    pk_url_kwarg = "club_id"
+
+    def get_object(self):
+        obj = super().get_object()
+        if not obj:
+            return self.club
+        return obj
 
     def get_success_url(self, **kwargs):
         return reverse_lazy("club:poster_list", kwargs={"club_id": self.club.id})
 
-    def get_object(self, *args, **kwargs):
-        return self.club
 
-
+class PosterEditView(ClubTabsMixin, PosterEditBaseView, CanEditMixin):
-class PosterEditView(ClubTabsMixin, PosterEditBaseView):
     """Edit communication poster."""
 
-    current_tab = "posters"
-    extra_context = {"app": "club"}
-
     def get_success_url(self):
         return reverse_lazy("club:poster_list", kwargs={"club_id": self.club.id})
 
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "club"
+        return kwargs
 
-class PosterDeleteView(ClubTabsMixin, PosterDeleteBaseView):
+
+class PosterDeleteView(PosterDeleteBaseView, ClubTabsMixin, CanEditMixin):
     """Delete communication poster."""
 
-    current_tab = "posters"
-
     def get_success_url(self):
         return reverse_lazy("club:poster_list", kwargs={"club_id": self.club.id})

com/forms.py

@@ -2,6 +2,7 @@ from datetime import date
 
 from dateutil.relativedelta import relativedelta
 from django import forms
+from django.db.models import Exists, OuterRef
 from django.forms import CheckboxInput
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
@@ -34,18 +35,20 @@ class PosterForm(forms.ModelForm):
         label=_("Start date"),
         widget=SelectDateTime,
         required=True,
-        initial=timezone.now(),
+        initial=timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
     )
     date_end = forms.DateTimeField(
         label=_("End date"), widget=SelectDateTime, required=False
     )
 
-    def __init__(self, *args, user: User, **kwargs):
+    def __init__(self, *args, **kwargs):
+        self.user = kwargs.pop("user", None)
         super().__init__(*args, **kwargs)
-        if user.is_root or user.is_com_admin:
+        if self.user and not self.user.is_com_admin:
-            self.fields["club"].widget = AutoCompleteSelectClub()
+            self.fields["club"].queryset = Club.objects.filter(
-        else:
+                id__in=self.user.clubs_with_rights
-            self.fields["club"].queryset = Club.objects.having_board_member(user)
+            )
+            self.fields.pop("display_time")
 
 
 class NewsDateForm(forms.ModelForm):
@@ -158,9 +161,16 @@ class NewsForm(forms.ModelForm):
         # if the author is an admin, he/she can choose any club,
         # otherwise, only clubs for which he/she is a board member can be selected
         if author.is_root or author.is_com_admin:
-            self.fields["club"].widget = AutoCompleteSelectClub()
+            self.fields["club"] = forms.ModelChoiceField(
+                queryset=Club.objects.all(), widget=AutoCompleteSelectClub
+            )
         else:
-            self.fields["club"].queryset = Club.objects.having_board_member(author)
+            active_memberships = author.memberships.board().ongoing()
+            self.fields["club"] = forms.ModelChoiceField(
+                queryset=Club.objects.filter(
+                    Exists(active_memberships.filter(club=OuterRef("pk")))
+                )
+            )
 
     def is_valid(self):
         return super().is_valid() and self.date_form.is_valid()

com/models.py

@@ -412,5 +412,17 @@ class Poster(models.Model):
         if self.date_end and self.date_begin > self.date_end:
             raise ValidationError(_("Begin date should be before end date"))
 
+    def is_owned_by(self, user):
+        if user.is_anonymous:
+            return False
+        return user.is_com_admin or len(user.clubs_with_rights) > 0
+
+    def can_be_moderated_by(self, user):
+        return user.is_com_admin
+
     def get_display_name(self):
         return self.club.get_display_name()
+
+    @property
+    def page(self):
+        return self.club.page

com/static/bundled/com/slideshow-index.ts

@@ -1,49 +0,0 @@
-const INTERVAL = 10;
-
-interface Poster {
-  url: string; // URL of the poster
-  displayTime: number; // Number of seconds to display that poster
-}
-
-document.addEventListener("alpine:init", () => {
-  Alpine.data("slideshow", (posters: Poster[]) => ({
-    posters: posters,
-    progress: 0,
-    elapsed: 0,
-
-    current: 0,
-    previous: 0,
-
-    init() {
-      this.$watch("elapsed", () => {
-        const displayTime = this.posters[this.current].displayTime * 1000;
-        if (this.elapsed > displayTime) {
-          this.previous = this.current;
-          this.current = this.getNext();
-          this.elapsed = 0;
-        }
-        if (displayTime === 0) {
-          this.progress = 100;
-        } else {
-          this.progress = (100 * this.elapsed) / displayTime;
-        }
-      });
-      setInterval(() => {
-        this.elapsed += INTERVAL;
-      }, INTERVAL);
-    },
-
-    getNext() {
-      return (this.current + 1) % this.posters.length;
-    },
-
-    async toggleFullScreen(event: Event) {
-      if (document.fullscreenElement) {
-        await document.exitFullscreen();
-        return;
-      }
-      const target = event.target as HTMLElement;
-      await target.requestFullscreen();
-    },
-  }));
-});

com/static/com/css/posters.scss

@@ -111,7 +111,7 @@
             top: 0;
             left: 0;
             z-index: 10;
-            content: attr(hover);
+            content: "Click to expand";
             color: white;
             background-color: rgba(black, 0.5);
           }

com/static/com/js/poster_list.js

@@ -0,0 +1,23 @@
+$(document).ready(() => {
+  $("#poster_list #view").click(() => {
+    $("#view").removeClass("active");
+  });
+
+  $("#poster_list .poster .image").click((e) => {
+    let el = $(e.target);
+    if (el.hasClass("image")) {
+      el = el.find("img");
+    }
+    $("#poster_list #view #placeholder").html(el.clone());
+
+    $("#view").addClass("active");
+  });
+
+  $(document).keyup((e) => {
+    if (e.keyCode === 27) {
+      // escape key maps to keycode `27`
+      e.preventDefault();
+      $("#view").removeClass("active");
+    }
+  });
+});

com/static/com/js/slideshow.js

@@ -0,0 +1,98 @@
+$(document).ready(() => {
+  const transitionTime = 1000;
+
+  let i = 0;
+  const max = $("#slideshow .slide").length;
+
+  function enterFullscreen() {
+    const element = document.getElementById("slideshow");
+    $(element).addClass("fullscreen");
+    if (element.requestFullscreen) {
+      element.requestFullscreen();
+    } else if (element.mozRequestFullScreen) {
+      element.mozRequestFullScreen();
+    } else if (element.webkitRequestFullscreen) {
+      element.webkitRequestFullscreen();
+    } else if (element.msRequestFullscreen) {
+      element.msRequestFullscreen();
+    }
+  }
+
+  function exitFullscreen() {
+    const element = document.getElementById("slideshow");
+    $(element).removeClass("fullscreen");
+    if (document.exitFullscreen) {
+      document.exitFullscreen();
+    } else if (document.webkitExitFullscreen) {
+      document.webkitExitFullscreen();
+    } else if (document.mozCancelFullScreen) {
+      document.mozCancelFullScreen();
+    } else if (document.msExitFullscreen) {
+      document.msExitFullscreen();
+    }
+  }
+
+  function initProgressBar() {
+    $("#slideshow #progress_bar").css("transition", "none");
+    $("#slideshow #progress_bar").removeClass("progress");
+    $("#slideshow #progress_bar").addClass("init");
+  }
+
+  function startProgressBar(displayTime) {
+    $("#slideshow #progress_bar").removeClass("init");
+    $("#slideshow #progress_bar").addClass("progress");
+    $("#slideshow #progress_bar").css("transition", `width ${displayTime}s linear`);
+  }
+
+  function next() {
+    initProgressBar();
+    const slide = $($("#slideshow .slide").get(i % max));
+    slide.removeClass("center");
+    slide.addClass("left");
+
+    const nextSlide = $($("#slideshow .slide").get((i + 1) % max));
+    nextSlide.removeClass("right");
+    nextSlide.addClass("center");
+    const displayTime = nextSlide.attr("display_time") || 2;
+
+    $("#slideshow .bullet").removeClass("active");
+    const bullet = $("#slideshow .bullet")[(i + 1) % max];
+    $(bullet).addClass("active");
+
+    i = (i + 1) % max;
+
+    setTimeout(() => {
+      const othersLeft = $("#slideshow .slide.left");
+      othersLeft.removeClass("left");
+      othersLeft.addClass("right");
+
+      startProgressBar(displayTime);
+      setTimeout(next, displayTime * 1000);
+    }, transitionTime);
+  }
+
+  const displayTime = $("#slideshow .center").attr("display_time");
+  initProgressBar();
+  setTimeout(() => {
+    if (max > 1) {
+      startProgressBar(displayTime);
+      setTimeout(next, displayTime * 1000);
+    }
+  }, 10);
+
+  $("#slideshow").click(() => {
+    if ($("#slideshow").hasClass("fullscreen")) {
+      exitFullscreen();
+    } else {
+      enterFullscreen();
+    }
+  });
+
+  $(document).keyup((e) => {
+    if (e.keyCode === 27) {
+      // escape key maps to keycode `27`
+      e.preventDefault();
+      exitFullscreen();
+    }
+  });
+});

com/static/css/slideshow.scss

@@ -1,4 +1,4 @@
-body {
+body{
   position: absolute;
   width: 100vw;
   height: 100vh;
@@ -7,22 +7,22 @@ body {
   margin: 0;
 }
 
-#slideshow {
+#slideshow{
   position: relative;
   background-color: lightgrey;
 
   height: 100%;
 
-  * {
+  *{
     -webkit-user-select: none;
     -moz-user-select: none;
     -ms-user-select: none;
     user-select: none;
   }
 
-  &:hover {
+  &:hover{
 
-    &::before {
+    &::before{
 
       position: absolute;
       width: 100%;
@@ -34,7 +34,7 @@ body {
 
       z-index: 10;
 
-      content: attr(hover);
+      content: "Click to expand";
 
       color: white;
       background-color: rgba(black, 0.5);
@@ -43,7 +43,7 @@ body {
 
   }
 
-  &:fullscreen {
+  &.fullscreen{
     position: fixed;
     width: 100%;
     height: 100%;
@@ -51,78 +51,57 @@ body {
     left: 0;
     background: none;
 
-    &:before {
+    &:before{
-      display: none;
+      display:none;
     }
 
-    #slides {
+    #slides{
       height: 100vh;
     }
 
   }
 
-  #slides {
+  #slides{
     position: relative;
     height: 100%;
     overflow: hidden;
-    background-color: grey;
 
-    .slide {
+    .slide{
       position: absolute;
       width: 100%;
       height: 100%;
 
-      display: none;
+      display: inline-flex;
       justify-content: center;
 
       top: 0px;
-      left: 0%;
 
-      img {
+      background-color: grey;
+      transition: left 1s ease-out;
+
+      img{
         max-width: 100%;
         max-height: 100%;
         object-fit: contain;
       }
+    }
 
-      &.current {
+    .slide.left{
-        display: inline-flex;
+      left: -100%;
-        left: 0%;
+    }
-        animation: scrolling-in 1s linear;
-      }
 
-      &.previous {
+    .slide.center{
-        display: inline-flex;
+      left: 0px;
-        animation: scrolling-out 1s linear;
+    }
-        opacity: 0;
-        transition: opacity 0.1s;
-        transition-delay: 0.9s;
-      }
-
-      @keyframes scrolling-in {
-        0% {
-          transform: translateX(100%);
-        }
-
-        100% {
-          transform: translateX(0%);
-        }
-      }
-
-      @keyframes scrolling-out {
-        0% {
-          transform: translateX(0%);
-        }
-
-        100% {
-          transform: translateX(-100%);
-        }
-      }
 
+    .slide.right{
+      left: 100%;
+      transition: none;
     }
   }
 
 
-  #progress_bullets {
+  #progress_bullets{
     position: absolute;
     bottom: 10px;
     width: 100%;
@@ -133,7 +112,7 @@ body {
 
     margin-bottom: 10px;
 
-    .bullet {
+    .bullet{
       height: 10px;
       width: 10px;
 
@@ -144,33 +123,27 @@ body {
 
       background-color: grey;
 
-      &.active {
+      &.active{
         background-color: #c99836;
       }
     }
   }
 
-  progress {
+  #progress_bar{
-    --color: #304c83;
-
     position: absolute;
     bottom: 0px;
     height: 10px;
-    color: var(--color);
+    background-color: #304c83;
-    width: 100%;
-    margin-bottom: 0px;
-    border: none;
 
-    &::-moz-progress-bar {
+    &.init{
-      background: var(--color);
+      width: 0px;
+      transition: none;
     }
 
-    &::-webkit-progress-value {
+    &.progress{
-      background: var(--color);
+      width: 100%;
-    }
+      transition: width 10s linear;
-
-    &[value] {
-      background-color: transparent;
     }
   }
-}
+}
+

com/templates/com/macros.jinja

@@ -76,20 +76,18 @@
               It will stay hidden for other users until it has been published.
             {% endtrans %}
           </p>
-          {%- if user.has_perm("com.moderate_news") -%}
+          {% if user.has_perm("com.moderate_news") %}
             {# This is an additional query for each non-moderated news,
             but it will be executed only for admin users, and only one time
-            (if they do their job and moderate news as soon as they see them),
+            (if they do their job and moderated news as soon as they see them),
             so it's still reasonable #}
             <div
-              {% if news is integer or news is string -%}
+              {% if news is integer or news is string %}
                 x-data="{ nbEvents: 0 }"
                 x-init="nbEvents = await nbToPublish()"
-              {%- elif news.is_published -%}
+              {% else %}
-                x-data="{ nbEvents: 0 }"
-              {%- else -%}
                 x-data="{ nbEvents: {{ news.dates.count() }} }"
-              {%- endif -%}
+              {% endif %}
             >
               <template x-if="nbEvents > 1">
                 <div>

com/templates/com/poster_list.jinja

@@ -1,5 +1,11 @@
 {% extends "core/base.jinja" %}
 
+{% block script %}
+  {{ super() }}
+  <script src="{{ static('com/js/poster_list.js') }}"></script>
+{% endblock %}
+
+
 {% block title %}
   {% trans %}Poster{% endtrans %}
 {% endblock %}
@@ -9,7 +15,7 @@
 {% endblock %}
 
 {% block content %}
-  <div id="poster_list" x-data="{ active: null }">
+  <div id="poster_list">
 
     <div id="title">
       <h3>{% trans %}Posters{% endtrans %}</h3>
@@ -32,13 +38,7 @@
         {% for poster in poster_list %}
           <div class="poster{% if not poster.is_moderated %} not_moderated{% endif %}">
             <div class="name">{{ poster.name }}</div>
-            <div
+            <div class="image"><img src="{{ poster.file.url }}"></img></div>
-              class="image"
-              hover="{% trans %}Click to expand{% endtrans %}"
-              @click="active = $el.firstElementChild"
-            >
-              <img src="{{ poster.file.url }}"></img>
-            </div>
             <div class="dates">
               <div class="begin">{{ poster.date_begin | localtime | date("d/M/Y H:m") }}</div>
               <div class="end">{{ poster.date_end | localtime | date("d/M/Y H:m") }}</div>
@@ -62,14 +62,7 @@
 
     </div>
 
-    <div
+    <div id="view"><div id="placeholder"></div></div>
-      id="view"
-      @keyup.escape.window="active = null"
-      @click="active = null"
-      :class="{active: active !== null}"
-    >
-      <div id="placeholder"><img :src="active?.src"></div>
-    </div>
 
   </div>
 {% endblock %}

com/templates/com/screen_slideshow.jinja

@@ -2,44 +2,28 @@
 <html lang="fr">
   <head>
     <title>{% trans %}Slideshow{% endtrans %}</title>
-    <link rel="shortcut icon" href="{{ static('core/img/favicon.ico') }}">
     <link href="{{ static('css/slideshow.scss') }}" rel="stylesheet" type="text/css" />
-    <script type="module" src="{{ static('bundled/alpine-index.js') }}"></script>
+    <script src="{{ static('bundled/vendored/jquery.min.js') }}"></script>
-    <script type="module" src="{{ static('bundled/com/slideshow-index.ts') }}"></script>
+    <script src="{{ static('com/js/slideshow.js') }}"></script>
   </head>
-  <body x-data="slideshow([
+  <body>
-                {% for poster in posters %}
+    <div id="slideshow">
-                  {
-                  url: '{{ poster.file.url }}',
-                  displayTime: {{ poster.display_time }}
-                  },
-                {% endfor %}
-                ])">
-    <div
-      id="slideshow"
-      @click="toggleFullScreen"
-      hover="{% trans %}Click to expand{% endtrans %}"
-      @keyup.f.window="toggleFullScreen"
-    >
 
       <div id="slides">
-        <template x-for="(poster, index) in posters">
+        {% for poster in posters %}
-          <div class="slide" :class="{
+          <div class="slide {% if loop.first %}center{% else %}right{% endif %}" display_time="{{ poster.display_time }}">
-                                     current: index === current,
+            <img src="{{ poster.file.url }}">
-                                     previous: index !== current && index === previous,
-                                     }">
-            <img :src="poster.url">
           </div>
-        </template>
+        {% endfor %}
       </div>
 
       <div id="progress_bullets">
-        <template x-for="(poster, index) in posters">
+        {% for poster in posters %}
-          <div class="bullet" :class="{active: current === index}"></div>
+          <div class="bullet {% if loop.first %}active{% endif %}"></div>
-        </template>
+        {% endfor %}
       </div>
 
-      <progress :value="progress" max="100" x-show="posters.length > 1 && progress > 0"></progress>
+      <div id="progress_bar"></div>
 
     </div>
   </body>

com/templates/com/weekmail.jinja

@@ -31,7 +31,9 @@
           <td>
             <a href="{{ url('com:weekmail_article_edit', article_id=a.id) }}">{% trans %}Edit{% endtrans %}</a> |
             <a href="{{ url('com:weekmail_article_delete', article_id=a.id) }}">{% trans %}Delete{% endtrans %}</a> |
-            <a href="?add_article={{ a.id }}">{% trans %}Add to weekmail{% endtrans %}</a>
+            <a href="?add_article={{ a.id }}">{% trans %}Add to weekmail{% endtrans %}</a> |
+            <a href="?up_article={{ a.id }}">{% trans %}Up{% endtrans %}</a> |
+            <a href="?down_article={{ a.id }}">{% trans %}Down{% endtrans %}</a>
           </td>
         </tr>
       {% endfor %}

com/tests/test_views.py

@@ -18,16 +18,17 @@ from unittest.mock import patch
 import pytest
 from django.conf import settings
 from django.contrib.sites.models import Site
+from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import Client, TestCase
 from django.urls import reverse
 from django.utils import html
-from django.utils.timezone import now
+from django.utils.timezone import localtime, now
 from django.utils.translation import gettext as _
 from model_bakery import baker
 from pytest_django.asserts import assertNumQueries, assertRedirects
 
 from club.models import Club, Membership
-from com.models import News, NewsDate, Sith, Weekmail, WeekmailArticle
+from com.models import News, NewsDate, Poster, Sith, Weekmail, WeekmailArticle
 from core.baker_recipes import subscriber_user
 from core.models import AnonymousUser, Group, User
 
@@ -206,6 +207,31 @@ class TestWeekmailArticle(TestCase):
         assert not self.article.is_owned_by(self.sli)
 
 
+class TestPoster(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.com_admin = User.objects.get(username="comunity")
+        cls.poster = Poster.objects.create(
+            name="dummy",
+            file=SimpleUploadedFile("dummy.jpg", b"azertyuiop"),
+            club=Club.objects.first(),
+            date_begin=localtime(now()),
+        )
+        cls.sli = User.objects.get(username="sli")
+        cls.sli.memberships.all().delete()
+        Membership(user=cls.sli, club=Club.objects.first(), role=5).save()
+        cls.susbcriber = User.objects.get(username="subscriber")
+        cls.anonymous = AnonymousUser()
+
+    def test_poster_owner(self):
+        """Test that poster are owned by com admins and board members in clubs."""
+        assert self.poster.is_owned_by(self.com_admin)
+        assert not self.poster.is_owned_by(self.anonymous)
+
+        assert not self.poster.is_owned_by(self.susbcriber)
+        assert self.poster.is_owned_by(self.sli)
+
+
 class TestNewsCreation(TestCase):
     @classmethod
     def setUpTestData(cls):

com/views.py

@@ -28,10 +28,7 @@ from typing import Any
 
 from dateutil.relativedelta import relativedelta
 from django.conf import settings
-from django.contrib import messages
+from django.contrib.auth.mixins import AccessMixin, PermissionRequiredMixin
-from django.contrib.auth.mixins import (
-    PermissionRequiredMixin,
-)
 from django.contrib.syndication.views import Feed
 from django.core.exceptions import PermissionDenied, ValidationError
 from django.db.models import Max
@@ -53,10 +50,9 @@ from core.auth.mixins import (
     CanEditPropMixin,
     CanViewMixin,
     PermissionOrAuthorRequiredMixin,
-    PermissionOrClubBoardRequiredMixin,
 )
 from core.models import User
-from core.views.mixins import TabedViewMixin
+from core.views.mixins import QuickNotifMixin, TabedViewMixin
 from core.views.widgets.markdown import MarkdownInput
 
 # Sith object
@@ -103,6 +99,13 @@ class ComTabsMixin(TabedViewMixin):
         ]
 
 
+class IsComAdminMixin(AccessMixin):
+    def dispatch(self, request, *args, **kwargs):
+        if not request.user.is_com_admin:
+            raise PermissionDenied
+        return super().dispatch(request, *args, **kwargs)
+
+
 class ComEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
     model = Sith
     template_name = "core/edit.jinja"
@@ -334,7 +337,7 @@ class NewsFeed(Feed):
 # Weekmail
 
 
-class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
+class WeekmailPreviewView(ComTabsMixin, QuickNotifMixin, CanEditPropMixin, DetailView):
     model = Weekmail
     template_name = "com/weekmail_preview.jinja"
     success_url = reverse_lazy("com:weekmail")
@@ -346,11 +349,12 @@ class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
 
     def post(self, request, *args, **kwargs):
         self.object = self.get_object()
-        messages.success(self.request, _("Weekmail sent successfully"))
         if request.POST["send"] == "validate":
             try:
                 self.object.send()
-                return HttpResponseRedirect(reverse("com:weekmail"))
+                return HttpResponseRedirect(
+                    reverse("com:weekmail") + "?qn_weekmail_send_success"
+                )
             except SMTPRecipientsRefused as e:
                 self.bad_recipients = e.recipients
         elif request.POST["send"] == "clean":
@@ -361,6 +365,7 @@ class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
                 for u in users:
                     u.preferences.receive_weekmail = False
                     u.preferences.save()
+                self.quick_notif_list += ["qn_success"]
         return super().get(request, *args, **kwargs)
 
     def get_object(self, queryset=None):
@@ -374,7 +379,7 @@ class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
         return kwargs
 
 
-class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
+class WeekmailEditView(ComTabsMixin, QuickNotifMixin, CanEditPropMixin, UpdateView):
     model = Weekmail
     template_name = "com/weekmail.jinja"
     form_class = modelform_factory(
@@ -414,10 +419,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
                 art.rank, prev_art.rank = prev_art.rank, art.rank
                 art.save()
                 prev_art.save()
-                messages.success(
+                self.quick_notif_list += ["qn_success"]
-                    self.request,
-                    _("%(title)s moved up in the Weekmail") % {"title": art.title},
-                )
         if "down_article" in request.GET:
             art = get_object_or_404(
                 WeekmailArticle, id=request.GET["down_article"], weekmail=self.object
@@ -429,10 +431,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
                 art.rank, next_art.rank = next_art.rank, art.rank
                 art.save()
                 next_art.save()
-                messages.success(
+                self.quick_notif_list += ["qn_success"]
-                    self.request,
-                    _("%(title)s moved down in the Weekmail") % {"title": art.title},
-                )
         if "add_article" in request.GET:
             art = get_object_or_404(
                 WeekmailArticle, id=request.GET["add_article"], weekmail=None
@@ -441,10 +440,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
             art.rank = self.object.articles.aggregate(Max("rank"))["rank__max"] or 0
             art.rank += 1
             art.save()
-            messages.success(
+            self.quick_notif_list += ["qn_success"]
-                self.request,
-                _("%(title)s added to the Weekmail") % {"title": art.title},
-            )
         if "del_article" in request.GET:
             art = get_object_or_404(
                 WeekmailArticle, id=request.GET["del_article"], weekmail=self.object
@@ -452,10 +448,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
             art.weekmail = None
             art.rank = -1
             art.save()
-            messages.success(
+            self.quick_notif_list += ["qn_success"]
-                self.request,
-                _("%(title)s removed from the Weekmail") % {"title": art.title},
-            )
         return super().get(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
@@ -465,7 +458,9 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
         return kwargs
 
 
-class WeekmailArticleEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
+class WeekmailArticleEditView(
+    ComTabsMixin, QuickNotifMixin, CanEditPropMixin, UpdateView
+):
     """Edit an article."""
 
     model = WeekmailArticle
@@ -477,10 +472,11 @@ class WeekmailArticleEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
     pk_url_kwarg = "article_id"
     template_name = "core/edit.jinja"
     success_url = reverse_lazy("com:weekmail")
+    quick_notif_url_arg = "qn_weekmail_article_edit"
     current_tab = "weekmail"
 
 
-class WeekmailArticleCreateView(CreateView):
+class WeekmailArticleCreateView(QuickNotifMixin, CreateView):
     """Post an article."""
 
     model = WeekmailArticle
@@ -491,6 +487,7 @@ class WeekmailArticleCreateView(CreateView):
     )
     template_name = "core/create.jinja"
     success_url = reverse_lazy("core:user_tools")
+    quick_notif_url_arg = "qn_weekmail_new_article"
 
     def get_initial(self):
         if "club" not in self.request.GET:
@@ -561,109 +558,161 @@ class MailingModerateView(View):
         raise PermissionDenied
 
 
-class PosterListBaseView(PermissionOrClubBoardRequiredMixin, ListView):
+class PosterAdminViewMixin(IsComAdminMixin, ComTabsMixin):
+    current_tab = "posters"
+
+
+class PosterListBaseView(PosterAdminViewMixin, ListView):
     """List communication posters."""
 
+    current_tab = "posters"
     model = Poster
     template_name = "com/poster_list.jinja"
-    permission_required = "com.view_poster"
+
-    ordering = ["-date_begin"]
+    def dispatch(self, request, *args, **kwargs):
+        club_id = kwargs.pop("club_id", None)
+        self.club = None
+        if club_id:
+            self.club = get_object_or_404(Club, pk=club_id)
+        return super().dispatch(request, *args, **kwargs)
+
+    def get_queryset(self):
+        if self.request.user.is_com_admin:
+            return Poster.objects.all().order_by("-date_begin")
+        else:
+            return Poster.objects.filter(club=self.club.id)
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
+        kwargs = super().get_context_data(**kwargs)
+        if not self.request.user.is_com_admin:
+            kwargs["club"] = self.club
+        return kwargs
 
 
-class PosterCreateBaseView(PermissionOrClubBoardRequiredMixin, CreateView):
+class PosterCreateBaseView(PosterAdminViewMixin, CreateView):
     """Create communication poster."""
 
+    current_tab = "posters"
     form_class = PosterForm
     template_name = "core/create.jinja"
-    permission_required = "com.add_poster"
 
     def get_queryset(self):
         return Poster.objects.all()
 
-    def get_form_kwargs(self):
+    def dispatch(self, request, *args, **kwargs):
-        return super().get_form_kwargs() | {"user": self.request.user}
+        if "club_id" in kwargs:
+            self.club = get_object_or_404(Club, pk=kwargs["club_id"])
+        return super().dispatch(request, *args, **kwargs)
 
-    def get_initial(self):
+    def get_form_kwargs(self):
-        return {"club": self.club}
+        kwargs = super().get_form_kwargs()
+        kwargs.update({"user": self.request.user})
+        return kwargs
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
+        kwargs = super().get_context_data(**kwargs)
+        if not self.request.user.is_com_admin:
+            kwargs["club"] = self.club
+        return kwargs
 
     def form_valid(self, form):
-        if self.request.user.has_perm("com.moderate_poster"):
+        if self.request.user.is_com_admin:
             form.instance.is_moderated = True
         return super().form_valid(form)
 
 
-class PosterEditBaseView(PermissionOrClubBoardRequiredMixin, UpdateView):
+class PosterEditBaseView(PosterAdminViewMixin, UpdateView):
     """Edit communication poster."""
 
     pk_url_kwarg = "poster_id"
+    current_tab = "posters"
     form_class = PosterForm
     template_name = "com/poster_edit.jinja"
-    permission_required = "com.change_poster"
+
+    def get_initial(self):
+        return {
+            "date_begin": self.object.date_begin.strftime("%Y-%m-%d %H:%M:%S")
+            if self.object.date_begin
+            else None,
+            "date_end": self.object.date_end.strftime("%Y-%m-%d %H:%M:%S")
+            if self.object.date_end
+            else None,
+        }
+
+    def dispatch(self, request, *args, **kwargs):
+        if kwargs.get("club_id"):
+            try:
+                self.club = Club.objects.get(pk=kwargs["club_id"])
+            except Club.DoesNotExist as e:
+                raise PermissionDenied from e
+        return super().dispatch(request, *args, **kwargs)
 
     def get_queryset(self):
         return Poster.objects.all()
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"user": self.request.user}
+        kwargs = super().get_form_kwargs()
+        kwargs.update({"user": self.request.user})
+        return kwargs
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
+        kwargs = super().get_context_data(**kwargs)
+        if hasattr(self, "club"):
+            kwargs["club"] = self.club
+        return kwargs
 
     def form_valid(self, form):
-        if not self.request.user.has_perm("com.moderate_poster"):
+        if self.request.user.is_com_admin:
             form.instance.is_moderated = False
         return super().form_valid(form)
 
 
-class PosterDeleteBaseView(
+class PosterDeleteBaseView(PosterAdminViewMixin, DeleteView):
-    PermissionOrClubBoardRequiredMixin, ComTabsMixin, DeleteView
-):
     """Edit communication poster."""
 
     pk_url_kwarg = "poster_id"
     current_tab = "posters"
     model = Poster
     template_name = "core/delete_confirm.jinja"
-    permission_required = "com.delete_poster"
+
+    def dispatch(self, request, *args, **kwargs):
+        if kwargs.get("club_id"):
+            try:
+                self.club = Club.objects.get(pk=kwargs["club_id"])
+            except Club.DoesNotExist as e:
+                raise PermissionDenied from e
+        return super().dispatch(request, *args, **kwargs)
 
 
-class PosterListView(ComTabsMixin, PosterListBaseView):
+class PosterListView(PosterListBaseView):
     """List communication posters."""
 
-    current_tab = "posters"
-
-    def get_queryset(self):
-        qs = super().get_queryset()
-        if self.request.user.has_perm("com.view_poster"):
-            return qs
-        return qs.filter(club=self.club.id)
-
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)
         kwargs["app"] = "com"
         return kwargs
 
 
-class PosterCreateView(ComTabsMixin, PosterCreateBaseView):
+class PosterCreateView(PosterCreateBaseView):
     """Create communication poster."""
 
-    current_tab = "posters"
     success_url = reverse_lazy("com:poster_list")
-    extra_context = {"app": "com"}
+
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
-class PosterEditView(ComTabsMixin, PosterEditBaseView):
+class PosterEditView(PosterEditBaseView):
     """Edit communication poster."""
 
-    current_tab = "posters"
     success_url = reverse_lazy("com:poster_list")
-    extra_context = {"app": "com"}
+
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
 class PosterDeleteView(PosterDeleteBaseView):
@@ -672,39 +721,44 @@ class PosterDeleteView(PosterDeleteBaseView):
     success_url = reverse_lazy("com:poster_list")
 
 
-class PosterModerateListView(PermissionRequiredMixin, ComTabsMixin, ListView):
+class PosterModerateListView(PosterAdminViewMixin, ListView):
     """Moderate list communication poster."""
 
     current_tab = "posters"
     model = Poster
     template_name = "com/poster_moderate.jinja"
     queryset = Poster.objects.filter(is_moderated=False).all()
-    permission_required = "com.moderate_poster"
+
-    extra_context = {"app": "com"}
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
-class PosterModerateView(PermissionRequiredMixin, ComTabsMixin, View):
+class PosterModerateView(PosterAdminViewMixin, View):
     """Moderate communication poster."""
 
-    current_tab = "posters"
-    permission_required = "com.moderate_poster"
-    extra_context = {"app": "com"}
-
     def get(self, request, *args, **kwargs):
         obj = get_object_or_404(Poster, pk=kwargs["object_id"])
-        obj.is_moderated = True
+        if obj.can_be_moderated_by(request.user):
-        obj.moderator = request.user
+            obj.is_moderated = True
-        obj.save()
+            obj.moderator = request.user
-        return redirect("com:poster_moderate_list")
+            obj.save()
+            return redirect("com:poster_moderate_list")
+        raise PermissionDenied
+
+    def get_context_data(self, **kwargs):
+        kwargs = super(PosterModerateListView, self).get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
-class ScreenListView(PermissionRequiredMixin, ComTabsMixin, ListView):
+class ScreenListView(IsComAdminMixin, ComTabsMixin, ListView):
     """List communication screens."""
 
     current_tab = "screens"
     model = Screen
     template_name = "com/screen_list.jinja"
-    permission_required = "com.view_screen"
 
 
 class ScreenSlideshowView(DetailView):
@@ -715,12 +769,12 @@ class ScreenSlideshowView(DetailView):
     template_name = "com/screen_slideshow.jinja"
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
+        kwargs = super().get_context_data(**kwargs)
-            "posters": self.object.active_posters()
+        kwargs["posters"] = self.object.active_posters()
-        }
+        return kwargs
 
 
-class ScreenCreateView(PermissionRequiredMixin, ComTabsMixin, CreateView):
+class ScreenCreateView(IsComAdminMixin, ComTabsMixin, CreateView):
     """Create communication screen."""
 
     current_tab = "screens"
@@ -728,10 +782,9 @@ class ScreenCreateView(PermissionRequiredMixin, ComTabsMixin, CreateView):
     fields = ["name"]
     template_name = "core/create.jinja"
     success_url = reverse_lazy("com:screen_list")
-    permission_required = "com.add_screen"
 
 
-class ScreenEditView(PermissionRequiredMixin, ComTabsMixin, UpdateView):
+class ScreenEditView(IsComAdminMixin, ComTabsMixin, UpdateView):
     """Edit communication screen."""
 
     pk_url_kwarg = "screen_id"
@@ -740,10 +793,9 @@ class ScreenEditView(PermissionRequiredMixin, ComTabsMixin, UpdateView):
     fields = ["name"]
     template_name = "com/screen_edit.jinja"
     success_url = reverse_lazy("com:screen_list")
-    permission_required = "com.change_screen"
 
 
-class ScreenDeleteView(PermissionRequiredMixin, ComTabsMixin, DeleteView):
+class ScreenDeleteView(IsComAdminMixin, ComTabsMixin, DeleteView):
     """Delete communication screen."""
 
     pk_url_kwarg = "screen_id"
@@ -751,4 +803,3 @@ class ScreenDeleteView(PermissionRequiredMixin, ComTabsMixin, DeleteView):
     model = Screen
     template_name = "core/delete_confirm.jinja"
     success_url = reverse_lazy("com:screen_list")
-    permission_required = "com.delete_screen"

core/api.py

@@ -25,7 +25,6 @@ from core.schemas import (
     UserFamilySchema,
     UserFilterSchema,
     UserProfileSchema,
-    UserSchema,
 )
 from core.templatetags.renderer import markdown
 
@@ -70,22 +69,16 @@ class MailingListController(ControllerBase):
         return data
 
 
-@api_controller("/user")
+@api_controller("/user", permissions=[CanAccessLookup])
 class UserController(ControllerBase):
-    @route.get("", response=list[UserProfileSchema], permissions=[CanAccessLookup])
+    @route.get("", response=list[UserProfileSchema])
     def fetch_profiles(self, pks: Query[set[int]]):
         return User.objects.filter(pk__in=pks)
 
-    @route.get("/{int:user_id}", response=UserSchema, permissions=[CanView])
-    def fetch_user(self, user_id: int):
-        """Fetch a single user"""
-        return self.get_object_or_exception(User, id=user_id)
-
     @route.get(
         "/search",
         response=PaginatedResponseSchema[UserProfileSchema],
         url_name="search_users",
-        permissions=[CanAccessLookup],
     )
     @paginate(PageNumberPaginationExtra, page_size=20)
     def search_users(self, filters: Query[UserFilterSchema]):

core/auth/mixins.py

@@ -29,14 +29,8 @@ from typing import TYPE_CHECKING, Any, LiteralString
 
 from django.contrib.auth.mixins import AccessMixin, PermissionRequiredMixin
 from django.core.exceptions import ImproperlyConfigured, PermissionDenied
-from django.http import Http404
-from django.shortcuts import get_object_or_404
-from django.utils.functional import cached_property
-from django.utils.translation import gettext as _
 from django.views.generic.base import View
 
-from club.models import Club
-
 if TYPE_CHECKING:
     from django.db.models import Model
 
@@ -303,50 +297,3 @@ class PermissionOrAuthorRequiredMixin(PermissionRequiredMixin):
             self.author_field += "_id"
         author_id = getattr(obj, self.author_field, None)
         return author_id == self.request.user.id
-
-
-class PermissionOrClubBoardRequiredMixin(PermissionRequiredMixin):
-    """Require that the user has the required perm or is the board of the club.
-
-    This mixin can be used in any view that is called from a url
-    having a `club_id` kwarg.
-
-    Example:
-
-        In `urls.py` :
-        ```python
-        urlpatterns = [
-            path("foo/<int:club_id>/bar/", FooView.as_view())
-        ]
-        ```
-
-        In `views.py` :
-
-        ```python
-        # this view is available to users that either have the
-        # "foo.view_foo" permission or are in the board of the club
-        # which id was given in the url
-        class FooView(PermissionOrClubBoardRequiredMixin, View):
-            permission_required = "foo.view_foo"
-        ```
-    """
-
-    club_pk_url_kwarg = "club_id"
-
-    @cached_property
-    def club(self):
-        club_id: str | int = self.kwargs.pop(self.club_pk_url_kwarg, None)
-        if club_id is None:
-            return None
-        if isinstance(club_id, int) or club_id.isdigit():
-            return get_object_or_404(Club, pk=club_id)
-        raise Http404(_("No club found with id %(id)s") % {"id": club_id})
-
-    def has_permission(self):
-        if self.request.user.is_anonymous:
-            return False
-        if super().has_permission():
-            return True
-        return self.club is not None and any(
-            g.id == self.club.board_group_id for g in self.request.user.cached_groups
-        )

core/management/commands/populate.py

@@ -768,7 +768,7 @@ class Command(BaseCommand):
         s = Subscription(
             member=user,
             subscription_type=subscription_type,
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
         )
         s.subscription_start = s.compute_start(start)
         s.subscription_end = s.compute_end(

core/management/commands/populate_more.py

@@ -94,11 +94,7 @@ class Command(BaseCommand):
                 username=self.faker.user_name(),
                 first_name=self.faker.first_name(),
                 last_name=self.faker.last_name(),
-                date_of_birth=(
+                date_of_birth=self.faker.date_of_birth(minimum_age=15, maximum_age=25),
-                    None
-                    if random.random() < 0.2
-                    else self.faker.date_of_birth(minimum_age=15, maximum_age=25)
-                ),
                 email=self.faker.email(),
                 phone=self.faker.phone_number(),
                 address=self.faker.address(),

core/models.py

@@ -1197,18 +1197,6 @@ class NotLocked(LockError):
     pass
 
 
-class PageQuerySet(models.QuerySet):
-    def viewable_by(self, user: User) -> Self:
-        if user.is_anonymous:
-            return self.filter(view_groups=settings.SITH_GROUP_PUBLIC_ID)
-        if user.has_perm("core.view_page"):
-            return self.all()
-        groups_ids = [g.id for g in user.cached_groups]
-        if user.is_subscribed:
-            groups_ids.append(settings.SITH_GROUP_SUBSCRIBERS_ID)
-        return self.filter(view_groups__in=groups_ids)
-
-
 # This function prevents generating migration upon settings change
 def get_default_owner_group():
     return settings.SITH_GROUP_ROOT_ID
@@ -1278,8 +1266,6 @@ class Page(models.Model):
         _("lock_timeout"), null=True, blank=True, default=None
     )
 
-    objects = PageQuerySet.as_manager()
-
     class Meta:
         unique_together = ("name", "parent")
         permissions = (
@@ -1289,9 +1275,12 @@ class Page(models.Model):
     def __str__(self):
         return self.get_full_name()
 
-    def save(self, *args, force_lock: bool = False, **kwargs):
+    def save(self, *args, **kwargs):
         """Performs some needed actions before and after saving a page in database."""
-        if not force_lock and not self.is_locked():
+        locked = kwargs.pop("force_lock", False)
+        if not locked:
+            locked = self.is_locked()
+        if not locked:
             raise NotLocked("The page is not locked and thus can not be saved")
         self.full_clean()
         if not self.id:
@@ -1303,7 +1292,7 @@ class Page(models.Model):
         # It also update all the children to maintain correct names
         self._full_name = self.get_full_name()
         for c in self.children.all():
-            c.save(force_lock=force_lock)
+            c.save()
         super().save(*args, **kwargs)
         self.unset_lock()
 
@@ -1419,14 +1408,14 @@ class Page(models.Model):
     def need_club_redirection(self):
         return self.is_club_page and self.name != settings.SITH_CLUB_ROOT_PAGE
 
-    def delete(self, *args, **kwargs):
+    def delete(self):
         self.unset_lock_recursive()
         self.set_lock_recursive(User.objects.get(id=0))
         for child in self.children.all():
             child.parent = self.parent
             child.save()
             child.unset_lock_recursive()
-        return super().delete(*args, **kwargs)
+        super().delete()
 
 
 class PageRev(models.Model):
@@ -1473,12 +1462,9 @@ class PageRev(models.Model):
     def get_absolute_url(self):
         return reverse("core:page", kwargs={"page_name": self.page._full_name})
 
-    def can_be_edited_by(self, user: User) -> bool:
+    def can_be_edited_by(self, user):
         return self.page.can_be_edited_by(user)
 
-    def is_owned_by(self, user: User) -> bool:
-        return any(g.id == self.page.owner_group_id for g in user.cached_groups)
-
 
 def get_notification_types():
     return settings.SITH_NOTIFICATIONS

core/schemas.py

@@ -34,22 +34,6 @@ class SimpleUserSchema(ModelSchema):
         fields = ["id", "nick_name", "first_name", "last_name"]
 
 
-class UserSchema(ModelSchema):
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "nick_name",
-            "first_name",
-            "last_name",
-            "date_of_birth",
-            "email",
-            "role",
-            "quote",
-            "promo",
-        ]
-
-
 class UserProfileSchema(ModelSchema):
     """The necessary information to show a user profile"""
 

core/static/bundled/alpine-index.js

@@ -1,9 +1,7 @@
-import { alpinePlugin } from "#core:utils/notifications";
 import sort from "@alpinejs/sort";
 import Alpine from "alpinejs";
 
 Alpine.plugin(sort);
-Alpine.magic("notifications", alpinePlugin);
 window.Alpine = Alpine;
 
 window.addEventListener("DOMContentLoaded", () => {

core/static/bundled/utils/notifications.ts

@@ -1,36 +0,0 @@
-export enum NotificationLevel {
-  Error = "error",
-  Warning = "warning",
-  Success = "success",
-}
-
-export function createNotification(message: string, level: NotificationLevel) {
-  const element = document.getElementById("quick-notifications");
-  if (element === null) {
-    return false;
-  }
-  return element.dispatchEvent(
-    new CustomEvent("quick-notification-add", {
-      detail: { text: message, tag: level },
-    }),
-  );
-}
-
-export function deleteNotifications() {
-  const element = document.getElementById("quick-notifications");
-  if (element === null) {
-    return false;
-  }
-  return element.dispatchEvent(new CustomEvent("quick-notification-delete"));
-}
-
-export function alpinePlugin() {
-  return {
-    error: (message: string) => createNotification(message, NotificationLevel.Error),
-    warning: (message: string) =>
-      createNotification(message, NotificationLevel.Warning),
-    success: (message: string) =>
-      createNotification(message, NotificationLevel.Success),
-    clear: () => deleteNotifications(),
-  };
-}

core/static/core/components/ajax-select.scss

@@ -36,7 +36,6 @@
   > .ts-control {
     box-shadow: none;
     max-width: 300px;
-    width: 300px;
     background-color: var(--nf-input-background-color);
 
     &::after {

core/static/core/forms.scss

@@ -47,7 +47,6 @@
   }
 
   input,
-  select,
   textarea[type="text"],
   [type="number"],
   .ts-control {
@@ -241,23 +240,6 @@ form {
       }
     }
   }
-  input[type="text"],
-  input[type="email"],
-  input[type="tel"],
-  input[type="url"],
-  input[type="password"],
-  input[type="number"],
-  input[type="date"],
-  input[type="datetime-local"],
-  input[type="week"],
-  input[type="time"],
-  input[type="month"],
-  input[type="search"],
-  textarea,
-  select,
-  .ts-control {
-    min-height: calc(var(--nf-input-size) * 2.5);
-  }
 
   input[type="text"],
   input[type="checkbox"],

core/static/core/header.scss

@@ -321,6 +321,7 @@ $hovered-red-text-color: #ff4d4d;
 
         >#header_notif {
           box-sizing: border-box;
+          display: none;
           position: absolute;
           margin: 0;
           background-color: whitesmoke;

core/static/core/js/script.js

@@ -0,0 +1,38 @@
+$(() => {
+  $("#quick_notif li").click(function () {
+    $(this).hide();
+  });
+});
+
+// biome-ignore lint/correctness/noUnusedVariables: used in other scripts
+function createQuickNotif(msg) {
+  const el = document.createElement("li");
+  el.textContent = msg;
+  el.addEventListener("click", () => el.parentNode.removeChild(el));
+  document.getElementById("quick_notif").appendChild(el);
+}
+
+// biome-ignore lint/correctness/noUnusedVariables: used in other scripts
+function deleteQuickNotifs() {
+  const el = document.getElementById("quick_notif");
+  while (el.firstChild) {
+    el.removeChild(el.firstChild);
+  }
+}
+
+// biome-ignore lint/correctness/noUnusedVariables: used in other scripts
+function displayNotif() {
+  $("#header_notif").toggle().parent().toggleClass("white");
+}
+
+// You can't get the csrf token from the template in a widget
+// We get it from a cookie as a workaround, see this link
+// https://docs.djangoproject.com/en/2.0/ref/csrf/#ajax
+// Sadly, getting the cookie is not possible with CSRF_COOKIE_HTTPONLY or CSRF_USE_SESSIONS is True
+// So, the true workaround is to get the token from the dom
+// https://docs.djangoproject.com/en/2.0/ref/csrf/#acquiring-the-token-if-csrf-use-sessions-is-true
+// biome-ignore lint/style/useNamingConvention: can't find it used anywhere but I will not play with the devil
+// biome-ignore lint/correctness/noUnusedVariables: used in other scripts
+function getCSRFToken() {
+  return $("[name=csrfmiddlewaretoken]").val();
+}

core/static/core/style.scss

@@ -270,6 +270,17 @@ body {
   }
 
   /*--------------------------------CONTENT------------------------------*/
+  #quick_notif {
+    width: 100%;
+    margin: 0 auto;
+    list-style-type: none;
+    background: $second-color;
+
+    li {
+      padding: 10px;
+    }
+  }
+
   #content {
     padding: 1em 1%;
     box-shadow: $shadow-color 0 5px 10px;
@@ -506,10 +517,6 @@ th {
   >ul {
     margin-top: 0;
   }
-
-  >input[type="checkbox"] {
-    padding: unset;
-  }
 }
 
 td {

core/templates/core/base.jinja

@@ -32,6 +32,10 @@
       <script type="module" src="{{ static('bundled/country-flags-index.ts') }}"></script>
       <script type="module" src="{{ static('bundled/core/tooltips-index.ts') }}"></script>
 
+      <!-- Jquery declared here to be accessible in every django widgets -->
+      <script src="{{ static('bundled/vendored/jquery.min.js') }}"></script>
+      <script src="{{ static('core/js/script.js') }}"></script>
+
       {% block additional_css %}{% endblock %}
       {% block additional_js %}{% endblock %}
     {% endblock %}
@@ -70,15 +74,17 @@
 
     <div id="page">
 
+      <ul id="quick_notif">
+        {% for n in quick_notifs %}
+          <li>{{ n }}</li>
+        {% endfor %}
+      </ul>
+
       <div id="content">
         {%- block tabs -%}
           {% include "core/base/tabs.jinja" %}
         {%- endblock -%}
 
-        {% block notifications %}
-          {% include "core/base/notifications.jinja" %}
-        {% endblock %}
-
         {%- block errors -%}
           {% if error %}
             {{ error }}
@@ -95,6 +101,16 @@
     {% endblock %}
 
     {% block script %}
+      <script>
+        document.addEventListener("keydown", (e) => {
+          // Looking at the `s` key when not typing in a form
+          if (e.keyCode !== 83 || ["INPUT", "TEXTAREA", "SELECT"].includes(e.target.nodeName)) {
+            return;
+          }
+          document.getElementById("search").focus();
+          e.preventDefault(); // Don't type the character in the focused search input
+        })
+      </script>
     {% endblock %}
   </body>
 </html>

core/templates/core/base/header.jinja

@@ -74,25 +74,25 @@
             {% endif %}
           ></a>
         </div>
-        <div class="notification" x-data="{display: false}" :class="{white: display}">
+        <div class="notification">
-          <a href="#" @click.prevent="display = !display">
+          <a href="#" onclick="displayNotif()">
-            <i :class="`fa-${display ? 'solid': 'regular'} fa-bell`" x-transition></i>
+            <i class="fa-regular fa-bell"></i>
-            {% set notifications = user.notifications.filter(viewed=False).order_by("-date")|list %}
+            {% set notification_count = user.notifications.filter(viewed=False).count() %}
 
-            {%- if notifications|length > 0 -%}
+            {% if notification_count > 0 %}
               <span>
-                {% if notifications|length < 100 %}
+                {% if notification_count < 100 %}
-                  {{ notifications|length }}
+                  {{ notification_count }}
-                {%- else -%}
+                {% else %}
-                  99+
+                  &nbsp;
-                {%- endif -%}
+                {% endif %}
               </span>
             {% endif %}
           </a>
-          <div id="header_notif" x-show="display" x-cloak x-transition @click.outside="display = false">
+          <div id="header_notif">
             <ul>
-              {%- if notifications|length > 0 -%}
+              {% if user.notifications.filter(viewed=False).count() > 0 %}
-                {%- for n in notifications -%}
+                {% for n in user.notifications.filter(viewed=False).order_by('-date') %}
                   <li>
                     <a href="{{ url("core:notification", notif_id=n.id) }}">
                       <div class="datetime">
@@ -108,10 +108,10 @@
                       </div>
                     </a>
                   </li>
-                {%- endfor -%}
+                {% endfor %}
-              {%- else -%}
+              {% else %}
                 <li class="empty-notification">{% trans %}You do not have any unread notification{% endtrans %}</li>
-              {%- endif -%}
+              {% endif %}
             </ul>
             <div class="options">
               <a href="{{ url('core:notification_list') }}">

core/templates/core/base/notifications.jinja

@@ -1,24 +0,0 @@
-<div id="quick-notifications"
-     x-data="{
-             messages: [
-             {% if messages %}
-               {% for message in messages %}
-                 {
-                 tag: '{{ message.tags }}',
-                 text: '{{ message }}',
-                 },
-               {% endfor %}
-             {% endif %}
-             ]
-             }"
-     @quick-notification-add="(e) => messages.push(e?.detail)"
-     @quick-notification-delete="messages = []">
-  <template x-for="message in messages">
-    <div x-data="{show: true}" class="alert" :class="`alert-${message.tag}`" x-show="show" x-transition>
-      <span class="alert-main" x-text="message.text"></span>
-      <span class="clickable" @click="show = false">
-        <i class="fa fa-close"></i>
-      </span>
-    </div>
-  </template>
-</div>

core/templates/core/group_detail.jinja

@@ -15,7 +15,6 @@
       {{ select_all_checkbox("add_users") }}
       <hr>
       {% csrf_token %}
-      {{ form.non_field_errors() }}
       <label for="{{ form.users_removed.id_for_label }}">{{ form.users_removed.label }} :</label>
       {{ form.users_removed.errors }}
       {% for user in form.users_removed %}

core/templates/core/user_account_detail.jinja

@@ -30,11 +30,7 @@
               - {{ purchase.date|localtime|time(DATETIME_FORMAT) }}
             </td>
             <td>{{ purchase.counter }}</td>
-            {% if not purchase.seller %}
+            <td><a href="{{ purchase.seller.get_absolute_url() }}">{{ purchase.seller.get_display_name() }}</a></td>
-              <td>{% trans %}Deleted user{% endtrans %}</td>
-            {% else %}
-              <td><a href="{{ purchase.seller.get_absolute_url() }}">{{ purchase.seller.get_display_name() }}</a></td>
-            {% endif %}
             <td>{{ purchase.label }}</td>
             <td>{{ purchase.quantity }}</td>
             <td>{{ purchase.quantity * purchase.unit_price }} €</td>

core/templates/core/widgets/autocomplete_select.jinja

@@ -1,25 +1,23 @@
-{% spaceless %}
+{% for js in statics.js %}
-  {% for js in statics.js %}
+  <script-once type="module" src="{{ js }}"></script-once>
-    <script-once type="module" src="{{ js }}"></script-once>
+{% endfor %}
-  {% endfor %}
+{% for css in statics.css %}
-  {% for css in statics.css %}
+  <link-once rel="stylesheet" type="text/css" href="{{ css }}" defer></link-once>
-    <link-once rel="stylesheet" type="text/css" href="{{ css }}" defer></link-once>
+{% endfor %}
-  {% endfor %}
 
-  <{{ component }} name="{{ widget.name }}" {% include "django/forms/widgets/attrs.html" %}>
+<{{ component }} name="{{ widget.name }}" {% include "django/forms/widgets/attrs.html" %}>
-  {% for group_name, group_choices, group_index in widget.optgroups %}
+{% for group_name, group_choices, group_index in widget.optgroups %}
-    {% if group_name %}
+  {% if group_name %}
-      <optgroup label="{{ group_name }}">
+    <optgroup label="{{ group_name }}">
-    {% endif %}
-    {% for widget in group_choices %}
-      {% include widget.template_name %}
-    {% endfor %}
-    {% if group_name %}
-      </optgroup>
-    {% endif %}
-  {% endfor %}
-  {% if initial %}
-    <slot style="display:none" name="initial">{{ initial }}</slot>
   {% endif %}
-  </{{ component }}>
+  {% for widget in group_choices %}
-{% endspaceless %}
+    {% include widget.template_name %}
+  {% endfor %}
+  {% if group_name %}
+    </optgroup>
+  {% endif %}
+{% endfor %}
+{% if initial %}
+  <slot style="display:none" name="initial">{{ initial }}</slot>
+{% endif %}
+</{{ component }}>

core/tests/test_page.py

@@ -1,58 +0,0 @@
-import pytest
-from django.conf import settings
-from django.contrib.auth.models import Permission
-from django.test import Client
-from django.urls import reverse
-from model_bakery import baker
-from pytest_django.asserts import assertRedirects
-
-from core.baker_recipes import board_user, subscriber_user
-from core.models import AnonymousUser, Page, User
-from sith.settings import SITH_GROUP_OLD_SUBSCRIBERS_ID, SITH_GROUP_SUBSCRIBERS_ID
-
-
-@pytest.mark.django_db
-def test_edit_page(client: Client):
-    user = board_user.make()
-    page = baker.prepare(Page)
-    page.save(force_lock=True)
-    page.view_groups.add(user.groups.first())
-    client.force_login(user)
-
-    url = reverse("core:page_edit", kwargs={"page_name": page._full_name})
-    res = client.get(url)
-    assert res.status_code == 200
-
-    res = client.post(url, data={"content": "Hello World"})
-    assertRedirects(res, reverse("core:page", kwargs={"page_name": page._full_name}))
-    revision = page.revisions.last()
-    assert revision.content == "Hello World"
-
-
-@pytest.mark.django_db
-def test_viewable_by():
-    # remove existing pages to prevent side effect
-    Page.objects.all().delete()
-    view_groups = [
-        [settings.SITH_GROUP_PUBLIC_ID],
-        [settings.SITH_GROUP_PUBLIC_ID, SITH_GROUP_SUBSCRIBERS_ID],
-        [SITH_GROUP_SUBSCRIBERS_ID],
-        [SITH_GROUP_SUBSCRIBERS_ID, SITH_GROUP_OLD_SUBSCRIBERS_ID],
-        [],
-    ]
-    pages = baker.make(Page, _quantity=len(view_groups), _bulk_create=True)
-    for page, groups in zip(pages, view_groups, strict=True):
-        page.view_groups.set(groups)
-
-    viewable = Page.objects.viewable_by(AnonymousUser()).values_list("id", flat=True)
-    assert set(viewable) == {pages[0].id, pages[1].id}
-
-    subscriber = subscriber_user.make()
-    viewable = Page.objects.viewable_by(subscriber).values_list("id", flat=True)
-    assert set(viewable) == {p.id for p in pages[0:4]}
-
-    root_user = baker.make(
-        User, user_permissions=[Permission.objects.get(codename="view_page")]
-    )
-    viewable = Page.objects.viewable_by(root_user).values_list("id", flat=True)
-    assert set(viewable) == {p.id for p in pages}

core/tests/test_user.py

@@ -20,8 +20,7 @@ from core.baker_recipes import (
 )
 from core.models import Group, User
 from core.views import UserTabsMixin
-from counter.baker_recipes import sale_recipe
+from counter.models import Counter, Refilling, Selling
-from counter.models import Counter, Customer, Refilling, Selling
 from eboutic.models import Invoice, InvoiceItem
 
 
@@ -130,31 +129,6 @@ def test_user_account_not_found(client: Client):
     assert res.status_code == 404
 
 
-@pytest.mark.django_db
-def test_is_deleted_barman_shown_as_deleted(client: Client):
-    customer = baker.make(Customer)
-    date = now()
-    sale_recipe.make(
-        seller=iter([None, baker.make(User)]),
-        customer=customer,
-        date=date,
-        _quantity=2,
-        _bulk_create=True,
-    )
-    client.force_login(customer.user)
-    res = client.get(
-        reverse(
-            "core:user_account_detail",
-            kwargs={
-                "user_id": customer.user.id,
-                "year": date.year,
-                "month": date.month,
-            },
-        )
-    )
-    assert res.status_code == 200
-
-
 class TestFilterInactive(TestCase):
     @classmethod
     def setUpTestData(cls):

core/views/mixins.py

@@ -2,6 +2,7 @@ import copy
 import inspect
 from typing import Any, ClassVar, LiteralString, Protocol, Unpack
 
+from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.http import HttpRequest, HttpResponse
 from django.template.loader import render_to_string
@@ -40,6 +41,36 @@ class TabedViewMixin(View):
         return kwargs
 
 
+class QuickNotifMixin:
+    quick_notif_list = []
+
+    def dispatch(self, request, *arg, **kwargs):
+        # In some cases, the class can stay instanciated, so we need to reset the list
+        self.quick_notif_list = []
+        return super().dispatch(request, *arg, **kwargs)
+
+    def get_success_url(self):
+        ret = super().get_success_url()
+        if hasattr(self, "quick_notif_url_arg"):
+            if "?" in ret:
+                ret += "&" + self.quick_notif_url_arg
+            else:
+                ret += "?" + self.quick_notif_url_arg
+        return ret
+
+    def get_context_data(self, **kwargs):
+        """Add quick notifications to context."""
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["quick_notifs"] = []
+        for n in self.quick_notif_list:
+            kwargs["quick_notifs"].append(settings.SITH_QUICK_NOTIF[n])
+        for key, val in settings.SITH_QUICK_NOTIF.items():
+            for gk in self.request.GET:
+                if key == gk:
+                    kwargs["quick_notifs"].append(val)
+        return kwargs
+
+
 class AllowFragment:
     """Add `is_fragment` to templates. It's only True if the request is emitted by htmx"""
 

core/views/page.py

@@ -43,25 +43,23 @@ class CanEditPagePropMixin(CanEditPropMixin):
         return res
 
 
-class PageListView(ListView):
+class PageListView(CanViewMixin, ListView):
     model = Page
     template_name = "core/page_list.jinja"
-
+    queryset = (
-    def get_queryset(self):
+        Page.objects.annotate(
-        return (
+            display_name=Coalesce(
-            Page.objects.viewable_by(self.request.user)
+                Subquery(
-            .annotate(
+                    PageRev.objects.filter(page=OuterRef("id"))
-                display_name=Coalesce(
+                    .order_by("-date")
-                    Subquery(
+                    .values("title")[:1]
-                        PageRev.objects.filter(page=OuterRef("id"))
+                ),
-                        .order_by("-date")
+                F("name"),
-                        .values("title")[:1]
-                    ),
-                    F("name"),
-                )
             )
-            .select_related("parent")
         )
+        .prefetch_related("view_groups")
+        .select_related("parent")
+    )
 
 
 class PageView(CanViewMixin, DetailView):
@@ -186,7 +184,7 @@ class PageEditViewBase(CanEditMixin, UpdateView):
     )
     template_name = "core/pagerev_edit.jinja"
 
-    def get_object(self, *args, **kwargs):
+    def get_object(self):
         self.page = Page.get_page_by_full_name(self.kwargs["page_name"])
         return self._get_revision()
 

core/views/user.py

@@ -65,7 +65,7 @@ from core.views.forms import (
     UserGroupsForm,
     UserProfileForm,
 )
-from core.views.mixins import TabedViewMixin, UseFragmentsMixin
+from core.views.mixins import QuickNotifMixin, TabedViewMixin, UseFragmentsMixin
 from counter.models import Counter, Refilling, Selling
 from eboutic.models import Invoice
 from subscription.models import Subscription
@@ -564,7 +564,7 @@ class UserUpdateGroupView(UserTabsMixin, CanEditPropMixin, UpdateView):
     current_tab = "groups"
 
 
-class UserToolsView(LoginRequiredMixin, UserTabsMixin, TemplateView):
+class UserToolsView(LoginRequiredMixin, QuickNotifMixin, UserTabsMixin, TemplateView):
     """Displays the logged user's tools."""
 
     template_name = "core/user_tools.jinja"

counter/models.py

@@ -535,6 +535,13 @@ class Counter(models.Model):
     def __str__(self):
         return self.name
 
+    def __getattribute__(self, name: str):
+        if name == "edit_groups":
+            return Group.objects.filter(
+                name=self.club.unix_name + settings.SITH_BOARD_SUFFIX
+            ).all()
+        return object.__getattribute__(self, name)
+
     def get_absolute_url(self) -> str:
         if self.type == "EBOUTIC":
             return reverse("eboutic:main")
@@ -683,10 +690,8 @@ class Counter(models.Model):
         Prices will be annotated
         """
 
-        products = (
+        products = self.products.select_related("product_type").prefetch_related(
-            self.products.filter(archived=False)
+            "buying_groups"
-            .select_related("product_type")
-            .prefetch_related("buying_groups")
         )
 
         # Only include age appropriate products

counter/templates/counter/counter_click.jinja

@@ -67,13 +67,13 @@
                 <option value="FIN">{% trans %}Confirm (FIN){% endtrans %}</option>
                 <option value="ANN">{% trans %}Cancel (ANN){% endtrans %}</option>
               </optgroup>
-              {%- for category in categories.keys() -%}
+              {% for category in categories.keys() %}
                 <optgroup label="{{ category }}">
-                  {%- for product in categories[category] -%}
+                  {% for product in categories[category] %}
                     <option value="{{ product.id }}">{{ product }}</option>
-                  {%- endfor -%}
+                  {% endfor %}
                 </optgroup>
-              {%- endfor -%}
+              {% endfor %}
             </counter-product-select>
 
             <input type="submit" value="{% trans %}Go{% endtrans %}"/>

counter/tests/test_counter.py

@@ -583,16 +583,6 @@ class TestCounterClick(TestFullClickBase):
             - self.beer.selling_price
         )
 
-    def test_no_fetch_archived_product(self):
-        counter = baker.make(Counter)
-        customer = baker.make(Customer)
-        product_recipe.make(archived=True, counters=[counter])
-        unarchived_products = product_recipe.make(
-            archived=False, counters=[counter], _quantity=3
-        )
-        customer_products = counter.get_products_for(customer)
-        assert unarchived_products == customer_products
-
 
 class TestCounterStats(TestCase):
     @classmethod

docs/explanation/ia.md

@@ -0,0 +1,120 @@
+Cette page expose la politique du Pôle informatique de l'AE
+en ce qui concerne l'usage et l'implémentation de systèmes d'IA
+dans le cadre de l'AE et du développement de ses outils.
+
+## Cadre
+
+En accord avec le règlement européen sur 
+l'intelligence artificielle du 13 juin 2024,
+nous définissons comme IA :
+
+> Un système basé sur une machine qui est 
+> conçu pour fonctionner avec différents niveaux d'autonomie 
+> et qui peut faire preuve d'adaptabilité après son déploiement, 
+> et qui, pour des objectifs explicites ou implicites, déduit,
+> à partir des données qu'il reçoit, 
+> comment générer des résultats tels que des prédictions, 
+> du contenu, des recommandations ou des décisions 
+> qui peuvent influencer des environnements physiques ou virtuels.
+
+Cette définition recouvre toutes les IAs génératives, ce qui inclut
+ChatGPT, DeepSeek, Claude, Copilot, Mistral, Llama et autres outils similaires.
+
+## Utilisation dans le développement
+
+!!!abstract
+    La soumission de code généré par IA est strictement interdite.
+
+Aucune contribution contenant du code généré par IA n'est acceptée.
+Toute PR contenant en proportion significative du code duquel
+on peut raisonnablement penser qu'il a été généré par IA 
+ne sera acceptée.
+
+Nous déconseillons également fortement l'usage de tout
+recours à un système d'IA dans le processus de développement,
+quel que soit son usage (debug, recherche d'information ou autres).
+A la place de l'IA, Référez-vous en priorité à la documentation du site,
+à celle de Django et à l'aide des autres développeurs.
+
+## Intégration dans le site
+
+L'intégration sur le site AE de systèmes d'IA 
+et de toute fonctionnalité basée sur des systèmes d'IA
+est strictement prohibée, quel qu'en soit l'objectif.
+
+Toute tâche de modération, de génération
+ou de détection de contenu ne doit être accomplie
+que par des êtres humains ou par des algorithmes
+déterministes, testés et compris.
+
+L'usage des données du site a des fins d'entrainement d'IA,
+ainsi que la transmission de ces données à un système d'IA
+est strictement interdit.
+Tout acte de cette nature sera considéré comme une violation
+grave de la politique de gestion des données de l'AE.
+
+## Motifs
+
+Le site AE est un programme écrit par des humains, pour des humains.
+C'est un logiciel dont la complexité nécessite des connaissances
+plus approfondies que ce qui est attendu de la part d'un
+étudiant en TC ou en base branche.
+À ce titre, l'interdiction de l'IA dans le cadre de son
+développement est pensée avant tout dans une optique 
+de formation des développeurs, de stabilité de la base de code
+et de transmission des connaissances.
+
+### Formation des développeurs
+
+Travailler sur le site AE est possiblement le meilleur moyen de
+monter en compétences en informatique pour un étudiant de l'UTBM.
+Automatisation des tests, gestion des données et de la sécurité,
+infrastructure, maintenance du code existant...
+
+Le site AE est un logiciel complet, dont le développement
+possède une dimension pédagogique réelle.
+En utilisant l'IA, le développement n'est plus un moyen efficace
+de se former.
+
+### Stabilité de la base de code
+
+Les développeurs du site AE sont pour la plupart en cours de formation,
+sans compréhension globale de la base de code du site,
+des outils logiciels sur lesquels il se base et des bonnes
+pratiques permettant d'écrire du code viable.
+
+En se reposant sur un système d'IA sans être capacité
+de comprendre intégralement le code proposé ni de le mettre
+en perspective avec le reste de la base de code,
+c'est toute la maintenance de la base de code qui se retrouve compromise.
+
+### Transmission des connaissances
+
+L'équipe du pôle informatique se renouvelle très souvent.
+À ce titre, les nouveaux développeurs se doivent d'hériter
+d'une base de code viable. 
+Quant aux anciens développeurs, ils se doivent d'en avoir 
+compris le fonctionnement, afin d'être en mesure
+de guider et d'aider leurs successeurs.
+
+Comme développé dans les deux points précédents, 
+cet objectif est incompatible avec l'usage de systèmes d'IA.
+
+### Autres motifs
+
+En plus de ces aspects purement liés à la qualité
+du code et à la pédagogie, l'IA pose des problèmes
+écologiques et éthiques :
+
+- Les projets commerciaux d'IA se livrent fréquemment 
+  à des violations flagrantes du droit d'auteur 
+  et à un mépris complet des petits acteurs du web
+  (dont le site AE fait partie) pour entraîner leurs modèles.
+- Leurs activités nécessitent une consommation massive d'énergie et d'eau,
+  ainsi qu'une quantité massive de matériel, entrainant conflits d'usage,
+  et intensification des dommages sociaux et environnementaux de l'industrie.
+- La promotion et l'utilisation des modèles d'IA ont causé un préjudice
+  important aux salariés, une aliénation de leur travail et une baisse de la qualité des services.
+- Les LLM ont favorisé les activités de spam et d'escroquerie.
+- L'IA est devenu un maillon essentiel du fichage des individus,
+  du renforcement des biais sociétaux, et de la désinformation de masse.

docs/reference/core/mixins.md

@@ -4,6 +4,7 @@
         heading_level: 3
         members:
             - TabedViewMixin
+            - QuickNotifMixin
             - AllowFragment
             - FragmentMixin
             - UseFragmentsMixin

eboutic/static/bundled/eboutic/eboutic-index.ts

@@ -17,6 +17,7 @@ document.addEventListener("alpine:init", () => {
       this.$watch("basket", () => {
         this.saveBasket();
       });
+
       // Invalidate basket if a purchase was made
       if (lastPurchaseTime !== null && localStorage.basketTimestamp !== undefined) {
         if (

eboutic/templates/eboutic/eboutic_billing_info.jinja

@@ -31,5 +31,12 @@
   </div>
 
   <br>
-  {% include "core/base/notifications.jinja" %}
+
+  {% if messages %}
+    {% for message in messages %}
+      <div class="alert alert-{{ message.tags }}">
+        {{ message }}
+      </div>
+    {% endfor %}
+  {% endif %}
 </div>

eboutic/templates/eboutic/eboutic_checkout.jinja

@@ -1,9 +1,5 @@
 {% extends "core/base.jinja" %}
 
-{% block notifications %}
-  {# Notifications are moved inside the billing info fragment #}
-{% endblock %}
-
 {% block title %}
   {% trans %}Basket state{% endtrans %}
 {% endblock %}

eboutic/templates/eboutic/eboutic_main.jinja

@@ -22,6 +22,14 @@
 {% block content %}
   <h1 id="eboutic-title">{% trans %}Eboutic{% endtrans %}</h1>
 
+  {% if messages %}
+    {% for message in messages %}
+      <div class="alert alert-{{ message.tags }}">
+        {{ message }}
+      </div>
+    {% endfor %}
+  {% endif %}
+
   <div id="eboutic" x-data="basket({{ last_purchase_time }})">
     <div id="basket">
       <h3>Panier</h3>

eboutic/templates/eboutic/eboutic_payment_result.jinja

@@ -4,6 +4,14 @@
   <h3>{% trans %}Eboutic{% endtrans %}</h3>
 
   <div>
+    {% if messages %}
+      {% for message in messages %}
+        <div class="alert alert-{{ message.tags }}">
+          {{ message }}
+        </div>
+      {% endfor %}
+    {% endif %}
+
     {% if success %}
       {% trans %}Payment successful{% endtrans %}
     {% else %}

locale/fr/LC_MESSAGES/django.po

@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-09-26 17:36+0200\n"
+"POT-Creation-Date: 2025-09-01 18:18+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"
@@ -174,12 +174,12 @@ msgid "You can not add the same user twice"
 msgstr "Vous ne pouvez pas ajouter deux fois le même utilisateur"
 
 #: club/forms.py
-msgid "You must be subscribed to join a club"
+msgid "You should specify a role"
-msgstr "Vous devez être cotisant pour faire partie d'un club"
+msgstr "Vous devez choisir un rôle"
 
-#: club/forms.py
+#: club/forms.py sas/forms.py
-msgid "You are already a member of this club"
+msgid "You do not have the permission to do that"
-msgstr "Vous êtes déjà membre de ce club."
+msgstr "Vous n'avez pas la permission de faire cela"
 
 #: club/models.py
 msgid "slug name"
@@ -350,6 +350,11 @@ msgstr "Depuis"
 msgid "There are no members in this club."
 msgstr "Il n'y a pas de membres dans ce club."
 
+#: club/templates/club/club_members.jinja core/templates/core/file_detail.jinja
+#: core/views/forms.py trombi/templates/trombi/detail.jinja
+msgid "Add"
+msgstr "Ajouter"
+
 #: club/templates/club/club_old_members.jinja
 msgid "Club old members"
 msgstr "Anciens membres du club"
@@ -509,8 +514,8 @@ msgstr "Éditer le Trombi"
 msgid "New Trombi"
 msgstr "Nouveau Trombi"
 
-#: club/templates/club/club_tools.jinja club/views.py
+#: club/templates/club/club_tools.jinja com/templates/com/poster_list.jinja
-#: com/templates/com/poster_list.jinja core/templates/core/user_tools.jinja
+#: core/templates/core/user_tools.jinja
 msgid "Posters"
 msgstr "Affiches"
 
@@ -564,24 +569,6 @@ msgstr ""
 msgid "Save"
 msgstr "Sauver"
 
-#: club/templates/club/fragments/add_member.jinja
-msgid "Add a new member"
-msgstr "Ajouter un nouveau membre"
-
-#: club/templates/club/fragments/add_member.jinja
-msgid "Join club"
-msgstr "Rejoindre le club"
-
-#: club/templates/club/fragments/add_member.jinja
-#: core/templates/core/file_detail.jinja core/views/forms.py
-#: trombi/templates/trombi/detail.jinja
-msgid "Add"
-msgstr "Ajouter"
-
-#: club/templates/club/fragments/add_member.jinja
-msgid "Join"
-msgstr "Rejoindre"
-
 #: club/templates/club/mailing.jinja
 msgid "Mailing lists"
 msgstr "Mailing listes"
@@ -688,14 +675,9 @@ msgstr "Vente"
 msgid "Mailing list"
 msgstr "Listes de diffusion"
 
-#: club/views.py
+#: club/views.py com/views.py
-#, python-format
+msgid "Posters list"
-msgid "%(user)s has been added to club."
+msgstr "Liste d'affiches"
-msgstr "%(user)s a été ajouté au club."
-
-#: club/views.py
-msgid "You are now a member of this club."
-msgstr "Vous êtes maintenant membre de ce club."
 
 #: com/forms.py
 msgid "Format: 16:9 | Resolution: 1920x1080"
@@ -1125,10 +1107,6 @@ msgstr "Modération"
 msgid "No posters"
 msgstr "Aucune affiche"
 
-#: com/templates/com/poster_list.jinja com/templates/com/screen_slideshow.jinja
-msgid "Click to expand"
-msgstr "Cliquez pour agrandir"
-
 #: com/templates/com/poster_moderate.jinja
 msgid "Posters - moderation"
 msgstr "Affiches - modération"
@@ -1186,14 +1164,6 @@ msgstr "Contenu"
 msgid "Add to weekmail"
 msgstr "Ajouter au Weekmail"
 
-#: com/templates/com/weekmail.jinja
-msgid "Articles included the next weekmail"
-msgstr "Article inclus dans le prochain Weekmail"
-
-#: com/templates/com/weekmail.jinja
-msgid "Delete from weekmail"
-msgstr "Supprimer du Weekmail"
-
 #: com/templates/com/weekmail.jinja
 msgid "Up"
 msgstr "Monter"
@@ -1202,6 +1172,14 @@ msgstr "Monter"
 msgid "Down"
 msgstr "Descendre"
 
+#: com/templates/com/weekmail.jinja
+msgid "Articles included the next weekmail"
+msgstr "Article inclus dans le prochain Weekmail"
+
+#: com/templates/com/weekmail.jinja
+msgid "Delete from weekmail"
+msgstr "Supprimer du Weekmail"
+
 #: com/templates/com/weekmail_preview.jinja
 #: core/templates/core/user_account_detail.jinja
 #: pedagogy/templates/pedagogy/uv_detail.jinja
@@ -1271,10 +1249,6 @@ msgstr "Message d'info"
 msgid "Alert message"
 msgstr "Message d'alerte"
 
-#: com/views.py
-msgid "Posters list"
-msgstr "Liste d'affiches"
-
 #: com/views.py
 msgid "Screens list"
 msgstr "Liste d'écrans"
@@ -1283,10 +1257,6 @@ msgstr "Liste d'écrans"
 msgid "All incoming events"
 msgstr "Tous les événements à venir"
 
-#: com/views.py
-msgid "Weekmail sent successfully"
-msgstr "Weekmail envoyé avec succès"
-
 #: com/views.py
 msgid "Delete and save to regenerate"
 msgstr "Supprimer et sauver pour régénérer"
@@ -1295,26 +1265,6 @@ msgstr "Supprimer et sauver pour régénérer"
 msgid "Weekmail of the "
 msgstr "Weekmail du "
 
-#: com/views.py
-#, python-format
-msgid "%(title)s moved up in the Weekmail"
-msgstr "%(title)s monté dans le Weekmail"
-
-#: com/views.py
-#, python-format
-msgid "%(title)s moved down in the Weekmail"
-msgstr "%(title)s descendu dans le Weekmail"
-
-#: com/views.py
-#, python-format
-msgid "%(title)s added to the Weekmail"
-msgstr "%(title)s ajouté dans Weekmail"
-
-#: com/views.py
-#, python-format
-msgid "%(title)s removed from the Weekmail"
-msgstr "%(title)s retiré du Weekmail"
-
 #: com/views.py
 msgid ""
 "You must be a board member of the selected club to post in the Weekmail."
@@ -1322,11 +1272,6 @@ msgstr ""
 "Vous devez êtres un membre du bureau du club sélectionné pour poster dans le "
 "Weekmail."
 
-#: core/auth/mixins.py
-#, python-format
-msgid "No club found with id %(id)s"
-msgstr "Pas de club avec l'id %(id)s trouvé"
-
 #: core/models.py
 msgid "Is manually manageable"
 msgstr "Est gérable manuellement"
@@ -1768,8 +1713,8 @@ msgid ""
 "AE UTBM is a voluntary organisation run by UTBM students. It organises "
 "student life at UTBM and manages its student facilities."
 msgstr ""
-"L'AE UTBM est une association bénévole gérée par les étudiants de l'UTBM. "
+"L'AE UTBM est une association bénévole gérée par les étudiants de "
-"Elle organise la vie étudiante de l'UTBM et gère ses lieux de vie."
+"l'UTBM. Elle organise la vie étudiante de l'UTBM et gère ses lieux de vie."
 
 #: core/templates/core/base/footer.jinja core/templates/core/base/navbar.jinja
 msgid "Contacts"
@@ -2212,6 +2157,10 @@ msgstr ""
 msgid "Page history"
 msgstr "Historique de la page"
 
+#: core/templates/core/page_list.jinja
+msgid "There is no page in this website."
+msgstr "Il n'y a pas de page sur ce site web."
+
 #: core/templates/core/page_prop.jinja
 msgid "Page properties"
 msgstr "Propriétés de la page"
@@ -2390,10 +2339,6 @@ msgstr "Etickets"
 msgid "User has no account"
 msgstr "L'utilisateur n'a pas de compte"
 
-#: core/templates/core/user_account_detail.jinja
-msgid "Deleted user"
-msgstr "Utilisateur supprimé"
-
 #: core/templates/core/user_account_detail.jinja
 #: counter/templates/counter/last_ops.jinja
 #: counter/templates/counter/refilling_list.jinja
@@ -4594,6 +4539,22 @@ msgstr "Signaler ce commentaire"
 msgid "Edit UE"
 msgstr "Éditer l'UE"
 
+#: pedagogy/templates/pedagogy/uv_edit.jinja
+msgid "Import from UTBM"
+msgstr "Importer depuis l'UTBM"
+
+#: pedagogy/templates/pedagogy/uv_edit.jinja
+msgid "Unknown UE code"
+msgstr "Code d'UE inconnu"
+
+#: pedagogy/templates/pedagogy/uv_edit.jinja
+msgid "Successful autocomplete"
+msgstr "Autocomplétion réussite"
+
+#: pedagogy/templates/pedagogy/uv_edit.jinja
+msgid "An error occurred: "
+msgstr "Une erreur est survenue : "
+
 #: rootplace/forms.py
 msgid "User that will be kept"
 msgstr "Utilisateur qui sera conservé"
@@ -4667,10 +4628,6 @@ msgstr "Pas de ban actif"
 msgid "Add a new album"
 msgstr "Ajouter un nouvel album"
 
-#: sas/forms.py
-msgid "You do not have the permission to do that"
-msgstr "Vous n'avez pas la permission de faire cela"
-
 #: sas/forms.py
 msgid "Upload images"
 msgstr "Envoyer les images"
@@ -4861,8 +4818,8 @@ msgid "N/A"
 msgstr "N/A"
 
 #: sith/settings.py
-msgid "AE account"
+msgid "Transfert"
-msgstr "Compte AE"
+msgstr "Virement"
 
 #: sith/settings.py
 msgid "Belfort"
@@ -4974,47 +4931,47 @@ msgstr "Suppression de rechargement"
 
 #: sith/settings.py
 msgid "One semester"
-msgstr "Un semestre"
+msgstr "Un semestre, 20 €"
 
 #: sith/settings.py
 msgid "Two semesters"
-msgstr "Deux semestres"
+msgstr "Deux semestres, 35 €"
 
 #: sith/settings.py
 msgid "Common core cursus"
-msgstr "Cursus tronc commun"
+msgstr "Cursus tronc commun, 60 €"
 
 #: sith/settings.py
 msgid "Branch cursus"
-msgstr "Cursus branche"
+msgstr "Cursus branche, 60 €"
 
 #: sith/settings.py
 msgid "Alternating cursus"
-msgstr "Cursus alternant"
+msgstr "Cursus alternant, 30 €"
 
 #: sith/settings.py
 msgid "Honorary member"
-msgstr "Membre honoraire"
+msgstr "Membre honoraire, 0 €"
 
 #: sith/settings.py
 msgid "Assidu member"
-msgstr "Membre d'Assidu"
+msgstr "Membre d'Assidu, 0 €"
 
 #: sith/settings.py
 msgid "Amicale/DOCEO member"
-msgstr "Membre de l'Amicale/DOCEO"
+msgstr "Membre de l'Amicale/DOCEO, 0 €"
 
 #: sith/settings.py
 msgid "UT network member"
-msgstr "Cotisant du réseau UT"
+msgstr "Cotisant du réseau UT, 0 €"
 
 #: sith/settings.py
 msgid "CROUS member"
-msgstr "Membres du CROUS"
+msgstr "Membres du CROUS, 0 €"
 
 #: sith/settings.py
 msgid "Sbarro/ESTA member"
-msgstr "Membre de Sbarro ou de l'ESTA"
+msgstr "Membre de Sbarro ou de l'ESTA, 20 €"
 
 #: sith/settings.py
 msgid "One semester Welcome Week"
@@ -5041,28 +4998,28 @@ msgid "One day"
 msgstr "Un jour"
 
 #: sith/settings.py
-msgid "GA staff member (2 weeks)"
+msgid "GA staff member"
-msgstr "Membre staff GA (2 semaines)"
+msgstr "Membre staff GA (2 semaines), 1 €"
 
 #: sith/settings.py
 msgid "One semester (-20%)"
-msgstr "Un semestre (-20%)"
+msgstr "Un semestre (-20%), 12 €"
 
 #: sith/settings.py
 msgid "Two semesters (-20%)"
-msgstr "Deux semestres (-20%)"
+msgstr "Deux semestres (-20%), 22 €"
 
 #: sith/settings.py
 msgid "Common core cursus (-20%)"
-msgstr "Cursus tronc commun (-20%)"
+msgstr "Cursus tronc commun (-20%), 36 €"
 
 #: sith/settings.py
 msgid "Branch cursus (-20%)"
-msgstr "Cursus branche (-20%)"
+msgstr "Cursus branche (-20%), 36 €"
 
 #: sith/settings.py
 msgid "Alternating cursus (-20%)"
-msgstr "Cursus alternant (-20%)"
+msgstr "Cursus alternant (-20%), 24 €"
 
 #: sith/settings.py
 msgid "One year for free(CA offer)"
@@ -5150,6 +5107,26 @@ msgstr "Vous avez acheté %s"
 msgid "You have a notification"
 msgstr "Vous avez une notification"
 
+#: sith/settings.py
+msgid "Success!"
+msgstr "Succès !"
+
+#: sith/settings.py
+msgid "Fail!"
+msgstr "Échec !"
+
+#: sith/settings.py
+msgid "You successfully posted an article in the Weekmail"
+msgstr "Article posté avec succès dans le Weekmail"
+
+#: sith/settings.py
+msgid "You successfully edited an article in the Weekmail"
+msgstr "Article édité avec succès dans le Weekmail"
+
+#: sith/settings.py
+msgid "You successfully sent the Weekmail"
+msgstr "Weekmail envoyé avec succès"
+
 #: sith/settings.py
 msgid "AE tee-shirt"
 msgstr "Tee-shirt AE"
@@ -5158,10 +5135,6 @@ msgstr "Tee-shirt AE"
 msgid "A user with that email address already exists"
 msgstr "Un utilisateur avec cette adresse email existe déjà"
 
-#: subscription/forms.py
-msgid "This user didn't fill its birthdate yet."
-msgstr "Cet utilisateur n'a pas encore renseigné sa date de naissance"
-
 #: subscription/models.py
 msgid "Bad subscription type"
 msgstr "Mauvais type de cotisation"
@@ -5190,14 +5163,6 @@ msgstr "lieu"
 msgid "You can not subscribe many time for the same period"
 msgstr "Vous ne pouvez pas cotiser plusieurs fois pour la même période"
 
-#: subscription/templates/subscription/forms/create_existing_user.jinja
-msgid ""
-"If the subscription is done using the AE account, you must also click it on "
-"the AE counter."
-msgstr ""
-"Si la cotisation est faite en utilisant le compte AE, vous devez également "
-"la cliquer sur le comptoir AE."
-
 #: subscription/templates/subscription/fragments/creation_success.jinja
 #, python-format
 msgid "Subscription created for %(user)s"
@@ -5209,7 +5174,7 @@ msgid ""
 "%(user)s received its new %(type)s subscription. It will be active until "
 "%(end)s included."
 msgstr ""
-"%(user)s a reçu sa nouvelle cotisaton %(type)s. Elle sera active jusqu'au "
+"%(user)s a reçu sa nouvelle cotisaton %(type)s. Elle sert active jusqu'au "
 "%(end)s inclu."
 
 #: subscription/templates/subscription/fragments/creation_success.jinja
@@ -5461,38 +5426,10 @@ msgstr "Mes photos"
 msgid "Admin tools"
 msgstr "Admin Trombi"
 
-#: trombi/views.py
-msgid "Trombi modified"
-msgstr "Trombi modifié"
-
-#: trombi/views.py
-msgid "User added to the trombi"
-msgstr "Utilisateur ajouté au trombi"
-
-#: trombi/views.py
-msgid "User couldn't be added to the trombi"
-msgstr "L'utilisateur n'a pas pu être ajouté au trombi"
-
-#: trombi/views.py
-msgid "User removed from the trombi"
-msgstr "Utilisateur retiré du trombi"
-
 #: trombi/views.py
 msgid "Explain why you rejected the comment"
 msgstr "Expliquez pourquoi vous refusez le commentaire"
 
-#: trombi/views.py
-msgid "Comment accepted"
-msgstr "Commentaire accepté"
-
-#: trombi/views.py
-msgid "Comment rejected"
-msgstr "Commentaire rejeté"
-
-#: trombi/views.py
-msgid "Comment removed"
-msgstr "Commentaire retiré"
-
 #: trombi/views.py
 msgid "Rejected comment"
 msgstr "Commentaire rejeté"
@@ -5533,10 +5470,6 @@ msgstr ""
 "pouvez vous inscrire qu'à un seul Trombi, donc ne jouez pas avec cet option "
 "ou vous encourerez la colère des admins!"
 
-#: trombi/views.py
-msgid "User modified"
-msgstr "Utilisateur modifié"
-
 #: trombi/views.py
 msgid "Personal email (not UTBM)"
 msgstr "Email personnel (pas UTBM)"
@@ -5549,14 +5482,6 @@ msgstr "Téléphone"
 msgid "Native town"
 msgstr "Ville d'origine"
 
-#: trombi/views.py
-msgid "User removed from trombi"
-msgstr "Utilisateur retiré du trombi"
-
-#: trombi/views.py
-msgid "Comment added"
-msgstr "Commentaire ajouté"
-
 #: trombi/views.py
 msgid ""
 "You can not yet write comment, you must wait for the subscription deadline "

mkdocs.yml

@@ -57,6 +57,7 @@ nav:
     - Accueil: explanation/index.md
     - Technologies utilisées: explanation/technos.md
     - Conventions: explanation/conventions.md
+    - Politique IA: explanation/ia.md
     - Archives: explanation/archives.md
   - Tutoriels:
     - Installer le projet: tutorial/install.md

package-lock.json

@@ -30,6 +30,7 @@
         "easymde": "^2.19.0",
         "glob": "^11.0.0",
         "htmx.org": "^2.0.3",
+        "jquery": "^3.7.1",
         "js-cookie": "^3.0.5",
         "lit-html": "^3.3.0",
         "native-file-system-adapter": "^3.0.1",
@@ -46,9 +47,10 @@
         "@types/alpinejs": "^3.13.10",
         "@types/cytoscape-cxtmenu": "^3.4.4",
         "@types/cytoscape-klay": "^3.1.4",
+        "@types/jquery": "^3.5.31",
         "@types/js-cookie": "^3.0.6",
         "typescript": "^5.8.3",
-        "vite": "^6.3.6",
+        "vite": "^6.2.6",
         "vite-bundle-visualizer": "^1.2.1",
         "vite-plugin-static-copy": "^3.1.2"
       }
@@ -2887,6 +2889,16 @@
       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
       "license": "MIT"
     },
+    "node_modules/@types/jquery": {
+      "version": "3.5.33",
+      "resolved": "https://registry.npmjs.org/@types/jquery/-/jquery-3.5.33.tgz",
+      "integrity": "sha512-SeyVJXlCZpEki5F0ghuYe+L+PprQta6nRZqhONt9F13dWBtR/ftoaIbdRQ7cis7womE+X2LKhsDdDtkkDhJS6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/sizzle": "*"
+      }
+    },
     "node_modules/@types/js-cookie": {
       "version": "3.0.6",
       "resolved": "https://registry.npmjs.org/@types/js-cookie/-/js-cookie-3.0.6.tgz",
@@ -2907,6 +2919,13 @@
       "integrity": "sha512-a79Yc3TOk6dGdituy8hmTTJXjOkZ7zsFYV10L337ttq/rec8lRMDBpV7fL3uLx6TgbFCa5DU/h8FmIBQPSbU0w==",
       "license": "MIT"
     },
+    "node_modules/@types/sizzle": {
+      "version": "2.3.10",
+      "resolved": "https://registry.npmjs.org/@types/sizzle/-/sizzle-2.3.10.tgz",
+      "integrity": "sha512-TC0dmN0K8YcWEAEfiPi5gJP14eJe30TTGjkvek3iM/1NdHHsdCA/Td6GvNndMOo/iSnIsZ4HuuhrYPDAmbxzww==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/tern": {
       "version": "0.23.9",
       "resolved": "https://registry.npmjs.org/@types/tern/-/tern-0.23.9.tgz",
@@ -4365,6 +4384,12 @@
         "jiti": "lib/jiti-cli.mjs"
       }
     },
+    "node_modules/jquery": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.7.1.tgz",
+      "integrity": "sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg==",
+      "license": "MIT"
+    },
     "node_modules/js-cookie": {
       "version": "3.0.5",
       "resolved": "https://registry.npmjs.org/js-cookie/-/js-cookie-3.0.5.tgz",
@@ -5712,9 +5737,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.3.6",
+      "version": "6.3.5",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.5.tgz",
-      "integrity": "sha512-0msEVHJEScQbhkbVTb/4iHZdJ6SXp/AvxL2sjwYQFfBqleHtnCqv1J3sa9zbWz/6kW1m9Tfzn92vW+kZ1WV6QA==",
+      "integrity": "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {

package.json

@@ -32,9 +32,10 @@
     "@types/alpinejs": "^3.13.10",
     "@types/cytoscape-cxtmenu": "^3.4.4",
     "@types/cytoscape-klay": "^3.1.4",
+    "@types/jquery": "^3.5.31",
     "@types/js-cookie": "^3.0.6",
     "typescript": "^5.8.3",
-    "vite": "^6.3.6",
+    "vite": "^6.2.6",
     "vite-bundle-visualizer": "^1.2.1",
     "vite-plugin-static-copy": "^3.1.2"
   },
@@ -60,6 +61,7 @@
     "easymde": "^2.19.0",
     "glob": "^11.0.0",
     "htmx.org": "^2.0.3",
+    "jquery": "^3.7.1",
     "js-cookie": "^3.0.5",
     "lit-html": "^3.3.0",
     "native-file-system-adapter": "^3.0.1",

pedagogy/templates/pedagogy/uv_detail.jinja

@@ -13,15 +13,16 @@
 {% block content %}
   <div class="pedagogy">
     <div id="uv_detail">
-      <button onclick='(function(){
+      <p id="return_noscript"><a href="{{ url('pedagogy:guide') }}">{% trans %}Back{% endtrans %}</a></p>
-                       // If comes from the guide page, go back with history
+      <button id="return_js" onclick='(function(){
-                       if (document.referrer.replace(/\?(.+)/gm,"").endsWith(`{{ url("pedagogy:guide") }}`)){
+                                      // If comes from the guide page, go back with history
-                       window.history.back();
+                                      if (document.referrer.replace(/\?(.+)/gm,"").endsWith(`{{ url("pedagogy:guide") }}`)){
-                       return;
+                                      window.history.back();
-                       }
+                                      return;
-                       // Simply goes to the guide page
+                                      }
-                       window.location.href = `{{ url("pedagogy:guide") }}`;
+                                      // Simply goes to the guide page
-                       })()' hidden>{% trans %}Back{% endtrans %}</button>
+                                      window.location.href = `{{ url("pedagogy:guide") }}`;
+                                      })()' hidden>{% trans %}Back{% endtrans %}</button>
 
       <h1>{{ object.code }} - {{ object.title }}</h1>
       <br>
@@ -216,4 +217,9 @@
 
     </div>
   </div>
+
+  <script type="text/javascript">
+    $("#return_noscript").hide();
+    $("#return_js").show();
+  </script>
 {% endblock %}

pedagogy/templates/pedagogy/uv_edit.jinja

@@ -21,6 +21,11 @@
           {{ field.errors }}
           <label for="{{ field.name }}">{{ field.label }}</label>
           {{ field }}
+
+
+          {% if field.name == 'code' %}
+            <button type="button" id="autofill">{% trans %}Import from UTBM{% endtrans %}</button>
+          {% endif %}
         </p>
       {% endif %}
 
@@ -31,3 +36,48 @@
     <p><input type="submit" value="{% trans %}Update{% endtrans %}" /></p>
   </form>
 {% endblock %}
+
+{% block script %}
+  {{ super() }}
+
+  <script type="text/javascript">
+    document.addEventListener('DOMContentLoaded', function() {
+      const autofillBtn = document.getElementById('autofill')
+      const codeInput = document.querySelector('input[name="code"]')
+
+      autofillBtn.addEventListener('click', () => {
+        const url = `/api/uv/${codeInput.value}`;
+        deleteQuickNotifs()
+
+        $.ajax({
+          dataType: "json",
+          url: url,
+          success: function(data, _, xhr) {
+            if (xhr.status !== 200) {
+              createQuickNotif("{% trans %}Unknown UE code{% endtrans %}")
+              return
+            }
+            Object.entries(data)
+              .filter(([_, val]) => !!val)  // skip entries with null or undefined value
+              .map(([key, val]) => {  // convert keys to DOM elements
+                return [document.querySelector('[name="' + key + '"]'), val];
+              })
+              .filter(([elem, _]) => !!elem)  // skip non-existing DOM elements
+              .forEach(([elem, val]) => {  // write the value in the form field
+                if (elem.tagName === 'TEXTAREA') {
+                  // MD editor text input
+                  elem.parentNode.querySelector('.CodeMirror').CodeMirror.setValue(val);
+                } else {
+                  elem.value = val;
+                }
+              });
+            createQuickNotif('{% trans %}Successful autocomplete{% endtrans %}')
+          },
+          error: function(_, _, statusMessage) {
+            createQuickNotif('{% trans %}An error occurred: {% endtrans %}' + statusMessage)
+          },
+        })
+      })
+    })
+  </script>
+{% endblock %}

sas/static/bundled/sas/viewer-index.ts

@@ -309,7 +309,6 @@ exportToHtml("loadViewer", (config: ViewerConfig) => {
         // Clear selection and cache of retrieved user so they can be filtered again
         widget.clear(false);
         widget.clearOptions();
-        widget.setTextboxValue("");
       },
 
       /**

sith/settings.py

@@ -405,6 +405,9 @@ SITH_FORUM_PAGE_LENGTH = 30
 SITH_SAS_ROOT_DIR_ID = env.int("SITH_SAS_ROOT_DIR_ID", default=4)
 SITH_SAS_IMAGES_PER_PAGE = 60
 
+SITH_BOARD_SUFFIX = "-bureau"
+SITH_MEMBER_SUFFIX = "-membres"
+
 SITH_PROFILE_DEPARTMENTS = [
     ("TC", _("TC")),
     ("IMSI", _("IMSI")),
@@ -421,11 +424,18 @@ SITH_PROFILE_DEPARTMENTS = [
     ("NA", _("N/A")),
 ]
 
+SITH_ACCOUNTING_PAYMENT_METHOD = [
+    ("CHECK", _("Check")),
+    ("CASH", _("Cash")),
+    ("TRANSFERT", _("Transfert")),
+    ("CARD", _("Credit card")),
+]
+
 SITH_SUBSCRIPTION_PAYMENT_METHOD = [
     ("CHECK", _("Check")),
     ("CARD", _("Credit card")),
     ("CASH", _("Cash")),
-    ("AE_ACCOUNT", _("AE account")),
+    ("EBOUTIC", _("Eboutic")),
     ("OTHER", _("Other")),
 ]
 
@@ -434,7 +444,6 @@ SITH_SUBSCRIPTION_LOCATIONS = [
     ("SEVENANS", _("Sevenans")),
     ("MONTBELIARD", _("Montbéliard")),
     ("EBOUTIC", _("Eboutic")),
-    ("OTHER", _("Other")),
 ]
 
 SITH_COUNTER_BARS = [(1, "MDE"), (2, "Foyer"), (35, "La Gommette")]
@@ -541,7 +550,7 @@ SITH_SUBSCRIPTIONS = {
         "duration": 4,
     },
     "cursus-branche": {"name": _("Branch cursus"), "price": 60, "duration": 6},
-    "cursus-alternant": {"name": _("Alternating cursus"), "price": 35, "duration": 6},
+    "cursus-alternant": {"name": _("Alternating cursus"), "price": 30, "duration": 6},
     "membre-honoraire": {"name": _("Honorary member"), "price": 0, "duration": 666},
     "assidu": {"name": _("Assidu member"), "price": 0, "duration": 2},
     "amicale/doceo": {"name": _("Amicale/DOCEO member"), "price": 0, "duration": 2},
@@ -553,6 +562,8 @@ SITH_SUBSCRIPTIONS = {
         "price": 0,
         "duration": 1,
     },
+    "un-mois-essai": {"name": _("One month for free"), "price": 0, "duration": 0.166},
+    "deux-mois-essai": {"name": _("Two months for free"), "price": 0, "duration": 0.33},
     "benevoles-euroks": {"name": _("Eurok's volunteer"), "price": 5, "duration": 0.1},
     "six-semaines-essai": {
         "name": _("Six weeks for free"),
@@ -683,6 +694,14 @@ SITH_PERMANENT_NOTIFICATIONS = {
     "SAS_MODERATION": "sas.models.sas_notification_callback",
 }
 
+SITH_QUICK_NOTIF = {
+    "qn_success": _("Success!"),
+    "qn_fail": _("Fail!"),
+    "qn_weekmail_new_article": _("You successfully posted an article in the Weekmail"),
+    "qn_weekmail_article_edit": _("You successfully edited an article in the Weekmail"),
+    "qn_weekmail_send_success": _("You successfully sent the Weekmail"),
+}
+
 # Mailing related settings
 
 SITH_MAILING_DOMAIN = "utbm.fr"

subscription/forms.py

@@ -2,7 +2,6 @@ import secrets
 from typing import Any
 
 from django import forms
-from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.utils.translation import gettext_lazy as _
 
@@ -24,28 +23,13 @@ class SelectionDateForm(forms.Form):
 
 
 class SubscriptionForm(forms.ModelForm):
-    allowed_payment_methods = ["CARD", "CASH", "AE_ACCOUNT"]
+    def __init__(self, *args, **kwargs):
-
+        initial = kwargs.pop("initial", {})
-    class Meta:
-        model = Subscription
-        fields = ["subscription_type", "payment_method", "location"]
-        widgets = {"payment_method": forms.RadioSelect}
-
-    def __init__(self, *args, initial=None, **kwargs):
-        initial = initial or {}
         if "subscription_type" not in initial:
             initial["subscription_type"] = "deux-semestres"
         if "payment_method" not in initial:
             initial["payment_method"] = "CARD"
         super().__init__(*args, initial=initial, **kwargs)
-        self.fields["payment_method"].choices = [
-            m
-            for m in settings.SITH_SUBSCRIPTION_PAYMENT_METHOD
-            if m[0] in self.allowed_payment_methods
-        ]
-        self.fields["location"].choices = [
-            m for m in settings.SITH_SUBSCRIPTION_LOCATIONS if m[0] != "EBOUTIC"
-        ]
 
     def save(self, *args, **kwargs):
         if self.errors:
@@ -77,8 +61,7 @@ class SubscriptionNewUserForm(SubscriptionForm):
         assert user.is_subscribed
     """
 
-    allowed_payment_methods = ["CARD", "CASH"]
+    template_name = "subscription/forms/create_new_user.html"
-    template_name = "subscription/forms/create_new_user.jinja"
 
     __user_fields = forms.fields_for_model(
         User,
@@ -90,6 +73,10 @@ class SubscriptionNewUserForm(SubscriptionForm):
     email = __user_fields["email"]
     date_of_birth = __user_fields["date_of_birth"]
 
+    class Meta:
+        model = Subscription
+        fields = ["subscription_type", "payment_method", "location"]
+
     field_order = [
         "first_name",
         "last_name",
@@ -143,57 +130,9 @@ class SubscriptionNewUserForm(SubscriptionForm):
 class SubscriptionExistingUserForm(SubscriptionForm):
     """Form to add a subscription to an existing user."""
 
-    template_name = "subscription/forms/create_existing_user.jinja"
+    template_name = "subscription/forms/create_existing_user.html"
-    required_css_class = "required"
 
-    birthdate = forms.fields_for_model(
+    class Meta:
-        User,
+        model = Subscription
-        ["date_of_birth"],
+        fields = ["member", "subscription_type", "payment_method", "location"]
-        widgets={"date_of_birth": SelectDate(attrs={"hidden": True})},
+        widgets = {"member": AutoCompleteSelectUser}
-        help_texts={"date_of_birth": _("This user didn't fill its birthdate yet.")},
-    )["date_of_birth"]
-
-    class Meta(SubscriptionForm.Meta):
-        fields = ["member", *SubscriptionForm.Meta.fields]
-        widgets = SubscriptionForm.Meta.widgets | {"member": AutoCompleteSelectUser}
-
-    field_order = [
-        "member",
-        "birthdate",
-        "subscription_type",
-        "payment_method",
-        "location",
-    ]
-
-    def __init__(self, *args, initial=None, **kwargs):
-        super().__init__(*args, initial=initial, **kwargs)
-        self.fields["birthdate"].required = True
-        if not initial:
-            return
-        member: str | None = initial.get("member")
-        if member and member.isdigit():
-            member: User | None = User.objects.filter(id=int(member)).first()
-        else:
-            member = None
-        if member and member.date_of_birth:
-            # if there is an initial member with a birthdate,
-            # there is no need to ask this to the user
-            self.fields["birthdate"].initial = member.date_of_birth
-        elif member:
-            # if there is an initial member without a birthdate,
-            # then the field must be displayed
-            self.fields["birthdate"].widget.attrs.update({"hidden": False})
-        # if there is no initial member, it means that it will be
-        # dynamically selected using the AutoCompleteSelectUser widget.
-        # JS will take care of un-hiding the field if necessary
-
-    def save(self, *args, **kwargs):
-        if self.errors:
-            return super().save(*args, **kwargs)
-        if (
-            self.cleaned_data["birthdate"] is not None
-            and self.instance.member.date_of_birth is None
-        ):
-            self.instance.member.date_of_birth = self.cleaned_data["birthdate"]
-            self.instance.member.save()
-        return super().save(*args, **kwargs)

subscription/migrations/0015_alter_subscription_location_and_more.py

@@ -1,56 +0,0 @@
-# Generated by Django 5.2.3 on 2025-09-08 05:38
-
-from django.db import migrations, models
-from django.db.migrations.state import StateApps
-
-
-def rename_enums(apps: StateApps, schema_editor):
-    Subscription = apps.get_model("subscription", "Subscription")
-    Subscription.objects.filter(subscription_type="EBOUTIC").update(
-        subscription_type="AE_ACCOUNT"
-    )
-
-
-def rename_enums_reverse(apps: StateApps, schema_editor):
-    Subscription = apps.get_model("subscription", "Subscription")
-    Subscription.objects.filter(subscription_type="AE_ACCOUNT").update(
-        subscription_type="EBOUTIC"
-    )
-
-
-class Migration(migrations.Migration):
-    dependencies = [("subscription", "0014_auto_20201207_2323")]
-
-    operations = [
-        migrations.AlterField(
-            model_name="subscription",
-            name="location",
-            field=models.CharField(
-                choices=[
-                    ("BELFORT", "Belfort"),
-                    ("SEVENANS", "Sevenans"),
-                    ("MONTBELIARD", "Montbéliard"),
-                    ("EBOUTIC", "Eboutic"),
-                    ("OTHER", "Other"),
-                ],
-                max_length=20,
-                verbose_name="location",
-            ),
-        ),
-        migrations.AlterField(
-            model_name="subscription",
-            name="payment_method",
-            field=models.CharField(
-                choices=[
-                    ("CHECK", "Check"),
-                    ("CARD", "Credit card"),
-                    ("CASH", "Cash"),
-                    ("AE_ACCOUNT", "AE account"),
-                    ("OTHER", "Other"),
-                ],
-                max_length=255,
-                verbose_name="payment method",
-            ),
-        ),
-        migrations.RunPython(rename_enums, reverse_code=rename_enums_reverse),
-    ]

subscription/migrations/0016_alter_subscription_subscription_type.py

@@ -1,21 +0,0 @@
-# Generated by Django 5.2.3 on 2025-10-06 11:24
-
-from django.db import migrations, models
-
-import subscription.models
-
-
-class Migration(migrations.Migration):
-    dependencies = [("subscription", "0015_alter_subscription_location_and_more")]
-
-    operations = [
-        migrations.AlterField(
-            model_name="subscription",
-            name="subscription_type",
-            field=models.CharField(
-                choices=subscription.models.get_subscription_types,
-                max_length=255,
-                verbose_name="subscription type",
-            ),
-        )
-    ]

subscription/models.py

@@ -38,19 +38,16 @@ def validate_payment(value):
         raise ValidationError(_("Bad payment method"))
 
 
-def get_subscription_types():
-    return (
-        (k, f"{v['name']}, {v['price']}€")
-        for k, v in sorted(settings.SITH_SUBSCRIPTIONS.items())
-    )
-
-
 class Subscription(models.Model):
     member = models.ForeignKey(
         User, related_name="subscriptions", on_delete=models.CASCADE
     )
     subscription_type = models.CharField(
-        _("subscription type"), max_length=255, choices=get_subscription_types
+        _("subscription type"),
+        max_length=255,
+        choices=(
+            (k, v["name"]) for k, v in sorted(settings.SITH_SUBSCRIPTIONS.items())
+        ),
     )
     subscription_start = models.DateField(_("subscription start"))
     subscription_end = models.DateField(_("subscription end"))

subscription/static/bundled/subscription/creation-form-existing-user-index.ts

@@ -1,5 +1,3 @@
-import { userFetchUser } from "#openapi";
-
 document.addEventListener("alpine:init", () => {
   Alpine.data("existing_user_subscription_form", () => ({
     loading: false,
@@ -14,24 +12,13 @@ document.addEventListener("alpine:init", () => {
     },
 
     async loadProfile(userId: number) {
-      const birthdayInput = document.getElementById("id_birthdate") as HTMLInputElement;
       if (!Number.isInteger(userId)) {
         this.profileFragment = "";
-        birthdayInput.hidden = true;
         return;
       }
       this.loading = true;
-      const [miniProfile, userInfos] = await Promise.all([
+      const response = await fetch(`/user/${userId}/mini/`);
-        fetch(`/user/${userId}/mini/`),
+      this.profileFragment = await response.text();
-        // biome-ignore lint/style/useNamingConvention: api is snake_case
-        userFetchUser({ path: { user_id: userId } }),
-      ]);
-      this.profileFragment = await miniProfile.text();
-      // If the user has no birthdate yet, show the form input
-      // to fill this info.
-      // Else keep the input hidden and change its value to the user birthdate
-      birthdayInput.value = userInfos.data.date_of_birth;
-      birthdayInput.hidden = userInfos.data.date_of_birth !== null;
       this.loading = false;
     },
   }));

subscription/static/subscription/css/subscription.scss

@@ -1,14 +1,4 @@
 #subscription-form form {
-  margin-top: 0;
-
-  .form-content {
-    margin-top: 0;
-  }
-
-  fieldset p:first-of-type, & > p:first-of-type {
-    margin-top: 0;
-  }
-
   .form-content.existing-user {
     max-height: 100%;
     display: flex;
@@ -23,11 +13,6 @@
      * then display the user profile right in the middle of the remaining space. */
     fieldset {
       flex: 0 1 auto;
-
-      p:has(input[hidden]) {
-        // when the input is hidden, hide the whole label+input+help text group
-        display: none;
-      }
     }
 
     #subscription-form-user-mini-profile {

subscription/templates/subscription/forms/create_existing_user.html

@@ -0,0 +1,14 @@
+{% load static %}
+{% load i18n %}
+
+
+<div x-data="existing_user_subscription_form" class="form-content existing-user">
+  <fieldset>
+    {{ form.as_p }}
+  </fieldset>
+  <div
+    id="subscription-form-user-mini-profile"
+    x-html="profileFragment"
+    :aria-busy="loading"
+  ></div>
+</div>

subscription/templates/subscription/forms/create_existing_user.jinja

@@ -1,28 +0,0 @@
-{% load static %}
-{% load i18n %}
-
-
-<div x-data="existing_user_subscription_form" class="form-content existing-user">
-  <fieldset>
-    {{ errors }}
-    {% for field, errors in fields %}
-      <p{% with classes=field.css_classes %}{% if classes %} class="{{ classes }}"{% endif %}{% endwith %}>
-        {{ field.label_tag }}
-        {{ field }}
-        {% if field.help_text %}
-          <span class="helptext">{{ field.help_text }}</span>
-        {% endif %}
-      </p>
-      {% if field.name == "payment_method" %}
-        <i>
-          {% blocktranslate %}If the subscription is done using the AE account, you must also click it on the AE counter.{% endblocktranslate %}
-        </i>
-      {% endif %}
-    {% endfor %}
-  </fieldset>
-  <div
-    id="subscription-form-user-mini-profile"
-    x-html="profileFragment"
-    :aria-busy="loading"
-  ></div>
-</div>

subscription/tests/test_dates.py

@@ -90,7 +90,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=self.user,
             subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[3],
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2017, 8, 29)
         s.subscription_end = s.compute_end(duration=0.166, start=s.subscription_start)
@@ -101,7 +101,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=self.user,
             subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[3],
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2017, 8, 29)
         s.subscription_end = s.compute_end(duration=0.333, start=s.subscription_start)
@@ -112,7 +112,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=self.user,
             subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[3],
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2017, 8, 29)
         s.subscription_end = s.compute_end(
@@ -126,7 +126,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=self.user,
             subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[3],
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2017, 8, 29)
         s.subscription_end = s.compute_end(duration=0.5, start=s.subscription_start)
@@ -137,7 +137,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=self.user,
             subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[3],
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2017, 8, 29)
         s.subscription_end = s.compute_end(duration=0.67, start=s.subscription_start)
@@ -148,7 +148,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=self.user,
             subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[3],
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2018, 9, 1)
         s.subscription_end = s.compute_end(duration=0.23, start=s.subscription_start)
@@ -160,7 +160,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=user,
             subscription_type="deux-semestres",
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2015, 8, 29)
         s.subscription_end = s.compute_end(
@@ -181,7 +181,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=user,
             subscription_type="deux-mois-essai",
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2015, 8, 29)
         s.subscription_end = s.compute_end(
@@ -202,7 +202,7 @@ class TestSubscriptionIntegration(TestCase):
         s = Subscription(
             member=user,
             subscription_type="deux-mois-essai",
-            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1],
+            payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0],
         )
         s.subscription_start = date(2015, 8, 29)
         s.subscription_end = s.compute_end(

subscription/tests/test_new_subscription.py

@@ -1,6 +1,6 @@
 """Tests focused on testing subscription creation"""
 
-from datetime import date, timedelta
+from datetime import timedelta
 from typing import Callable
 
 import pytest
@@ -31,42 +31,18 @@ def test_form_existing_user_valid(
 ):
     """Test `SubscriptionExistingUserForm`"""
     user = user_factory()
-    user.date_of_birth = date(year=1967, month=3, day=14)
-    user.save()
-    data = {
-        "member": user,
-        "birthdate": user.date_of_birth,
-        "subscription_type": "deux-semestres",
-        "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
-    }
-    form = SubscriptionExistingUserForm(data)
-    assert form.is_valid()
-    form.save()
-    user.refresh_from_db()
-    assert user.is_subscribed
-
-
-@pytest.mark.django_db
-def test_form_existing_user_with_birthdate(settings: SettingsWrapper):
-    """Test `SubscriptionExistingUserForm`"""
-    user = baker.make(User, date_of_birth=None)
     data = {
         "member": user,
         "subscription_type": "deux-semestres",
         "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
     }
     form = SubscriptionExistingUserForm(data)
-    assert not form.is_valid()
 
-    data |= {"birthdate": date(year=1967, month=3, day=14)}
-    form = SubscriptionExistingUserForm(data)
     assert form.is_valid()
     form.save()
     user.refresh_from_db()
     assert user.is_subscribed
-    assert user.date_of_birth == date(year=1967, month=3, day=14)
 
 
 @pytest.mark.django_db
@@ -81,7 +57,7 @@ def test_form_existing_user_invalid(settings: SettingsWrapper):
         "member": user,
         "subscription_type": "deux-semestres",
         "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
     }
     form = SubscriptionExistingUserForm(data)
 
@@ -99,7 +75,7 @@ def test_form_new_user(settings: SettingsWrapper):
         "date_of_birth": localdate() - relativedelta(years=18),
         "subscription_type": "deux-semestres",
         "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
     }
     form = SubscriptionNewUserForm(data)
     assert form.is_valid()
@@ -130,7 +106,7 @@ def test_form_set_new_user_as_student(settings: SettingsWrapper, subscription_ty
         "date_of_birth": localdate() - relativedelta(years=18),
         "subscription_type": subscription_type,
         "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
     }
     form = SubscriptionNewUserForm(data)
     assert form.is_valid()
@@ -156,14 +132,6 @@ def test_page_access(
     assert res.status_code == status_code
 
 
-@pytest.mark.django_db
-def test_page_access_with_get_data(client: Client):
-    user = old_subscriber_user.make()
-    client.force_login(baker.make(User, is_superuser=True))
-    res = client.get(reverse("subscription:subscription", query={"member": user.id}))
-    assert res.status_code == 200
-
-
 @pytest.mark.django_db
 def test_submit_form_existing_user(client: Client, settings: SettingsWrapper):
     client.force_login(
@@ -172,15 +140,14 @@ def test_submit_form_existing_user(client: Client, settings: SettingsWrapper):
             user_permissions=Permission.objects.filter(codename="add_subscription"),
         )
     )
-    user = old_subscriber_user.make(date_of_birth=date(year=1967, month=3, day=14))
+    user = old_subscriber_user.make()
     response = client.post(
         reverse("subscription:fragment-existing-user"),
         {
             "member": user.id,
-            "birthdate": user.date_of_birth,
             "subscription_type": "deux-semestres",
             "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-            "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+            "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
         },
     )
     user.refresh_from_db()
@@ -212,7 +179,7 @@ def test_submit_form_new_user(client: Client, settings: SettingsWrapper):
             "date_of_birth": localdate() - relativedelta(years=18),
             "subscription_type": "deux-semestres",
             "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
-            "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[1][0],
+            "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
         },
     )
     user = User.objects.get(email="jdoe@utbm.fr")

trombi/views.py

@@ -26,9 +26,7 @@ from datetime import date
 
 from django import forms
 from django.conf import settings
-from django.contrib import messages
 from django.contrib.auth.mixins import LoginRequiredMixin
-from django.contrib.messages.views import SuccessMessageMixin
 from django.core.exceptions import PermissionDenied
 from django.db import IntegrityError
 from django.forms.models import modelform_factory
@@ -48,7 +46,7 @@ from core.auth.mixins import (
 )
 from core.models import User
 from core.views.forms import SelectDate
-from core.views.mixins import TabedViewMixin
+from core.views.mixins import QuickNotifMixin, TabedViewMixin
 from core.views.widgets.ajax_select import AutoCompleteSelectUser
 from trombi.models import Trombi, TrombiClubMembership, TrombiComment, TrombiUser
 
@@ -136,15 +134,15 @@ class TrombiCreateView(CanCreateMixin, CreateView):
             return self.form_invalid(form)
 
 
-class TrombiEditView(
+class TrombiEditView(CanEditPropMixin, TrombiTabsMixin, UpdateView):
-    CanEditPropMixin, TrombiTabsMixin, SuccessMessageMixin, UpdateView
-):
     model = Trombi
     form_class = TrombiForm
     template_name = "core/edit.jinja"
     pk_url_kwarg = "trombi_id"
     current_tab = "admin_tools"
-    success_message = _("Trombi modified")
+
+    def get_success_url(self):
+        return super().get_success_url() + "?qn_success"
 
 
 class AddUserForm(forms.Form):
@@ -157,7 +155,7 @@ class AddUserForm(forms.Form):
     )
 
 
-class TrombiDetailView(CanEditMixin, TrombiTabsMixin, DetailView):
+class TrombiDetailView(CanEditMixin, QuickNotifMixin, TrombiTabsMixin, DetailView):
     model = Trombi
     template_name = "trombi/detail.jinja"
     pk_url_kwarg = "trombi_id"
@@ -169,9 +167,9 @@ class TrombiDetailView(CanEditMixin, TrombiTabsMixin, DetailView):
         if form.is_valid():
             try:
                 TrombiUser(user=form.cleaned_data["user"], trombi=self.object).save()
-                messages.success(self.request, _("User added to the trombi"))
+                self.quick_notif_list.append("qn_success")
             except IntegrityError:  # We don't care about duplicate keys
-                messages.error(self.request, _("User couldn't be added to the trombi"))
+                self.quick_notif_list.append("qn_fail")
         return super().get(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
@@ -187,20 +185,22 @@ class TrombiExportView(CanEditMixin, TrombiTabsMixin, DetailView):
     current_tab = "admin_tools"
 
 
-class TrombiDeleteUserView(
+class TrombiDeleteUserView(CanEditPropMixin, TrombiTabsMixin, DeleteView):
-    CanEditPropMixin, TrombiTabsMixin, SuccessMessageMixin, DeleteView
-):
     model = TrombiUser
     pk_url_kwarg = "user_id"
     template_name = "core/delete_confirm.jinja"
     current_tab = "admin_tools"
-    success_message = _("User removed from the trombi")
 
     def get_success_url(self):
-        return reverse("trombi:detail", kwargs={"trombi_id": self.object.trombi.id})
+        return (
+            reverse("trombi:detail", kwargs={"trombi_id": self.object.trombi.id})
+            + "?qn_success"
+        )
 
 
-class TrombiModerateCommentsView(CanEditPropMixin, TrombiTabsMixin, DetailView):
+class TrombiModerateCommentsView(
+    CanEditPropMixin, QuickNotifMixin, TrombiTabsMixin, DetailView
+):
     model = Trombi
     template_name = "trombi/comment_moderation.jinja"
     pk_url_kwarg = "trombi_id"
@@ -235,18 +235,16 @@ class TrombiModerateCommentView(DetailView):
             if request.POST["action"] == "accept":
                 self.object.is_moderated = True
                 self.object.save()
-                messages.success(self.request, _("Comment accepted"))
                 return redirect(
                     reverse(
                         "trombi:moderate_comments",
                         kwargs={"trombi_id": self.object.author.trombi.id},
                     )
+                    + "?qn_success"
                 )
             elif request.POST["action"] == "reject":
-                messages.success(self.request, _("Comment rejected"))
                 return super().get(request, *args, **kwargs)
             elif request.POST["action"] == "delete" and "reason" in request.POST:
-                messages.success(self.request, _("Comment removed"))
                 self.object.author.user.email_user(
                     subject="[%s] %s" % (settings.SITH_NAME, _("Rejected comment")),
                     message=_(
@@ -267,6 +265,7 @@ class TrombiModerateCommentView(DetailView):
                         "trombi:moderate_comments",
                         kwargs={"trombi_id": self.object.author.trombi.id},
                     )
+                    + "?qn_success"
                 )
         raise Http404
 
@@ -300,7 +299,9 @@ class UserTrombiForm(forms.Form):
     )
 
 
-class UserTrombiToolsView(LoginRequiredMixin, TrombiTabsMixin, TemplateView):
+class UserTrombiToolsView(
+    LoginRequiredMixin, QuickNotifMixin, TrombiTabsMixin, TemplateView
+):
     """Display a user's trombi tools."""
 
     template_name = "trombi/user_tools.jinja"
@@ -317,6 +318,7 @@ class UserTrombiToolsView(LoginRequiredMixin, TrombiTabsMixin, TemplateView):
                     user=request.user, trombi=self.form.cleaned_data["trombi"]
                 )
             trombi_user.save()
+            self.quick_notif_list += ["qn_success"]
         return super().get(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
@@ -333,24 +335,21 @@ class UserTrombiToolsView(LoginRequiredMixin, TrombiTabsMixin, TemplateView):
         return kwargs
 
 
-class UserTrombiEditPicturesView(
+class UserTrombiEditPicturesView(TrombiTabsMixin, UserIsInATrombiMixin, UpdateView):
-    TrombiTabsMixin, UserIsInATrombiMixin, SuccessMessageMixin, UpdateView
-):
     model = TrombiUser
     fields = ["profile_pict", "scrub_pict"]
     template_name = "core/edit.jinja"
     current_tab = "pictures"
-    success_message = _("User modified")
 
     def get_object(self):
         return self.request.user.trombi_user
 
     def get_success_url(self):
-        return reverse("trombi:user_tools")
+        return reverse("trombi:user_tools") + "?qn_success"
 
 
 class UserTrombiEditProfileView(
-    TrombiTabsMixin, UserIsInATrombiMixin, SuccessMessageMixin, UpdateView
+    QuickNotifMixin, TrombiTabsMixin, UserIsInATrombiMixin, UpdateView
 ):
     model = User
     form_class = modelform_factory(
@@ -371,20 +370,16 @@ class UserTrombiEditProfileView(
     )
     template_name = "trombi/edit_profile.jinja"
     current_tab = "profile"
-    success_message = _("User modified")
 
     def get_object(self):
         return self.request.user
 
     def get_success_url(self):
-        return reverse("trombi:user_tools")
+        return reverse("trombi:user_tools") + "?qn_success"
 
 
-class UserTrombiResetClubMembershipsView(
+class UserTrombiResetClubMembershipsView(UserIsInATrombiMixin, RedirectView):
-    UserIsInATrombiMixin, SuccessMessageMixin, RedirectView
-):
     permanent = False
-    success_message = _("User modified")
 
     def get(self, request, *args, **kwargs):
         user = self.request.user.trombi_user
@@ -392,18 +387,18 @@ class UserTrombiResetClubMembershipsView(
         return redirect(self.get_success_url())
 
     def get_success_url(self):
-        return reverse("trombi:profile")
+        return reverse("trombi:profile") + "?qn_success"
 
 
-class UserTrombiDeleteMembershipView(
+class UserTrombiDeleteMembershipView(TrombiTabsMixin, CanEditMixin, DeleteView):
-    TrombiTabsMixin, CanEditMixin, SuccessMessageMixin, DeleteView
-):
     model = TrombiClubMembership
     pk_url_kwarg = "membership_id"
     template_name = "core/delete_confirm.jinja"
     success_url = reverse_lazy("trombi:profile")
     current_tab = "profile"
-    success_message = _("User removed from trombi")
+
+    def get_success_url(self):
+        return super().get_success_url() + "?qn_success"
 
 
 # Used by admins when someone does not have every club in his list
@@ -433,18 +428,15 @@ class UserTrombiAddMembershipView(TrombiTabsMixin, CreateView):
         )
 
 
-class UserTrombiEditMembershipView(
+class UserTrombiEditMembershipView(CanEditMixin, TrombiTabsMixin, UpdateView):
-    CanEditMixin, TrombiTabsMixin, SuccessMessageMixin, UpdateView
-):
     model = TrombiClubMembership
     pk_url_kwarg = "membership_id"
     fields = ["role", "start", "end"]
     template_name = "core/edit.jinja"
     current_tab = "profile"
-    success_message = _("User modified")
 
     def get_success_url(self):
-        return super().get_success_url()
+        return super().get_success_url() + "?qn_success"
 
 
 class UserTrombiProfileView(TrombiTabsMixin, DetailView):
@@ -469,13 +461,12 @@ class UserTrombiProfileView(TrombiTabsMixin, DetailView):
         return super().get(request, *args, **kwargs)
 
 
-class TrombiCommentFormView(LoginRequiredMixin, SuccessMessageMixin, View):
+class TrombiCommentFormView(LoginRequiredMixin, View):
     """Create/edit a trombi comment."""
 
     model = TrombiComment
     fields = ["content"]
     template_name = "trombi/comment.jinja"
-    success_message = _("Comment added")
 
     def get_form_class(self):
         self.trombi = self.request.user.trombi_user.trombi
@@ -505,7 +496,7 @@ class TrombiCommentFormView(LoginRequiredMixin, SuccessMessageMixin, View):
         )
 
     def get_success_url(self):
-        return reverse("trombi:user_tools")
+        return reverse("trombi:user_tools") + "?qn_success"
 
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)

tsconfig.json

@@ -11,7 +11,7 @@
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
     "resolveJsonModule": true,
-    "types": ["alpinejs"],
+    "types": ["jquery", "alpinejs"],
     "paths": {
       "#openapi": ["./staticfiles/generated/openapi/client/index.ts"],
       "#openapi:*": ["./staticfiles/generated/openapi/client/*"],

vite.config.mts

@@ -4,6 +4,7 @@ import inject from "@rollup/plugin-inject";
 import { glob } from "glob";
 import { type AliasOptions, type UserConfig, defineConfig } from "vite";
 import type { Rollup } from "vite";
+import { viteStaticCopy } from "vite-plugin-static-copy";
 import tsconfig from "./tsconfig.json";
 
 const outDir = resolve(__dirname, "./staticfiles/generated/bundled");
@@ -86,6 +87,17 @@ export default defineConfig((config: UserConfig) => {
         Alpine: "alpinejs",
         htmx: "htmx.org",
       }),
+      viteStaticCopy({
+        targets: [
+          {
+            src: resolve(nodeModules, "jquery/dist/jquery.min.js"),
+            dest: vendored,
+          },
+        ],
+      }),
     ],
+    optimizeDeps: {
+      include: ["jquery"],
+    },
   } satisfies UserConfig;
 });