forbid past dates for product actions

Embed the timetable generator in the sith

club/forms.py

@@ -26,12 +26,16 @@ 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 SelectDate, SelectDateTime
-from core.views.widgets.ajax_select import AutoCompleteSelectMultipleUser
+from core.views.forms import SelectDateTime
+from core.views.widgets.ajax_select import (
+    AutoCompleteSelectMultipleUser,
+    AutoCompleteSelectUser,
+)
 from counter.models import Counter, Selling
 
 
@@ -188,105 +192,113 @@ class SellingsForm(forms.Form):
         )
 
 
-class ClubMemberForm(forms.Form):
-    """Form handling the members of a club."""
+class ClubOldMemberForm(forms.Form):
+    members_old = forms.ModelMultipleChoiceField(
+        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"
 
-    users = forms.ModelMultipleChoiceField(
-        label=_("Users to add"),
-        help_text=_("Search users to add (one or more)."),
-        required=False,
-        widget=AutoCompleteSelectMultipleUser,
-        queryset=User.objects.all(),
-    )
+    class Meta:
+        model = Membership
+        fields = ["role", "description"]
 
-    def __init__(self, *args, **kwargs):
-        self.club = kwargs.pop("club")
-        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()
+    def __init__(self, *args, club: Club, request_user: User, **kwargs):
+        self.club = club
+        self.request_user = request_user
         self.request_user_membership = self.club.get_membership_for(self.request_user)
         super().__init__(*args, **kwargs)
+        self.fields["role"].required = True
+        self.fields["role"].choices = [
+            (value, name)
+            for value, name in settings.SITH_CLUB_ROLES.items()
+            if value <= self.max_available_role
+        ]
+        self.instance.club = club
 
-        # Using a ModelForm binds too much the form with the model and we don't want that
-        # We want the view to process the model creation since they are multiple users
-        # We also want the form to handle bulk deletion
-        self.fields.update(
-            forms.fields_for_model(
-                Membership,
-                fields=("role", "start_date", "description"),
-                widgets={"start_date": SelectDate},
-            )
-        )
+    @property
+    def max_available_role(self):
+        """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
 
-        # 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
+class ClubAddMemberForm(ClubMemberForm):
+    """Form to add a member to the club, as a board member."""
 
-        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)
-                ]
-            ).all(),
-            label=_("Mark as old"),
-            required=False,
-            widget=forms.CheckboxSelectMultiple,
-        )
-        if not self.request_user.is_root:
-            self.fields.pop("start_date")
+    class Meta(ClubMemberForm.Meta):
+        fields = ["user", *ClubMemberForm.Meta.fields]
+        widgets = {"user": AutoCompleteSelectUser}
 
-    def clean_users(self):
-        """Check that the user is not trying to add an user already in the club.
+    @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.
         """
-        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"
-                )
-            if self.club.get_membership_for(user):
-                raise forms.ValidationError(
-                    _("You can not add the same user twice"), code="invalid"
-                )
-            users.append(user)
-        return users
+        user = self.cleaned_data["user"]
+        if not user.is_subscribed:
+            raise forms.ValidationError(
+                _("User must be subscriber to take part to a club"), code="invalid"
+            )
+        if self.club.get_membership_for(user):
+            raise forms.ValidationError(
+                _("You can not add the same user twice"), code="invalid"
+            )
+        return user
+
+
+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 user rights for adding an user."""
-        cleaned_data = super().clean()
-
-        if "start_date" in cleaned_data and not cleaned_data["start_date"]:
-            # Drop start_date if allowed to edition but not specified
-            cleaned_data.pop("start_date")
-
-        if not cleaned_data.get("users"):
-            # No user to add equals no check needed
-            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
+        """Check that the user is subscribed and isn't already in the club."""
+        if not self.request_user.is_subscribed:
+            raise forms.ValidationError(
+                _("You must be subscribed to join a club"), code="invalid"
+            )
+        if self.club.get_membership_for(self.request_user):
+            raise forms.ValidationError(
+                _("You are already a member of this club"), code="invalid"
+            )
+        return super().clean()

club/models.py

@@ -30,7 +30,8 @@ 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
+from django.db.models import Exists, F, OuterRef, Q, Value
+from django.db.models.functions import Greatest
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.functional import cached_property
@@ -209,10 +210,6 @@ 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.
 
@@ -252,6 +249,44 @@ 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.
 
@@ -328,16 +363,12 @@ 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

@@ -0,0 +1,24 @@
+#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,15 +1,33 @@
 {% 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="users_old" method="post">
+    <form action="{{ url('club:club_members', club_id=club.id) }}" id="members_old" method="post">
       {% csrf_token %}
-      {% set users_old = dict(form.users_old | groupby("choice_label")) %}
-      {% if users_old %}
-        {{ select_all_checkbox("users_old") }}
-        <p></p>
+      {% if can_end_membership %}
+        {{ select_all_checkbox("members_old") }}
+        <br />
       {% endif %}
       <table id="club_members_table">
         <thead>
@@ -18,7 +36,7 @@
             <td>{% trans %}Role{% endtrans %}</td>
             <td>{% trans %}Description{% endtrans %}</td>
             <td>{% trans %}Since{% endtrans %}</td>
-            {% if users_old %}
+            {% if can_end_membership %}
               <td>{% trans %}Mark as old{% endtrans %}</td>
             {% endif %}
           </tr>
@@ -30,20 +48,24 @@
               <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
               <td>{{ m.description }}</td>
               <td>{{ m.start_date }}</td>
-              {% if users_old %}
+              {%- if can_end_membership -%}
                 <td>
-                  {% set user_old = users_old[m.user.get_display_name()] %}
-                  {% if user_old %}
-                    {{ user_old[0].tag() }}
-                  {% endif %}
+                  {%- if m.is_editable -%}
+                    <label for="id_members_old_{{ loop.index }}"></label>
+                    <input
+                      type="checkbox"
+                      name="members_old"
+                      value="{{ m.id }}"
+                      id="id_members_old_{{ loop.index }}"
+                    >
+                  {%- endif -%}
                 </td>
-              {% endif %}
+              {%- endif -%}
             </tr>
           {% endfor %}
         </tbody>
       </table>
-      {{ form.users_old.errors }}
-      {% if users_old %}
+      {% if can_end_membership %}
         <p></p>
         <input type="submit" name="submit" value="{% trans %}Mark as old{% endtrans %}">
       {% endif %}
@@ -51,32 +73,4 @@
   {% 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,20 +5,22 @@
   <h2>{% trans %}Club old members{% endtrans %}</h2>
   <table>
     <thead>
-      <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>
+        <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 m in club.members.exclude(end_date=None).order_by('-role', 'description', '-end_date').all() %}
+      {% for member in old_members %}
         <tr>
-          <td>{{ user_profile_link(m.user) }}</td>
-          <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
-          <td>{{ m.description }}</td>
-          <td>{{ m.start_date }}</td>
-          <td>{{ m.end_date }}</td>
+          <td>{{ user_profile_link(member.user) }}</td>
+          <td>{{ settings.SITH_CLUB_ROLES[member.role] }}</td>
+          <td>{{ member.description }}</td>
+          <td>{{ member.start_date }}</td>
+          <td>{{ member.end_date }}</td>
         </tr>
       {% endfor %}
     </tbody>

club/templates/club/fragments/add_member.jinja

@@ -0,0 +1,46 @@
+<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,6 +43,9 @@ 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_membership.py

@@ -1,13 +1,20 @@
+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 ClubMemberForm
-from club.models import Membership
+from club.forms import ClubAddMemberForm, JoinClubForm
+from club.models import Club, Membership
 from club.tests.base import TestClub
 from core.baker_recipes import subscriber_user
 from core.models import AnonymousUser, User
@@ -137,6 +144,38 @@ 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."""
@@ -151,7 +190,7 @@ class TestMembership(TestClub):
 
     def assert_membership_ended_today(self, user: User):
         """Assert that the given user have a membership which ended today."""
-        today = localtime(now()).date()
+        today = localdate()
         assert user.memberships.filter(club=self.club, end_date=today).exists()
         assert self.club.get_membership_for(user) is None
 
@@ -160,7 +199,9 @@ class TestMembership(TestClub):
         cannot see the page.
         """
         response = self.client.post(self.members_url)
-        assert response.status_code == 403
+        assertRedirects(
+            response, reverse("core:login", query={"next": self.members_url})
+        )
 
         self.client.force_login(self.public)
         response = self.client.post(self.members_url)
@@ -171,7 +212,9 @@ class TestMembership(TestClub):
         information are displayed.
         """
         self.client.force_login(self.simple_board_member)
-        response = self.client.get(self.members_url)
+        response = self.client.get(
+            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")
@@ -197,59 +240,45 @@ class TestMembership(TestClub):
             assert cols[2].text == membership.description
             assert cols[3].text == str(membership.start_date)
 
-            if membership.role <= 3:  # 3 is the role of simple_board_member
+            if membership.role < 3 or membership.user_id == self.simple_board_member.id:
+                # 3 is the role of simple_board_member
                 form_input = cols[4].find("input")
                 expected_attrs = {
                     "type": "checkbox",
-                    "name": "users_old",
-                    "value": str(user.id),
+                    "name": "members_old",
+                    "value": str(membership.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, one at a time."""
+        """Test that root users can add members to clubs"""
         self.client.force_login(self.root)
         response = self.client.post(
-            self.members_url,
-            {"users": [self.subscriber.id], "role": 3},
+            self.new_members_url, {"user": 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 = ClubMemberForm(
-                data={"users": [user.id], "role": 1},
+            form = ClubAddMemberForm(
+                data={"user": user.id, "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
 
             assert not form.is_valid()
             assert form.errors == {
-                "users": [
-                    "L'utilisateur doit être cotisant pour faire partie d'un club"
-                ]
+                "user": ["L'utilisateur doit être cotisant pour faire partie d'un club"]
             }
 
     def test_add_members_already_members(self):
@@ -281,16 +310,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 = ClubMemberForm(
-                data={"users": members, "role": 1},
+            form = ClubAddMemberForm(
+                data={"user": members, "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
             assert not form.is_valid()
             assert form.errors == {
-                "users": [
+                "user": [
                     "Sélectionnez un choix valide. "
-                    f"{max_id + 1} n\u2019en fait pas partie."
+                    "Ce choix ne fait pas partie de ceux disponibles."
                 ]
             }
         self.club.refresh_from_db()
@@ -303,10 +332,12 @@ class TestMembership(TestClub):
         nb_subscriber_memberships = self.subscriber.memberships.count()
         self.client.force_login(president)
         response = self.client.post(
-            self.members_url,
-            {"users": self.subscriber.id, "role": 9},
+            self.new_members_url, {"user": 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
@@ -317,8 +348,8 @@ class TestMembership(TestClub):
         """Test that a member of the club member cannot create
         a membership with a greater role than its own.
         """
-        form = ClubMemberForm(
-            data={"users": [self.subscriber.id], "role": 10},
+        form = ClubAddMemberForm(
+            data={"user": self.subscriber.id, "role": 10},
             request_user=self.simple_board_member,
             club=self.club,
         )
@@ -326,7 +357,7 @@ class TestMembership(TestClub):
 
         assert not form.is_valid()
         assert form.errors == {
-            "__all__": ["Vous n'avez pas la permission de faire cela"]
+            "role": ["Sélectionnez un choix valide. 10 n\u2019en fait pas partie."]
         }
         self.club.refresh_from_db()
         assert nb_memberships == self.club.members.count()
@@ -334,23 +365,53 @@ class TestMembership(TestClub):
 
     def test_add_member_without_role(self):
         """Test that trying to add members without specifying their role fails."""
-        self.client.force_login(self.root)
-        form = ClubMemberForm(
-            data={"users": [self.subscriber.id]},
-            request_user=self.simple_board_member,
-            club=self.club,
+        form = ClubAddMemberForm(
+            data={"user": self.subscriber.id}, request_user=self.root, club=self.club
         )
 
         assert not form.is_valid()
-        assert form.errors == {"role": ["Vous devez choisir un rôle"]}
+        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 == {
+                "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)
-        self.client.post(
-            self.members_url,
-            {"users_old": self.simple_board_member.id},
-        )
+        membership = self.club.members.get(end_date=None, user=self.simple_board_member)
+        self.client.post(self.members_url, {"members_old": [membership.id]})
         self.simple_board_member.refresh_from_db()
         self.assert_membership_ended_today(self.simple_board_member)
 
@@ -358,15 +419,13 @@ class TestMembership(TestClub):
         """Test that board members of the club can end memberships
         of users with lower roles.
         """
-        # remainder : simple_board_member has role 3, president has role 10, richard has role 1
+        # reminder : simple_board_member has role 3
         self.client.force_login(self.simple_board_member)
-        response = self.client.post(
-            self.members_url,
-            {"users_old": self.richard.id},
-        )
+        membership = baker.make(Membership, club=self.club, role=2, end_date=None)
+        response = self.client.post(self.members_url, {"members_old": [membership.id]})
         self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
-        self.assert_membership_ended_today(self.richard)
+        self.assert_membership_ended_today(membership.user)
 
     def test_end_membership_higher_role(self):
         """Test that board members of the club cannot end memberships
@@ -374,46 +433,30 @@ 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,
-            {"users_old": self.president.id},
-        )
+        self.client.post(self.members_url, {"members_old": [membership.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 = self.president.memberships.filter(club=self.club).first()
+        membership.refresh_from_db()
         assert membership.end_date is None
 
-    def test_end_membership_as_main_club_board(self):
-        """Test that board members of the main club can end the membership
-        of anyone.
-        """
+    def test_end_membership_with_permission(self):
+        """Test that users with permission can end any membership."""
         # 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(subscriber)
+        self.client.force_login(
+            subscriber_user.make(
+                user_permissions=[Permission.objects.get(codename="change_membership")]
+            )
+        )
+        president_membership = self.club.president
         response = self.client.post(
-            self.members_url,
-            {"users_old": self.president.id},
+            self.members_url, {"members_old": [president_membership.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_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)
+        self.assert_membership_ended_today(president_membership.user)
         assert self.club.members.ongoing().count() == nb_memberships - 1
 
     def test_end_membership_as_foreigner(self):
@@ -421,14 +464,11 @@ 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,
-            {"users_old": [self.richard.id]},
-        )
+        self.client.post(self.members_url, {"members_old": [self.richard.id]})
         # nothing should have changed
-        new_mem = self.club.get_membership_for(self.richard)
+        membership.refresh_from_db()
         assert self.club.members.count() == nb_memberships
-        assert membership == new_mem
+        assert membership.end_date is None
 
     def test_remove_from_club_group(self):
         """Test that when a membership ends, the user is removed from club groups."""
@@ -490,3 +530,85 @@ 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/urls.py

@@ -25,6 +25,7 @@
 from django.urls import path
 
 from club.views import (
+    ClubAddMembersFragment,
     ClubCreateView,
     ClubEditView,
     ClubListView,
@@ -60,6 +61,11 @@ 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,30 +23,31 @@
 #
 
 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 Sum
-from django.http import (
-    Http404,
-    HttpResponseRedirect,
-    StreamingHttpResponse,
-)
+from django.db.models import Q, Sum
+from django.http import Http404, HttpResponseRedirect, StreamingHttpResponse
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse, reverse_lazy
 from django.utils import timezone
-from django.utils.functional import cached_property
+from django.utils.safestring import SafeString
+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,
-    ClubMemberForm,
+    ClubOldMemberForm,
+    JoinClubForm,
     MailingForm,
     SellingsForm,
 )
@@ -58,13 +59,10 @@ from com.views import (
     PosterEditBaseView,
     PosterListBaseView,
 )
-from core.auth.mixins import (
-    CanEditMixin,
-    CanViewMixin,
-)
+from core.auth.mixins import CanEditMixin
 from core.models import PageRev
-from core.views import DetailFormView, PageEditViewBase
-from core.views.mixins import TabedViewMixin
+from core.views import DetailFormView, PageEditViewBase, UseFragmentsMixin
+from core.views.mixins import FragmentMixin, FragmentRenderer, TabedViewMixin
 from counter.models import Selling
 
 
@@ -86,7 +84,7 @@ class ClubTabsMixin(TabedViewMixin):
                 "name": _("Infos"),
             }
         ]
-        if self.request.user.can_view(self.object):
+        if self.request.user.has_perm("club.view_club"):
             tab_list.extend(
                 [
                     {
@@ -105,16 +103,16 @@ class ClubTabsMixin(TabedViewMixin):
                     },
                 ]
             )
-        if self.object.page:
-            tab_list.append(
-                {
-                    "url": reverse(
-                        "club:club_hist", kwargs={"club_id": self.object.id}
-                    ),
-                    "slug": "history",
-                    "name": _("History"),
-                }
-            )
+            if self.object.page:
+                tab_list.append(
+                    {
+                        "url": reverse(
+                            "club:club_hist", kwargs={"club_id": self.object.id}
+                        ),
+                        "slug": "history",
+                        "name": _("History"),
+                    }
+                )
         if self.request.user.can_edit(self.object):
             tab_list.extend(
                 [
@@ -235,13 +233,14 @@ class ClubPageEditView(ClubTabsMixin, PageEditViewBase):
         return reverse_lazy("club:club_view", kwargs={"club_id": self.club.id})
 
 
-class ClubPageHistView(ClubTabsMixin, CanViewMixin, DetailView):
+class ClubPageHistView(ClubTabsMixin, PermissionRequiredMixin, 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):
@@ -253,57 +252,121 @@ class ClubToolsView(ClubTabsMixin, CanEditMixin, DetailView):
     current_tab = "tools"
 
 
-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 = ClubMemberForm
+    form_class = ClubOldMemberForm
     template_name = "club/club_members.jinja"
     current_tab = "members"
+    permission_required = "club.view_club"
 
-    @cached_property
-    def members(self) -> list[Membership]:
-        return list(self.object.members.ongoing().order_by("-role"))
+    def get_fragments(self) -> dict[str, type[FragmentMixin] | FragmentRenderer]:
+        membership = self.object.get_membership_for(self.request.user)
+        if (
+            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):
-        kwargs = super().get_form_kwargs()
-        kwargs["request_user"] = self.request.user
-        kwargs["club"] = self.object
-        kwargs["club_members"] = self.members
-        return kwargs
+        return super().get_form_kwargs() | {
+            "user": self.request.user,
+            "club": self.object,
+        }
 
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)
-        kwargs["members"] = self.members
+        editable = list(
+            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):
-        """Check user rights."""
-        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()
+        for membership in form.cleaned_data.get("members_old"):
+            membership.end_date = now()
             membership.save()
-        return resp
+        return super().form_valid(form)
 
     def get_success_url(self, **kwargs):
         return self.request.path
 
 
-class ClubOldMembersView(ClubTabsMixin, CanViewMixin, DetailView):
+class ClubOldMembersView(ClubTabsMixin, PermissionRequiredMixin, 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):

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

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

com/templates/com/macros.jinja

@@ -76,18 +76,20 @@
               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 moderated news as soon as they see them),
+            (if they do their job and moderate 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()"
-              {% else %}
+              {%- elif news.is_published -%}
+                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

@@ -205,6 +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>

core/models.py

@@ -651,9 +651,6 @@ class User(AbstractUser):
 
 
 class AnonymousUser(AuthAnonymousUser):
-    def __init__(self):
-        super().__init__()
-
     @property
     def was_subscribed(self):
         return False
@@ -662,10 +659,6 @@ class AnonymousUser(AuthAnonymousUser):
     def is_subscribed(self):
         return False
 
-    @property
-    def subscribed(self):
-        return False
-
     @property
     def is_root(self):
         return False

core/static/bundled/alpine-index.js

@@ -1,9 +1,8 @@
-import { limitedChoices } from "#core:alpine/limited-choices";
 import { alpinePlugin } from "#core:utils/notifications";
 import sort from "@alpinejs/sort";
 import Alpine from "alpinejs";
 
-Alpine.plugin([sort, limitedChoices]);
+Alpine.plugin(sort);
 Alpine.magic("notifications", alpinePlugin);
 window.Alpine = Alpine;
 

core/static/bundled/alpine/limited-choices.ts

@@ -1,69 +0,0 @@
-import type { Alpine as AlpineType } from "alpinejs";
-
-export function limitedChoices(Alpine: AlpineType) {
-  /**
-   * Directive to limit the number of elements
-   * that can be selected in a group of checkboxes.
-   *
-   * When the max numbers of selectable elements is reached,
-   * new elements will still be inserted, but oldest ones will be deselected.
-   * For example, if checkboxes A, B and C have been selected and the max
-   * number of selections is 3, then selecting D will result in having
-   * B, C and D selected.
-   *
-   * # Example in template
-   * ```html
-   * <div x-data="{nbMax: 2}", x-limited-choices="nbMax">
-   *   <button @click="nbMax += 1">Click me to increase the limit</button>
-   *   <input type="checkbox" value="A" name="foo">
-   *   <input type="checkbox" value="B" name="foo">
-   *   <input type="checkbox" value="C" name="foo">
-   *   <input type="checkbox" value="D" name="foo">
-   * </div>
-   * ```
-   */
-  Alpine.directive(
-    "limited-choices",
-    (el, { expression }, { evaluateLater, effect }) => {
-      const getMaxChoices = evaluateLater(expression);
-      let maxChoices: number;
-      const inputs: HTMLInputElement[] = Array.from(
-        el.querySelectorAll("input[type='checkbox']"),
-      );
-      const checked = [] as HTMLInputElement[];
-
-      const manageDequeue = () => {
-        if (checked.length <= maxChoices) {
-          // There isn't too many checkboxes selected. Nothing to do
-          return;
-        }
-        const popped = checked.splice(0, checked.length - maxChoices);
-        for (const p of popped) {
-          p.checked = false;
-        }
-      };
-
-      for (const input of inputs) {
-        input.addEventListener("change", (_e) => {
-          if (input.checked) {
-            checked.push(input);
-          } else {
-            checked.splice(checked.indexOf(input), 1);
-          }
-          manageDequeue();
-        });
-      }
-      effect(() => {
-        getMaxChoices((value: string) => {
-          const previousValue = maxChoices;
-          maxChoices = Number.parseInt(value);
-          if (maxChoices < previousValue) {
-            // The maximum number of selectable items has been lowered.
-            // Some currently selected elements may need to be removed
-            manageDequeue();
-          }
-        });
-      });
-    },
-  );
-}

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

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

core/static/core/forms.scss

@@ -47,6 +47,7 @@
   }
 
   input,
+  select,
   textarea[type="text"],
   [type="number"],
   .ts-control {
@@ -153,10 +154,8 @@ form {
     margin-bottom: 1rem;
   }
 
-  .row {
-    label {
-      margin: unset;
-    }
+  .row > label {
+    margin: unset;
   }
 
   // ------------- LABEL
@@ -240,6 +239,23 @@ 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/style.scss

@@ -506,6 +506,10 @@ th {
   >ul {
     margin-top: 0;
   }
+
+  >input[type="checkbox"] {
+    padding: unset;
+  }
 }
 
 td {

core/templates/core/base/header.jinja

@@ -77,22 +77,22 @@
         <div class="notification" x-data="{display: false}" :class="{white: display}">
           <a href="#" @click.prevent="display = !display">
             <i :class="`fa-${display ? 'solid': 'regular'} fa-bell`" x-transition></i>
-            {% set notification_count = user.notifications.filter(viewed=False).count() %}
+            {% set notifications = user.notifications.filter(viewed=False).order_by("-date")|list %}
 
-            {% if notification_count > 0 %}
+            {%- if notifications|length > 0 -%}
               <span>
-                {% if notification_count < 100 %}
-                  {{ notification_count }}
-                {% else %}
-                  &nbsp;
-                {% endif %}
+                {% if notifications|length < 100 %}
+                  {{ notifications|length }}
+                {%- else -%}
+                  99+
+                {%- endif -%}
               </span>
             {% endif %}
           </a>
           <div id="header_notif" x-show="display" x-cloak x-transition @click.outside="display = false">
             <ul>
-              {% if user.notifications.filter(viewed=False).count() > 0 %}
-                {% for n in user.notifications.filter(viewed=False).order_by('-date') %}
+              {%- if notifications|length > 0 -%}
+                {%- for n in notifications -%}
                   <li>
                     <a href="{{ url("core:notification", notif_id=n.id) }}">
                       <div class="datetime">
@@ -108,10 +108,10 @@
                       </div>
                     </a>
                   </li>
-                {% endfor %}
-              {% else %}
+                {%- endfor -%}
+              {%- 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/widgets/autocomplete_select.jinja

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

core/views/forms.py

@@ -115,7 +115,7 @@ class SelectUser(TextInput):
 
 def validate_future_timestamp(value: date | datetime):
     if value <= now():
-        raise ValueError(_("Ensure this timestamp is set in the future"))
+        raise ValidationError(_("Ensure this timestamp is set in the future"))
 
 
 class FutureDateTimeField(forms.DateTimeField):

counter/forms.py

@@ -1,13 +1,23 @@
+import json
 import math
+import uuid
 
 from django import forms
 from django.db.models import Q
+from django.forms import BaseModelFormSet
+from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
+from django_celery_beat.models import ClockedSchedule
 from phonenumber_field.widgets import RegionalPhoneNumberWidget
 
 from club.widgets.ajax_select import AutoCompleteSelectClub
 from core.models import User
-from core.views.forms import NFCTextInput, SelectDate, SelectDateTime
+from core.views.forms import (
+    FutureDateTimeField,
+    NFCTextInput,
+    SelectDate,
+    SelectDateTime,
+)
 from core.views.widgets.ajax_select import (
     AutoCompleteSelect,
     AutoCompleteSelectMultipleGroup,
@@ -22,7 +32,9 @@ from counter.models import (
     Product,
     Refilling,
     ReturnableProduct,
+    ScheduledProductAction,
     StudentCard,
+    get_product_actions,
 )
 from counter.widgets.ajax_select import (
     AutoCompleteSelectMultipleCounter,
@@ -158,7 +170,101 @@ class CounterEditForm(forms.ModelForm):
         }
 
 
-class ProductEditForm(forms.ModelForm):
+class ScheduledProductActionForm(forms.ModelForm):
+    """Form for automatic product archiving.
+
+    The `save` method will update or create tasks using celery-beat.
+    """
+
+    required_css_class = "required"
+    prefix = "scheduled"
+
+    class Meta:
+        model = ScheduledProductAction
+        fields = ["task"]
+        widgets = {"task": forms.RadioSelect(choices=get_product_actions)}
+        labels = {"task": _("Action")}
+        help_texts = {"task": ""}
+
+    trigger_at = FutureDateTimeField(
+        label=_("Date and time of action"), widget=SelectDateTime
+    )
+    counters = forms.ModelMultipleChoiceField(
+        label=_("New counters"),
+        help_text=_("The selected counters will replace the current ones"),
+        required=False,
+        widget=AutoCompleteSelectMultipleCounter,
+        queryset=Counter.objects.all(),
+    )
+
+    def __init__(self, *args, product: Product, **kwargs):
+        self.product = product
+        super().__init__(*args, **kwargs)
+        if not self.instance._state.adding:
+            self.fields["trigger_at"].initial = self.instance.clocked.clocked_time
+            self.fields["counters"].initial = json.loads(self.instance.kwargs).get(
+                "counters"
+            )
+
+    def clean(self):
+        if not self.changed_data or "trigger_at" in self.errors:
+            return super().clean()
+        if "trigger_at" in self.changed_data:
+            if not self.instance.clocked_id:
+                self.instance.clocked = ClockedSchedule(
+                    clocked_time=self.cleaned_data["trigger_at"]
+                )
+            else:
+                self.instance.clocked.clocked_time = self.cleaned_data["trigger_at"]
+            self.instance.clocked.save()
+        task_kwargs = {"product_id": self.product.id}
+        if (
+            self.cleaned_data["task"] == "counter.tasks.change_counters"
+            and "counters" in self.changed_data
+        ):
+            task_kwargs["counters"] = [c.id for c in self.cleaned_data["counters"]]
+        self.instance.product = self.product
+        self.instance.kwargs = json.dumps(task_kwargs)
+        self.instance.name = (
+            f"{self.cleaned_data['task']} - {self.product} - {uuid.uuid4()}"
+        )
+        return super().clean()
+
+
+class BaseScheduledProductActionFormSet(BaseModelFormSet):
+    def __init__(self, *args, product: Product, **kwargs):
+        if product.id:
+            queryset = (
+                product.scheduled_actions.filter(
+                    enabled=True, clocked__clocked_time__gt=now()
+                )
+                .order_by("clocked__clocked_time")
+                .select_related("clocked")
+            )
+        else:
+            queryset = ScheduledProductAction.objects.none()
+        form_kwargs = {"product": product}
+        super().__init__(*args, queryset=queryset, form_kwargs=form_kwargs, **kwargs)
+
+    def delete_existing(self, obj: ScheduledProductAction, commit: bool = True):  # noqa FBT001
+        clocked = obj.clocked
+        super().delete_existing(obj, commit=commit)
+        if commit:
+            clocked.delete()
+
+
+ScheduledProductActionFormSet = forms.modelformset_factory(
+    ScheduledProductAction,
+    ScheduledProductActionForm,
+    formset=BaseScheduledProductActionFormSet,
+    absolute_max=None,
+    can_delete=True,
+    can_delete_extra=False,
+    extra=2,
+)
+
+
+class ProductForm(forms.ModelForm):
     error_css_class = "error"
     required_css_class = "required"
 
@@ -199,22 +305,21 @@ class ProductEditForm(forms.ModelForm):
         queryset=Counter.objects.all(),
     )
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    def __init__(self, *args, instance=None, **kwargs):
+        super().__init__(*args, instance=instance, **kwargs)
         if self.instance.id:
             self.fields["counters"].initial = self.instance.counters.all()
+        self.action_formset = ScheduledProductActionFormSet(
+            *args, product=self.instance, **kwargs
+        )
+
+    def is_valid(self):
+        return super().is_valid() and self.action_formset.is_valid()
 
     def save(self, *args, **kwargs):
         ret = super().save(*args, **kwargs)
-        if self.fields["counters"].initial:
-            # Remove the product from all counter it was added to
-            # It will then only be added to selected counters
-            for counter in self.fields["counters"].initial:
-                counter.products.remove(self.instance)
-                counter.save()
-        for counter in self.cleaned_data["counters"]:
-            counter.products.add(self.instance)
-            counter.save()
+        self.instance.counters.set(self.cleaned_data["counters"])
+        self.action_formset.save()
         return ret
 
 
@@ -266,7 +371,7 @@ class CloseCustomerAccountForm(forms.Form):
     )
 
 
-class ProductForm(forms.Form):
+class BasketProductForm(forms.Form):
     quantity = forms.IntegerField(min_value=1, required=True)
     id = forms.IntegerField(min_value=0, required=True)
 
@@ -371,5 +476,5 @@ class BaseBasketForm(forms.BaseFormSet):
 
 
 BasketForm = forms.formset_factory(
-    ProductForm, formset=BaseBasketForm, absolute_max=None, min_num=1
+    BasketProductForm, formset=BaseBasketForm, absolute_max=None, min_num=1
 )

counter/migrations/0032_scheduledproductaction.py

@@ -0,0 +1,40 @@
+# Generated by Django 5.2.3 on 2025-09-14 11:29
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("counter", "0031_alter_counter_options"),
+        ("django_celery_beat", "0019_alter_periodictasks_options"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ScheduledProductAction",
+            fields=[
+                (
+                    "periodictask_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="django_celery_beat.periodictask",
+                    ),
+                ),
+                (
+                    "product",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="scheduled_actions",
+                        to="counter.product",
+                    ),
+                ),
+            ],
+            options={"verbose_name": "Product scheduled action"},
+            bases=("django_celery_beat.periodictask",),
+        ),
+    ]

counter/models.py

@@ -34,6 +34,7 @@ from django.urls import reverse
 from django.utils import timezone
 from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
+from django_celery_beat.models import PeriodicTask
 from django_countries.fields import CountryField
 from ordered_model.models import OrderedModel
 from phonenumber_field.modelfields import PhoneNumberField
@@ -445,7 +446,8 @@ class Product(models.Model):
         buying_groups = list(self.buying_groups.all())
         if not buying_groups:
             return True
-        return any(user.is_in_group(pk=group.id) for group in buying_groups)
+        res = any(user.is_in_group(pk=group.id) for group in buying_groups)
+        return res
 
     @property
     def profit(self):
@@ -479,7 +481,7 @@ class CounterQuerySet(models.QuerySet):
         return self.annotate(has_annotated_barman=Exists(subquery))
 
     def annotate_is_open(self) -> Self:
-        """Annotate tue queryset with the `is_open` field.
+        """Annotate the queryset with the `is_open` field.
 
         For each counter, if `is_open=True`, then the counter is currently opened.
         Else the counter is closed.
@@ -1357,3 +1359,39 @@ class ReturnableProductBalance(models.Model):
             f"return balance of {self.customer} "
             f"for {self.returnable.product_id} : {self.balance}"
         )
+
+
+def get_product_actions():
+    return [
+        ("counter.tasks.archive_product", _("Archiving")),
+        ("counter.tasks.change_counters", _("Counters change")),
+    ]
+
+
+class ScheduledProductAction(PeriodicTask):
+    """Extension of celery-beat tasks dedicated to perform actions on Product."""
+
+    product = models.ForeignKey(
+        Product, related_name="scheduled_actions", on_delete=models.CASCADE
+    )
+
+    class Meta:
+        verbose_name = _("Product scheduled action")
+
+    def __init__(self, *args, **kwargs):
+        self._meta.get_field("task").choices = get_product_actions()
+        super().__init__(*args, **kwargs)
+
+    def full_clean(self, *args, **kwargs):
+        self.one_off = True  # A product action should occur one time only
+        return super().full_clean(*args, **kwargs)
+
+    def clean_clocked(self):
+        if not self.clocked:
+            raise ValidationError(_("Product actions must declare a clocked schedule."))
+
+    def validate_unique(self, *args, **kwargs):
+        # The checks done in PeriodicTask.validate_unique aren't
+        # adapted in the case of scheduled product action,
+        # so we skip it and execute directly Model.validate_unique
+        return super(PeriodicTask, self).validate_unique(*args, **kwargs)

counter/static/counter/css/counter-click.scss

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

counter/tasks.py

@@ -0,0 +1,19 @@
+# Create your tasks here
+
+from celery import shared_task
+
+from counter.models import Counter, Product
+
+
+@shared_task
+def archive_product(*, product_id: int, **kwargs):
+    product = Product.objects.get(id=product_id)
+    product.archived = True
+    product.save()
+
+
+@shared_task
+def change_counters(*, product_id: int, counters: list[int], **kwargs):
+    product = Product.objects.get(id=product_id)
+    counters = Counter.objects.filter(id__in=counters)
+    product.counters.set(counters)

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/templates/counter/product_form.jinja

@@ -0,0 +1,56 @@
+{% extends "core/base.jinja" %}
+
+{% block content %}
+  {% if object %}
+    <h2>{% trans name=object %}Edit product {{ name }}{% endtrans %}</h2>
+  {% else %}
+    <h2>{% trans %}Product creation{% endtrans %}</h2>
+  {% endif %}
+  <form method="post">
+    {% csrf_token %}
+    {{ form.as_p() }}
+
+    <br />
+
+    <h3>{% trans %}Automatic actions{% endtrans %}</h3>
+
+    <p class="margin-bottom">
+      <em>
+        {%- trans trimmed -%}
+          Automatic actions allows to schedule product changes
+          ahead of time.
+        {%- endtrans -%}
+      </em>
+    </p>
+
+    {{ form.action_formset.management_form }}
+    {%- for action_form in form.action_formset.forms -%}
+      <fieldset x-data="{action: '{{ action_form.task.initial }}'}">
+        {{ action_form.non_field_errors() }}
+        <div class="row gap-2x margin-bottom">
+          <div>
+            {{ action_form.task.errors }}
+            {{ action_form.task.label_tag() }}
+            {{ action_form.task|add_attr("x-model=action") }}
+          </div>
+          <div>{{ action_form.trigger_at.as_field_group() }}</div>
+        </div>
+        <div x-show="action==='counter.tasks.change_counters'" class="margin-bottom">
+          {{ action_form.counters.as_field_group() }}
+        </div>
+        {%- if action_form.DELETE -%}
+          <div class="row gap">
+            {{ action_form.DELETE.as_field_group() }}
+          </div>
+        {%- endif -%}
+        {%- for field in action_form.hidden_fields() -%}
+          {{ field }}
+        {%- endfor -%}
+      </fieldset>
+      {%- if not loop.last -%}
+        <hr class="margin-bottom">
+      {%- endif -%}
+    {%- endfor -%}
+    <p><input type="submit" value="{% trans %}Save{% endtrans %}" /></p>
+  </form>
+{% endblock %}

counter/tests/test_auto_actions.py

@@ -0,0 +1,116 @@
+import json
+from datetime import timedelta
+
+import pytest
+from django.conf import settings
+from django.test import Client
+from django.urls import reverse
+from django.utils.timezone import now
+from django_celery_beat.models import ClockedSchedule
+from model_bakery import baker
+
+from core.models import Group, User
+from counter.baker_recipes import counter_recipe, product_recipe
+from counter.forms import ScheduledProductActionForm, ScheduledProductActionFormSet
+from counter.models import ScheduledProductAction
+
+
+@pytest.mark.django_db
+def test_edit_product(client: Client):
+    client.force_login(
+        baker.make(
+            User, groups=[Group.objects.get(id=settings.SITH_GROUP_COUNTER_ADMIN_ID)]
+        )
+    )
+    product = product_recipe.make()
+    url = reverse("counter:product_edit", kwargs={"product_id": product.id})
+    res = client.get(url)
+    assert res.status_code == 200
+
+    res = client.post(url, data={})
+    # This is actually a failure, but we just want to check that
+    # we don't have a 403 or a 500.
+    # The actual behaviour will be tested directly on the form.
+    assert res.status_code == 200
+
+
+@pytest.mark.django_db
+class TestProductActionForm:
+    def test_single_form_archive(self):
+        product = product_recipe.make()
+        trigger_at = now() + timedelta(minutes=10)
+        form = ScheduledProductActionForm(
+            product=product,
+            data={
+                "scheduled-task": "counter.tasks.archive_product",
+                "scheduled-trigger_at": trigger_at,
+            },
+        )
+        assert form.is_valid()
+        instance = form.save()
+        assert instance.clocked.clocked_time == trigger_at
+        assert instance.enabled is True
+        assert instance.one_off is True
+        assert instance.task == "counter.tasks.archive_product"
+        assert instance.kwargs == json.dumps({"product_id": product.id})
+
+    def test_single_form_change_counters(self):
+        product = product_recipe.make()
+        counter = counter_recipe.make()
+        trigger_at = now() + timedelta(minutes=10)
+        form = ScheduledProductActionForm(
+            product=product,
+            data={
+                "scheduled-task": "counter.tasks.change_counters",
+                "scheduled-trigger_at": trigger_at,
+                "scheduled-counters": [counter.id],
+            },
+        )
+        assert form.is_valid()
+        instance = form.save()
+        instance.refresh_from_db()
+        assert instance.clocked.clocked_time == trigger_at
+        assert instance.enabled is True
+        assert instance.one_off is True
+        assert instance.task == "counter.tasks.change_counters"
+        assert instance.kwargs == json.dumps(
+            {"product_id": product.id, "counters": [counter.id]}
+        )
+
+    def test_delete(self):
+        product = product_recipe.make()
+        clocked = baker.make(ClockedSchedule, clocked_time=now() + timedelta(minutes=2))
+        task = baker.make(
+            ScheduledProductAction,
+            product=product,
+            one_off=True,
+            clocked=clocked,
+            task="counter.tasks.archive_product",
+        )
+        formset = ScheduledProductActionFormSet(product=product)
+        formset.delete_existing(task)
+        assert not ScheduledProductAction.objects.filter(id=task.id).exists()
+        assert not ClockedSchedule.objects.filter(id=clocked.id).exists()
+
+
+@pytest.mark.django_db
+class TestProductActionFormSet:
+    def test_ok(self):
+        product = product_recipe.make()
+        counter = counter_recipe.make()
+        trigger_at = now() + timedelta(minutes=10)
+        formset = ScheduledProductActionFormSet(
+            product=product,
+            data={
+                "form-TOTAL_FORMS": "2",
+                "form-INITIAL_FORMS": "0",
+                "form-0-task": "counter.tasks.archive_product",
+                "form-0-trigger_at": trigger_at,
+                "form-1-task": "counter.tasks.change_counters",
+                "form-1-trigger_at": trigger_at,
+                "form-1-counters": [counter.id],
+            },
+        )
+        assert formset.is_valid()
+        formset.save()
+        assert ScheduledProductAction.objects.filter(product=product).count() == 2

counter/tests/test_product.py

@@ -6,14 +6,16 @@ import pytest
 from django.conf import settings
 from django.core.cache import cache
 from django.core.files.uploadedfile import SimpleUploadedFile
-from django.test import Client
+from django.test import Client, TestCase
 from django.urls import reverse
 from model_bakery import baker
 from PIL import Image
-from pytest_django.asserts import assertNumQueries
+from pytest_django.asserts import assertNumQueries, assertRedirects
 
+from club.models import Club
 from core.baker_recipes import board_user, subscriber_user
 from core.models import Group, User
+from counter.forms import ProductForm
 from counter.models import Product, ProductType
 
 
@@ -84,3 +86,49 @@ def test_fetch_product_nb_queries(client: Client):
         # - 1 for the actual request
         # - 1 to prefetch the related buying_groups
         client.get(reverse("api:search_products_detailed"))
+
+
+class TestCreateProduct(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.product_type = baker.make(ProductType)
+        cls.club = baker.make(Club)
+        cls.data = {
+            "name": "foo",
+            "description": "bar",
+            "product_type": cls.product_type.id,
+            "club": cls.club.id,
+            "code": "FOO",
+            "purchase_price": 1.0,
+            "selling_price": 1.0,
+            "special_selling_price": 1.0,
+            "limit_age": 0,
+            "form-TOTAL_FORMS": 0,
+            "form-INITIAL_FORMS": 0,
+        }
+
+    def test_form(self):
+        form = ProductForm(data=self.data)
+        assert form.is_valid()
+        instance = form.save()
+        assert instance.club == self.club
+        assert instance.product_type == self.product_type
+        assert instance.name == "foo"
+        assert instance.selling_price == 1.0
+
+    def test_view(self):
+        self.client.force_login(
+            baker.make(
+                User,
+                groups=[Group.objects.get(id=settings.SITH_GROUP_COUNTER_ADMIN_ID)],
+            )
+        )
+        url = reverse("counter:new_product")
+        response = self.client.get(url)
+        assert response.status_code == 200
+        response = self.client.post(url, data=self.data)
+        assertRedirects(response, reverse("counter:product_list"))
+        product = Product.objects.last()
+        assert product.name == "foo"
+        assert product.club == self.club
+        assert product.product_type == self.product_type

counter/views/admin.py

@@ -32,7 +32,7 @@ from core.utils import get_semester_code, get_start_of_semester
 from counter.forms import (
     CloseCustomerAccountForm,
     CounterEditForm,
-    ProductEditForm,
+    ProductForm,
     ReturnableProductForm,
 )
 from counter.models import (
@@ -146,8 +146,8 @@ class ProductCreateView(CounterAdminTabsMixin, CounterAdminMixin, CreateView):
     """A create view for the admins."""
 
     model = Product
-    form_class = ProductEditForm
-    template_name = "core/create.jinja"
+    form_class = ProductForm
+    template_name = "counter/product_form.jinja"
     current_tab = "products"
 
 
@@ -155,9 +155,9 @@ class ProductEditView(CounterAdminTabsMixin, CounterAdminMixin, UpdateView):
     """An edit view for the admins."""
 
     model = Product
-    form_class = ProductEditForm
+    form_class = ProductForm
     pk_url_kwarg = "product_id"
-    template_name = "core/edit.jinja"
+    template_name = "counter/product_form.jinja"
     current_tab = "products"
 
 

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

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

eboutic/views.py

@@ -48,7 +48,7 @@ from django_countries.fields import Country
 
 from core.auth.mixins import CanViewMixin
 from core.views.mixins import FragmentMixin, UseFragmentsMixin
-from counter.forms import BaseBasketForm, BillingInfoForm, ProductForm
+from counter.forms import BaseBasketForm, BasketProductForm, BillingInfoForm
 from counter.models import (
     BillingInfo,
     Customer,
@@ -78,7 +78,7 @@ class BaseEbouticBasketForm(BaseBasketForm):
 
 
 EbouticBasketForm = forms.formset_factory(
-    ProductForm, formset=BaseEbouticBasketForm, absolute_max=None, min_num=1
+    BasketProductForm, formset=BaseEbouticBasketForm, absolute_max=None, min_num=1
 )
 
 

election/forms.py

@@ -1,155 +0,0 @@
-from django import forms
-from django.utils.translation import gettext_lazy as _
-
-from core.models import User
-from core.views.forms import SelectDateTime
-from core.views.widgets.ajax_select import (
-    AutoCompleteSelect,
-    AutoCompleteSelectMultipleGroup,
-    AutoCompleteSelectUser,
-)
-from core.views.widgets.markdown import MarkdownInput
-from election.models import Candidature, Election, ElectionList, Role
-
-
-class LimitedCheckboxField(forms.ModelMultipleChoiceField):
-    """A `ModelMultipleChoiceField`, with a max limit of selectable inputs."""
-
-    def __init__(self, queryset, max_choice, **kwargs):
-        self.max_choice = max_choice
-        super().__init__(queryset, **kwargs)
-
-    def clean(self, value):
-        qs = super().clean(value)
-        self.validate(qs)
-        return qs
-
-    def validate(self, qs):
-        if qs.count() > self.max_choice:
-            raise forms.ValidationError(
-                _("You have selected too many candidates."), code="invalid"
-            )
-
-
-class CandidateForm(forms.ModelForm):
-    """Form to candidate."""
-
-    required_css_class = "required"
-
-    class Meta:
-        model = Candidature
-        fields = ["user", "role", "program", "election_list"]
-        labels = {
-            "user": _("User to candidate"),
-        }
-        widgets = {
-            "program": MarkdownInput,
-            "user": AutoCompleteSelectUser,
-            "role": AutoCompleteSelect,
-            "election_list": AutoCompleteSelect,
-        }
-
-    def __init__(self, *args, election: Election, can_edit: bool = False, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.fields["role"].queryset = election.roles.select_related("election")
-        self.fields["election_list"].queryset = election.election_lists.all()
-        if not can_edit:
-            self.fields["user"].widget = forms.HiddenInput()
-
-
-class VoteForm(forms.Form):
-    def __init__(self, election: Election, user: User, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if not election.can_vote(user):
-            return
-        for role in election.roles.all():
-            cand = role.candidatures
-            if role.max_choice > 1:
-                self.fields[role.title] = LimitedCheckboxField(
-                    cand, role.max_choice, required=False
-                )
-            else:
-                self.fields[role.title] = forms.ModelChoiceField(
-                    cand,
-                    required=False,
-                    widget=forms.RadioSelect(),
-                    empty_label=_("Blank vote"),
-                )
-
-
-class RoleForm(forms.ModelForm):
-    """Form for creating a role."""
-
-    class Meta:
-        model = Role
-        fields = ["title", "election", "description", "max_choice"]
-        widgets = {"election": AutoCompleteSelect}
-
-    def __init__(self, *args, **kwargs):
-        election_id = kwargs.pop("election_id", None)
-        super().__init__(*args, **kwargs)
-        if election_id:
-            self.fields["election"].queryset = Election.objects.filter(
-                id=election_id
-            ).all()
-
-    def clean(self):
-        cleaned_data = super().clean()
-        title = cleaned_data.get("title")
-        election = cleaned_data.get("election")
-        if Role.objects.filter(title=title, election=election).exists():
-            raise forms.ValidationError(
-                _("This role already exists for this election"), code="invalid"
-            )
-
-
-class ElectionListForm(forms.ModelForm):
-    class Meta:
-        model = ElectionList
-        fields = ("title", "election")
-        widgets = {"election": AutoCompleteSelect}
-
-    def __init__(self, *args, **kwargs):
-        election_id = kwargs.pop("election_id", None)
-        super().__init__(*args, **kwargs)
-        if election_id:
-            self.fields["election"].queryset = Election.objects.filter(
-                id=election_id
-            ).all()
-
-
-class ElectionForm(forms.ModelForm):
-    class Meta:
-        model = Election
-        fields = [
-            "title",
-            "description",
-            "archived",
-            "start_candidature",
-            "end_candidature",
-            "start_date",
-            "end_date",
-            "edit_groups",
-            "view_groups",
-            "vote_groups",
-            "candidature_groups",
-        ]
-        widgets = {
-            "edit_groups": AutoCompleteSelectMultipleGroup,
-            "view_groups": AutoCompleteSelectMultipleGroup,
-            "vote_groups": AutoCompleteSelectMultipleGroup,
-            "candidature_groups": AutoCompleteSelectMultipleGroup,
-        }
-
-    start_date = forms.DateTimeField(
-        label=_("Start date"), widget=SelectDateTime, required=True
-    )
-    end_date = forms.DateTimeField(
-        label=_("End date"), widget=SelectDateTime, required=True
-    )
-    start_candidature = forms.DateTimeField(
-        label=_("Start candidature"), widget=SelectDateTime, required=True
-    )
-    end_candidature = forms.DateTimeField(
-        label=_("End candidature"), widget=SelectDateTime, required=True
-    )

election/migrations/0005_alter_candidature_program_alter_candidature_user.py

@@ -1,30 +0,0 @@
-# Generated by Django 4.2.20 on 2025-03-14 18:18
-
-import django.db.models.deletion
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ("election", "0004_auto_20191006_0049"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="candidature",
-            name="program",
-            field=models.TextField(blank=True, default="", verbose_name="description"),
-        ),
-        migrations.AlterField(
-            model_name="candidature",
-            name="user",
-            field=models.ForeignKey(
-                on_delete=django.db.models.deletion.CASCADE,
-                related_name="candidates",
-                to=settings.AUTH_USER_MODEL,
-                verbose_name="user",
-            ),
-        ),
-    ]

election/models.py

@@ -1,7 +1,5 @@
 from django.db import models
-from django.db.models import Count
 from django.utils import timezone
-from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 from ordered_model.models import OrderedModel
 
@@ -24,18 +22,21 @@ class Election(models.Model):
         verbose_name=_("edit groups"),
         blank=True,
     )
+
     view_groups = models.ManyToManyField(
         Group,
         related_name="viewable_elections",
         verbose_name=_("view groups"),
         blank=True,
     )
+
     vote_groups = models.ManyToManyField(
         Group,
         related_name="votable_elections",
         verbose_name=_("vote groups"),
         blank=True,
     )
+
     candidature_groups = models.ManyToManyField(
         Group,
         related_name="candidate_elections",
@@ -44,7 +45,7 @@ class Election(models.Model):
     )
 
     voters = models.ManyToManyField(
-        User, verbose_name=_("voters"), related_name="voted_elections"
+        User, verbose_name=("voters"), related_name="voted_elections"
     )
     archived = models.BooleanField(_("archived"), default=False)
 
@@ -54,20 +55,20 @@ class Election(models.Model):
     @property
     def is_vote_active(self):
         now = timezone.now()
-        return self.start_date <= now <= self.end_date
+        return bool(now <= self.end_date and now >= self.start_date)
 
     @property
     def is_vote_finished(self):
-        return timezone.now() > self.end_date
+        return bool(timezone.now() > self.end_date)
 
     @property
     def is_candidature_active(self):
         now = timezone.now()
-        return self.start_candidature <= now <= self.end_candidature
+        return bool(now <= self.end_candidature and now >= self.start_candidature)
 
     @property
     def is_vote_editable(self):
-        return timezone.now() <= self.end_candidature
+        return bool(timezone.now() <= self.end_candidature)
 
     def can_candidate(self, user):
         for group_id in self.candidature_groups.values_list("pk", flat=True):
@@ -86,7 +87,7 @@ class Election(models.Model):
     def has_voted(self, user):
         return self.voters.filter(id=user.id).exists()
 
-    @cached_property
+    @property
     def results(self):
         results = {}
         total_vote = self.voters.count()
@@ -94,6 +95,12 @@ class Election(models.Model):
             results[role.title] = role.results(total_vote)
         return results
 
+    def delete(self, *args, **kwargs):
+        self.election_lists.all().delete()
+        super().delete(*args, **kwargs)
+
+    # Permissions
+
 
 class Role(OrderedModel):
     """This class allows to create a new role avaliable for a candidature."""
@@ -108,37 +115,36 @@ class Role(OrderedModel):
     description = models.TextField(_("description"), null=True, blank=True)
     max_choice = models.IntegerField(_("max choice"), default=1)
 
-    def __str__(self):
-        return f"{self.title} - {self.election.title}"
-
-    def results(self, total_vote: int) -> dict[str, dict[str, int | float]]:
-        if total_vote == 0:
-            candidates = self.candidatures.values_list("user__username")
-            return {
-                key: {"vote": 0, "percent": 0} for key in ["blank_votes", *candidates]
-            }
+    def results(self, total_vote):
+        results = {}
         total_vote *= self.max_choice
-        results = {"total vote": total_vote}
         non_blank = 0
-        candidatures = self.candidatures.annotate(nb_votes=Count("votes")).values(
-            "nb_votes", "user__username"
-        )
-        for candidature in candidatures:
-            non_blank += candidature["nb_votes"]
-            results[candidature["user__username"]] = {
-                "vote": candidature["nb_votes"],
-                "percent": candidature["nb_votes"] * 100 / total_vote,
+        for candidature in self.candidatures.all():
+            cand_results = {}
+            cand_results["vote"] = self.votes.filter(candidature=candidature).count()
+            if total_vote == 0:
+                cand_results["percent"] = 0
+            else:
+                cand_results["percent"] = cand_results["vote"] * 100 / total_vote
+            non_blank += cand_results["vote"]
+            results[candidature.user.username] = cand_results
+        results["total vote"] = total_vote
+        if total_vote == 0:
+            results["blank vote"] = {"vote": 0, "percent": 0}
+        else:
+            results["blank vote"] = {
+                "vote": total_vote - non_blank,
+                "percent": (total_vote - non_blank) * 100 / total_vote,
             }
-        results["blank vote"] = {
-            "vote": total_vote - non_blank,
-            "percent": (total_vote - non_blank) * 100 / total_vote,
-        }
         return results
 
     @property
     def edit_groups(self):
         return self.election.edit_groups
 
+    def __str__(self):
+        return ("%s : %s") % (self.election.title, self.title)
+
 
 class ElectionList(models.Model):
     """To allow per list vote."""
@@ -157,6 +163,11 @@ class ElectionList(models.Model):
     def can_be_edited_by(self, user):
         return user.can_edit(self.election)
 
+    def delete(self, *args, **kwargs):
+        for candidature in self.candidatures.all():
+            candidature.delete()
+        super().delete(*args, **kwargs)
+
 
 class Candidature(models.Model):
     """This class is a component of responsability."""
@@ -171,9 +182,10 @@ class Candidature(models.Model):
         User,
         verbose_name=_("user"),
         related_name="candidates",
+        blank=True,
         on_delete=models.CASCADE,
     )
-    program = models.TextField(_("description"), default="", blank=True)
+    program = models.TextField(_("description"), null=True, blank=True)
     election_list = models.ForeignKey(
         ElectionList,
         related_name="candidatures",
@@ -184,10 +196,13 @@ class Candidature(models.Model):
     def __str__(self):
         return f"{self.role.title} : {self.user.username}"
 
+    def delete(self):
+        for vote in self.votes.all():
+            vote.delete()
+        super().delete()
+
     def can_be_edited_by(self, user):
-        return (
-            (user == self.user) or user.can_edit(self.role.election)
-        ) and self.role.election.is_vote_editable
+        return (user == self.user) or user.can_edit(self.role.election)
 
 
 class Vote(models.Model):

election/templates/election/election_detail.jinja

@@ -31,7 +31,7 @@
       <time datetime="{{ election.end_date }}">{{ election.end_date|localtime|date(DATETIME_FORMAT)}}</time>
       {% trans %} at {% endtrans %}<time>{{ election.end_date|localtime|time(DATETIME_FORMAT)}}</time>
     </p>
-    {%- if user_has_voted %}
+    {%- if election.has_voted(user) %}
       <p class="election__elector-infos">
         {%- if election.is_vote_active %}
           <span>{% trans %}You already have submitted your vote.{% endtrans %}</span>
@@ -45,11 +45,12 @@
     <form action="{{ url('election:vote', election.id) }}" method="post" class="election__vote-form" name="vote-form" id="vote-form">
       {% csrf_token %}
       <table class="election_table">
+        {%- set election_lists = election.election_lists.all() -%}
         <thead class="lists">
           <tr>
-            <th class="column" style="width: {{ 100 / (election_lists|length + 1) }}%">{% trans %}Blank vote{% endtrans %}</th>
+            <th class="column" style="width: {{ 100 / (election_lists.count() + 1) }}%">{% trans %}Blank vote{% endtrans %}</th>
             {%- for election_list in election_lists %}
-              <th class="column" style="width: {{ 100 / (election_lists|length + 1) }}%">
+              <th class="column" style="width: {{ 100 / (election_lists.count() + 1) }}%">
                 <span>{{ election_list.title }}</span>
                 {% if user.can_edit(election_list) and election.is_vote_editable -%}
                   <a href="{{ url('election:delete_list', list_id=election_list.id) }}"><i class="fa-regular fa-trash-can delete-action"></i></a>
@@ -58,26 +59,18 @@
             {%- endfor %}
           </tr>
         </thead>
-        {%- for role in election_roles %}
+        {%- set role_list = election.roles.order_by('order').all() %}
+        {%- for role in role_list %}
+          {%- set count = [0] %}
           {%- set role_data = election_form.data.getlist(role.title) if role.title in election_form.data else [] %}
-
-          <tbody
-            {% if role.max_choice > 1 -%}
-              x-data x-limited-choices="{{ role.max_choice }}"
-            {%- endif %}
-            class="role {% if role.title in election_form.errors %}role_error{% endif %}"
-          >
+          <tbody data-max-choice="{{role.max_choice}}" class="role{{ ' role_error' if role.title in election_form.errors else '' }}{{ ' role__multiple-choices' if role.max_choice > 1 else ''}}">
             <tr>
               <td class="role_title">
                 <div class="role_text">
                   <h4>{{ role.title }}</h4>
                   <p class="role_description" show-more="300">{{ role.description }}</p>
-                  {%- if role.max_choice > 1 and show_vote_buttons %}
-                    <strong>
-                      {% trans trimmed nb_choices=role.max_choice %}
-                        You may choose up to {{ nb_choices }} people.
-                      {% endtrans %}
-                    </strong>
+                  {%- if role.max_choice > 1 and not election.has_voted(user) and election.can_vote(user) %}
+                    <strong>{% trans %}You may choose up to{% endtrans %} {{ role.max_choice }} {% trans %}people.{% endtrans %}</strong>
                   {%- endif %}
 
                   {%- if election_form.errors[role.title] is defined %}
@@ -88,40 +81,36 @@
                 </div>
                 {% if user.can_edit(role) and election.is_vote_editable -%}
                   <div class="role_buttons">
-                    <a href="{{ url('election:update_role', role_id=role.id) }}">️
-                      <i class="fa-regular fa-pen-to-square edit-action"></i>
-                    </a>
-                    <a href="{{ url('election:delete_role', role_id=role.id) }}">
-                      <i class="fa-regular fa-trash-can delete-action"></i>
-                    </a>
-                    {%- if loop.last -%}
+                    <a href="{{url('election:update_role', role_id=role.id)}}">️<i class="fa-regular fa-pen-to-square edit-action"></i></a>
+                    <a href="{{url('election:delete_role', role_id=role.id)}}"><i class="fa-regular fa-trash-can delete-action"></i></a>
+                    {%- if role == role_list.last() %}
                       <button disabled><i class="fa fa-arrow-down"></i></button>
                       <button disabled><i class="fa fa-caret-down"></i></button>
-                    {%- else -%}
+                    {%- else %}
                       <button type="button" onclick="window.location.replace('?role={{ role.id }}&action=bottom');"><i class="fa fa-arrow-down"></i></button>
                       <button type="button" onclick="window.location.replace('?role={{ role.id }}&action=down');"><i class="fa fa-caret-down"></i></button>
-                    {%- endif -%}
-                    {%- if loop.first -%}
+                    {%- endif %}
+                    {% if role == role_list.first() %}
                       <button disabled><i class="fa fa-caret-up"></i></button>
                       <button disabled><i class="fa fa-arrow-up"></i></button>
-                    {%- else -%}
+                    {% else %}
                       <button type="button" onclick="window.location.replace('?role={{ role.id }}&action=up');"><i class="fa fa-caret-up"></i></button>
                       <button type="button" onclick="window.location.replace('?role={{ role.id }}&action=top');"><i class="fa fa-arrow-up"></i></button>
-                    {%- endif -%}
+                    {% endif %}
                   </div>
                 {%- endif -%}
               </td>
             </tr>
             <tr class="role_candidates">
-              <td class="list_per_role" style="width: 100%; max-width: {{ 100 / (election_lists|length + 1) }}%">
-                {%- if role.max_choice == 1 and show_vote_buttons %}
+              <td class="list_per_role" style="width: 100%; max-width: {{ 100 / (election_lists.count() + 1) }}%">
+                {%- if role.max_choice == 1 and election.can_vote(user) %}
                   <div class="radio-btn">
-                    {% set input_id = "blank_vote_" + role.id|string %}
-                    <input id="{{ input_id }}" type="radio" name="{{ role.title }}">
-                    <label for="{{ input_id }}">
+                    <input id="id_{{ role.title }}_{{ count[0] }}" type="radio" name="{{ role.title }}" value {{ '' if role_data in election_form else 'checked' }} {{ 'disabled' if election.has_voted(user) else '' }}>
+                    <label for="id_{{ role.title }}_{{ count[0] }}">
                       <span>{% trans %}Choose blank vote{% endtrans %}</span>
                     </label>
                   </div>
+                  {%- set _ = count.append(count.pop() + 1) %}
                 {%- endif %}
                 {%- if election.is_vote_finished %}
                   {%- set results = election_results[role.title]['blank vote'] %}
@@ -131,14 +120,13 @@
                 {%- endif %}
               </td>
               {%- for election_list in election_lists %}
-                <td class="list_per_role" style="width: 100%; max-width: {{ 100 / (election_lists|length + 1) }}%">
+                <td class="list_per_role" style="width: 100%; max-width: {{ 100 / (election_lists.count() + 1) }}%">
                   <ul class="candidates">
-                    {%- for candidature in election_list.candidatures.select_related("user", "user__profile_pict").filter(role=role) %}
+                    {%- for candidature in election_list.candidatures.filter(role=role) %}
                       <li class="candidate">
-                        {%- if show_vote_buttons %}
-                          {% set input_id = "candidature_" + candidature.id|string %}
-                          <input id="{{ input_id }}" type="{{ 'checkbox' if role.max_choice > 1 else 'radio' }}" {{ 'checked' if candidature.id|string in role_data else '' }} {{ 'disabled' if user_has_voted else '' }} name="{{ role.title }}" value="{{ candidature.id }}">
-                          <label for="{{ input_id }}">
+                        {%- if election.can_vote(user) %}
+                          <input id="id_{{ role.title }}_{{ count[0] }}" type="{{ 'checkbox' if role.max_choice > 1 else 'radio' }}" {{ 'checked' if candidature.id|string in role_data else '' }} {{ 'disabled' if election.has_voted(user) else '' }} name="{{ role.title }}" value="{{ candidature.id }}">
+                          <label for="id_{{ role.title }}_{{ count[0] }}">
                         {%- endif %}
                         <figure>
                           {%- if user.is_subscriber_viewable %}
@@ -152,7 +140,7 @@
                             <h5>{{ candidature.user.first_name }} <em>{{candidature.user.nick_name or ''}} </em>{{ candidature.user.last_name }}</h5>
                             {%- if not election.is_vote_finished %}
                               <q class="candidate_program" show-more="200">
-                                {{ candidature.program|markdown }}
+                                {{ candidature.program|markdown or '' }}
                               </q>
                             {%- endif %}
                           </figcaption>
@@ -165,8 +153,9 @@
                             {%- endif -%}
                           {%- endif -%}
                         </figure>
-                        {%- if show_vote_buttons %}
+                        {%- if election.can_vote(user) %}
                           </label>
+                          {%- set _ = count.append(count.pop() + 1) %}
                         {%- endif %}
                         {%- if election.is_vote_finished %}
                           {%- set results = election_results[role.title][candidature.user.username] %}
@@ -202,9 +191,36 @@
       <a  class="button" href="{{ url('election:delete', election_id=object.id) }}">{% trans %}Delete{% endtrans %}</a>
     {%- endif %}
   </section>
-  {%- if show_vote_buttons %}
+  {%- if not election.has_voted(user) and election.can_vote(user) %}
     <section class="buttons">
       <button class="button button_send" form="vote-form">{% trans %}Submit the vote !{% endtrans %}</button>
     </section>
   {%- endif %}
 {% endblock %}
+
+{% block script %}
+  {{ super() }}
+  <script type="text/javascript">
+    document.querySelectorAll('.role__multiple-choices').forEach(setupRestrictions);
+
+    function setupRestrictions(role) {
+      var selectedChoices = [];
+      role.querySelectorAll('input').forEach(setupRestriction);
+
+      function setupRestriction(choice) {
+        if (choice.checked)
+          selectedChoices.push(choice);
+        choice.addEventListener('change', onChange);
+
+        function onChange() {
+          if (choice.checked)
+            selectedChoices.push(choice);
+          else
+            selectedChoices.splice(selectedChoices.indexOf(choice), 1);
+          while (selectedChoices.length > role.dataset.maxChoice)
+            selectedChoices.shift().checked = false;
+        }
+      }
+    }
+  </script>
+{% endblock %}

election/tests.py

@@ -1,15 +1,9 @@
-from datetime import timedelta
-
-import pytest
 from django.conf import settings
-from django.test import Client, TestCase
+from django.test import TestCase
 from django.urls import reverse
-from django.utils.timezone import now
-from model_bakery import baker
 
-from core.baker_recipes import subscriber_user
 from core.models import Group, User
-from election.models import Candidature, Election, ElectionList, Role, Vote
+from election.models import Election
 
 
 class TestElection(TestCase):
@@ -18,7 +12,8 @@ class TestElection(TestCase):
         cls.election = Election.objects.first()
         cls.public_group = Group.objects.get(id=settings.SITH_GROUP_PUBLIC_ID)
         cls.sli = User.objects.get(username="sli")
-        cls.public = baker.make(User)
+        cls.subscriber = User.objects.get(username="subscriber")
+        cls.public = User.objects.get(username="public")
 
 
 class TestElectionDetail(TestElection):
@@ -41,7 +36,7 @@ class TestElectionDetail(TestElection):
 
 class TestElectionUpdateView(TestElection):
     def test_permission_denied(self):
-        self.client.force_login(subscriber_user.make())
+        self.client.force_login(self.subscriber)
         response = self.client.get(
             reverse("election:update", args=str(self.election.id))
         )
@@ -50,68 +45,3 @@ class TestElectionUpdateView(TestElection):
             reverse("election:update", args=str(self.election.id))
         )
         assert response.status_code == 403
-
-
-@pytest.mark.django_db
-def test_election_create_list_permission(client: Client):
-    election = baker.make(Election, end_candidature=now() + timedelta(hours=1))
-    groups = [
-        Group.objects.get(pk=settings.SITH_GROUP_SUBSCRIBERS_ID),
-        baker.make(Group),
-    ]
-    election.candidature_groups.add(groups[0])
-    election.edit_groups.add(groups[1])
-    url = reverse("election:create_list", kwargs={"election_id": election.id})
-    for user in subscriber_user.make(), baker.make(User, groups=[groups[1]]):
-        client.force_login(user)
-        assert client.get(url).status_code == 200
-        # the post is a 200 instead of a 302, because we don't give form data,
-        # but we don't care as we only test permissions here
-        assert client.post(url).status_code == 200
-    client.force_login(baker.make(User))
-    assert client.get(url).status_code == 403
-    assert client.post(url).status_code == 403
-
-
-@pytest.mark.django_db
-def test_election_results():
-    election = baker.make(
-        Election, voters=baker.make(User, _quantity=50, _bulk_create=True)
-    )
-    lists = baker.make(ElectionList, election=election, _quantity=2, _bulk_create=True)
-    roles = baker.make(
-        Role, election=election, max_choice=iter([1, 2]), _quantity=2, _bulk_create=True
-    )
-    users = baker.make(User, _quantity=4, _bulk_create=True)
-    cand = [
-        baker.make(Candidature, role=roles[0], user=users[0], election_list=lists[0]),
-        baker.make(Candidature, role=roles[0], user=users[1], election_list=lists[1]),
-        baker.make(Candidature, role=roles[1], user=users[2], election_list=lists[0]),
-        baker.make(Candidature, role=roles[1], user=users[3], election_list=lists[1]),
-    ]
-    votes = [
-        baker.make(Vote, role=roles[0], _quantity=20, _bulk_create=True),
-        baker.make(Vote, role=roles[0], _quantity=25, _bulk_create=True),
-        baker.make(Vote, role=roles[1], _quantity=20, _bulk_create=True),
-        baker.make(Vote, role=roles[1], _quantity=35, _bulk_create=True),
-        baker.make(Vote, role=roles[1], _quantity=10, _bulk_create=True),
-    ]
-    cand[0].votes.set(votes[0])
-    cand[1].votes.set(votes[1])
-    cand[2].votes.set([*votes[2], *votes[4]])
-    cand[3].votes.set([*votes[3], *votes[4]])
-
-    assert election.results == {
-        roles[0].title: {
-            cand[0].user.username: {"percent": 40.0, "vote": 20},
-            cand[1].user.username: {"percent": 50.0, "vote": 25},
-            "blank vote": {"percent": 10.0, "vote": 5},
-            "total vote": 50,
-        },
-        roles[1].title: {
-            cand[2].user.username: {"percent": 30.0, "vote": 30},
-            cand[3].user.username: {"percent": 45.0, "vote": 45},
-            "blank vote": {"percent": 25.0, "vote": 25},
-            "total vote": 100,
-        },
-    }

election/views.py

@@ -1,34 +1,183 @@
 from typing import TYPE_CHECKING
 
-from cryptography.utils import cached_property
-from django.conf import settings
-from django.contrib.auth.mixins import (
-    LoginRequiredMixin,
-    PermissionRequiredMixin,
-    UserPassesTestMixin,
-)
+from django import forms
+from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
 from django.core.exceptions import PermissionDenied
 from django.db import transaction
-from django.db.models import QuerySet
-from django.shortcuts import get_object_or_404
+from django.db.models.query import QuerySet
+from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse, reverse_lazy
+from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView
 from django.views.generic.edit import CreateView, DeleteView, FormView, UpdateView
 
-from core.auth.mixins import CanEditMixin, CanViewMixin
-from election.forms import (
-    CandidateForm,
-    ElectionForm,
-    ElectionListForm,
-    RoleForm,
-    VoteForm,
+from core.auth.mixins import CanCreateMixin, CanEditMixin, CanViewMixin
+from core.views.forms import SelectDateTime
+from core.views.widgets.ajax_select import (
+    AutoCompleteSelect,
+    AutoCompleteSelectMultipleGroup,
+    AutoCompleteSelectUser,
 )
+from core.views.widgets.markdown import MarkdownInput
 from election.models import Candidature, Election, ElectionList, Role, Vote
 
 if TYPE_CHECKING:
     from core.models import User
 
 
+# Custom form field
+
+
+class LimitedCheckboxField(forms.ModelMultipleChoiceField):
+    """A `ModelMultipleChoiceField`, with a max limit of selectable inputs."""
+
+    def __init__(self, queryset, max_choice, **kwargs):
+        self.max_choice = max_choice
+        super().__init__(queryset, **kwargs)
+
+    def clean(self, value):
+        qs = super().clean(value)
+        self.validate(qs)
+        return qs
+
+    def validate(self, qs):
+        if qs.count() > self.max_choice:
+            raise forms.ValidationError(
+                _("You have selected too much candidates."), code="invalid"
+            )
+
+
+# Forms
+
+
+class CandidateForm(forms.ModelForm):
+    """Form to candidate."""
+
+    class Meta:
+        model = Candidature
+        fields = ["user", "role", "program", "election_list"]
+        labels = {
+            "user": _("User to candidate"),
+        }
+        widgets = {
+            "program": MarkdownInput,
+            "user": AutoCompleteSelectUser,
+            "role": AutoCompleteSelect,
+            "election_list": AutoCompleteSelect,
+        }
+
+    def __init__(self, *args, **kwargs):
+        election_id = kwargs.pop("election_id", None)
+        can_edit = kwargs.pop("can_edit", False)
+        super().__init__(*args, **kwargs)
+        if election_id:
+            self.fields["role"].queryset = Role.objects.filter(
+                election__id=election_id
+            ).all()
+            self.fields["election_list"].queryset = ElectionList.objects.filter(
+                election__id=election_id
+            ).all()
+        if not can_edit:
+            self.fields["user"].widget = forms.HiddenInput()
+
+
+class VoteForm(forms.Form):
+    def __init__(self, election, user, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not election.has_voted(user):
+            for role in election.roles.all():
+                cand = role.candidatures
+                if role.max_choice > 1:
+                    self.fields[role.title] = LimitedCheckboxField(
+                        cand, role.max_choice, required=False
+                    )
+                else:
+                    self.fields[role.title] = forms.ModelChoiceField(
+                        cand,
+                        required=False,
+                        widget=forms.RadioSelect(),
+                        empty_label=_("Blank vote"),
+                    )
+
+
+class RoleForm(forms.ModelForm):
+    """Form for creating a role."""
+
+    class Meta:
+        model = Role
+        fields = ["title", "election", "description", "max_choice"]
+        widgets = {"election": AutoCompleteSelect}
+
+    def __init__(self, *args, **kwargs):
+        election_id = kwargs.pop("election_id", None)
+        super().__init__(*args, **kwargs)
+        if election_id:
+            self.fields["election"].queryset = Election.objects.filter(
+                id=election_id
+            ).all()
+
+    def clean(self):
+        cleaned_data = super().clean()
+        title = cleaned_data.get("title")
+        election = cleaned_data.get("election")
+        if Role.objects.filter(title=title, election=election).exists():
+            raise forms.ValidationError(
+                _("This role already exists for this election"), code="invalid"
+            )
+
+
+class ElectionListForm(forms.ModelForm):
+    class Meta:
+        model = ElectionList
+        fields = ("title", "election")
+        widgets = {"election": AutoCompleteSelect}
+
+    def __init__(self, *args, **kwargs):
+        election_id = kwargs.pop("election_id", None)
+        super().__init__(*args, **kwargs)
+        if election_id:
+            self.fields["election"].queryset = Election.objects.filter(
+                id=election_id
+            ).all()
+
+
+class ElectionForm(forms.ModelForm):
+    class Meta:
+        model = Election
+        fields = [
+            "title",
+            "description",
+            "archived",
+            "start_candidature",
+            "end_candidature",
+            "start_date",
+            "end_date",
+            "edit_groups",
+            "view_groups",
+            "vote_groups",
+            "candidature_groups",
+        ]
+        widgets = {
+            "edit_groups": AutoCompleteSelectMultipleGroup,
+            "view_groups": AutoCompleteSelectMultipleGroup,
+            "vote_groups": AutoCompleteSelectMultipleGroup,
+            "candidature_groups": AutoCompleteSelectMultipleGroup,
+        }
+
+    start_date = forms.DateTimeField(
+        label=_("Start date"), widget=SelectDateTime, required=True
+    )
+    end_date = forms.DateTimeField(
+        label=_("End date"), widget=SelectDateTime, required=True
+    )
+    start_candidature = forms.DateTimeField(
+        label=_("Start candidature"), widget=SelectDateTime, required=True
+    )
+    end_candidature = forms.DateTimeField(
+        label=_("End candidature"), widget=SelectDateTime, required=True
+    )
+
+
 # Display elections
 
 
@@ -36,21 +185,25 @@ class ElectionsListView(CanViewMixin, ListView):
     """A list of all non archived elections visible."""
 
     model = Election
-    queryset = model.objects.filter(archived=False)
     ordering = ["-id"]
     paginate_by = 10
     template_name = "election/election_list.jinja"
 
+    def get_queryset(self):
+        return super().get_queryset().filter(archived=False).all()
+
 
 class ElectionListArchivedView(CanViewMixin, ListView):
     """A list of all archived elections visible."""
 
     model = Election
-    queryset = model.objects.filter(archived=True)
     ordering = ["-id"]
     paginate_by = 10
     template_name = "election/election_list.jinja"
 
+    def get_queryset(self):
+        return super().get_queryset().filter(archived=True).all()
+
 
 class ElectionDetailView(CanViewMixin, DetailView):
     """Details an election responsability by responsability."""
@@ -59,67 +212,46 @@ class ElectionDetailView(CanViewMixin, DetailView):
     template_name = "election/election_detail.jinja"
     pk_url_kwarg = "election_id"
 
-    @staticmethod
-    def _reorder_votes(action: str, role: int):
-        role = Role.objects.filter(id=role).first()
-        if not role:
-            return
-        if action == "up":
-            role.up()
-        elif action == "down":
-            role.down()
-        elif action == "bottom":
-            role.bottom()
-        elif action == "top":
-            role.top()
-
     def get(self, request, *arg, **kwargs):
+        response = super().get(request, *arg, **kwargs)
         election: Election = self.get_object()
-        if election.is_vote_editable and request.user.can_edit(election):
+        if request.user.can_edit(election) and election.is_vote_editable:
             action = request.GET.get("action", None)
             role = request.GET.get("role", None)
-            if action and role and role.isdigit():
-                self._reorder_votes(action, int(role))
-        return super().get(request, *arg, **kwargs)
+            if action and role and Role.objects.filter(id=role).exists():
+                if action == "up":
+                    Role.objects.get(id=role).up()
+                elif action == "down":
+                    Role.objects.get(id=role).down()
+                elif action == "bottom":
+                    Role.objects.get(id=role).bottom()
+                elif action == "top":
+                    Role.objects.get(id=role).top()
+                return redirect(
+                    reverse("election:detail", kwargs={"election_id": election.id})
+                )
+        return response
 
     def get_context_data(self, **kwargs):
         """Add additionnal data to the template."""
-        user: User = self.request.user
-        return super().get_context_data(**kwargs) | {
-            "election_form": VoteForm(self.object, user),
-            "show_vote_buttons": self.object.can_vote(user),
-            "user_has_voted": self.object.has_voted(user),
-            "election_results": (
-                self.object.results if self.object.is_vote_finished else None
-            ),
-            "election_lists": list(self.object.election_lists.all()),
-            "election_roles": list(self.object.roles.order_by("order")),
-        }
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["election_form"] = VoteForm(self.object, self.request.user)
+        kwargs["election_results"] = self.object.results
+        return kwargs
 
 
 # Form view
 
 
-class VoteFormView(LoginRequiredMixin, UserPassesTestMixin, FormView):
+class VoteFormView(CanCreateMixin, FormView):
     """Alows users to vote."""
 
     form_class = VoteForm
     template_name = "election/election_detail.jinja"
 
-    @cached_property
-    def election(self):
-        return get_object_or_404(Election, pk=self.kwargs["election_id"])
-
-    def test_func(self):
-        groups = set(self.election.vote_groups.values_list("id", flat=True))
-        if (
-            settings.SITH_GROUP_SUBSCRIBERS_ID in groups
-            and self.request.user.is_subscribed
-        ):
-            # the subscriber group isn't truly attached to users,
-            # so it must be dealt with separately
-            return True
-        return self.request.user.groups.filter(id__in=groups).exists()
+    def dispatch(self, request, *arg, **kwargs):
+        self.election = get_object_or_404(Election, pk=kwargs["election_id"])
+        return super().dispatch(request, *arg, **kwargs)
 
     def vote(self, election_data):
         with transaction.atomic():
@@ -139,16 +271,20 @@ class VoteFormView(LoginRequiredMixin, UserPassesTestMixin, FormView):
             self.election.voters.add(self.request.user)
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "election": self.election,
-            "user": self.request.user,
-        }
+        kwargs = super().get_form_kwargs()
+        kwargs["election"] = self.election
+        kwargs["user"] = self.request.user
+        return kwargs
 
     def form_valid(self, form):
         """Verify that the user is part in a vote group."""
         data = form.clean()
-        self.vote(data)
-        return super().form_valid(form)
+        res = super(FormView, self).form_valid(form)
+        for grp_id in self.election.vote_groups.values_list("pk", flat=True):
+            if self.request.user.is_in_group(pk=grp_id):
+                self.vote(data)
+                return res
+        return res
 
     def get_success_url(self, **kwargs):
         return reverse_lazy("election:detail", kwargs={"election_id": self.election.id})
@@ -174,22 +310,26 @@ class CandidatureCreateView(LoginRequiredMixin, CreateView):
 
     def dispatch(self, request, *arg, **kwargs):
         self.election = get_object_or_404(Election, pk=kwargs["election_id"])
-        self.can_edit = self.request.user.can_edit(self.election)
         return super().dispatch(request, *arg, **kwargs)
 
     def get_initial(self):
-        return {"user": self.request.user.id}
+        init = {}
+        self.can_edit = self.request.user.can_edit(self.election)
+        init["user"] = self.request.user.id
+        return init
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "election": self.election,
-            "can_edit": self.can_edit,
-        }
+        kwargs = super().get_form_kwargs()
+        kwargs["election_id"] = self.election.id
+        kwargs["can_edit"] = self.can_edit
+        return kwargs
 
-    def form_valid(self, form: CandidateForm):
+    def form_valid(self, form):
         """Verify that the selected user is in candidate group."""
         obj = form.instance
         obj.election = self.election
+        if not hasattr(obj, "user"):
+            obj.user = self.request.user
         if (obj.election.can_candidate(obj.user)) and (
             obj.user == self.request.user or self.can_edit
         ):
@@ -197,7 +337,9 @@ class CandidatureCreateView(LoginRequiredMixin, CreateView):
         raise PermissionDenied
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"election": self.election}
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["election"] = self.election
+        return kwargs
 
     def get_success_url(self, **kwargs):
         return reverse_lazy("election:detail", kwargs={"election_id": self.election.id})
@@ -213,79 +355,80 @@ class ElectionCreateView(PermissionRequiredMixin, CreateView):
         return reverse("election:detail", kwargs={"election_id": self.object.id})
 
 
-class RoleCreateView(LoginRequiredMixin, UserPassesTestMixin, CreateView):
+class RoleCreateView(CanCreateMixin, CreateView):
     model = Role
     form_class = RoleForm
     template_name = "core/create.jinja"
 
-    @cached_property
-    def election(self):
-        return get_object_or_404(Election, pk=self.kwargs["election_id"])
-
-    def test_func(self):
+    def dispatch(self, request, *arg, **kwargs):
+        self.election = get_object_or_404(Election, pk=kwargs["election_id"])
         if not self.election.is_vote_editable:
-            return False
-        if self.request.user.has_perm("election.add_role"):
-            return True
-        groups = set(self.election.edit_groups.values_list("id", flat=True))
-        if (
-            settings.SITH_GROUP_SUBSCRIBERS_ID in groups
-            and self.request.user.is_subscribed
-        ):
-            # the subscriber group isn't truly attached to users,
-            # so it must be dealt with separately
-            return True
-        return self.request.user.groups.filter(id__in=groups).exists()
+            raise PermissionDenied
+        return super().dispatch(request, *arg, **kwargs)
 
     def get_initial(self):
-        return {"election": self.election}
+        init = {}
+        init["election"] = self.election
+        return init
+
+    def form_valid(self, form):
+        """Verify that the user can edit properly."""
+        obj: Role = form.instance
+        user: User = self.request.user
+        if obj.election:
+            for grp_id in obj.election.edit_groups.values_list("pk", flat=True):
+                if user.is_in_group(pk=grp_id):
+                    return super(CreateView, self).form_valid(form)
+        raise PermissionDenied
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"election_id": self.election.id}
+        kwargs = super().get_form_kwargs()
+        kwargs["election_id"] = self.election.id
+        return kwargs
 
     def get_success_url(self, **kwargs):
-        return reverse(
-            "election:detail", kwargs={"election_id": self.object.election_id}
+        return reverse_lazy(
+            "election:detail", kwargs={"election_id": self.object.election.id}
         )
 
 
-class ElectionListCreateView(LoginRequiredMixin, UserPassesTestMixin, CreateView):
+class ElectionListCreateView(CanCreateMixin, CreateView):
     model = ElectionList
     form_class = ElectionListForm
     template_name = "core/create.jinja"
 
-    @cached_property
-    def election(self):
-        return get_object_or_404(Election, pk=self.kwargs["election_id"])
-
-    def test_func(self):
+    def dispatch(self, request, *arg, **kwargs):
+        self.election = get_object_or_404(Election, pk=kwargs["election_id"])
         if not self.election.is_vote_editable:
-            return False
-        if self.request.user.has_perm("election.add_electionlist"):
-            return True
-        groups = set(
-            self.election.candidature_groups.values("id")
-            .union(self.election.edit_groups.values("id"))
-            .values_list("id", flat=True)
-        )
-        if (
-            settings.SITH_GROUP_SUBSCRIBERS_ID in groups
-            and self.request.user.is_subscribed
-        ):
-            # the subscriber group isn't truly attached to users,
-            # so it must be dealt with separately
-            return True
-        return self.request.user.groups.filter(id__in=groups).exists()
+            raise PermissionDenied
+        return super().dispatch(request, *arg, **kwargs)
 
     def get_initial(self):
-        return {"election": self.election}
+        init = {}
+        init["election"] = self.election
+        return init
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"election_id": self.election.id}
+        kwargs = super().get_form_kwargs()
+        kwargs["election_id"] = self.election.id
+        return kwargs
+
+    def form_valid(self, form):
+        """Verify that the user can vote on this election."""
+        obj: ElectionList = form.instance
+        user: User = self.request.user
+        if obj.election:
+            for grp_id in obj.election.candidature_groups.values_list("pk", flat=True):
+                if user.is_in_group(pk=grp_id):
+                    return super(CreateView, self).form_valid(form)
+            for grp_id in obj.election.edit_groups.values_list("pk", flat=True):
+                if user.is_in_group(pk=grp_id):
+                    return super(CreateView, self).form_valid(form)
+        raise PermissionDenied
 
     def get_success_url(self, **kwargs):
-        return reverse(
-            "election:detail", kwargs={"election_id": self.object.election_id}
+        return reverse_lazy(
+            "election:detail", kwargs={"election_id": self.object.election.id}
         )
 
 
@@ -314,23 +457,45 @@ class ElectionUpdateView(CanEditMixin, UpdateView):
         return reverse_lazy("election:detail", kwargs={"election_id": self.object.id})
 
 
-class CandidatureUpdateView(LoginRequiredMixin, CanEditMixin, UpdateView):
+class CandidatureUpdateView(CanEditMixin, UpdateView):
     model = Candidature
     form_class = CandidateForm
     template_name = "core/edit.jinja"
     pk_url_kwarg = "candidature_id"
 
-    def get_form(self, *args, **kwargs):
-        form = super().get_form(*args, **kwargs)
-        form.fields.pop("role", None)
-        return form
+    def dispatch(self, request, *arg, **kwargs):
+        self.object = self.get_object()
+        if not self.object.role.election.is_vote_editable:
+            raise PermissionDenied
+        return super().dispatch(request, *arg, **kwargs)
+
+    def remove_fields(self):
+        self.form.fields.pop("role", None)
+
+    def get(self, request, *args, **kwargs):
+        self.form = self.get_form()
+        self.remove_fields()
+        return self.render_to_response(self.get_context_data(form=self.form))
+
+    def post(self, request, *args, **kwargs):
+        self.form = self.get_form()
+        self.remove_fields()
+        if (
+            request.user.is_authenticated
+            and request.user.can_edit(self.object)
+            and self.form.is_valid()
+        ):
+            return super().form_valid(self.form)
+        return self.form_invalid(self.form)
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"election": self.object.role.election}
+        kwargs = super().get_form_kwargs()
+        kwargs["election_id"] = self.object.role.election.id
+        return kwargs
 
     def get_success_url(self, **kwargs):
-        return reverse(
-            "election:detail", kwargs={"election_id": self.object.role.election_id}
+        return reverse_lazy(
+            "election:detail", kwargs={"election_id": self.object.role.election.id}
         )
 
 
@@ -381,12 +546,18 @@ class RoleUpdateView(CanEditMixin, UpdateView):
 # Delete Views
 
 
-class ElectionDeleteView(PermissionRequiredMixin, DeleteView):
+class ElectionDeleteView(DeleteView):
     model = Election
     template_name = "core/delete_confirm.jinja"
     pk_url_kwarg = "election_id"
-    permission_required = "election.delete_election"
-    success_url = reverse_lazy("election:list")
+
+    def dispatch(self, request, *args, **kwargs):
+        if request.user.is_root:
+            return super().dispatch(request, *args, **kwargs)
+        raise PermissionDenied
+
+    def get_success_url(self, **kwargs):
+        return reverse_lazy("election:list")
 
 
 class CandidatureDeleteView(CanEditMixin, DeleteView):
@@ -402,7 +573,7 @@ class CandidatureDeleteView(CanEditMixin, DeleteView):
         return super().dispatch(request, *arg, **kwargs)
 
     def get_success_url(self, **kwargs):
-        return reverse("election:detail", kwargs={"election_id": self.election.id})
+        return reverse_lazy("election:detail", kwargs={"election_id": self.election.id})
 
 
 class RoleDeleteView(CanEditMixin, DeleteView):
@@ -418,7 +589,7 @@ class RoleDeleteView(CanEditMixin, DeleteView):
         return super().dispatch(request, *arg, **kwargs)
 
     def get_success_url(self, **kwargs):
-        return reverse("election:detail", kwargs={"election_id": self.election.id})
+        return reverse_lazy("election:detail", kwargs={"election_id": self.election.id})
 
 
 class ElectionListDeleteView(CanEditMixin, DeleteView):
@@ -434,4 +605,4 @@ class ElectionListDeleteView(CanEditMixin, DeleteView):
         return super().dispatch(request, *args, **kwargs)
 
     def get_success_url(self, **kwargs):
-        return reverse("election:detail", kwargs={"election_id": self.election.id})
+        return reverse_lazy("election:detail", kwargs={"election_id": self.election.id})

locale/fr/LC_MESSAGES/django.po

@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-09-25 15:33+0200\n"
+"POT-Creation-Date: 2025-09-26 17:36+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"
@@ -117,7 +117,7 @@ msgstr "S'abonner"
 msgid "Remove"
 msgstr "Retirer"
 
-#: club/forms.py pedagogy/templates/pedagogy/moderation.jinja
+#: club/forms.py counter/forms.py pedagogy/templates/pedagogy/moderation.jinja
 msgid "Action"
 msgstr "Action"
 
@@ -141,7 +141,7 @@ msgstr "vous devez spécifier au moins un utilisateur ou une adresse email"
 msgid "Begin date"
 msgstr "Date de début"
 
-#: club/forms.py com/forms.py counter/forms.py election/forms.py
+#: club/forms.py com/forms.py counter/forms.py election/views.py
 #: subscription/forms.py
 msgid "End date"
 msgstr "Date de fin"
@@ -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 should specify a role"
-msgstr "Vous devez choisir un rôle"
+msgid "You must be subscribed to join a club"
+msgstr "Vous devez être cotisant pour faire partie d'un club"
 
-#: club/forms.py sas/forms.py
-msgid "You do not have the permission to do that"
-msgstr "Vous n'avez pas la permission de faire cela"
+#: club/forms.py
+msgid "You are already a member of this club"
+msgstr "Vous êtes déjà membre de ce club."
 
 #: club/models.py
 msgid "slug name"
@@ -350,11 +350,6 @@ 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"
@@ -561,6 +556,7 @@ msgstr ""
 #: core/templates/core/user_godfathers_tree.jinja
 #: core/templates/core/user_preferences.jinja
 #: counter/templates/counter/cash_register_summary.jinja
+#: counter/templates/counter/product_form.jinja
 #: forum/templates/forum/reply.jinja
 #: subscription/templates/subscription/fragments/creation_form.jinja
 #: trombi/templates/trombi/comment.jinja
@@ -569,6 +565,24 @@ 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"
@@ -675,11 +689,20 @@ msgstr "Vente"
 msgid "Mailing list"
 msgstr "Listes de diffusion"
 
+#: club/views.py
+#, python-format
+msgid "%(user)s has been added to club."
+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"
 msgstr "Format : 16:9 | Résolution : 1920x1080"
 
-#: com/forms.py election/forms.py subscription/forms.py
+#: com/forms.py election/views.py subscription/forms.py
 msgid "Start date"
 msgstr "Date de début"
 
@@ -1039,6 +1062,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"
@@ -2929,6 +2956,18 @@ msgstr "Cet UID est invalide"
 msgid "User not found"
 msgstr "Utilisateur non trouvé"
 
+#: counter/forms.py
+msgid "Date and time of action"
+msgstr "Date et heure de l'action"
+
+#: counter/forms.py
+msgid "New counters"
+msgstr "Nouveaux comptoirs"
+
+#: counter/forms.py
+msgid "The selected counters will replace the current ones"
+msgstr "Les comptoirs sélectionnés remplaceront les comptoirs actuels"
+
 #: counter/forms.py
 msgid ""
 "Describe the product. If it's an event's click, give some insights about it, "
@@ -3263,6 +3302,18 @@ msgid "The returnable product cannot be the same as the returned one"
 msgstr ""
 "Le produit consigné ne peut pas être le même que le produit de déconsigne"
 
+#: counter/models.py
+msgid "Archiving"
+msgstr "Archivage"
+
+#: counter/models.py
+msgid "Counters change"
+msgstr "Changement des comptoirs"
+
+#: counter/models.py
+msgid "Product scheduled action"
+msgstr "Actions sur produit planifiées"
+
 #: counter/templates/counter/activity.jinja
 #, python-format
 msgid "%(counter_name)s activity"
@@ -3581,6 +3632,25 @@ msgstr ""
 "votre cotisation. Si vous ne renouvelez pas votre cotisation, il n'y aura "
 "aucune conséquence autre que le retrait de l'argent de votre compte."
 
+#: counter/templates/counter/product_form.jinja
+#, python-format
+msgid "Edit product %(name)s"
+msgstr "Édition du produit %(name)s"
+
+#: counter/templates/counter/product_form.jinja
+msgid "Product creation"
+msgstr "Création de produit"
+
+#: counter/templates/counter/product_form.jinja
+msgid "Automatic actions"
+msgstr "Actions automatiques"
+
+#: counter/templates/counter/product_form.jinja
+msgid "Automatic actions allows to schedule product changes ahead of time."
+msgstr ""
+"Les actions automatiques vous permettent de planifier des modifications du "
+"produit à l'avance."
+
 #: counter/templates/counter/product_list.jinja
 msgid "Product list"
 msgstr "Liste des produits"
@@ -3930,30 +4000,6 @@ msgstr ""
 msgid "You can't buy a refilling with sith money"
 msgstr "Vous ne pouvez pas acheter un rechargement avec de l'argent du sith"
 
-#: election/forms.py
-msgid "You have selected too many candidates."
-msgstr "Vous avez sélectionné trop de candidats."
-
-#: election/forms.py
-msgid "User to candidate"
-msgstr "Utilisateur se présentant"
-
-#: election/forms.py election/templates/election/election_detail.jinja
-msgid "Blank vote"
-msgstr "Vote blanc"
-
-#: election/forms.py
-msgid "This role already exists for this election"
-msgstr "Ce rôle existe déjà pour cette élection"
-
-#: election/forms.py
-msgid "Start candidature"
-msgstr "Début des candidatures"
-
-#: election/forms.py
-msgid "End candidature"
-msgstr "Fin des candidatures"
-
 #: election/models.py
 msgid "start candidature"
 msgstr "début des candidatures"
@@ -3978,10 +4024,6 @@ msgstr "groupe de vote"
 msgid "candidature groups"
 msgstr "groupe de candidature"
 
-#: election/models.py
-msgid "voters"
-msgstr "électeurs"
-
 #: election/models.py
 msgid "election"
 msgstr "élection"
@@ -4037,10 +4079,17 @@ msgstr "Vous avez déjà soumis votre vote."
 msgid "You have voted in this election."
 msgstr "Vous avez déjà voté pour cette élection."
 
+#: election/templates/election/election_detail.jinja election/views.py
+msgid "Blank vote"
+msgstr "Vote blanc"
+
 #: election/templates/election/election_detail.jinja
-#, python-format
-msgid "You may choose up to %(nb_choices)s people."
-msgstr "Vous pouvez choisir jusqu'à %(nb_choices)s personnes."
+msgid "You may choose up to"
+msgstr "Vous pouvez choisir jusqu'à"
+
+#: election/templates/election/election_detail.jinja
+msgid "people."
+msgstr "personne(s)"
 
 #: election/templates/election/election_detail.jinja
 msgid "Choose blank vote"
@@ -4082,6 +4131,26 @@ msgstr "au"
 msgid "Polls open from"
 msgstr "Votes ouverts du"
 
+#: election/views.py
+msgid "You have selected too much candidates."
+msgstr "Vous avez sélectionné trop de candidats."
+
+#: election/views.py
+msgid "User to candidate"
+msgstr "Utilisateur se présentant"
+
+#: election/views.py
+msgid "This role already exists for this election"
+msgstr "Ce rôle existe déjà pour cette élection"
+
+#: election/views.py
+msgid "Start candidature"
+msgstr "Début des candidatures"
+
+#: election/views.py
+msgid "End candidature"
+msgstr "Fin des candidatures"
+
 #: forum/models.py
 msgid "is a category"
 msgstr "est une catégorie"
@@ -4646,6 +4715,10 @@ 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"
@@ -5211,6 +5284,18 @@ 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"
@@ -5547,4 +5632,4 @@ msgstr "Vous ne pouvez plus écrire de commentaires, la date est passée."
 #: trombi/views.py
 #, python-format
 msgid "Maximum characters: %(max_length)s"
-msgstr "Nombre de caractères max: %(max_length)s"
+msgstr "Nombre de caractères max: %(max_length)s"

package-lock.json

@@ -29,6 +29,7 @@
         "d3-force-3d": "^3.0.5",
         "easymde": "^2.19.0",
         "glob": "^11.0.0",
+        "html2canvas": "^1.4.1",
         "htmx.org": "^2.0.3",
         "js-cookie": "^3.0.5",
         "lit-html": "^3.3.0",
@@ -3105,6 +3106,15 @@
         "@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",
@@ -3493,6 +3503,15 @@
         "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",
@@ -4165,6 +4184,19 @@
         "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.org": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/htmx.org/-/htmx.org-2.0.6.tgz",
@@ -5454,6 +5486,15 @@
       "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",
@@ -5711,6 +5752,15 @@
         "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",
       "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",

package.json

@@ -59,6 +59,7 @@
     "d3-force-3d": "^3.0.5",
     "easymde": "^2.19.0",
     "glob": "^11.0.0",
+    "html2canvas": "^1.4.1",
     "htmx.org": "^2.0.3",
     "js-cookie": "^3.0.5",
     "lit-html": "^3.3.0",

sith/settings.py

@@ -125,6 +125,7 @@ INSTALLED_APPS = (
     "pedagogy",
     "galaxy",
     "antispam",
+    "timetable",
     "api",
 )
 

sith/urls.py

@@ -53,6 +53,7 @@ urlpatterns = [
     path("i18n/", include("django.conf.urls.i18n")),
     path("jsi18n/", JavaScriptCatalog.as_view(), name="javascript-catalog"),
     path("captcha/", include("captcha.urls")),
+    path("edt/", include(("timetable.urls", "timetable"), namespace="timetable")),
 ]
 
 if settings.DEBUG:

timetable/admin.py

@@ -0,0 +1 @@
+# Register your models here.

timetable/apps.py

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

timetable/models.py

@@ -0,0 +1 @@
+# Create your models here.

timetable/static/bundled/timetable/generator-index.ts

@@ -0,0 +1,184 @@
+import html2canvas from "html2canvas";
+
+// see https://regex101.com/r/QHSaPM/2
+const TIMETABLE_ROW_RE: RegExp =
+  /^(?<ueCode>\w.+\w)\s+(?<courseType>[A-Z]{2}\d)\s+((?<weekGroup>[AB])\s+)?(?<weekday>(lundi)|(mardi)|(mercredi)|(jeudi)|(vendredi)|(samedi)|(dimanche))\s+(?<startHour>\d{2}:\d{2})\s+(?<endHour>\d{2}:\d{2})\s+[\dA-B]\s+((?<attendance>[\wé]*)\s+)?(?<room>\w+(?:, \w+)?)$/;
+
+const DEFAULT_TIMETABLE: string = `DS52\t\tCM1\t\tlundi\t08:00\t10:00\t1\tPrésentiel\tA113
+DS53\t\tCM1\t\tlundi\t10:15\t12:15\t1\tPrésentiel\tA101
+DS53\t\tTP1\t\tlundi\t13:00\t16:00\t1\tPrésentiel\tH010
+SO03\t\tCM1\t\tlundi\t16:15\t17:45\t1\tPrésentiel\tA103
+SO03\t\tTD1\t\tlundi\t17:45\t19:45\t1\tPrésentiel\tA103
+DS50\t\tTP1\t\tmardi\t08:00\t10:00\t1\tPrésentiel\tA216
+DS51\t\tCM1\t\tmardi\t10:15\t12:15\t1\tPrésentiel\tA216
+DS51\t\tTP1\t\tmardi\t14:00\t18:00\t1\tPrésentiel\tH010
+DS52\t\tTP2\tA\tjeudi\t08:00\t10:00\tA\tPrésentiel\tA110a, A110b
+DS52\t\tTD1\t\tjeudi\t10:15\t12:15\t1\tPrésentiel\tA110a, A110b
+LC02\t\tTP1\t\tjeudi\t15:00\t16:00\t1\tPrésentiel\tA209
+LC02\t\tTD1\t\tjeudi\t16:15\t18:15\t1\tPrésentiel\tA206`;
+
+type WeekDay =
+  | "lundi"
+  | "mardi"
+  | "mercredi"
+  | "jeudi"
+  | "vendredi"
+  | "samedi"
+  | "dimanche";
+
+const WEEKDAYS = [
+  "lundi",
+  "mardi",
+  "mercredi",
+  "jeudi",
+  "vendredi",
+  "samedi",
+  "dimanche",
+] as const;
+
+const SLOT_HEIGHT = 20 as const; // Each 15min has a height of 20px in the timetable
+const SLOT_WIDTH = 250 as const; // Each weekday ha a width of 400px in the timetable
+const MINUTES_PER_SLOT = 15 as const;
+
+interface TimetableSlot {
+  courseType: string;
+  room: string;
+  startHour: string;
+  endHour: string;
+  startSlot: number;
+  endSlot: number;
+  ueCode: string;
+  weekGroup?: string;
+  weekday: WeekDay;
+}
+
+function parseSlots(s: string): TimetableSlot[] {
+  return s
+    .split("\n")
+    .filter((s: string) => s.length > 0)
+    .map((row: string) => {
+      const parsed = TIMETABLE_ROW_RE.exec(row);
+      if (!parsed) {
+        throw new Error(`Couldn't parse row ${row}`);
+      }
+      const [startHour, startMin] = parsed.groups.startHour
+        .split(":")
+        .map((i) => Number.parseInt(i));
+      const [endHour, endMin] = parsed.groups.endHour
+        .split(":")
+        .map((i) => Number.parseInt(i));
+      return {
+        ...parsed.groups,
+        startSlot: Math.floor((startHour * 60 + startMin) / MINUTES_PER_SLOT),
+        endSlot: Math.floor((endHour * 60 + endMin) / MINUTES_PER_SLOT),
+      } as unknown as TimetableSlot;
+    });
+}
+
+document.addEventListener("alpine:init", () => {
+  Alpine.data("timetableGenerator", () => ({
+    content: DEFAULT_TIMETABLE,
+    error: "",
+    displayedWeekdays: [] as WeekDay[],
+    courses: [] as TimetableSlot[],
+    startSlot: 0,
+    endSlot: 0,
+    table: {
+      height: 0,
+      width: 0,
+    },
+
+    colors: {} as Record<string, string>,
+    colorPalette: [
+      "#27ae60",
+      "#2980b9",
+      "#c0392b",
+      "#7f8c8d",
+      "#f1c40f",
+      "#1abc9c",
+      "#95a5a6",
+      "#26C6DA",
+      "#c2185b",
+      "#e64a19",
+      "#1b5e20",
+    ],
+
+    generate() {
+      try {
+        this.courses = parseSlots(this.content);
+      } catch {
+        this.error = gettext(
+          "Wrong timetable format. Make sure you copied if from your student folder.",
+        );
+        return;
+      }
+
+      // color each UE
+      let colorIndex = 0;
+      for (const slot of this.courses) {
+        if (!this.colors[slot.ueCode]) {
+          this.colors[slot.ueCode] =
+            this.colorPalette[colorIndex % this.colorPalette.length];
+          colorIndex++;
+        }
+      }
+
+      this.displayedWeekdays = WEEKDAYS.filter((day) =>
+        this.courses.some((slot: TimetableSlot) => slot.weekday === day),
+      );
+      this.startSlot = this.courses.reduce(
+        (acc: number, curr: TimetableSlot) => Math.min(acc, curr.startSlot),
+        25 * 4,
+      );
+      this.endSlot = this.courses.reduce(
+        (acc: number, curr: TimetableSlot) => Math.max(acc, curr.endSlot),
+        1,
+      );
+      this.table.height = SLOT_HEIGHT * (this.endSlot - this.startSlot);
+      this.table.width = SLOT_WIDTH * this.displayedWeekdays.length;
+    },
+
+    getStyle(slot: TimetableSlot) {
+      const hasWeekGroup = slot.weekGroup !== undefined;
+      const width = hasWeekGroup ? SLOT_WIDTH / 2 : SLOT_WIDTH;
+      const leftOffset = slot.weekGroup === "B" ? SLOT_WIDTH / 2 : 0;
+      return {
+        height: `${(slot.endSlot - slot.startSlot) * SLOT_HEIGHT}px`,
+        width: `${width}px`,
+        top: `${(slot.startSlot - this.startSlot) * SLOT_HEIGHT}px`,
+        left: `${this.displayedWeekdays.indexOf(slot.weekday) * SLOT_WIDTH + leftOffset}px`,
+        backgroundColor: this.colors[slot.ueCode],
+      };
+    },
+
+    getHours(): [string, object][] {
+      let hour: number = Number.parseInt(
+        this.courses
+          .map((c: TimetableSlot) => c.startHour)
+          .reduce((res: string, hour: string) => (hour < res ? hour : res), "24:00")
+          .split(":")[0],
+      );
+      const res: [string, object][] = [];
+      for (let i = 0; i <= this.endSlot - this.startSlot; i += 60 / MINUTES_PER_SLOT) {
+        res.push([`${hour}:00`, { top: `${i * SLOT_HEIGHT}px` }]);
+        hour += 1;
+      }
+      return res;
+    },
+
+    getWidth() {
+      return this.displayedWeekdays.length * SLOT_WIDTH + 20;
+    },
+
+    async savePng() {
+      const elem = document.getElementById("timetable");
+      const img = (await html2canvas(elem)).toDataURL();
+      const downloadLink = document.createElement("a");
+      downloadLink.href = img;
+      downloadLink.download = "edt.png";
+      document.body.appendChild(downloadLink);
+      downloadLink.click();
+      downloadLink.remove();
+    },
+  }));
+});

timetable/static/timetable/css/generator.scss

@@ -0,0 +1,67 @@
+@import "core/static/core/colors";
+
+#timetable {
+  --hour-side-width: 60px;
+
+  display: block;
+  margin: 2em auto;
+  .header {
+    background-color: $white-color;
+    font-weight: bold;
+    box-shadow: none;
+    width: calc(100% - var(--hour-side-width) - 10px);
+    margin-left: var(--hour-side-width);
+    padding-left: 0;
+    display: flex;
+    flex-direction: row;
+    gap: 0;
+    span {
+      flex: 1;
+      text-align: center;
+    }
+  }
+  .content {
+    position: relative;
+  }
+  .hours {
+    position: absolute;
+    width: 40px;
+    left: 0;
+    top: -.5em;
+
+    .hour {
+      position: absolute;
+
+      .hour-bar {
+        content: "";
+        position: absolute;
+        height: 1px;
+        background: lightgray;
+        top: 50%;
+        left: 100%;
+        margin-left: 10px;
+      }
+    }
+  }
+  .courses {
+    position: absolute;
+    text-align: center;
+    top: 0;
+    left: var(--hour-side-width);
+
+    .slot {
+      background-color: cadetblue;
+      position: absolute;
+      display: flex;
+      flex-direction: column;
+      justify-content: center;
+
+      .course-type {
+        position: absolute;
+        top: 0;
+        right: 0;
+        padding: 10px;
+      }
+    }
+  }
+}

timetable/templates/timetable/generator.jinja

@@ -0,0 +1,68 @@
+{% extends 'core/base.jinja' %}
+
+{%- block additional_css -%}
+  <link rel="stylesheet" href="{{ static('timetable/css/generator.scss') }}">
+{%- endblock -%}
+
+{%- block additional_js -%}
+  <script type="module" src="{{ static('bundled/timetable/generator-index.ts') }}"></script>
+{%- endblock -%}
+
+{% block title %}
+  {% trans %}Timetable generator{% endtrans %}
+{% endblock %}
+
+{% block content %}
+  <div x-data="timetableGenerator">
+    <form @submit.prevent="generate()">
+      <h1>Générateur d'emploi du temps</h1>
+      <div class="alert alert-red" x-show="!!error" x-cloak>
+        <span class="alert-main" x-text="error"></span>
+      </div>
+      <div class="form-group">
+        <label for="timetable-input">Colle ton emploi du temps (sans l'entête)</label>
+        <textarea id="timetable-input" cols="30" rows="15" x-model="content"></textarea>
+      </div>
+      <input type="submit" class="btn btn-blue" value="{% trans %}Generate{% endtrans %}">
+    </form>
+    <div
+      id="timetable"
+      x-show="table.height > 0 && table.width > 0"
+      :style="{width: `${table.width+80}px`, height: `${table.height+40}px`}"
+    >
+      <div class="header">
+        <template x-for="weekday in displayedWeekdays">
+          <span x-text="weekday"></span>
+        </template>
+      </div>
+      <div class="content">
+        <div class="hours" :height="(endSlot - endSlot%4) - (startSlot - startSlot%4)">
+          <template x-for="[hour, style] in getHours()">
+            <div class="hour" :style="style">
+              <div x-text="hour"></div>
+              <div class="hour-bar" :style="{width: `${getWidth()}px`}"></div>
+            </div>
+          </template>
+        </div>
+        <div class="courses">
+          <template x-for="course in courses">
+            <div class="slot" :style="getStyle(course)">
+              <span class="course-type" x-text="course.courseType"></span>
+              <span x-text="course.ueCode"></span>
+              <span x-text="`${course.startHour} - ${course.endHour}`"></span>
+              <span x-text="(course.weekGroup ? `\nGroupe ${course.weekGroup}` : '')"></span>
+              <span x-text="course.room"></span>
+            </div>
+          </template>
+        </div>
+      </div>
+    </div>
+    <button
+      class="margin-bottom btn btn-blue"
+      @click="savePng"
+      x-show="table.height > 0 && table.width > 0"
+    >
+      {% trans %}Save to PNG{% endtrans %}
+    </button>
+  </div>
+{% endblock content %}

timetable/tests.py

@@ -0,0 +1 @@
+# Create your tests here.

timetable/urls.py

@@ -0,0 +1,5 @@
+from django.urls import path
+
+from timetable.views import GeneratorView
+
+urlpatterns = [path("", GeneratorView.as_view(), name="generator")]

timetable/views.py

@@ -0,0 +1,8 @@
+# Create your views here.
+from django.views.generic import TemplateView
+
+from core.auth.mixins import FormerSubscriberMixin
+
+
+class GeneratorView(FormerSubscriberMixin, TemplateView):
+    template_name = "timetable/generator.jinja"