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,81 +188,70 @@ 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 = [
+        # Using a ModelForm binds too much the form with the model and we don't want that
-            (value, name)
+        # We want the view to process the model creation since they are multiple users
-            for value, name in settings.SITH_CLUB_ROLES.items()
+        # We also want the form to handle bulk deletion
-            if value <= self.max_available_role
+        self.fields.update(
+            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
+
+        # Start date and description are never really required
+        self.fields["start_date"].required = False
+        self.fields["description"].required = False
+
+        self.fields["users_old"] = forms.ModelMultipleChoiceField(
+            User.objects.filter(
+                id__in=[
+                    ms.user.id
+                    for ms in self.club_members
+                    if ms.can_be_edited_by(self.request_user)
                 ]
-        self.instance.club = club
+            ).all(),
+            label=_("Mark as old"),
+            required=False,
+            widget=forms.CheckboxSelectMultiple,
+        )
+        if not self.request_user.is_root:
+            self.fields.pop("start_date")
 
-    @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."""
-        # this is unreachable, because it will be overridden by subclasses
-        return -1  # pragma: no cover
-
-
-class ClubAddMemberForm(ClubMemberForm):
-    """Form to add a member to the club, as a board member."""
-
-    class Meta(ClubMemberForm.Meta):
-        fields = ["user", *ClubMemberForm.Meta.fields]
-        widgets = {"user": AutoCompleteSelectUser}
-
-    @cached_property
-    def max_available_role(self):
-        """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()
+        users = []
+        for user in cleaned_data["users"]:
             if not user.is_subscribed:
                 raise forms.ValidationError(
                     _("User must be subscriber to take part to a club"), code="invalid"
@@ -275,30 +260,33 @@ class ClubAddMemberForm(ClubMemberForm):
                 raise forms.ValidationError(
                     _("You can not add the same user twice"), code="invalid"
                 )
-        return user
+            users.append(user)
-
+        return users
-
-class JoinClubForm(ClubMemberForm):
-    """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 %}Role{% endtrans %}</td>
       <td>{% trans %}Description{% endtrans %}</td>
       <td>{% trans %}From{% 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/club_tools.jinja

@@ -1,63 +1,25 @@
 {% extends "core/base.jinja" %}
-{% from "reservation/macros.jinja" import room_detail %}
-
-{% block additional_css %}
-  <link rel="stylesheet" href="{{ static("core/components/card.scss") }}">
-{% endblock %}
 
 {% block content %}
-  <h3>{% trans %}Club tools{% endtrans %} ({{ club.name }})</h3>
+  <h3>{% trans %}Club tools{% endtrans %}</h3>
   <div>
     <h4>{% trans %}Communication:{% endtrans %}</h4>
     <ul>
-      <li>
+      <li> <a href="{{ url('com:news_new') }}?club={{ object.id }}">{% trans %}Create a news{% endtrans %}</a></li>
-        <a href="{{ url('com:news_new') }}?club={{ object.id }}">
+      <li> <a href="{{ url('com:weekmail_article') }}?club={{ object.id }}">{% trans %}Post in the Weekmail{% endtrans %}</a></li>
-          {% trans %}Create a news{% endtrans %}
-        </a>
-      </li>
-      <li>
-        <a href="{{ url('com:weekmail_article') }}?club={{ object.id }}">
-          {% trans %}Post in the Weekmail{% endtrans %}
-        </a>
-      </li>
       {% if object.trombi %}
-        <li>
+        <li> <a href="{{ url('trombi:detail', trombi_id=object.trombi.id) }}">{% trans %}Edit Trombi{% endtrans %}</a></li>
-          <a href="{{ url('trombi:detail', trombi_id=object.trombi.id) }}">
-            {% trans %}Edit Trombi{% endtrans %}</a>
-        </li>
       {% else %}
-        <li><a href="{{ url('trombi:create', club_id=object.id) }}">{% trans %}New Trombi{% endtrans %}</a></li>
+        <li> <a href="{{ url('trombi:create', club_id=object.id) }}">{% trans %}New Trombi{% endtrans %}</a></li>
-        <li><a href="{{ url('club:poster_list', club_id=object.id) }}">{% trans %}Posters{% endtrans %}</a></li>
+        <li> <a href="{{ url('club:poster_list', club_id=object.id) }}">{% trans %}Posters{% endtrans %}</a></li>
       {% endif %}
     </ul>
-    <h4>{% trans %}Reservable rooms{% endtrans %}</h4>
-    <a
-      href="{{ url("reservation:room_create") }}?club={{ object.id }}"
-      class="btn btn-blue"
-    >
-      {% trans %}Add a room{% endtrans %}
-    </a>
-    {%- if reservable_rooms|length > 0 -%}
-      <ul class="card-group">
-        {%- for room in reservable_rooms -%}
-          {{ room_detail(
-          room,
-          can_edit=user.can_edit(room),
-          can_delete=request.user.has_perm("reservation.delete_room")
-          ) }}
-        {%- endfor -%}
-      </ul>
-    {%- else -%}
-      <p>
-        {% trans %}This club manages no reservable room{% endtrans %}
-      </p>
-    {%- endif -%}
     <h4>{% trans %}Counters:{% endtrans %}</h4>
     <ul>
-      {% for counter in counters %}
+      {% for c in object.counters.filter(type="OFFICE") %}
-        <li>{{ counter }}:
+        <li>{{ c }}:
-          <a href="{{ url('counter:details', counter_id=counter.id) }}">View</a>
+          <a href="{{ url('counter:details', counter_id=c.id) }}">View</a>
-          <a href="{{ url('counter:admin', counter_id=counter.id) }}">Edit</a>
+          <a href="{{ url('counter:admin', counter_id=c.id) }}">Edit</a>
         </li>
       {% endfor %}
     </ul>

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 == {
-            "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 == {
+        assert form.errors == {"role": ["Vous devez choisir un rôle"]}
-                "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(
                 [
                     {
@@ -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):
@@ -262,128 +245,58 @@ class ClubToolsView(ClubTabsMixin, CanEditMixin, DetailView):
     template_name = "club/club_tools.jinja"
     current_tab = "tools"
 
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "reservable_rooms": list(self.object.reservable_rooms.all()),
-            "counters": list(self.object.counters.filter(type="OFFICE")),
-        }
 
-
+class ClubMembersView(ClubTabsMixin, CanViewMixin, DetailFormView):
-class ClubAddMembersFragment(
-    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):
@@ -424,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"]:
@@ -442,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"]:
@@ -775,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/components/ics-calendar.scss

@@ -16,74 +16,14 @@
   --event-details-padding: 20px;
   --event-details-border: 1px solid #EEEEEE;
   --event-details-border-radius: 4px;
-  --event-details-box-shadow: 0 6px 20px 4px rgb(0 0 0 / 16%);
+  --event-details-box-shadow: 0px 6px 20px 4px rgb(0 0 0 / 16%);
   --event-details-max-width: 600px;
 }
 
-ics-calendar,
+ics-calendar {
-room-scheduler {
   border: none;
   box-shadow: none;
 
-  a.fc-col-header-cell-cushion,
-  a.fc-col-header-cell-cushion:hover {
-    color: black;
-  }
-
-  a.fc-daygrid-day-number,
-  a.fc-daygrid-day-number:hover {
-    color: rgb(34, 34, 34);
-  }
-
-  td {
-    overflow: visible; // Show events on multiple days
-  }
-
-  td, th {
-    text-align: unset;
-  }
-
-  //Reset from style.scss
-  table {
-    box-shadow: none;
-    border-radius: 0;
-    -moz-border-radius: 0;
-    margin: 0;
-  }
-
-  // Reset from style.scss
-  thead {
-    background-color: white;
-    color: black;
-  }
-
-  // Reset from style.scss
-  tbody > tr {
-    &:nth-child(even):not(.highlight) {
-      background: white;
-    }
-  }
-
-  .fc .fc-toolbar.fc-footer-toolbar {
-    margin-bottom: 0.5em;
-  }
-
-  button.text-copy,
-  button.text-copy:focus,
-  button.text-copy:hover {
-    background-color: #67AE6E !important;
-    transition: 500ms ease-in;
-  }
-
-  button.text-copied,
-  button.text-copied:focus,
-  button.text-copied:hover {
-    transition: 500ms ease-out;
-  }
-
-}
-
-ics-calendar {
   #event-details {
     z-index: 10;
     max-width: 1151px;
@@ -120,47 +60,68 @@ ics-calendar {
       align-items: start;
       flex-direction: row;
       background-color: var(--event-details-background-color);
-      margin-top: 0;
+      margin-top: 0px;
       margin-bottom: 4px;
     }
   }
-}
 
-// Reset from style.scss
+  a.fc-col-header-cell-cushion,
-thead {
+  a.fc-col-header-cell-cushion:hover {
+    color: black;
+  }
+
+  a.fc-daygrid-day-number,
+  a.fc-daygrid-day-number:hover {
+    color: rgb(34, 34, 34);
+  }
+
+  td {
+    overflow: visible; // Show events on multiple days
+  }
+
+  //Reset from style.scss
+  table {
+    box-shadow: none;
+    border-radius: 0px;
+    -moz-border-radius: 0px;
+    margin: 0px;
+  }
+
+  // Reset from style.scss
+  thead {
     background-color: white;
     color: black;
-}
+  }
 
-// Reset from style.scss
+  // Reset from style.scss
-tbody > tr {
+  tbody>tr {
     &:nth-child(even):not(.highlight) {
       background: white;
     }
-}
+  }
 
-.fc .fc-toolbar.fc-footer-toolbar {
+  .fc .fc-toolbar.fc-footer-toolbar {
     margin-bottom: 0.5em;
-}
+  }
 
-button.text-copy,
+  button.text-copy,
-button.text-copy:focus,
+  button.text-copy:focus,
-button.text-copy:hover {
+  button.text-copy:hover {
     background-color: #67AE6E !important;
     transition: 500ms ease-in;
-}
+  }
 
-button.text-copied,
+  button.text-copied,
-button.text-copied:focus,
+  button.text-copied:focus,
-button.text-copied:hover {
+  button.text-copied:hover {
     transition: 500ms ease-out;
-}
+  }
 
-.fc .fc-getCalendarLink-button {
+  .fc .fc-getCalendarLink-button {
     margin-right: 0.5rem;
-}
+  }
 
-.fc .fc-helpButton-button {
+  .fc .fc-helpButton-button {
     border-radius: 70%;
     padding-left: 0.5rem;
     padding-right: 0.5rem;
@@ -169,11 +130,12 @@ button.text-copied:hover {
     width: 30px;
     height: 30px;
     font-size: 11px;
-}
+  }
 
 
-.fc .fc-helpButton-button:hover {
+  .fc .fc-helpButton-button:hover {
     background-color: rgba(20, 20, 20, 0.6);
+  }
 }
 
 .tooltip.calendar-copy-tooltip {

com/static/com/css/news-list.scss

@@ -81,9 +81,9 @@
     }
 
     #links_content {
+      overflow: auto;
       box-shadow: $shadow-color 1px 1px 1px;
-      min-height: 20em;
+      height: 20em;
-      padding-bottom: 1em;
 
       h4 {
         margin-left: 5px;

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 {
-        display: inline-flex;
-        left: 0%;
-        animation: scrolling-in 1s linear;
     }
 
-      &.previous {
+    .slide.left{
-        display: inline-flex;
+      left: -100%;
-        animation: scrolling-out 1s linear;
-        opacity: 0;
-        transition: opacity 0.1s;
-        transition-delay: 0.9s;
     }
 
-      @keyframes scrolling-in {
+    .slide.center{
-        0% {
+      left: 0px;
-          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;
+
+    &.init{
+      width: 0px;
+      transition: none;
+    }
+
+    &.progress{
       width: 100%;
-    margin-bottom: 0px;
+      transition: width 10s linear;
-    border: none;
-
-    &::-moz-progress-bar {
-      background: var(--color);
-    }
-
-    &::-webkit-progress-value {
-      background: var(--color);
-    }
-
-    &[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/news_list.jinja

@@ -1,11 +1,9 @@
 {% extends "core/base.jinja" %}
 {% from "com/macros.jinja" import news_moderation_alert %}
 
-{% block title %}AE UTBM{% endblock %}
-
 {% block additional_css %}
   <link rel="stylesheet" href="{{ static('com/css/news-list.scss') }}">
-  <link rel="stylesheet" href="{{ static('core/components/calendar.scss') }}">
+  <link rel="stylesheet" href="{{ static('com/components/ics-calendar.scss') }}">
 
   {# Atom feed discovery, not really css but also goes there #}
   <link rel="alternate" type="application/rss+xml" title="{% trans %}News feed{% endtrans %}" href="{{ url("com:news_feed") }}">
@@ -207,20 +205,10 @@
               <i class="fa-solid fa-graduation-cap fa-xl"></i>
               <a href="{{ url("pedagogy:guide") }}">{% trans %}UV Guide{% endtrans %}</a>
             </li>
-            <li>
-              <i class="fa-solid fa-calendar-days fa-xl"></i>
-              <a href="{{ url("timetable:generator") }}">{% trans %}Timetable{% endtrans %}</a>
-            </li>
             <li>
               <i class="fa-solid fa-magnifying-glass fa-xl"></i>
               <a href="{{ url("matmat:search_clear") }}">{% trans %}Matmatronch{% endtrans %}</a>
             </li>
-            {% if user.has_perm("reservation.view_reservationslot") %}
-              <li>
-                <i class="fa-solid fa-thumbtack fa-xl"></i>
-                <a href="{{ url("reservation:main") }}">{% trans %}Room reservation{% endtrans %}</a>
-              </li>
-            {% endif %}
             <li>
               <i class="fa-solid fa-check-to-slot fa-xl"></i>
               <a href="{{ url("election:list") }}">{% trans %}Elections{% endtrans %}</a>

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"])
+        if obj.can_be_moderated_by(request.user):
             obj.is_moderated = True
             obj.moderator = request.user
             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(
@@ -789,11 +789,7 @@ class Command(BaseCommand):
 
         subscribers = Group.objects.create(name="Cotisants")
         subscribers.permissions.add(
-            *list(
+            *list(perms.filter(codename__in=["add_news", "add_uvcomment"]))
-                perms.filter(
-                    codename__in=["add_news", "add_uvcomment", "view_reservationslot"]
-                )
-            )
         )
         old_subscribers = Group.objects.create(name="Anciens cotisants")
         old_subscribers.permissions.add(

core/management/commands/populate_more.py

@@ -1,7 +1,6 @@
 import random
 from datetime import date, timedelta
 from datetime import timezone as tz
-from math import ceil
 from typing import Iterator
 
 from dateutil.relativedelta import relativedelta
@@ -25,7 +24,6 @@ from counter.models import (
 )
 from forum.models import Forum, ForumMessage, ForumTopic
 from pedagogy.models import UV
-from reservation.models import ReservationSlot, Room
 from subscription.models import Subscription
 
 
@@ -42,20 +40,45 @@ class Command(BaseCommand):
 
         self.stdout.write("Creating users...")
         users = self.create_users()
-        # len(subscribers) is approximately 480
         subscribers = random.sample(users, k=int(0.8 * len(users)))
         self.stdout.write("Creating subscriptions...")
         self.create_subscriptions(subscribers)
         self.stdout.write("Creating club memberships...")
-        self.create_club_memberships(subscribers)
+        users_qs = User.objects.filter(id__in=[s.id for s in subscribers])
-        self.stdout.write("Creating rooms and reservation...")
+        subscribers_now = list(
-        self.create_resources_and_reservations(random.sample(subscribers, k=40))
+            users_qs.annotate(
+                filter=Exists(
+                    Subscription.objects.filter(
+                        member_id=OuterRef("pk"), subscription_end__gte=now()
+                    )
+                )
+            )
+        )
+        old_subscribers = list(
+            users_qs.annotate(
+                filter=Exists(
+                    Subscription.objects.filter(
+                        member_id=OuterRef("pk"), subscription_end__lt=now()
+                    )
+                )
+            )
+        )
+        self.make_club(
+            Club.objects.get(id=settings.SITH_MAIN_CLUB_ID),
+            random.sample(subscribers_now, k=min(30, len(subscribers_now))),
+            random.sample(old_subscribers, k=min(60, len(old_subscribers))),
+        )
+        self.make_club(
+            Club.objects.get(name="Troll Penché"),
+            random.sample(subscribers_now, k=min(20, len(subscribers_now))),
+            random.sample(old_subscribers, k=min(80, len(old_subscribers))),
+        )
         self.stdout.write("Creating uvs...")
         self.create_uvs()
         self.stdout.write("Creating products...")
         self.create_products()
         self.stdout.write("Creating sales and refills...")
-        sellers = list(User.objects.order_by("?")[:100])
+        sellers = random.sample(list(User.objects.all()), 100)
         self.create_sales(sellers)
         self.stdout.write("Creating permanences...")
         self.create_permanences(sellers)
@@ -71,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(),
@@ -169,97 +188,6 @@ class Command(BaseCommand):
         memberships = Membership.objects.bulk_create(memberships)
         Membership._add_club_groups(memberships)
 
-    def create_club_memberships(self, users: list[User]):
-        users_qs = User.objects.filter(id__in=[s.id for s in users])
-        subscribers_now = list(
-            users_qs.annotate(
-                filter=Exists(
-                    Subscription.objects.filter(
-                        member_id=OuterRef("pk"), subscription_end__gte=now()
-                    )
-                )
-            )
-        )
-        old_subscribers = list(
-            users_qs.annotate(
-                filter=Exists(
-                    Subscription.objects.filter(
-                        member_id=OuterRef("pk"), subscription_end__lt=now()
-                    )
-                )
-            )
-        )
-        self.make_club(
-            Club.objects.get(id=settings.SITH_MAIN_CLUB_ID),
-            random.sample(subscribers_now, k=min(30, len(subscribers_now))),
-            random.sample(old_subscribers, k=min(60, len(old_subscribers))),
-        )
-        self.make_club(
-            Club.objects.get(name="Troll Penché"),
-            random.sample(subscribers_now, k=min(20, len(subscribers_now))),
-            random.sample(old_subscribers, k=min(80, len(old_subscribers))),
-        )
-
-    def create_resources_and_reservations(self, users: list[User]):
-        """Generate reservable rooms and reservations slots for those rooms.
-
-        Contrary to the other data generator,
-        this one generates more data than what is expected on the real db.
-        """
-        ae = Club.objects.get(id=settings.SITH_MAIN_CLUB_ID)
-        pdf = Club.objects.get(id=settings.SITH_PDF_CLUB_ID)
-        troll = Club.objects.get(name="Troll Penché")
-        rooms = [
-            Room(
-                name=name,
-                club=club,
-                location=location,
-                description=self.faker.text(100),
-            )
-            for name, club, location in [
-                ("Champi", ae, "BELFORT"),
-                ("Muzik", ae, "BELFORT"),
-                ("Pôle Tech", ae, "BELFORT"),
-                ("Jolly", troll, "BELFORT"),
-                ("Cookut", pdf, "BELFORT"),
-                ("Lucky", pdf, "BELFORT"),
-                ("Potards", pdf, "SEVENANS"),
-                ("Bureau AE", ae, "SEVENANS"),
-            ]
-        ]
-        rooms = Room.objects.bulk_create(rooms)
-        reservations = []
-        for room in rooms:
-            # how much people use this room.
-            # The higher the number, the more reservations exist,
-            # the smaller the interval between two slot is,
-            # and the more future reservations have already been made ahead of time
-            affluence = random.randint(2, 6)
-            slot_start = make_aware(self.faker.past_datetime("-5y").replace(minute=0))
-            generate_until = make_aware(
-                self.faker.future_datetime(timedelta(days=1) * affluence**2)
-            )
-            while slot_start < generate_until:
-                if slot_start.hour < 8:
-                    # if a reservation would start in the middle of the night
-                    # make it start the next morning instead
-                    slot_start += timedelta(hours=10 - slot_start.hour)
-                duration = timedelta(minutes=15) * (1 + int(random.gammavariate(3, 2)))
-                reservations.append(
-                    ReservationSlot(
-                        room=room,
-                        author=random.choice(users),
-                        start_at=slot_start,
-                        end_at=slot_start + duration,
-                        created_at=slot_start - self.faker.time_delta("+7d"),
-                    )
-                )
-                slot_start += duration + (
-                    timedelta(minutes=15) * ceil(random.expovariate(affluence / 192))
-                )
-        reservations.sort(key=lambda slot: slot.created_at)
-        ReservationSlot.objects.bulk_create(reservations)
-
     def create_uvs(self):
         root = User.objects.get(username="root")
         categories = ["CS", "TM", "OM", "QC", "EC"]
@@ -457,7 +385,7 @@ class Command(BaseCommand):
         Permanency.objects.bulk_create(perms)
 
     def create_forums(self):
-        forumers = list(User.objects.order_by("?")[:100])
+        forumers = random.sample(list(User.objects.all()), 100)
         most_actives = random.sample(forumers, 10)
         categories = list(Forum.objects.filter(is_category=True))
         new_forums = [
@@ -475,7 +403,7 @@ class Command(BaseCommand):
             for _ in range(100)
         ]
         ForumTopic.objects.bulk_create(new_topics)
-        topics = list(ForumTopic.objects.values_list("id", flat=True))
+        topics = list(ForumTopic.objects.all())
 
         def get_author():
             if random.random() > 0.5:
@@ -483,7 +411,7 @@ class Command(BaseCommand):
             return random.choice(forumers)
 
         messages = []
-        for topic_id in topics:
+        for t in topics:
             nb_messages = max(1, int(random.normalvariate(mu=90, sigma=50)))
             dates = sorted(
                 [
@@ -495,7 +423,7 @@ class Command(BaseCommand):
             messages.extend(
                 [
                     ForumMessage(
-                        topic_id=topic_id,
+                        topic=t,
                         author=get_author(),
                         date=d,
                         message="\n\n".join(

core/models.py

@@ -651,6 +651,9 @@ class User(AbstractUser):
 
 
 class AnonymousUser(AuthAnonymousUser):
+    def __init__(self):
+        super().__init__()
+
     @property
     def was_subscribed(self):
         return False
@@ -659,6 +662,10 @@ class AnonymousUser(AuthAnonymousUser):
     def is_subscribed(self):
         return False
 
+    @property
+    def subscribed(self):
+        return False
+
     @property
     def is_root(self):
         return False
@@ -1190,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
@@ -1271,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 = (
@@ -1282,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:
@@ -1296,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()
 
@@ -1412,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):
@@ -1466,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,10 +1,7 @@
-import { alpinePlugin } from "#core:utils/notifications";
-import { morph } from "@alpinejs/morph";
 import sort from "@alpinejs/sort";
 import Alpine from "alpinejs";
 
-Alpine.plugin([sort, morph]);
+Alpine.plugin(sort);
-Alpine.magic("notifications", alpinePlugin);
 window.Alpine = Alpine;
 
 window.addEventListener("DOMContentLoaded", () => {

core/static/bundled/htmx-index.js

@@ -1,5 +1,4 @@
 import htmx from "htmx.org";
-import "htmx-ext-alpine-morph";
 
 document.body.addEventListener("htmx:beforeRequest", (event) => {
   event.target.ariaBusy = true;

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/components/card.scss

@@ -16,13 +16,6 @@
   }
 }
 
-.card-group {
-  display: flex;
-  gap: 15px;
-  margin-bottom: 30px;
-  flex-wrap: wrap;
-}
-
 .card {
   background-color: $primary-neutral-light-color;
   border-radius: 5px;
@@ -99,23 +92,13 @@
   }
 
   @media screen and (max-width: 765px) {
-    @include row-layout;
+    @include row-layout
   }
 
   // When combined with card, card-row display the card in a row layout,
   // whatever the size of the screen.
   &.card-row {
-    @include row-layout;
+    @include row-layout
-
-    &.card-row-m {
-      //width: 50%;
-      max-width: 50%;
-    }
-
-    &.card-row-s {
-      //width: 33%;
-      max-width: 33%;
-    }
   }
 }
 

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/static/core/tooltips.scss

@@ -10,9 +10,10 @@
   border-radius: 5px;
   padding: 5px 10px;
   position: absolute;
+  white-space: nowrap;
   opacity: 0;
   transition: opacity 500ms ease-out;
-  width: max-content;
+
   white-space: normal;
 
   left: 0;

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>{% 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,13 +1,12 @@
-{% spaceless %}
+{% for js in statics.js %}
-  {% for js in statics.js %}
   <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>
-  {% 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 %}
     <optgroup label="{{ group_name }}">
   {% endif %}
@@ -17,9 +16,8 @@
   {% if group_name %}
     </optgroup>
   {% endif %}
-  {% endfor %}
+{% endfor %}
-  {% if initial %}
+{% if initial %}
   <slot style="display:none" name="initial">{{ initial }}</slot>
-  {% endif %}
+{% endif %}
-  </{{ component }}>
+</{{ component }}>
-{% endspaceless %}

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/forms.py

@@ -39,8 +39,9 @@ from django.forms import (
     DateInput,
     DateTimeInput,
     TextInput,
+    Widget,
 )
-from django.utils.timezone import localtime, now
+from django.utils.timezone import now
 from django.utils.translation import gettext
 from django.utils.translation import gettext_lazy as _
 from phonenumber_field.widgets import RegionalPhoneNumberWidget
@@ -114,7 +115,7 @@ class SelectUser(TextInput):
 
 def validate_future_timestamp(value: date | datetime):
     if value <= now():
-        raise ValidationError(_("Ensure this timestamp is set in the future"))
+        raise ValueError(_("Ensure this timestamp is set in the future"))
 
 
 class FutureDateTimeField(forms.DateTimeField):
@@ -122,8 +123,8 @@ class FutureDateTimeField(forms.DateTimeField):
 
     default_validators = [validate_future_timestamp]
 
-    def widget_attrs(self, widget: forms.Widget) -> dict[str, str]:
+    def widget_attrs(self, widget: Widget) -> dict[str, str]:
-        return {"min": widget.format_value(localtime())}
+        return {"min": widget.format_value(now())}
 
 
 # Forms

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"""
 
@@ -78,7 +109,7 @@ class FragmentMixin(TemplateResponseMixin, ContextMixin):
             return render(
                 request,
                 "app/template.jinja",
-                context={"fragment": fragment(request)}
+                context={"fragment": fragment(request)
             }
 
         # in urls.py

core/views/page.py

@@ -43,14 +43,11 @@ 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 (
-            Page.objects.viewable_by(self.request.user)
-            .annotate(
             display_name=Coalesce(
                 Subquery(
                     PageRev.objects.filter(page=OuterRef("id"))
@@ -60,6 +57,7 @@ class PageListView(ListView):
                 F("name"),
             )
         )
+        .prefetch_related("view_groups")
         .select_related("parent")
     )
 
@@ -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/static/counter/css/counter-click.scss

@@ -39,7 +39,6 @@
   flex: auto;
   margin: 0.2em;
   width: 20%;
-  min-width: 350px;
 
   ul {
     list-style-type: none;

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 22:40+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"
@@ -239,7 +239,7 @@ msgid "role"
 msgstr "rôle"
 
 #: club/models.py core/models.py counter/models.py election/models.py
-#: forum/models.py reservation/models.py
+#: forum/models.py
 msgid "description"
 msgstr "description"
 
@@ -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,23 +514,11 @@ 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"
 
-#: club/templates/club/club_tools.jinja
-msgid "Reservable rooms"
-msgstr "Salles réservables"
-
-#: club/templates/club/club_tools.jinja
-msgid "Add a room"
-msgstr "Ajouter une salle"
-
-#: club/templates/club/club_tools.jinja
-msgid "This club manages no reservable room"
-msgstr "Ce club ne gère pas de salle réservable"
-
 #: club/templates/club/club_tools.jinja
 msgid "Counters:"
 msgstr "Comptoirs : "
@@ -576,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"
@@ -700,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"
@@ -789,7 +759,7 @@ msgstr "Une description plus détaillée et exhaustive de l'évènement."
 msgid "The club which organizes the event."
 msgstr "Le club qui organise l'évènement."
 
-#: com/models.py pedagogy/models.py reservation/models.py trombi/models.py
+#: com/models.py pedagogy/models.py trombi/models.py
 msgid "author"
 msgstr "auteur"
 
@@ -1073,19 +1043,10 @@ msgstr "Nos services"
 msgid "UV Guide"
 msgstr "Guide des UVs"
 
-#: com/templates/com/news_list.jinja
-msgid "Timetable"
-msgstr "Emploi du temps"
-
 #: com/templates/com/news_list.jinja core/templates/core/base/navbar.jinja
 msgid "Matmatronch"
 msgstr "Matmatronch"
 
-#: com/templates/com/news_list.jinja
-#: reservation/templates/reservation/schedule.jinja
-msgid "Room reservation"
-msgstr "Réservation de salle"
-
 #: com/templates/com/news_list.jinja core/templates/core/base/navbar.jinja
 #: core/templates/core/user_tools.jinja
 msgid "Elections"
@@ -1146,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"
@@ -1207,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"
@@ -1223,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
@@ -1292,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"
@@ -1304,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"
@@ -1316,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."
@@ -1343,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"
@@ -1789,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"
@@ -1952,7 +1876,6 @@ msgstr "Confirmation"
 #: core/templates/core/file_delete_confirm.jinja
 #: counter/templates/counter/counter_click.jinja
 #: counter/templates/counter/fragments/delete_student_card.jinja
-#: reservation/templates/reservation/fragments/create_reservation.jinja
 #: sas/templates/sas/ask_picture_removal.jinja
 msgid "Cancel"
 msgstr "Annuler"
@@ -2234,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"
@@ -2412,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
@@ -3077,7 +3000,7 @@ msgstr "Mettre à True si le mail a reçu une erreur"
 msgid "The operation that emptied the account."
 msgstr "L'opération qui a vidé le compte."
 
-#: counter/models.py pedagogy/models.py reservation/models.py
+#: counter/models.py pedagogy/models.py
 msgid "comment"
 msgstr "commentaire"
 
@@ -4616,72 +4539,21 @@ msgstr "Signaler ce commentaire"
 msgid "Edit UE"
 msgstr "Éditer l'UE"
 
-#: reservation/forms.py
+#: pedagogy/templates/pedagogy/uv_edit.jinja
-msgid "The start must be set before the end"
+msgid "Import from UTBM"
-msgstr "Le début doit être placé avant la fin"
+msgstr "Importer depuis l'UTBM"
 
-#: reservation/models.py
+#: pedagogy/templates/pedagogy/uv_edit.jinja
-msgid "room name"
+msgid "Unknown UE code"
-msgstr "Nom de la salle"
+msgstr "Code d'UE inconnu"
 
-#: reservation/models.py
+#: pedagogy/templates/pedagogy/uv_edit.jinja
-msgid "room owner"
+msgid "Successful autocomplete"
-msgstr "propriétaire de la salle"
+msgstr "Autocomplétion réussite"
 
-#: reservation/models.py
+#: pedagogy/templates/pedagogy/uv_edit.jinja
-msgid "The club which manages this room"
+msgid "An error occurred: "
-msgstr "Le club qui gère cette salle"
+msgstr "Une erreur est survenue : "
-
-#: reservation/models.py
-msgid "site"
-msgstr "site"
-
-#: reservation/models.py
-msgid "reservable room"
-msgstr "salle réservable"
-
-#: reservation/models.py
-msgid "reservable rooms"
-msgstr "salles réservables"
-
-#: reservation/models.py
-msgid "reserved room"
-msgstr "salle réservée"
-
-#: reservation/models.py
-msgid "slot start"
-msgstr "début du créneau"
-
-#: reservation/models.py
-msgid "slot end"
-msgstr "fin du créneau"
-
-#: reservation/models.py
-msgid "reservation slot"
-msgstr "créneau de réservation"
-
-#: reservation/models.py
-msgid "reservation slots"
-msgstr "créneaux de réservation"
-
-#: reservation/models.py
-msgid "There is already a reservation on this slot."
-msgstr "Il y a déjà une réservation sur ce créneau."
-
-#: reservation/templates/reservation/fragments/create_reservation.jinja
-msgid "Book a room"
-msgstr "Réserver une salle"
-
-#: reservation/templates/reservation/schedule.jinja
-msgid "You can book a room by selecting a free slot in the calendar."
-msgstr ""
-"Vous pouvez réserver une salle en sélectionnant un emplacement libre dans le "
-"calendrier."
-
-#: reservation/views.py
-#, python-format
-msgid "%(name)s was updated successfully"
-msgstr "%(name)s a été mis à jour avec succès"
 
 #: rootplace/forms.py
 msgid "User that will be kept"
@@ -4756,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"
@@ -4950,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"
@@ -5239,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"
@@ -5247,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"
@@ -5279,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"
@@ -5298,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
@@ -5325,18 +5201,6 @@ msgstr "Membre existant"
 msgid "the groups that can create subscriptions"
 msgstr "les groupes pouvant créer des cotisations"
 
-#: timetable/templates/timetable/generator.jinja
-msgid "Timetable generator"
-msgstr "Générateur d'emploi du temps"
-
-#: timetable/templates/timetable/generator.jinja
-msgid "Generate"
-msgstr "Générer"
-
-#: timetable/templates/timetable/generator.jinja
-msgid "Save to PNG"
-msgstr "Sauver en PNG"
-
 #: trombi/models.py
 msgid "subscription deadline"
 msgstr "fin des inscriptions"
@@ -5562,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é"
@@ -5634,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)"
@@ -5650,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 "

locale/fr/LC_MESSAGES/djangojs.po

@@ -251,14 +251,6 @@ msgstr "Types de produits réordonnés !"
 msgid "Product type reorganisation failed with status code : %d"
 msgstr "La réorganisation des types de produit a échoué avec le code : %d"
 
-#: reservation/static/bundled/reservation/components/room-scheduler-index.ts
-msgid "Rooms"
-msgstr "Salles"
-
-#: reservation/static/bundled/reservation/slot-reservation-index.ts
-msgid "This slot has been successfully moved"
-msgstr "Ce créneau a été bougé avec succès"
-
 #: sas/static/bundled/sas/pictures-download-index.ts
 msgid "pictures.%(extension)s"
 msgstr "photos.%(extension)s"

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

@@ -9,18 +9,14 @@
       "version": "3",
       "license": "GPL-3.0-only",
       "dependencies": {
-        "@alpinejs/morph": "^3.14.9",
         "@alpinejs/sort": "^3.14.7",
         "@arendjr/text-clipper": "npm:@jsr/arendjr__text-clipper@^3.0.0",
         "@floating-ui/dom": "^1.6.13",
         "@fortawesome/fontawesome-free": "^6.6.0",
-        "@fullcalendar/core": "^6.1.19",
+        "@fullcalendar/core": "^6.1.15",
-        "@fullcalendar/daygrid": "^6.1.19",
+        "@fullcalendar/daygrid": "^6.1.15",
-        "@fullcalendar/icalendar": "^6.1.19",
+        "@fullcalendar/icalendar": "^6.1.15",
-        "@fullcalendar/interaction": "^6.1.19",
+        "@fullcalendar/list": "^6.1.15",
-        "@fullcalendar/list": "^6.1.19",
-        "@fullcalendar/resource": "^6.1.19",
-        "@fullcalendar/resource-timeline": "^6.1.19",
         "@sentry/browser": "^9.29.0",
         "@zip.js/zip.js": "^2.7.52",
         "3d-force-graph": "^1.73.4",
@@ -33,9 +29,8 @@
         "d3-force-3d": "^3.0.5",
         "easymde": "^2.19.0",
         "glob": "^11.0.0",
-        "html2canvas": "^1.4.1",
-        "htmx-ext-alpine-morph": "^2.0.1",
         "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",
@@ -52,19 +47,14 @@
         "@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"
       }
     },
-    "node_modules/@alpinejs/morph": {
-      "version": "3.14.9",
-      "resolved": "https://registry.npmjs.org/@alpinejs/morph/-/morph-3.14.9.tgz",
-      "integrity": "sha512-i1mrH5Gza/egszxnCVwQWypRhsKGq28RFWHWuW7aI0+rWo1pvFw+aPhJLImbpt7hx44DtDOr5m4l9Ah+JPFmFw==",
-      "license": "MIT"
-    },
     "node_modules/@alpinejs/sort": {
       "version": "3.14.9",
       "resolved": "https://registry.npmjs.org/@alpinejs/sort/-/sort-3.14.9.tgz",
@@ -2282,15 +2272,6 @@
         "ical.js": "^1.4.0"
       }
     },
-    "node_modules/@fullcalendar/interaction": {
-      "version": "6.1.19",
-      "resolved": "https://registry.npmjs.org/@fullcalendar/interaction/-/interaction-6.1.19.tgz",
-      "integrity": "sha512-GOciy79xe8JMVp+1evAU3ytdwN/7tv35t5i1vFkifiuWcQMLC/JnLg/RA2s4sYmQwoYhTw/p4GLcP0gO5B3X5w==",
-      "license": "MIT",
-      "peerDependencies": {
-        "@fullcalendar/core": "~6.1.19"
-      }
-    },
     "node_modules/@fullcalendar/list": {
       "version": "6.1.19",
       "resolved": "https://registry.npmjs.org/@fullcalendar/list/-/list-6.1.19.tgz",
@@ -2300,67 +2281,6 @@
         "@fullcalendar/core": "~6.1.19"
       }
     },
-    "node_modules/@fullcalendar/premium-common": {
-      "version": "6.1.19",
-      "resolved": "https://registry.npmjs.org/@fullcalendar/premium-common/-/premium-common-6.1.19.tgz",
-      "integrity": "sha512-bOWHm1u1dUy6M4fQ0hNK7qEI7SrVWrN1ovv/z4/FE/ybfM19ukz7SFs907Ur7KUBWLNKTQYXBtdrY/ginwWraw==",
-      "license": "SEE LICENSE IN LICENSE.md",
-      "peerDependencies": {
-        "@fullcalendar/core": "~6.1.19"
-      }
-    },
-    "node_modules/@fullcalendar/resource": {
-      "version": "6.1.19",
-      "resolved": "https://registry.npmjs.org/@fullcalendar/resource/-/resource-6.1.19.tgz",
-      "integrity": "sha512-br1ylX/aIOfd8m7Tzl2LpJBSI+N9Q6aS1qw7K9qnQjYXWQyHBlfLG6ZcPmmkjfaqTUJc8ARRbtNWj1ts5qOZgQ==",
-      "license": "SEE LICENSE IN LICENSE.md",
-      "dependencies": {
-        "@fullcalendar/premium-common": "~6.1.19"
-      },
-      "peerDependencies": {
-        "@fullcalendar/core": "~6.1.19"
-      }
-    },
-    "node_modules/@fullcalendar/resource-timeline": {
-      "version": "6.1.19",
-      "resolved": "https://registry.npmjs.org/@fullcalendar/resource-timeline/-/resource-timeline-6.1.19.tgz",
-      "integrity": "sha512-oC3aVR++dLqJNeBwmLHq9sDgRDFfIG0qSteV7bgBekvNlqEMqXx8wPjUxnELrq8rrhMmK4iV3wO7AB/48IVgyg==",
-      "license": "SEE LICENSE IN LICENSE.md",
-      "dependencies": {
-        "@fullcalendar/premium-common": "~6.1.19",
-        "@fullcalendar/scrollgrid": "~6.1.19",
-        "@fullcalendar/timeline": "~6.1.19"
-      },
-      "peerDependencies": {
-        "@fullcalendar/core": "~6.1.19",
-        "@fullcalendar/resource": "~6.1.19"
-      }
-    },
-    "node_modules/@fullcalendar/scrollgrid": {
-      "version": "6.1.19",
-      "resolved": "https://registry.npmjs.org/@fullcalendar/scrollgrid/-/scrollgrid-6.1.19.tgz",
-      "integrity": "sha512-S1pbiYHvmV0ep6z5sWXJQfgW4Y/jrS5iLIAqSagDFPK0jr327nBxl7Ryi3Zb5UdMIP0/O4GXs8jwZabQPd8SOg==",
-      "license": "SEE LICENSE IN LICENSE.md",
-      "dependencies": {
-        "@fullcalendar/premium-common": "~6.1.19"
-      },
-      "peerDependencies": {
-        "@fullcalendar/core": "~6.1.19"
-      }
-    },
-    "node_modules/@fullcalendar/timeline": {
-      "version": "6.1.19",
-      "resolved": "https://registry.npmjs.org/@fullcalendar/timeline/-/timeline-6.1.19.tgz",
-      "integrity": "sha512-d2P961mnUTXtJeWNmIq1neoDmZcrPUaK7nGFoc+jQAlnmG3aNSVWQmD1ia694AMqLWtcWkwipW9MuaJgx2QvrA==",
-      "license": "SEE LICENSE IN LICENSE.md",
-      "dependencies": {
-        "@fullcalendar/premium-common": "~6.1.19",
-        "@fullcalendar/scrollgrid": "~6.1.19"
-      },
-      "peerDependencies": {
-        "@fullcalendar/core": "~6.1.19"
-      }
-    },
     "node_modules/@hey-api/json-schema-ref-parser": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/@hey-api/json-schema-ref-parser/-/json-schema-ref-parser-1.0.6.tgz",
@@ -2969,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",
@@ -2989,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",
@@ -3187,15 +3124,6 @@
         "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
-    "node_modules/base64-arraybuffer": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz",
-      "integrity": "sha512-I3yl4r9QB5ZRY3XuJVEPfc2XhZO6YweFPI+UovAzn+8/hb3oJ6lnysaFcjVpkCPfVWFUDvoZ8kmVDP7WyRtYtQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6.0"
-      }
-    },
     "node_modules/binary-extensions": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
@@ -3584,15 +3512,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/css-line-break": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/css-line-break/-/css-line-break-2.1.0.tgz",
-      "integrity": "sha512-FHcKFCZcAha3LwfVBhCQbW2nCNbkZXn7KVUJcsT5/P8YmfsVja0FMPJr0B903j/E69HUphKiV9iQArX8SDYA4w==",
-      "license": "MIT",
-      "dependencies": {
-        "utrie": "^1.0.2"
-      }
-    },
     "node_modules/cytoscape": {
       "version": "3.33.1",
       "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz",
@@ -4265,27 +4184,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/html2canvas": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/html2canvas/-/html2canvas-1.4.1.tgz",
-      "integrity": "sha512-fPU6BHNpsyIhr8yyMpTLLxAbkaK8ArIBcmZIRiBLiDhjeqvXolaEmDGmELFuX9I4xDcaKKcJl+TKZLqruBbmWA==",
-      "license": "MIT",
-      "dependencies": {
-        "css-line-break": "^2.1.0",
-        "text-segmentation": "^1.0.3"
-      },
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/htmx-ext-alpine-morph": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/htmx-ext-alpine-morph/-/htmx-ext-alpine-morph-2.0.1.tgz",
-      "integrity": "sha512-teGpcVatx5IjDUYQs959x9FcePM1TIksjfW5tSe1KVQVEVSmbGxEoemneC7XV6RYpX+27i/xn1fPjduwvHDrAw==",
-      "dependencies": {
-        "htmx.org": "^2.0.2"
-      }
-    },
     "node_modules/htmx.org": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/htmx.org/-/htmx.org-2.0.6.tgz",
@@ -4486,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",
@@ -5575,15 +5479,6 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/text-segmentation": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/text-segmentation/-/text-segmentation-1.0.3.tgz",
-      "integrity": "sha512-iOiPUo/BGnZ6+54OsWxZidGCsdU8YbE4PSpdPinp7DeMtUJNJBoJ/ouUSTJjHkh1KntHaltHl/gDs2FC4i5+Nw==",
-      "license": "MIT",
-      "dependencies": {
-        "utrie": "^1.0.2"
-      }
-    },
     "node_modules/three": {
       "version": "0.177.0",
       "resolved": "https://registry.npmjs.org/three/-/three-0.177.0.tgz",
@@ -5841,19 +5736,10 @@
         "browserslist": ">= 4.21.0"
       }
     },
-    "node_modules/utrie": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/utrie/-/utrie-1.0.2.tgz",
-      "integrity": "sha512-1MLa5ouZiOmQzUbjbu9VmjLzn1QLXBhwpUa7kdLUQK+KQ5KA9I1vk5U4YHe/X2Ch7PYnJfWuWT+VbuxbGwljhw==",
-      "license": "MIT",
-      "dependencies": {
-        "base64-arraybuffer": "^1.0.2"
-      }
-    },
     "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

@@ -21,8 +21,7 @@
     "#core:*": "./core/static/bundled/*",
     "#pedagogy:*": "./pedagogy/static/bundled/*",
     "#counter:*": "./counter/static/bundled/*",
-    "#com:*": "./com/static/bundled/*",
+    "#com:*": "./com/static/bundled/*"
-    "#reservation:*": "./reservation/static/bundled/*"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
@@ -33,25 +32,22 @@
     "@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"
   },
   "dependencies": {
-    "@alpinejs/morph": "^3.14.9",
     "@alpinejs/sort": "^3.14.7",
     "@arendjr/text-clipper": "npm:@jsr/arendjr__text-clipper@^3.0.0",
     "@floating-ui/dom": "^1.6.13",
     "@fortawesome/fontawesome-free": "^6.6.0",
-    "@fullcalendar/core": "^6.1.19",
+    "@fullcalendar/core": "^6.1.15",
-    "@fullcalendar/daygrid": "^6.1.19",
+    "@fullcalendar/daygrid": "^6.1.15",
-    "@fullcalendar/icalendar": "^6.1.19",
+    "@fullcalendar/icalendar": "^6.1.15",
-    "@fullcalendar/interaction": "^6.1.19",
+    "@fullcalendar/list": "^6.1.15",
-    "@fullcalendar/list": "^6.1.19",
-    "@fullcalendar/resource": "^6.1.19",
-    "@fullcalendar/resource-timeline": "^6.1.19",
     "@sentry/browser": "^9.29.0",
     "@zip.js/zip.js": "^2.7.52",
     "3d-force-graph": "^1.73.4",
@@ -64,9 +60,8 @@
     "d3-force-3d": "^3.0.5",
     "easymde": "^2.19.0",
     "glob": "^11.0.0",
-    "html2canvas": "^1.4.1",
-    "htmx-ext-alpine-morph": "^2.0.1",
     "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,7 +13,8 @@
 {% 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>
+      <button id="return_js" onclick='(function(){
                                       // If comes from the guide page, go back with history
                                       if (document.referrer.replace(/\?(.+)/gm,"").endsWith(`{{ url("pedagogy:guide") }}`)){
                                       window.history.back();
@@ -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 %}

reservation/admin.py

@@ -1,19 +0,0 @@
-from django.contrib import admin
-
-from reservation.models import ReservationSlot, Room
-
-
-@admin.register(Room)
-class RoomAdmin(admin.ModelAdmin):
-    list_display = ("name", "club")
-    list_filter = (("club", admin.RelatedOnlyFieldListFilter), "location")
-    autocomplete_fields = ("club",)
-    search_fields = ("name",)
-
-
-@admin.register(ReservationSlot)
-class ReservationSlotAdmin(admin.ModelAdmin):
-    list_display = ("room", "start_at", "end_at", "author")
-    autocomplete_fields = ("author",)
-    list_filter = ("room",)
-    date_hierarchy = "start_at"

reservation/api.py

@@ -1,64 +0,0 @@
-from typing import Any, Literal
-
-from django.core.exceptions import ValidationError
-from ninja import Query
-from ninja_extra import ControllerBase, api_controller, paginate, route
-from ninja_extra.pagination import PageNumberPaginationExtra
-from ninja_extra.schemas import PaginatedResponseSchema
-
-from api.permissions import HasPerm
-from reservation.models import ReservationSlot, Room
-from reservation.schemas import (
-    RoomFilterSchema,
-    RoomSchema,
-    SlotFilterSchema,
-    SlotSchema,
-    UpdateReservationSlotSchema,
-)
-
-
-@api_controller("/reservation/room")
-class ReservableRoomController(ControllerBase):
-    @route.get(
-        "",
-        response=list[RoomSchema],
-        permissions=[HasPerm("reservation.view_room")],
-        url_name="fetch_reservable_rooms",
-    )
-    def fetch_rooms(self, filters: Query[RoomFilterSchema]):
-        return filters.filter(Room.objects.select_related("club"))
-
-
-@api_controller("/reservation/slot")
-class ReservationSlotController(ControllerBase):
-    @route.get(
-        "",
-        response=PaginatedResponseSchema[SlotSchema],
-        permissions=[HasPerm("reservation.view_reservationslot")],
-        url_name="fetch_reservation_slots",
-    )
-    @paginate(PageNumberPaginationExtra)
-    def fetch_slots(self, filters: Query[SlotFilterSchema]):
-        return filters.filter(
-            ReservationSlot.objects.select_related("author").order_by("start_at")
-        )
-
-    @route.patch(
-        "/reservation/slot/{int:slot_id}",
-        permissions=[HasPerm("reservation.change_reservationslot")],
-        response={
-            200: None,
-            409: dict[Literal["detail"], dict[str, list[str]]],
-            422: dict[Literal["detail"], list[dict[str, Any]]],
-        },
-        url_name="change_reservation_slot",
-    )
-    def update_slot(self, slot_id: int, params: UpdateReservationSlotSchema):
-        slot = self.get_object_or_exception(ReservationSlot, id=slot_id)
-        slot.start_at = params.start_at
-        slot.end_at = params.end_at
-        try:
-            slot.full_clean()
-            slot.save()
-        except ValidationError as e:
-            return self.create_response({"detail": dict(e)}, status_code=409)

reservation/apps.py

@@ -1,6 +0,0 @@
-from django.apps import AppConfig
-
-
-class ReservationConfig(AppConfig):
-    default_auto_field = "django.db.models.BigAutoField"
-    name = "reservation"

reservation/forms.py

@@ -1,60 +0,0 @@
-from django import forms
-from django.core.exceptions import NON_FIELD_ERRORS
-from django.utils.translation import gettext_lazy as _
-
-from club.widgets.ajax_select import AutoCompleteSelectClub
-from core.models import User
-from core.views.forms import FutureDateTimeField, SelectDateTime
-from reservation.models import ReservationSlot, Room
-
-
-class RoomCreateForm(forms.ModelForm):
-    required_css_class = "required"
-    error_css_class = "error"
-
-    class Meta:
-        model = Room
-        fields = ["name", "club", "location", "description"]
-        widgets = {"club": AutoCompleteSelectClub}
-
-
-class RoomUpdateForm(forms.ModelForm):
-    required_css_class = "required"
-    error_css_class = "error"
-
-    class Meta:
-        model = Room
-        fields = ["name", "club", "location", "description"]
-        widgets = {"club": AutoCompleteSelectClub}
-
-    def __init__(self, *args, request_user: User, **kwargs):
-        super().__init__(*args, **kwargs)
-        if not request_user.has_perm("reservation.change_room"):
-            # if the user doesn't have the global edition permission
-            # (i.e. it's a club board member, but not a sith admin)
-            # some fields aren't editable
-            del self.fields["club"]
-
-
-class ReservationForm(forms.ModelForm):
-    required_css_class = "required"
-    error_css_class = "error"
-
-    class Meta:
-        model = ReservationSlot
-        fields = ["room", "start_at", "end_at", "comment"]
-        field_classes = {"start_at": FutureDateTimeField, "end_at": FutureDateTimeField}
-        widgets = {"start_at": SelectDateTime(), "end_at": SelectDateTime()}
-        error_messages = {
-            NON_FIELD_ERRORS: {
-                "start_after_end": _("The start must be set before the end")
-            }
-        }
-
-    def __init__(self, *args, author: User, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.author = author
-
-    def save(self, commit: bool = True):  # noqa FBT001
-        self.instance.author = self.author
-        return super().save(commit)

reservation/migrations/0001_initial.py

@@ -1,117 +0,0 @@
-# Generated by Django 5.2.1 on 2025-06-05 10:44
-
-import django.core.validators
-import django.db.models.deletion
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    initial = True
-
-    dependencies = [
-        ("club", "0014_alter_club_options_rename_unix_name_club_slug_name_and_more"),
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="Room",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=100, verbose_name="room name")),
-                (
-                    "description",
-                    models.TextField(
-                        blank=True, default="", verbose_name="description"
-                    ),
-                ),
-                (
-                    "location",
-                    models.CharField(
-                        blank=True,
-                        choices=[
-                            ("BELFORT", "Belfort"),
-                            ("SEVENANS", "Sévenans"),
-                            ("MONTBELIARD", "Montbéliard"),
-                        ],
-                        verbose_name="site",
-                    ),
-                ),
-                (
-                    "club",
-                    models.ForeignKey(
-                        help_text="The club which manages this room",
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="reservable_rooms",
-                        to="club.club",
-                        verbose_name="room owner",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "reservable room",
-                "verbose_name_plural": "reservable rooms",
-            },
-        ),
-        migrations.CreateModel(
-            name="ReservationSlot",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "comment",
-                    models.TextField(blank=True, default="", verbose_name="comment"),
-                ),
-                (
-                    "start_at",
-                    models.DateTimeField(db_index=True, verbose_name="slot start"),
-                ),
-                ("end_at", models.DateTimeField(verbose_name="slot end")),
-                ("created_at", models.DateTimeField(auto_now_add=True)),
-                (
-                    "author",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="author",
-                    ),
-                ),
-                (
-                    "room",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="slots",
-                        to="reservation.room",
-                        verbose_name="reserved room",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "reservation slot",
-                "verbose_name_plural": "reservation slots",
-                "constraints": [
-                    models.CheckConstraint(
-                        condition=models.Q(("end_at__gt", models.F("start_at"))),
-                        name="reservation_slot_end_after_start",
-                        violation_error_code="start_after_end",
-                    )
-                ],
-            },
-        ),
-    ]

reservation/models.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from typing import Self
-
-from django.core.exceptions import ValidationError
-from django.db import models
-from django.db.models import F, Q
-from django.utils.translation import gettext_lazy as _
-
-from club.models import Club
-from core.models import User
-
-
-class Room(models.Model):
-    name = models.CharField(_("room name"), max_length=100)
-    description = models.TextField(_("description"), blank=True, default="")
-    club = models.ForeignKey(
-        Club,
-        on_delete=models.CASCADE,
-        related_name="reservable_rooms",
-        verbose_name=_("room owner"),
-        help_text=_("The club which manages this room"),
-    )
-    location = models.CharField(
-        _("site"),
-        blank=True,
-        choices=[
-            ("BELFORT", "Belfort"),
-            ("SEVENANS", "Sévenans"),
-            ("MONTBELIARD", "Montbéliard"),
-        ],
-    )
-
-    class Meta:
-        verbose_name = _("reservable room")
-        verbose_name_plural = _("reservable rooms")
-
-    def __str__(self):
-        return self.name
-
-    def can_be_edited_by(self, user: User) -> bool:
-        # a user may edit a room if it has the global perm
-        # or is in the owner club board
-        return user.has_perm("reservation.change_room") or self.club.board_group_id in [
-            g.id for g in user.cached_groups
-        ]
-
-
-class ReservationSlotQuerySet(models.QuerySet):
-    def overlapping_with(self, slot: ReservationSlot) -> Self:
-        return self.filter(
-            Q(start_at__lt=slot.start_at, end_at__gt=slot.start_at)
-            | Q(start_at__lt=slot.end_at, end_at__gt=slot.end_at)
-        )
-
-
-class ReservationSlot(models.Model):
-    room = models.ForeignKey(
-        Room,
-        on_delete=models.CASCADE,
-        related_name="slots",
-        verbose_name=_("reserved room"),
-    )
-    author = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name=_("author"))
-    comment = models.TextField(_("comment"), blank=True, default="")
-    start_at = models.DateTimeField(_("slot start"), db_index=True)
-    end_at = models.DateTimeField(_("slot end"))
-    created_at = models.DateTimeField(auto_now_add=True)
-
-    objects = ReservationSlotQuerySet.as_manager()
-
-    class Meta:
-        verbose_name = _("reservation slot")
-        verbose_name_plural = _("reservation slots")
-        constraints = [
-            models.CheckConstraint(
-                condition=Q(end_at__gt=F("start_at")),
-                name="reservation_slot_end_after_start",
-                violation_error_code="start_after_end",
-            )
-        ]
-
-    def __str__(self):
-        return f"{self.room.name} : {self.start_at} - {self.end_at}"
-
-    def clean(self):
-        super().clean()
-        if self.end_at is None or self.start_at is None:
-            # if there is no start or no end, then there is no
-            # point to check if this perm overlap with another,
-            # so in this case, don't do the overlap check and let
-            # Django manage the non-null constraint error.
-            return
-        overlapping = ReservationSlot.objects.overlapping_with(self).filter(
-            room_id=self.room_id
-        )
-        if self.id is not None:
-            overlapping = overlapping.exclude(id=self.id)
-        if overlapping.exists():
-            raise ValidationError(_("There is already a reservation on this slot."))

reservation/schemas.py

@@ -1,46 +0,0 @@
-from datetime import datetime
-
-from ninja import FilterSchema, ModelSchema, Schema
-from pydantic import Field, FutureDatetime
-
-from club.schemas import SimpleClubSchema
-from core.schemas import SimpleUserSchema
-from reservation.models import ReservationSlot, Room
-
-
-class RoomFilterSchema(FilterSchema):
-    club: set[int] | None = Field(None, q="club_id__in")
-
-
-class RoomSchema(ModelSchema):
-    class Meta:
-        model = Room
-        fields = ["id", "name", "description", "location"]
-
-    club: SimpleClubSchema
-
-    @staticmethod
-    def resolve_location(obj: Room):
-        return obj.get_location_display()
-
-
-class SlotFilterSchema(FilterSchema):
-    after: datetime = Field(default=None, q="end_at__gt")
-    before: datetime = Field(default=None, q="start_at__lt")
-    room: set[int] | None = None
-    club: set[int] | None = None
-
-
-class SlotSchema(ModelSchema):
-    class Meta:
-        model = ReservationSlot
-        fields = ["id", "room", "comment"]
-
-    start: datetime = Field(alias="start_at")
-    end: datetime = Field(alias="end_at")
-    author: SimpleUserSchema
-
-
-class UpdateReservationSlotSchema(Schema):
-    start_at: FutureDatetime
-    end_at: FutureDatetime

reservation/static/bundled/reservation/components/room-scheduler-index.ts

@@ -1,138 +0,0 @@
-import { inheritHtmlElement, registerComponent } from "#core:utils/web-components";
-import {
-  Calendar,
-  type DateSelectArg,
-  type EventDropArg,
-  type EventSourceFuncArg,
-} from "@fullcalendar/core";
-import enLocale from "@fullcalendar/core/locales/en-gb";
-import frLocale from "@fullcalendar/core/locales/fr";
-
-import {
-  type ReservationslotFetchSlotsData,
-  type SlotSchema,
-  reservableroomFetchRooms,
-  reservationslotFetchSlots,
-  reservationslotUpdateSlot,
-} from "#openapi";
-
-import { paginated } from "#core:utils/api";
-import type { SlotSelectedEventArg } from "#reservation:reservation/types";
-import interactionPlugin, { type EventResizeDoneArg } from "@fullcalendar/interaction";
-import resourceTimelinePlugin from "@fullcalendar/resource-timeline";
-
-@registerComponent("room-scheduler")
-export class RoomScheduler extends inheritHtmlElement("div") {
-  static observedAttributes = ["locale", "can_edit_slot", "can_create_slot"];
-  private scheduler: Calendar;
-  private locale = "en";
-  private canEditSlot = false;
-  private canBookSlot = false;
-  private canDeleteSlot = false;
-
-  attributeChangedCallback(name: string, _oldValue?: string, newValue?: string) {
-    if (name === "locale") {
-      this.locale = newValue;
-    }
-    if (name === "can_edit_slot") {
-      this.canEditSlot = newValue.toLowerCase() === "true";
-    }
-    if (name === "can_create_slot") {
-      this.canBookSlot = newValue.toLowerCase() === "true";
-    }
-    if (name === "can_delete_slot") {
-      this.canDeleteSlot = newValue.toLowerCase() === "true";
-    }
-  }
-
-  /**
-   * Fetch the events displayed in the timeline.
-   * cf https://fullcalendar.io/docs/events-function
-   */
-  async fetchEvents(fetchInfo: EventSourceFuncArg) {
-    const res: SlotSchema[] = await paginated(reservationslotFetchSlots, {
-      query: { after: fetchInfo.startStr, before: fetchInfo.endStr },
-    } as ReservationslotFetchSlotsData);
-    return res.map((i) =>
-      Object.assign(i, {
-        title: `${i.author.first_name} ${i.author.last_name}`,
-        resourceId: i.room,
-        editable: new Date(i.start) > new Date(),
-      }),
-    );
-  }
-
-  /**
-   * Fetch the resources which events are associated with.
-   * cf https://fullcalendar.io/docs/resources-function
-   */
-  async fetchResources() {
-    const res = await reservableroomFetchRooms();
-    return res.data.map((i) => Object.assign(i, { title: i.name, group: i.location }));
-  }
-
-  /**
-   * Send a request to the API to change
-   * the start and the duration of a reservation slot
-   */
-  async changeReservation(args: EventDropArg | EventResizeDoneArg) {
-    const response = await reservationslotUpdateSlot({
-      // biome-ignore lint/style/useNamingConvention: api is snake_case
-      path: { slot_id: Number.parseInt(args.event.id) },
-      // biome-ignore lint/style/useNamingConvention: api is snake_case
-      body: { start_at: args.event.startStr, end_at: args.event.endStr },
-    });
-    if (response.response.ok) {
-      document.dispatchEvent(new CustomEvent("reservationSlotChanged"));
-      this.scheduler.refetchEvents();
-    }
-  }
-
-  selectFreeSlot(infos: DateSelectArg) {
-    document.dispatchEvent(
-      new CustomEvent<SlotSelectedEventArg>("timeSlotSelected", {
-        detail: {
-          ressource: Number.parseInt(infos.resource.id),
-          start: infos.startStr,
-          end: infos.endStr,
-        },
-      }),
-    );
-  }
-
-  connectedCallback() {
-    super.connectedCallback();
-    this.scheduler = new Calendar(this.node, {
-      schedulerLicenseKey: "GPL-My-Project-Is-Open-Source",
-      initialView: "resourceTimelineDay",
-      headerToolbar: {
-        left: "prev,next today",
-        center: "title",
-        right: "resourceTimelineDay,resourceTimelineWeek",
-      },
-      plugins: [resourceTimelinePlugin, interactionPlugin],
-      locales: [frLocale, enLocale],
-      height: "auto",
-      locale: this.locale,
-      resourceGroupField: "group",
-      resourceAreaHeaderContent: gettext("Rooms"),
-      editable: this.canEditSlot,
-      snapDuration: "00:15",
-      eventConstraint: { start: new Date() }, // forbid edition of past events
-      eventOverlap: false,
-      eventResourceEditable: false,
-      refetchResourcesOnNavigate: true,
-      resourceAreaWidth: "20%",
-      resources: this.fetchResources,
-      events: this.fetchEvents,
-      select: this.selectFreeSlot,
-      selectOverlap: false,
-      selectable: this.canBookSlot,
-      selectConstraint: { start: new Date() },
-      nowIndicator: true,
-      eventDrop: this.changeReservation,
-      eventResize: this.changeReservation,
-    });
-    this.scheduler.render();
-  }
-}

reservation/static/bundled/reservation/slot-reservation-index.ts

@@ -1,39 +0,0 @@
-import { AlertMessage } from "#core:utils/alert-message";
-import type { SlotSelectedEventArg } from "#reservation:reservation/types";
-
-document.addEventListener("alpine:init", () => {
-  Alpine.data("slotReservation", () => ({
-    start: null as string,
-    end: null as string,
-    room: null as number,
-    showForm: false,
-
-    init() {
-      document.addEventListener(
-        "timeSlotSelected",
-        (event: CustomEvent<SlotSelectedEventArg>) => {
-          this.start = event.detail.start.split("+")[0];
-          this.end = event.detail.end.split("+")[0];
-          this.room = event.detail.ressource;
-          this.showForm = true;
-          this.$nextTick(() => this.$el.scrollIntoView({ behavior: "smooth" })).then();
-        },
-      );
-    },
-  }));
-
-  /**
-   * Component that will catch events sent from the scheduler
-   * to display success messages accordingly.
-   */
-  Alpine.data("scheduleMessages", () => ({
-    alertMessage: new AlertMessage({ defaultDuration: 2000 }),
-    init() {
-      document.addEventListener("reservationSlotChanged", (_event: CustomEvent) => {
-        this.alertMessage.display(gettext("This slot has been successfully moved"), {
-          success: true,
-        });
-      });
-    },
-  }));
-});

reservation/static/bundled/reservation/types.d.ts

@@ -1,5 +0,0 @@
-export interface SlotSelectedEventArg {
-  start: string;
-  end: string;
-  ressource: number;
-}

reservation/static/reservation/reservation.scss

@@ -1,39 +0,0 @@
-#slot-reservation {
-  margin-top: 3em;
-
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-
-  h3 {
-    display: block;
-    margin: auto;
-    text-align: left;
-  }
-
-  .alert, .error {
-    display: block;
-    margin: 1em auto auto;
-    max-width: 400px;
-    word-wrap: break-word;
-    text-wrap: wrap;
-  }
-
-  form {
-    display: flex;
-    flex-direction: column;
-    gap: .5em;
-    justify-content: center;
-
-    .buttons-row {
-      input[type="submit"], button {
-        margin: 0;
-      }
-    }
-    textarea {
-      max-width: unset;
-      width: 100%;
-      margin-top: unset;
-    }
-  }
-}

reservation/templates/reservation/fragments/create_reservation.jinja

@@ -1,51 +0,0 @@
-<section
-  id="slot-reservation"
-  x-data="slotReservation"
-  x-show="showForm"
-  hx-target="this"
-  hx-ext="alpine-morph"
-  hx-swap="morph"
->
-  <h3>{% trans %}Book a room{% endtrans %}</h3>
-  {% set non_field_errors = form.non_field_errors() %}
-  {% if non_field_errors %}
-    <div class="alert alert-red">
-      {% for error in non_field_errors %}
-        <span>{{ error }}</span>
-      {% endfor %}
-    </div>
-  {% endif %}
-  <form
-    id="slot-reservation-form"
-    hx-post="{{ url("reservation:make_reservation") }}"
-    hx-disabled-elt="find input[type='submit']"
-  >
-    {% csrf_token %}
-    <div class="form-group">
-      {{ form.room.errors }}
-      {{ form.room.label_tag() }}
-      {{ form.room|add_attr("x-model=room") }}
-    </div>
-    <div class="form-group">
-      {{ form.start_at.errors }}
-      {{ form.start_at.label_tag() }}
-      {{ form.start_at|add_attr("x-model=start") }}
-    </div>
-    <div class="form-group">
-      {{ form.end_at.errors }}
-      {{ form.end_at.label_tag() }}
-      {{ form.end_at|add_attr("x-model=end") }}
-    </div>
-    <div class="form-group">
-      {{ form.comment.errors }}
-      {{ form.comment.label_tag() }}
-      {{ form.comment }}
-    </div>
-    <div class="row gap buttons-row">
-      <button class="btn btn-grey grow" @click.prevent="showForm = false">
-        {% trans %}Cancel{% endtrans %}
-      </button>
-      <input class="btn btn-blue grow" type="submit">
-    </div>
-  </form>
-</section>

reservation/templates/reservation/macros.jinja

@@ -1,27 +0,0 @@
-{% macro room_detail(room, can_edit, can_delete) %}
-  <div class="card card-row card-row-m">
-    <div class="card-content">
-      <strong class="card-title">{{ room.name }}</strong>
-      <em>{{ room.get_location_display() }}</em>
-      <p>{{ room.description|truncate(250) }}</p>
-    </div>
-    <div class="card-top-left">
-      {% if can_edit %}
-        <a
-          class="btn btn-grey btn-no-text"
-          href="{{ url("reservation:room_edit", room_id=room.id) }}"
-        >
-          <i class="fa fa-edit"></i>
-        </a>
-      {% endif %}
-      {% if can_delete %}
-        <a
-          class="btn btn-red btn-no-text"
-          href="{{ url("reservation:room_delete", room_id=room.id) }}"
-        >
-          <i class="fa fa-trash"></i>
-        </a>
-      {% endif %}
-    </div>
-  </div>
-{% endmacro %}

reservation/templates/reservation/schedule.jinja

@@ -1,33 +0,0 @@
-{% extends "core/base.jinja" %}
-
-{% block additional_js %}
-  <script type="module" src="{{ static("bundled/reservation/components/room-scheduler-index.ts") }}"></script>
-  <script type="module" src="{{ static("bundled/reservation/slot-reservation-index.ts") }}"></script>
-{% endblock %}
-
-{% block additional_css %}
-  <link rel="stylesheet" href="{{ static('core/components/calendar.scss') }}">
-  <link rel="stylesheet" href="{{ static('reservation/reservation.scss') }}">
-{% endblock %}
-
-
-{% block content %}
-  <h2 class="margin-bottom">{% trans %}Room reservation{% endtrans %}</h2>
-  <p
-    x-data="scheduleMessages"
-    class="alert snackbar"
-    :class="alertMessage.success ? 'alert-green' : 'alert-red'"
-    x-show="alertMessage.open"
-    x-transition.duration.500ms
-    x-text="alertMessage.content"
-  ></p>
-  <room-scheduler
-    locale="{{ LANGUAGE_CODE }}"
-    can_edit_slot="{{ user.has_perm("reservation.change_reservationslot") }}"
-    can_create_slot="{{ user.has_perm("reservation.add_reservationslot") }}"
-  ></room-scheduler>
-  {% if user.has_perm("reservation.add_reservationslot") %}
-    <p><em>{% trans %}You can book a room by selecting a free slot in the calendar.{% endtrans %}</em></p>
-    {{ add_slot_fragment }}
-  {% endif %}
-{% endblock %}

reservation/tests/test_room.py

@@ -1,113 +0,0 @@
-import pytest
-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 assertNumQueries, assertRedirects
-
-from club.models import Club
-from core.models import User
-from reservation.forms import RoomUpdateForm
-from reservation.models import Room
-
-
-@pytest.mark.django_db
-class TestFetchRoom:
-    @pytest.fixture
-    def user(self):
-        return baker.make(
-            User,
-            user_permissions=[Permission.objects.get(codename="view_room")],
-        )
-
-    def test_fetch_simple(self, client: Client, user: User):
-        rooms = baker.make(Room, _quantity=3, _bulk_create=True)
-        client.force_login(user)
-        response = client.get(reverse("api:fetch_reservable_rooms"))
-        assert response.status_code == 200
-        assert response.json() == [
-            {
-                "id": room.id,
-                "name": room.name,
-                "description": room.description,
-                "location": room.location,
-                "club": {"id": room.club.id, "name": room.club.name},
-            }
-            for room in rooms
-        ]
-
-    def test_nb_queries(self, client: Client, user: User):
-        client.force_login(user)
-        with assertNumQueries(5):
-            # 4 for authentication
-            # 1 to fetch the actual data
-            client.get(reverse("api:fetch_reservable_rooms"))
-
-
-@pytest.mark.django_db
-class TestCreateRoom:
-    def test_ok(self, client: Client):
-        perm = Permission.objects.get(codename="add_room")
-        club = baker.make(Club)
-        client.force_login(
-            baker.make(User, user_permissions=[perm], groups=[club.board_group])
-        )
-        response = client.post(
-            reverse("reservation:room_create"),
-            data={"club": club.id, "name": "test", "location": "BELFORT"},
-        )
-        assertRedirects(response, reverse("club:tools", kwargs={"club_id": club.id}))
-        room = Room.objects.last()
-        assert room is not None
-        assert room.club == club
-        assert room.name == "test"
-        assert room.location == "BELFORT"
-
-    def test_permission_denied(self, client: Client):
-        club = baker.make(Club)
-        client.force_login(baker.make(User))
-        response = client.get(reverse("reservation:room_create"))
-        assert response.status_code == 403
-        response = client.post(
-            reverse("reservation:room_create"),
-            data={"club": club.id, "name": "test", "location": "BELFORT"},
-        )
-        assert response.status_code == 403
-
-
-@pytest.mark.django_db
-class TestUpdateRoom:
-    def test_ok(self, client: Client):
-        club = baker.make(Club)
-        room = baker.make(Room, club=club)
-        client.force_login(baker.make(User, groups=[club.board_group]))
-        url = reverse("reservation:room_edit", kwargs={"room_id": room.id})
-        response = client.post(url, data={"name": "test", "location": "BELFORT"})
-        assertRedirects(response, url)
-        room.refresh_from_db()
-        assert room.club == club
-        assert room.name == "test"
-        assert room.location == "BELFORT"
-
-    def test_permission_denied(self, client: Client):
-        club = baker.make(Club)
-        room = baker.make(Room, club=club)
-        client.force_login(baker.make(User))
-        url = reverse("reservation:room_edit", kwargs={"room_id": room.id})
-        response = client.get(url)
-        assert response.status_code == 403
-        response = client.post(url, data={"name": "test", "location": "BELFORT"})
-        assert response.status_code == 403
-
-
-@pytest.mark.django_db
-class TestUpdateRoomForm:
-    def test_form_club_edition_rights(self):
-        """The club field should appear only if the request user can edit it."""
-        room = baker.make(Room)
-        perm = Permission.objects.get(codename="change_room")
-        user_authorized = baker.make(User, user_permissions=[perm])
-        assert "club" in RoomUpdateForm(request_user=user_authorized).fields
-
-        user_forbidden = baker.make(User, groups=[room.club.board_group])
-        assert "club" not in RoomUpdateForm(request_user=user_forbidden).fields

reservation/tests/test_slot.py

@@ -1,207 +0,0 @@
-from datetime import timedelta
-
-import pytest
-from django.contrib.auth.models import Permission
-from django.test import Client
-from django.urls import reverse
-from django.utils.timezone import now
-from model_bakery import baker
-from pytest_django.asserts import assertNumQueries
-
-from core.models import User
-from reservation.forms import ReservationForm
-from reservation.models import ReservationSlot, Room
-
-
-@pytest.mark.django_db
-class TestFetchReservationSlotsApi:
-    @pytest.fixture
-    def user(self):
-        perm = Permission.objects.get(codename="view_reservationslot")
-        return baker.make(User, user_permissions=[perm])
-
-    def test_fetch_simple(self, client: Client, user: User):
-        slots = baker.make(ReservationSlot, _quantity=5, _bulk_create=True)
-        client.force_login(user)
-        response = client.get(reverse("api:fetch_reservation_slots"))
-        assert response.json()["results"] == [
-            {
-                "id": slot.id,
-                "room": slot.room_id,
-                "comment": slot.comment,
-                "start": slot.start_at.isoformat(timespec="milliseconds").replace(
-                    "+00:00", "Z"
-                ),
-                "end": slot.end_at.isoformat(timespec="milliseconds").replace(
-                    "+00:00", "Z"
-                ),
-                "author": {
-                    "id": slot.author.id,
-                    "first_name": slot.author.first_name,
-                    "last_name": slot.author.last_name,
-                    "nick_name": slot.author.nick_name,
-                },
-            }
-            for slot in slots
-        ]
-
-    def test_nb_queries(self, client: Client, user: User):
-        client.force_login(user)
-        with assertNumQueries(5):
-            # 4 for authentication
-            # 1 to fetch the actual data
-            client.get(reverse("api:fetch_reservation_slots"))
-
-
-@pytest.mark.django_db
-class TestUpdateReservationSlotApi:
-    @pytest.fixture
-    def user(self):
-        perm = Permission.objects.get(codename="change_reservationslot")
-        return baker.make(User, user_permissions=[perm])
-
-    @pytest.fixture
-    def slot(self):
-        return baker.make(
-            ReservationSlot,
-            start_at=now() + timedelta(hours=2),
-            end_at=now() + timedelta(hours=4),
-        )
-
-    def test_ok(self, client: Client, user: User, slot: ReservationSlot):
-        client.force_login(user)
-        new_start = (slot.start_at + timedelta(hours=1)).replace(microsecond=0)
-        response = client.patch(
-            reverse("api:change_reservation_slot", kwargs={"slot_id": slot.id}),
-            {"start_at": new_start, "end_at": new_start + timedelta(hours=2)},
-            content_type="application/json",
-        )
-        assert response.status_code == 200
-        slot.refresh_from_db()
-        assert slot.start_at.replace(microsecond=0) == new_start
-        assert slot.end_at.replace(microsecond=0) == new_start + timedelta(hours=2)
-
-    def test_change_past_event(self, client, user: User, slot: ReservationSlot):
-        """Test that moving a slot that already began is impossible."""
-        client.force_login(user)
-        new_start = now() - timedelta(hours=1)
-        response = client.patch(
-            reverse("api:change_reservation_slot", kwargs={"slot_id": slot.id}),
-            {"start_at": new_start, "end_at": new_start + timedelta(hours=2)},
-            content_type="application/json",
-        )
-
-        assert response.status_code == 422
-
-    def test_move_event_to_occupied_slot(
-        self, client: Client, user: User, slot: ReservationSlot
-    ):
-        client.force_login(user)
-        other_slot = baker.make(
-            ReservationSlot,
-            room=slot.room,
-            start_at=slot.end_at + timedelta(hours=1),
-            end_at=slot.end_at + timedelta(hours=3),
-        )
-        response = client.patch(
-            reverse("api:change_reservation_slot", kwargs={"slot_id": slot.id}),
-            {
-                "start_at": other_slot.start_at - timedelta(hours=1),
-                "end_at": other_slot.start_at + timedelta(hours=1),
-            },
-            content_type="application/json",
-        )
-        assert response.status_code == 409
-
-
-@pytest.mark.django_db
-class TestReservationForm:
-    def test_ok(self):
-        start = now() + timedelta(hours=2)
-        end = start + timedelta(hours=1)
-        form = ReservationForm(
-            author=baker.make(User),
-            data={"room": baker.make(Room), "start_at": start, "end_at": end},
-        )
-        assert form.is_valid()
-
-    @pytest.mark.parametrize(
-        ("start_date", "end_date", "errors"),
-        [
-            (
-                now() - timedelta(hours=2),
-                now() + timedelta(hours=2),
-                {"start_at": ["Assurez-vous que cet horodatage est dans le futur"]},
-            ),
-            (
-                now() + timedelta(hours=3),
-                now() + timedelta(hours=2),
-                {"__all__": ["Le début doit être placé avant la fin"]},
-            ),
-        ],
-    )
-    def test_invalid_timedates(self, start_date, end_date, errors):
-        form = ReservationForm(
-            author=baker.make(User),
-            data={"room": baker.make(Room), "start_at": start_date, "end_at": end_date},
-        )
-        assert not form.is_valid()
-        assert form.errors == errors
-
-    def test_unavailable_room(self):
-        room = baker.make(Room)
-        baker.make(
-            ReservationSlot,
-            room=room,
-            start_at=now() + timedelta(hours=2),
-            end_at=now() + timedelta(hours=4),
-        )
-        form = ReservationForm(
-            author=baker.make(User),
-            data={
-                "room": room,
-                "start_at": now() + timedelta(hours=1),
-                "end_at": now() + timedelta(hours=3),
-            },
-        )
-        assert not form.is_valid()
-        assert form.errors == {
-            "__all__": ["Il y a déjà une réservation sur ce créneau."]
-        }
-
-
-@pytest.mark.django_db
-class TestCreateReservationSlot:
-    @pytest.fixture
-    def user(self):
-        perms = Permission.objects.filter(
-            codename__in=["add_reservationslot", "view_reservationslot"]
-        )
-        return baker.make(User, user_permissions=list(perms))
-
-    def test_ok(self, client: Client, user: User):
-        client.force_login(user)
-        start = now() + timedelta(hours=2)
-        end = start + timedelta(hours=1)
-        room = baker.make(Room)
-        response = client.post(
-            reverse("reservation:make_reservation"),
-            {"room": room.id, "start_at": start, "end_at": end},
-        )
-        assert response.status_code == 200
-        assert response.headers.get("HX-Redirect", "") == reverse("reservation:main")
-        slot = ReservationSlot.objects.filter(room=room).last()
-        assert slot is not None
-        assert slot.start_at == start
-        assert slot.end_at == end
-        assert slot.author == user
-
-    def test_permissions_denied(self, client: Client):
-        client.force_login(baker.make(User))
-        start = now() + timedelta(hours=2)
-        end = start + timedelta(hours=1)
-        response = client.post(
-            reverse("reservation:make_reservation"),
-            {"room": baker.make(Room), "start_at": start, "end_at": end},
-        )
-        assert response.status_code == 403

reservation/urls.py

@@ -1,19 +0,0 @@
-from django.urls import path
-
-from reservation.views import (
-    ReservationFragment,
-    ReservationScheduleView,
-    RoomCreateView,
-    RoomDeleteView,
-    RoomUpdateView,
-)
-
-urlpatterns = [
-    path("", ReservationScheduleView.as_view(), name="main"),
-    path("room/create/", RoomCreateView.as_view(), name="room_create"),
-    path("room/<int:room_id>/edit", RoomUpdateView.as_view(), name="room_edit"),
-    path("room/<int:room_id>/delete", RoomDeleteView.as_view(), name="room_delete"),
-    path(
-        "fragment/reservation", ReservationFragment.as_view(), name="make_reservation"
-    ),
-]

reservation/views.py

@@ -1,72 +0,0 @@
-# Create your views here.
-
-from django.contrib.auth.mixins import PermissionRequiredMixin
-from django.contrib.messages.views import SuccessMessageMixin
-from django.urls import reverse, reverse_lazy
-from django.utils.translation import gettext_lazy as _
-from django.views.generic import CreateView, DeleteView, TemplateView, UpdateView
-
-from club.models import Club
-from core.auth.mixins import CanEditMixin
-from core.views import UseFragmentsMixin
-from core.views.mixins import FragmentMixin
-from reservation.forms import ReservationForm, RoomCreateForm, RoomUpdateForm
-from reservation.models import ReservationSlot, Room
-
-
-class ReservationFragment(PermissionRequiredMixin, FragmentMixin, CreateView):
-    model = ReservationSlot
-    form_class = ReservationForm
-    permission_required = "reservation.add_reservationslot"
-    template_name = "reservation/fragments/create_reservation.jinja"
-    success_url = reverse_lazy("reservation:main")
-    reload_on_redirect = True
-    object = None
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"author": self.request.user}
-
-
-class ReservationScheduleView(PermissionRequiredMixin, UseFragmentsMixin, TemplateView):
-    template_name = "reservation/schedule.jinja"
-    permission_required = "reservation.view_reservationslot"
-    fragments = {"add_slot_fragment": ReservationFragment}
-
-
-class RoomCreateView(PermissionRequiredMixin, CreateView):
-    form_class = RoomCreateForm
-    template_name = "core/create.jinja"
-    permission_required = "reservation.add_room"
-
-    def get_initial(self):
-        init = super().get_initial()
-        if "club" in self.request.GET:
-            club_id = self.request.GET["club"]
-            if club_id.isdigit() and int(club_id) > 0:
-                init["club"] = Club.objects.filter(id=int(club_id)).first()
-        return init
-
-    def get_success_url(self):
-        return reverse("club:tools", kwargs={"club_id": self.object.club_id})
-
-
-class RoomUpdateView(SuccessMessageMixin, CanEditMixin, UpdateView):
-    model = Room
-    pk_url_kwarg = "room_id"
-    form_class = RoomUpdateForm
-    template_name = "core/edit.jinja"
-    success_message = _("%(name)s was updated successfully")
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"request_user": self.request.user}
-
-    def get_success_url(self):
-        return self.request.path
-
-
-class RoomDeleteView(PermissionRequiredMixin, DeleteView):
-    model = Room
-    pk_url_kwarg = "room_id"
-    template_name = "core/delete_confirm.jinja"
-    success_url = reverse_lazy("reservation:room_list")
-    permission_required = "reservation.delete_room"