add condition for EBOUTIC counter type in subscription creation

.gitignore

@@ -24,9 +24,6 @@ node_modules/
 # compiled documentation
 site/
 
-# rollup-bundle-visualizer report
-.bundle-size-report.html
-
 ### Redis ###
 
 # Ignore redis binary dump (dump.rdb) files

.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.15.5
+    rev: v0.11.13
     hooks:
       - id: ruff-check  # just check the code, and print the errors
       - id: ruff-check  # actually fix the fixable errors, but print nothing
@@ -12,9 +12,9 @@ repos:
     rev: v0.6.1
     hooks:
       - id: biome-check
-        additional_dependencies: ["@biomejs/biome@2.4.6"]
+        additional_dependencies: ["@biomejs/biome@1.9.4"]
   - repo: https://github.com/rtts/djhtml
-    rev: 3.0.10
+    rev: 3.0.7
     hooks:
       - id: djhtml
         name: format templates

api/auth.py

@@ -6,8 +6,6 @@ from api.models import ApiClient, ApiKey
 
 
 class ApiKeyAuth(APIKeyHeader):
-    """Authentication through client api keys."""
-
     param_name = "X-APIKey"
 
     def authenticate(self, request: HttpRequest, key: str | None) -> ApiClient | None:

api/hashers.py

@@ -8,7 +8,7 @@ from django.utils.crypto import constant_time_compare
 
 class Sha512ApiKeyHasher(BasePasswordHasher):
     """
-    An API key hasher using the sha512 algorithm.
+    An API key hasher using the sha256 algorithm.
 
     This hasher shouldn't be used in Django's `PASSWORD_HASHERS` setting.
     It is insecure for use in hashing passwords, but is safe for hashing

api/tests/test_mixed_auth.py

@@ -1,48 +0,0 @@
-import pytest
-from django.test import Client
-from django.urls import path
-from model_bakery import baker
-from ninja import NinjaAPI
-from ninja.security import SessionAuth
-
-from api.auth import ApiKeyAuth
-from api.hashers import generate_key
-from api.models import ApiClient, ApiKey
-
-api = NinjaAPI()
-
-
-@api.post("", auth=[ApiKeyAuth(), SessionAuth()])
-def post_method(*args, **kwargs) -> None:
-    """Dummy POST route authenticated by either api key or session cookie."""
-    pass
-
-
-urlpatterns = [path("", api.urls)]
-
-
-@pytest.mark.django_db
-@pytest.mark.urls(__name__)
-@pytest.mark.parametrize("user_logged_in", [False, True])
-def test_csrf_token(user_logged_in):
-    """Test that CSRF check happens only when no api key is used."""
-    client = Client(enforce_csrf_checks=True)
-    key, hashed = generate_key()
-    api_client = baker.make(ApiClient)
-    baker.make(ApiKey, client=api_client, hashed_key=hashed)
-    if user_logged_in:
-        client.force_login(api_client.owner)
-
-    response = client.post("")
-    assert response.status_code == 403
-    assert response.json()["detail"] == "CSRF check Failed"
-
-    # if using a valid API key, CSRF check should not occur
-    response = client.post("", headers={"X-APIKey": key})
-    assert response.status_code == 200
-
-    # if using a wrong API key, ApiKeyAuth should fail,
-    # leading to a fallback into SessionAuth and a CSRF check
-    response = client.post("", headers={"X-APIKey": generate_key()[0]})
-    assert response.status_code == 403
-    assert response.json()["detail"] == "CSRF check Failed"

api/urls.py

@@ -1,4 +1,3 @@
-from ninja.security import SessionAuth
 from ninja_extra import NinjaExtraAPI
 
 api = NinjaExtraAPI(
@@ -6,6 +5,6 @@ api = NinjaExtraAPI(
     description="Portail Interactif de Communication avec les Outils Numériques",
     version="0.2.0",
     urls_namespace="api",
-    auth=[SessionAuth()],
+    csrf=True,
 )
 api.auto_discover_controllers()

biome.json

@@ -7,34 +7,20 @@
   },
   "files": {
     "ignoreUnknown": false,
-    "includes": ["**/static/**", "vite.config.mts"]
+    "ignore": ["*.min.*", "staticfiles/generated"]
   },
   "formatter": {
     "enabled": true,
     "indentStyle": "space",
     "lineWidth": 88
   },
+  "organizeImports": {
+    "enabled": true
+  },
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true,
-      "style": {
-        "useNamingConvention": "error"
-      },
-      "performance": {
-        "noNamespaceImport": "error"
-      },
-      "suspicious": {
-        "noConsole": {
-          "level": "error",
-          "options": { "allow": ["error", "warn"] }
-        }
-      },
-      "correctness": {
-        "noUnusedVariables": "error",
-        "noUndeclaredVariables": "error",
-        "noUndeclaredDependencies": "error"
-      }
+      "all": true
     }
   },
   "javascript": {

club/admin.py

@@ -13,10 +13,8 @@
 #
 #
 from django.contrib import admin
-from django.forms.models import ModelForm
-from django.http import HttpRequest
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 
 
 @admin.register(Club)
@@ -31,31 +29,6 @@ class ClubAdmin(admin.ModelAdmin):
         "page",
     )
 
-    def save_model(
-        self,
-        request: HttpRequest,
-        obj: Club,
-        form: ModelForm,
-        change: bool,  # noqa: FBT001
-    ):
-        super().save_model(request, obj, form, change)
-        if not change:
-            obj.create_default_roles()
-
-
-@admin.register(ClubRole)
-class ClubRoleAdmin(admin.ModelAdmin):
-    list_display = ("name", "club", "is_board", "is_presidency")
-    search_fields = ("name",)
-    autocomplete_fields = ("club",)
-    list_select_related = ("club",)
-    list_filter = (
-        "is_board",
-        "is_presidency",
-        ("club", admin.RelatedOnlyFieldListFilter),
-    )
-    show_facets = admin.ModelAdmin.show_facets.ALWAYS
-
 
 @admin.register(Membership)
 class MembershipAdmin(admin.ModelAdmin):

club/api.py

@@ -1,20 +1,16 @@
+from typing import Annotated
+
+from annotated_types import MinLen
 from django.db.models import Prefetch
-from ninja import Query
 from ninja.security import SessionAuth
 from ninja_extra import ControllerBase, api_controller, paginate, route
 from ninja_extra.pagination import PageNumberPaginationExtra
 from ninja_extra.schemas import PaginatedResponseSchema
 
 from api.auth import ApiKeyAuth
-from api.permissions import CanView, HasPerm
+from api.permissions import CanAccessLookup, HasPerm
 from club.models import Club, Membership
-from club.schemas import (
-    ClubSchema,
-    ClubSearchFilterSchema,
-    SimpleClubSchema,
-    UserMembershipSchema,
-)
-from core.models import User
+from club.schemas import ClubSchema, SimpleClubSchema
 
 
 @api_controller("/club")
@@ -22,43 +18,25 @@ class ClubController(ControllerBase):
     @route.get(
         "/search",
         response=PaginatedResponseSchema[SimpleClubSchema],
+        auth=[SessionAuth(), ApiKeyAuth()],
+        permissions=[CanAccessLookup],
         url_name="search_club",
     )
     @paginate(PageNumberPaginationExtra, page_size=50)
-    def search_club(self, filters: Query[ClubSearchFilterSchema]):
-        return filters.filter(Club.objects.order_by("name")).values()
+    def search_club(self, search: Annotated[str, MinLen(1)]):
+        return Club.objects.filter(name__icontains=search).values()
 
     @route.get(
         "/{int:club_id}",
         response=ClubSchema,
-        auth=[ApiKeyAuth(), SessionAuth()],
+        auth=[SessionAuth(), ApiKeyAuth()],
         permissions=[HasPerm("club.view_club")],
         url_name="fetch_club",
     )
     def fetch_club(self, club_id: int):
         prefetch = Prefetch(
-            "members",
-            queryset=Membership.objects.ongoing().select_related("user", "role"),
+            "members", queryset=Membership.objects.ongoing().select_related("user")
         )
         return self.get_object_or_exception(
             Club.objects.prefetch_related(prefetch), id=club_id
         )
-
-
-@api_controller("/user/{int:user_id}/club")
-class UserClubController(ControllerBase):
-    @route.get(
-        "",
-        response=list[UserMembershipSchema],
-        auth=[ApiKeyAuth(), SessionAuth()],
-        permissions=[CanView],
-        url_name="fetch_user_clubs",
-    )
-    def fetch_user_clubs(self, user_id: int):
-        """Get all the active memberships of the given user."""
-        user = self.get_object_or_exception(User, id=user_id)
-        return (
-            Membership.objects.ongoing()
-            .filter(user=user)
-            .select_related("club", "user", "role")
-        )

club/forms.py

@@ -23,12 +23,13 @@
 #
 
 from django import forms
-from django.db.models import Exists, OuterRef, Q, QuerySet
+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, ClubRole, Mailing, MailingSubscription, Membership
+from club.models import Club, Mailing, MailingSubscription, Membership
 from core.models import User
 from core.views.forms import SelectDateTime
 from core.views.widgets.ajax_select import (
@@ -36,7 +37,6 @@ from core.views.widgets.ajax_select import (
     AutoCompleteSelectUser,
 )
 from counter.models import Counter, Selling
-from counter.schemas import SaleFilterSchema
 
 
 class ClubEditForm(forms.ModelForm):
@@ -191,18 +191,6 @@ class SellingsForm(forms.Form):
             required=False,
         )
 
-    def to_filter_schema(self) -> SaleFilterSchema:
-        products = (
-            *self.cleaned_data["products"],
-            *self.cleaned_data["archived_products"],
-        )
-        return SaleFilterSchema(
-            after=self.cleaned_data["begin_date"],
-            before=self.cleaned_data["end_date"],
-            counters={c.id for c in self.cleaned_data["counters"]} or None,
-            products={p.id for p in products} or None,
-        )
-
 
 class ClubOldMemberForm(forms.Form):
     members_old = forms.ModelMultipleChoiceField(
@@ -214,7 +202,9 @@ class ClubOldMemberForm(forms.Form):
 
     def __init__(self, *args, user: User, club: Club, **kwargs):
         super().__init__(*args, **kwargs)
-        self.fields["members_old"].queryset = club.members.ongoing().editable_by(user)
+        self.fields["members_old"].queryset = (
+            Membership.objects.ongoing().filter(club=club).editable_by(user)
+        )
 
 
 class ClubMemberForm(forms.ModelForm):
@@ -232,14 +222,19 @@ class ClubMemberForm(forms.ModelForm):
         self.request_user = request_user
         self.request_user_membership = self.club.get_membership_for(self.request_user)
         super().__init__(*args, **kwargs)
-        self.fields["role"].queryset = self.available_roles
+        self.fields["role"].required = True
+        self.fields["role"].choices = [
+            (value, name)
+            for value, name in settings.SITH_CLUB_ROLES.items()
+            if value <= self.max_available_role
+        ]
         self.instance.club = club
 
     @property
-    def available_roles(self) -> QuerySet[ClubRole]:
-        """The roles that will be obtainable with this form."""
+    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 ClubRole.objects.none()  # pragma: no cover
+        return -1  # pragma: no cover
 
 
 class ClubAddMemberForm(ClubMemberForm):
@@ -250,22 +245,21 @@ class ClubAddMemberForm(ClubMemberForm):
         widgets = {"user": AutoCompleteSelectUser}
 
     @cached_property
-    def available_roles(self):
-        """The roles that will be obtainable with this form.
+    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
         """
-        qs = self.club.roles.filter(is_active=True)
-        if self.request_user.has_perm("club.add_membership"):
-            return qs.all()
+        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 not membership.role.is_board:
-            return ClubRole.objects.none()
-        if membership.role.is_presidency:
-            return qs.all()
-        return qs.above_instance(membership.role)
+        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.
@@ -289,11 +283,13 @@ class JoinClubForm(ClubMemberForm):
 
     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 available_roles(self):
-        return self.club.roles.filter(is_board=False, is_active=True)
+    def max_available_role(self):
+        return settings.SITH_MAXIMUM_FREE_ROLE
 
     def clean(self):
         """Check that the user is subscribed and isn't already in the club."""
@@ -306,88 +302,3 @@ class JoinClubForm(ClubMemberForm):
                 _("You are already a member of this club"), code="invalid"
             )
         return super().clean()
-
-
-class ClubSearchForm(forms.ModelForm):
-    class Meta:
-        model = Club
-        fields = ["name"]
-        widgets = {"name": forms.SearchInput(attrs={"autocomplete": "off"})}
-
-    club_status = forms.NullBooleanField(
-        label=_("Club status"),
-        widget=forms.RadioSelect(
-            choices=[(True, _("Active")), (False, _("Inactive")), ("", _("All clubs"))],
-        ),
-        initial=True,
-    )
-
-    def __init__(self, *args, data: dict | None = None, **kwargs):
-        super().__init__(*args, data=data, **kwargs)
-        if data is not None and "club_status" not in data:
-            # if the key is missing, it is considered as None,
-            # even though we want the default True value to be applied in such a case
-            # so we enforce it.
-            self.fields["club_status"].value = True
-        self.fields["name"].required = False
-
-
-class ClubRoleForm(forms.ModelForm):
-    error_css_class = "error"
-    required_css_class = "required"
-
-    class Meta:
-        model = ClubRole
-        fields = ["name", "description", "is_presidency", "is_board", "is_active"]
-        widgets = {
-            "is_presidency": forms.HiddenInput(),
-            "is_board": forms.HiddenInput(),
-            "is_active": forms.CheckboxInput(attrs={"class": "switch"}),
-        }
-
-    def clean(self):
-        cleaned_data = super().clean()
-        if "ORDER" in cleaned_data:
-            self.instance.order = cleaned_data["ORDER"] - 1
-        return cleaned_data
-
-
-class ClubRoleCreateForm(forms.ModelForm):
-    """Form to create a club role.
-
-    Notes:
-        For UX purposes, users are not meant to fill `is_presidency`
-        and `is_board`, so those values are required by the form constructor
-        in order to initialize the instance properly.
-    """
-
-    error_css_class = "error"
-    required_css_class = "required"
-
-    class Meta:
-        model = ClubRole
-        fields = ["name", "description"]
-
-    def __init__(
-        self, *args, club: Club, is_presidency: bool, is_board: bool, **kwargs
-    ):
-        super().__init__(*args, **kwargs)
-        self.instance.club = club
-        self.instance.is_presidency = is_presidency
-        self.instance.is_board = is_board
-
-
-class ClubRoleBaseFormSet(forms.BaseInlineFormSet):
-    ordering_widget = forms.HiddenInput()
-
-
-ClubRoleFormSet = forms.inlineformset_factory(
-    Club,
-    ClubRole,
-    ClubRoleForm,
-    ClubRoleBaseFormSet,
-    can_delete=False,
-    can_order=True,
-    edit_only=True,
-    extra=0,
-)

club/migrations/0012_club_board_group_club_members_group.py

@@ -2,15 +2,12 @@
 
 import django.db.models.deletion
 import django.db.models.functions.datetime
+from django.conf import settings
 from django.db import migrations, models
 from django.db.migrations.state import StateApps
 from django.db.models import Q
 from django.utils.timezone import localdate
 
-# Before the club role rework, the maximum free role
-# was the hardcoded highest non-board role
-MAXIMUM_FREE_ROLE = 1
-
 
 def migrate_meta_groups(apps: StateApps, schema_editor):
     """Attach the existing meta groups to the clubs.
@@ -49,7 +46,10 @@ def migrate_meta_groups(apps: StateApps, schema_editor):
         ).select_related("user")
         club.members_group.users.set([m.user for m in memberships])
         club.board_group.users.set(
-            [m.user for m in memberships.filter(role__gt=MAXIMUM_FREE_ROLE)]
+            [
+                m.user
+                for m in memberships.filter(role__gt=settings.SITH_MAXIMUM_FREE_ROLE)
+            ]
         )
 
 

club/migrations/0015_clubrole_alter_membership_role.py

@@ -1,161 +0,0 @@
-# Generated by Django 5.2.3 on 2025-06-21 21:59
-
-import django.db.models.deletion
-from django.db import migrations, models
-from django.db.migrations.state import StateApps
-from django.db.models import Case, When
-
-PRESIDENCY_ROLES = [10, 9]
-MAXIMUM_FREE_ROLE = 1
-SITH_CLUB_ROLES = {
-    10: "Président⸱e",
-    9: "Vice-Président⸱e",
-    7: "Trésorier⸱e",
-    5: "Responsable communication",
-    4: "Secrétaire",
-    3: "Responsable info",
-    2: "Membre du bureau",
-    1: "Membre actif⸱ve",
-    0: "Curieux⸱euse",
-}
-
-
-def migrate_roles(apps: StateApps, schema_editor):
-    ClubRole = apps.get_model("club", "ClubRole")
-    Membership = apps.get_model("club", "Membership")
-
-    updates = []
-    for club_id, role in Membership.objects.values_list("club", "role").distinct():
-        new_role = ClubRole.objects.create(
-            name=SITH_CLUB_ROLES[role],
-            is_board=role > MAXIMUM_FREE_ROLE,
-            is_presidency=role in PRESIDENCY_ROLES,
-            club_id=club_id,
-            order=max(SITH_CLUB_ROLES) - role,
-        )
-        updates.append(When(role=role, then=new_role.id))
-    # all updates must happen at the same time
-    # otherwise, the 10 first created ClubRole would be
-    # re-modified after their initial creation, and it would
-    # result in an incoherent state.
-    # To avoid that, all updates are wrapped in a single giant Case(When) statement
-    # cf. https://docs.djangoproject.com/fr/stable/ref/models/conditional-expressions/#conditional-update
-    Membership.objects.update(role=Case(*updates))
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("club", "0014_alter_club_options_rename_unix_name_club_slug_name_and_more"),
-        ("core", "0047_alter_notification_date_alter_notification_type"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="club",
-            name="page",
-            field=models.OneToOneField(
-                blank=True,
-                on_delete=django.db.models.deletion.PROTECT,
-                related_name="club",
-                to="core.page",
-            ),
-        ),
-        migrations.CreateModel(
-            name="ClubRole",
-            fields=[
-                (
-                    "id",
-                    models.AutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "order",
-                    models.PositiveIntegerField(
-                        db_index=True, editable=False, verbose_name="order"
-                    ),
-                ),
-                (
-                    "club",
-                    models.ForeignKey(
-                        help_text="The club with which this role is associated",
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="roles",
-                        to="club.club",
-                        verbose_name="club",
-                    ),
-                ),
-                ("name", models.CharField(max_length=50, verbose_name="name")),
-                (
-                    "description",
-                    models.TextField(
-                        default="", blank=True, verbose_name="description"
-                    ),
-                ),
-                (
-                    "is_board",
-                    models.BooleanField(default=False, verbose_name="Board role"),
-                ),
-                (
-                    "is_presidency",
-                    models.BooleanField(default=False, verbose_name="Presidency role"),
-                ),
-                (
-                    "is_active",
-                    models.BooleanField(
-                        default=True,
-                        help_text=(
-                            "If the role is inactive, people joining the club "
-                            "won't be able to get it."
-                        ),
-                        verbose_name="is active",
-                    ),
-                ),
-            ],
-            options={
-                "ordering": ("order",),
-                "verbose_name": "club role",
-                "verbose_name_plural": "club roles",
-            },
-        ),
-        migrations.AlterField(
-            model_name="club",
-            name="board_group",
-            field=models.OneToOneField(
-                editable=False,
-                on_delete=django.db.models.deletion.PROTECT,
-                related_name="club_board",
-                to="core.group",
-            ),
-        ),
-        migrations.AlterField(
-            model_name="club",
-            name="members_group",
-            field=models.OneToOneField(
-                editable=False,
-                on_delete=django.db.models.deletion.PROTECT,
-                related_name="club",
-                to="core.group",
-            ),
-        ),
-        migrations.AddConstraint(
-            model_name="clubrole",
-            constraint=models.CheckConstraint(
-                condition=models.Q(
-                    ("is_presidency", False), ("is_board", True), _connector="OR"
-                ),
-                name="clubrole_presidency_implies_board",
-                violation_error_message=(
-                    "A role cannot be in the presidency while not being in the board"
-                ),
-            ),
-        ),
-        migrations.RunPython(migrate_roles, migrations.RunPython.noop),
-        # because Postgres migrations run in a single transaction,
-        # we cannot change the actual values of Membership.role
-        # and apply the FOREIGN KEY constraint in the same migration.
-        # The constraint is created in the next migration
-    ]

club/migrations/0016_clubrole_alter_membership_role.py

@@ -1,25 +0,0 @@
-# Generated by Django 5.2.3 on 2025-09-27 09:57
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [("club", "0015_clubrole_alter_membership_role")]
-
-    operations = [
-        # because Postgres migrations run in a single transaction,
-        # we cannot change the actual values of Membership.role
-        # and apply the FOREIGN KEY constraint in the same migration.
-        # The data migration was made in the previous migration.
-        migrations.AlterField(
-            model_name="membership",
-            name="role",
-            field=models.ForeignKey(
-                on_delete=django.db.models.deletion.PROTECT,
-                related_name="members",
-                to="club.clubrole",
-                verbose_name="role",
-            ),
-        ),
-    ]

club/models.py

@@ -26,17 +26,18 @@ from __future__ import annotations
 from typing import Iterable, Self
 
 from django.conf import settings
+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 ProgrammingError, models, transaction
-from django.db.models import Exists, F, OuterRef, Q
+from django.db import models, transaction
+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
 from django.utils.text import slugify
 from django.utils.timezone import localdate
 from django.utils.translation import gettext_lazy as _
-from ordered_model.models import OrderedModel
 
 from core.fields import ResizedImageField
 from core.models import Group, Notification, Page, SithFile, User
@@ -89,13 +90,13 @@ class Club(models.Model):
         on_delete=models.SET_NULL,
     )
     page = models.OneToOneField(
-        Page, related_name="club", blank=True, on_delete=models.PROTECT
+        Page, related_name="club", blank=True, on_delete=models.CASCADE
     )
     members_group = models.OneToOneField(
-        Group, related_name="club", on_delete=models.PROTECT, editable=False
+        Group, related_name="club", on_delete=models.PROTECT
     )
     board_group = models.OneToOneField(
-        Group, related_name="club_board", on_delete=models.PROTECT, editable=False
+        Group, related_name="club_board", on_delete=models.PROTECT
     )
 
     objects = ClubQuerySet.as_manager()
@@ -138,7 +139,9 @@ class Club(models.Model):
     @cached_property
     def president(self) -> Membership | None:
         """Fetch the membership of the current president of this club."""
-        return self.members.filter(end_date=None).order_by("role__order").first()
+        return self.members.filter(
+            role=settings.SITH_CLUB_ROLES_ID["President"], end_date=None
+        ).first()
 
     def check_loop(self):
         """Raise a validation error when a loop is found within the parent list."""
@@ -183,41 +186,10 @@ class Club(models.Model):
             self.page.parent = self.parent.page
         self.page.save(force_lock=True)
 
-    def create_default_roles(self):
-        """Create some roles that should exist by default for this club.
-
-        The created roles are : president, treasurer, active member and curious.
-
-        Warnings:
-            When calling this method, no club must exist yet for this club.
-        """
-        if self.roles.exists():
-            raise ProgrammingError(
-                "Default roles can be created only for clubs "
-                "that don't have associated roles yet"
-            )
-        # The names are written in French, because there is no gettext involved
-        # for strings stored in database, and the majority of users are french.
-        roles = [
-            ClubRole(name="Président⸱e", is_board=True, is_presidency=True),
-            ClubRole(name="Trésorier⸱e", is_board=True, is_presidency=False),
-            ClubRole(name="Membre actif⸱ve", is_board=False, is_presidency=False),
-            ClubRole(
-                name="Curieux⸱euse",
-                description=(
-                    "Les gens qui suivent l'activité "
-                    "du club sans forcément y participer"
-                ),
-                is_board=False,
-                is_presidency=False,
-            ),
-        ]
-        for i, role in enumerate(roles):
-            role.club = self
-            role.order = i
-        ClubRole.objects.bulk_create(roles)
-
     def delete(self, *args, **kwargs) -> tuple[int, dict[str, int]]:
+        # Invalidate the cache of this club and of its memberships
+        for membership in self.members.ongoing().select_related("user"):
+            cache.delete(f"membership_{self.id}_{membership.user.id}")
         self.board_group.delete()
         self.members_group.delete()
         return super().delete(*args, **kwargs)
@@ -238,120 +210,29 @@ 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_roles_be_edited_by(self, user: User) -> bool:
-        """Return True if the given user can edit the roles of this club"""
-        return user.is_authenticated and (
-            user.has_perm("club.change_clubrole")
-            or self.members.ongoing()
-            .filter(user=user, role__is_presidency=True)
-            .exists()
-        )
-
-    @cached_property
-    def current_members(self) -> list[Membership]:
-        return list(
-            self.members.ongoing().select_related("user", "role").order_by("-role")
-        )
-
     def get_membership_for(self, user: User) -> Membership | None:
-        """Return the current membership of the given user."""
+        """Return the current membership the given user.
+
+        Note:
+            The result is cached.
+        """
         if user.is_anonymous:
             return None
-        return next((m for m in self.current_members if m.user_id == user.id), None)
+        membership = cache.get(f"membership_{self.id}_{user.id}")
+        if membership == "not_member":
+            return None
+        if membership is None:
+            membership = self.members.filter(user=user, end_date=None).first()
+            if membership is None:
+                cache.set(f"membership_{self.id}_{user.id}", "not_member")
+            else:
+                cache.set(f"membership_{self.id}_{user.id}", membership)
+        return membership
 
     def has_rights_in_club(self, user: User) -> bool:
         return user.is_in_group(pk=self.board_group_id)
 
 
-class ClubRole(OrderedModel):
-    club = models.ForeignKey(
-        Club,
-        verbose_name=_("club"),
-        help_text=_("The club with which this role is associated"),
-        related_name="roles",
-        on_delete=models.CASCADE,
-    )
-    name = models.CharField(_("name"), max_length=50)
-    description = models.TextField(_("description"), blank=True, default="")
-    is_board = models.BooleanField(_("Board role"), default=False)
-    is_presidency = models.BooleanField(_("Presidency role"), default=False)
-    is_active = models.BooleanField(
-        _("is active"),
-        default=True,
-        help_text=_(
-            "If the role is inactive, people joining the club won't be able to get it."
-        ),
-    )
-
-    order_with_respect_to = "club"
-
-    class Meta(OrderedModel.Meta):
-        verbose_name = _("club role")
-        verbose_name_plural = _("club roles")
-        constraints = [
-            # presidency IMPLIES board <=> NOT presidency OR board
-            # cf. MT1 :)
-            models.CheckConstraint(
-                condition=Q(is_presidency=False) | Q(is_board=True),
-                name="clubrole_presidency_implies_board",
-                violation_error_message=_(
-                    "A role cannot be in the presidency while not being in the board"
-                ),
-            )
-        ]
-
-    def __str__(self):
-        return self.name
-
-    def get_display_name(self):
-        return f"{self.name} - {self.club.name}"
-
-    def clean(self):
-        errors = []
-        roles = list(self.club.roles.all())
-        if (
-            self.is_board
-            and self.order
-            and any(r.order < self.order and not r.is_board for r in roles)
-        ):
-            errors.append(
-                ValidationError(
-                    _("Role %(role)s cannot be placed below a member role")
-                    % {"role": self.name}
-                )
-            )
-        if (
-            self.is_presidency
-            and self.order
-            and any(r.order < self.order and not r.is_presidency for r in roles)
-        ):
-            errors.append(
-                ValidationError(
-                    _("Role %(role)s cannot be placed below a non-presidency role")
-                    % {"role": self.name}
-                )
-            )
-        if errors:
-            raise ValidationError(errors)
-        return super().clean()
-
-    def save(self, *args, **kwargs):
-        auto_order = self.order is None and self.is_board
-        if not auto_order:
-            super().save(*args, **kwargs)
-            return
-        # get the role that should be placed after the role we are dealing with.
-        # So, if this is role is presidency, get the first board role ;
-        # if it is a board role, get the first member role ;
-        # and if it is a member role, get nothing (OrderedModel.save will
-        # automatically put it in the last position anyway)
-        filters = {"is_board": self.is_presidency, "is_presidency": False}
-        next_role = self.club.roles.filter(**filters).order_by("order").first()
-        super().save(*args, **kwargs)
-        if next_role:
-            self.above(next_role)
-
-
 class MembershipQuerySet(models.QuerySet):
     def ongoing(self) -> Self:
         """Filter all memberships which are not finished yet."""
@@ -364,10 +245,9 @@ class MembershipQuerySet(models.QuerySet):
         are included, even if there are no more members.
 
         If you want to get the users who are currently in the board,
-        mind combining this with the [MembershipQuerySet.ongoing][]
-        queryset method
+        mind combining this with the :meth:`ongoing` queryset method
         """
-        return self.filter(role__is_board=True)
+        return self.filter(role__gt=settings.SITH_MAXIMUM_FREE_ROLE)
 
     def editable_by(self, user: User) -> Self:
         """Filter Memberships that this user can edit.
@@ -390,42 +270,60 @@ class MembershipQuerySet(models.QuerySet):
         """
         if user.has_perm("club.change_membership"):
             return self.all()
-        return self.ongoing().filter(
+        return self.filter(
             Q(user=user)
             | Exists(
-                Membership.objects.ongoing().filter(
+                Membership.objects.filter(
+                    Q(
+                        role__gt=Greatest(
+                            OuterRef("role"), Value(settings.SITH_MAXIMUM_FREE_ROLE)
+                        )
+                    ),
                     user=user,
+                    end_date=None,
                     club=OuterRef("club"),
-                    role__is_board=True,
-                    role__order__lt=OuterRef("role__order"),
                 )
-            )
+            ),
+            end_date=None,
         )
 
     def update(self, **kwargs) -> int:
-        """Remove users from club groups they are no more in
+        """Refresh the cache and edit group ownership.
+
+        Update the cache, when necessary, remove
+        users from club groups they are no more in
         and add them in the club groups they should be in.
 
         Be aware that this adds three db queries :
-
-        - one to retrieve the updated memberships
-        - one to perform group removal
-        - and one to perform group attribution.
+        one to retrieve the updated memberships,
+        one to perform group removal and one to perform
+        group attribution.
         """
         nb_rows = super().update(**kwargs)
         if nb_rows == 0:
-            # if no row was affected, no need to edit club groups
+            # if no row was affected, no need to refresh the cache
             return 0
 
+        cache_memberships = {}
         memberships = set(self.select_related("club"))
         # delete all User-Group relations and recreate the necessary ones
+        # It's more concise to write and more reliable
         Membership._remove_club_groups(memberships)
         Membership._add_club_groups(memberships)
+        for member in memberships:
+            cache_key = f"membership_{member.club_id}_{member.user_id}"
+            if member.end_date is None:
+                cache_memberships[cache_key] = member
+            else:
+                cache_memberships[cache_key] = "not_member"
+        cache.set_many(cache_memberships)
         return nb_rows
 
     def delete(self) -> tuple[int, dict[str, int]]:
         """Work just like the default Django's delete() method,
-        but also remove the concerned users from the club groups.
+        but add a cache invalidation for the elements of the queryset
+        before the deletion,
+        and a removal of the user from the club groups.
 
         Be aware that this adds some db queries :
 
@@ -441,6 +339,12 @@ class MembershipQuerySet(models.QuerySet):
         nb_rows, rows_counts = super().delete()
         if nb_rows > 0:
             Membership._remove_club_groups(memberships)
+            cache.set_many(
+                {
+                    f"membership_{m.club_id}_{m.user_id}": "not_member"
+                    for m in memberships
+                }
+            )
         return nb_rows, rows_counts
 
 
@@ -469,11 +373,10 @@ class Membership(models.Model):
     )
     start_date = models.DateField(_("start date"), default=timezone.now)
     end_date = models.DateField(_("end date"), null=True, blank=True)
-    role = models.ForeignKey(
-        ClubRole,
-        verbose_name=_("role"),
-        related_name="members",
-        on_delete=models.PROTECT,
+    role = models.IntegerField(
+        _("role"),
+        choices=sorted(settings.SITH_CLUB_ROLES.items()),
+        default=sorted(settings.SITH_CLUB_ROLES.items())[0][0],
     )
     description = models.CharField(
         _("description"), max_length=128, null=False, blank=True
@@ -491,7 +394,7 @@ class Membership(models.Model):
     def __str__(self):
         return (
             f"{self.club.name} - {self.user.username} "
-            f"- {self.role.name} "
+            f"- {settings.SITH_CLUB_ROLES[self.role]} "
             f"- {str(_('past member')) if self.end_date is not None else ''}"
         )
 
@@ -505,6 +408,9 @@ class Membership(models.Model):
         self._remove_club_groups([self])
         if self.end_date is None:
             self._add_club_groups([self])
+            cache.set(f"membership_{self.club_id}_{self.user_id}", self)
+        else:
+            cache.set(f"membership_{self.club_id}_{self.user_id}", "not_member")
 
     def get_absolute_url(self):
         return reverse("club:club_members", kwargs={"club_id": self.club_id})
@@ -520,15 +426,12 @@ class Membership(models.Model):
         if user.is_root or user.is_board_member:
             return True
         membership = self.club.get_membership_for(user)
-        if not membership:
-            return False
-        return membership.user_id == user.id or (
-            membership.is_board and membership.role.order < self.role.order
-        )
+        return membership is not None and membership.role >= self.role
 
     def delete(self, *args, **kwargs):
         self._remove_club_groups([self])
         super().delete(*args, **kwargs)
+        cache.delete(f"membership_{self.club_id}_{self.user_id}")
 
     @staticmethod
     def _remove_club_groups(
@@ -600,7 +503,7 @@ class Membership(models.Model):
                     group_id=membership.club.members_group_id,
                 )
             )
-            if membership.role.is_board:
+            if membership.role > settings.SITH_MAXIMUM_FREE_ROLE:
                 club_groups.append(
                     User.groups.through(
                         user_id=membership.user_id,

club/schemas.py

@@ -1,22 +1,7 @@
-from typing import Annotated
+from ninja import ModelSchema
 
-from django.db.models import Q
-from ninja import FilterLookup, FilterSchema, ModelSchema
-
-from club.models import Club, ClubRole, Membership
-from core.schemas import NonEmptyStr, SimpleUserSchema
-
-
-class ClubSearchFilterSchema(FilterSchema):
-    search: Annotated[NonEmptyStr | None, FilterLookup("name__icontains")] = None
-    is_active: bool | None = None
-    parent_id: int | None = None
-    exclude_ids: set[int] | None = None
-
-    def filter_exclude_ids(self, value: set[int] | None):
-        if value is None:
-            return Q()
-        return ~Q(id__in=value)
+from club.models import Club, Membership
+from core.schemas import SimpleUserSchema
 
 
 class SimpleClubSchema(ModelSchema):
@@ -30,7 +15,7 @@ class ClubProfileSchema(ModelSchema):
 
     class Meta:
         model = Club
-        fields = ["id", "name", "logo", "is_active", "short_description"]
+        fields = ["id", "name", "logo"]
 
     url: str
 
@@ -39,21 +24,12 @@ class ClubProfileSchema(ModelSchema):
         return obj.get_absolute_url()
 
 
-class ClubRoleSchema(ModelSchema):
-    class Meta:
-        model = ClubRole
-        fields = ["id", "name", "is_presidency", "is_board"]
-
-
 class ClubMemberSchema(ModelSchema):
-    """A schema to represent all memberships in a club."""
-
     class Meta:
         model = Membership
-        fields = ["start_date", "end_date", "description"]
+        fields = ["start_date", "end_date", "role", "description"]
 
     user: SimpleUserSchema
-    role: ClubRoleSchema
 
 
 class ClubSchema(ModelSchema):
@@ -62,14 +38,3 @@ class ClubSchema(ModelSchema):
         fields = ["id", "name", "logo", "is_active", "short_description", "address"]
 
     members: list[ClubMemberSchema]
-
-
-class UserMembershipSchema(ModelSchema):
-    """A schema to represent the active club memberships of a user."""
-
-    class Meta:
-        model = Membership
-        fields = ["id", "start_date", "description"]
-
-    club: SimpleClubSchema
-    role: ClubRoleSchema

club/static/bundled/club/components/ajax-select-index.ts

@@ -1,7 +1,7 @@
+import { AjaxSelect } from "#core:core/components/ajax-select-base";
+import { registerComponent } from "#core:utils/web-components";
 import type { TomOption } from "tom-select/dist/types/types";
 import type { escape_html } from "tom-select/dist/types/utils";
-import { AjaxSelect } from "#core:core/components/ajax-select-base.ts";
-import { registerComponent } from "#core:utils/web-components.ts";
 import { type ClubSchema, clubSearchClub } from "#openapi";
 
 @registerComponent("club-ajax-select")

club/static/bundled/club/role-list-index.ts

@@ -1,61 +0,0 @@
-import type { AlpineComponent } from "alpinejs";
-
-interface RoleGroupData {
-  isBoard: boolean;
-  isPresidency: boolean;
-  roleId: number;
-}
-
-document.addEventListener("alpine:init", () => {
-  Alpine.data("clubRoleList", (config: { userRoleId: number | null }) => ({
-    confirmOnSubmit: false,
-
-    /**
-     * Edit relevant item data after it has been moved by x-sort
-     */
-    reorder(item: AlpineComponent<RoleGroupData>, conf: RoleGroupData) {
-      item.isBoard = conf.isBoard;
-      item.isPresidency = conf.isPresidency;
-      // if the user has moved its own role outside the presidency,
-      // submitting the form will require a confirmation
-      this.confirmOnSubmit = config.userRoleId === item.roleId && !item.isPresidency;
-      this.resetOrder();
-    },
-    /**
-     * Reset the value of the ORDER input of all items in the list.
-     * This is to be called after any reordering operation, in order to make sure
-     * that the order that will be saved is coherent with what is displayed.
-     */
-    resetOrder() {
-      // When moving items with x-sort, the only information we truly have is
-      // the end position in the target group, not the previous position nor
-      // the position in the global list.
-      // To overcome this, we loop through an enumeration of all inputs
-      // that are in the form `roles-X-ORDER` and sequentially set the value of the field.
-      const inputs = document.querySelectorAll<HTMLInputElement>(
-        "input[name^='roles'][name$='ORDER']",
-      );
-      for (const [i, elem] of inputs.entries()) {
-        elem.value = (i + 1).toString();
-      }
-    },
-
-    /**
-     * If the user moved its role out of the presidency, ask a confirmation
-     * before submitting the form
-     */
-    confirmSubmission(event: SubmitEvent) {
-      if (
-        this.confirmOnSubmit &&
-        !confirm(
-          gettext(
-            "You're going to remove your own role from the presidency. " +
-              "You may lock yourself out of this page. Do you want to continue ? ",
-          ),
-        )
-      ) {
-        event.preventDefault();
-      }
-    },
-  }));
-});

club/static/club/list.scss

@@ -1,47 +0,0 @@
-#club-list {
-  display: flex;
-  flex-direction: column;
-  gap: 2em;
-  padding: 2em;
-
-  .card {
-    display: block;
-    background-color: unset;
-
-    .club-image {
-      float: left;
-      margin-right: 2rem;
-      margin-bottom: .5rem;
-      width: 150px;
-      height: 150px;
-      border-radius: 10%;
-      background-color: rgba(173, 173, 173, 0.2);
-
-      @media screen and (max-width: 500px) {
-        width: 100px;
-        height: 100px;
-      }
-    }
-
-    i.club-image {
-      display: flex;
-      flex-direction: column;
-      justify-content: center;
-      color: black;
-    }
-
-    .content {
-      display: block;
-      text-align: justify;
-
-      h4 {
-        margin-top: 0;
-        margin-right: .5rem;
-      }
-
-      p {
-        font-size: 100%;
-      }
-    }
-  }
-}

club/static/club/roles.scss

@@ -1,7 +0,0 @@
-.fa-grip-vertical {
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-  cursor: pointer;
-  margin-right: .5em;
-}

club/templates/club/club_detail.jinja

@@ -9,18 +9,6 @@
   {{ club.short_description }}
 {%- endblock %}
 
-{% block metatags %}
-  <meta property="og:url" content="{{ request.build_absolute_uri(club.get_absolute_url()) }}" />
-  <meta property="og:type" content="website" />
-  <meta property="og:title" content="{{ club.name }}" />
-  <meta property="og:description" content="{{ club.short_description }}" />
-  {% if club.logo %}
-    <meta property="og:image" content="{{ request.build_absolute_uri(club.logo.url) }}" />
-  {% else %}
-    <meta property="og:image" content="{{ request.build_absolute_uri(static("core/img/logo_no_text.png")) }}" />
-  {% endif %}
-{% endblock %}
-
 {% block content %}
   <div id="club_detail">
     {% if club.logo %}
@@ -29,7 +17,7 @@
     {% if page_revision %}
       {{ page_revision|markdown }}
     {% else %}
-      <h3>{{ club.name }}</h3>
+      <h3>{% trans %}Club{% endtrans %}</h3>
     {% endif %}
   </div>
 {% endblock %}

club/templates/club/club_list.jinja

@@ -1,76 +1,52 @@
-{% if is_fragment %}
-  {% extends "core/base_fragment.jinja" %}
+{% extends "core/base.jinja" %}
 
-  {# Don't display tabs and errors #}
-  {% block tabs %}
-  {% endblock %}
-  {% block errors %}
-  {% endblock %}
-{% else %}
-  {% extends "core/base.jinja" %}
-  {% block additional_css %}
-    <link rel="stylesheet" href="{{ static("club/list.scss") }}">
-  {% endblock %}
-  {% block description -%}
-    {% trans %}The list of all clubs existing at UTBM.{% endtrans %}
-  {%- endblock %}
-  {% block title -%}
-    {% trans %}Club list{% endtrans %}
-  {%- endblock %}
-{% endif %}
+{% block title -%}
+  {% trans %}Club list{% endtrans %}
+{%- endblock %}
 
-{% from "core/macros.jinja" import paginate_htmx %}
+{% block description -%}
+  {% trans %}The list of all clubs existing at UTBM.{% endtrans %}
+{%- endblock %}
+
+{% macro display_club(club) -%}
+
+  {% if club.is_active or user.is_root %}
+
+    <li><a href="{{ url('club:club_view', club_id=club.id) }}">{{ club.name }}</a>
+
+      {% if not club.is_active %}
+        ({% trans %}inactive{% endtrans %})
+      {% endif %}
+
+      {% if club.president %} - <a href="{{ url('core:user_profile', user_id=club.president.user.id) }}">{{ club.president.user }}</a>{% endif %}
+      {% if club.short_description %}<p>{{ club.short_description|markdown }}</p>{% endif %}
+
+  {% endif %}
+
+  {%- if club.children.all()|length != 0 %}
+    <ul>
+      {%- for c in club.children.order_by('name').prefetch_related("children") %}
+        {{ display_club(c) }}
+      {%- endfor %}
+    </ul>
+  {%- endif -%}
+  </li>
+{%- endmacro %}
 
 {% block content %}
-  <main>
-    <h3>{% trans %}Filters{% endtrans %}</h3>
-    <form
-      id="club-list-filters"
-      hx-get="{{ url("club:club_list") }}"
-      hx-target="#content"
-      hx-swap="outerHtml"
-      hx-push-url="true"
-    >
-      <div class="row gap-4x">
-        {{ form }}
-      </div>
-      <button type="submit" class="btn btn-blue margin-bottom">
-        <i class="fa fa-magnifying-glass"></i>{% trans %}Search{% endtrans %}
-      </button>
-    </form>
+  {% if user.is_root %}
+    <p><a href="{{ url('club:club_new') }}">{% trans %}New club{% endtrans %}</a></p>
+  {% endif %}
+  {% if club_list %}
     <h3>{% trans %}Club list{% endtrans %}</h3>
-    {% if user.has_perm("club.add_club") %}
-      <br>
-      <a href="{{ url('club:club_new') }}" class="btn btn-blue">
-        <i class="fa fa-plus"></i> {% trans %}New club{% endtrans %}
-      </a>
-    {% endif %}
-    <section class="aria-busy-grow" id="club-list">
-      {% for club in object_list %}
-        <div class="card">
-          {% set club_url = club.get_absolute_url() %}
-          <a href="{{ club_url }}">
-            {% if club.logo %}
-              <img class="club-image" src="{{ club.logo.url }}" alt="logo {{ club.name }}">
-            {% else %}
-              <i class="fa-regular fa-image fa-4x club-image"></i>
-            {% endif %}
-          </a>
-          <div class="content">
-            <a href="{{ club_url }}">
-              <h4>
-                {{ club.name }} {% if not club.is_active %}({% trans %}inactive{% endtrans %}){% endif %}
-              </h4>
-            </a>
-            {{ club.short_description|markdown }}
-          </div>
-        </div>
-      {% endfor %}
-    </section>
-    {% if is_paginated %}
-      {{ paginate_htmx(request, page_obj, paginator) }}
-    {% endif %}
-  </main>
+    <ul>
+      {%- for club in club_list %}
+        {{ display_club(club) }}
+      {%- endfor %}
+    </ul>
+  {% else %}
+    {% trans %}There is no club in this website.{% endtrans %}
+  {% endif %}
 {% endblock %}
 
 

club/templates/club/club_members.jinja

@@ -1,7 +1,11 @@
 {% 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 %}
 
@@ -12,15 +16,6 @@
 
   <h2>{% trans %}Club members{% endtrans %}</h2>
 
-  {% if club.can_roles_be_edited_by(user) %}
-    <a
-      href="{{ url("club:club_roles", club_id=object.id) }}"
-      class="btn btn-blue margin-bottom"
-    >
-      <i class="fa fa-users-gear"></i> {% trans %}Manage roles{% endtrans %}
-    </a>
-  {% endif %}
-
   {% if add_member_fragment %}
     <br />
     {{ add_member_fragment }}
@@ -50,7 +45,7 @@
           {% for m in members %}
             <tr>
               <td>{{ user_profile_link(m.user) }}</td>
-              <td>{{ m.role.name }}</td>
+              <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
               <td>{{ m.description }}</td>
               <td>{{ m.start_date }}</td>
               {%- if can_end_membership -%}

club/templates/club/club_old_members.jinja

@@ -17,7 +17,7 @@
       {% for member in old_members %}
         <tr>
           <td>{{ user_profile_link(member.user) }}</td>
-          <td>{{ member.role.name }}</td>
+          <td>{{ settings.SITH_CLUB_ROLES[member.role] }}</td>
           <td>{{ member.description }}</td>
           <td>{{ member.start_date }}</td>
           <td>{{ member.end_date }}</td>

club/templates/club/club_roles.jinja

@@ -1,172 +0,0 @@
-{% extends "core/base.jinja" %}
-
-{% block additional_js %}
-  <script type="module" src="{{ static("bundled/club/role-list-index.ts") }}" xmlns="http://www.w3.org/1999/html"></script>
-{% endblock %}
-
-{% block additional_css %}
-  <link rel="stylesheet" href="{{ static("club/roles.scss") }}">
-{% endblock %}
-
-{% macro display_subform(subform) %}
-  <div
-    class="row"
-    x-data="{
-            isPresidency: {{ subform.is_presidency.value()|lower }},
-            isBoard: {{ subform.is_board.value()|lower }},
-            roleId: {{ subform.id.value() }},
-            }"
-    x-sort:item="$data"
-  >
-    {# hidden fields #}
-    {{ subform.ORDER }}
-    {{ subform.id }}
-    {{ subform.club }}
-    {{ subform.is_presidency|add_attr("x-model=isPresidency") }}
-    {{ subform.is_board|add_attr("x-model=isBoard") }}
-    <i class="fa fa-grip-vertical" x-sort:handle></i>
-    <details class="accordion grow" {% if subform.errors %}open{% endif %}>
-      <summary>
-        {{ subform.name.value() }}
-        {% if not subform.instance.is_active -%}
-          ({% trans %}inactive{% endtrans %})
-        {%- endif %}
-      </summary>
-      <div class="accordion-content">
-        {{ subform.non_field_errors() }}
-        <div class="form-group">
-          {{ subform.name.as_field_group() }}
-        </div>
-        <div class="form-group">
-          {{ subform.description.as_field_group() }}
-        </div>
-        <div class="form-group">
-          <div>
-            {{ subform.is_active }}
-            {{ subform.is_active.label_tag() }}
-          </div>
-          <span class="helptext">
-            {{ subform.is_active.help_text }}
-          </span>
-        </div>
-      </div>
-    </details>
-  </div>
-{% endmacro %}
-
-{% block content %}
-  <p>
-    {% trans trimmed %}
-      Roles give rights on the club.
-      Higher roles grant more rights, and the members having them are displayed higher
-      in the club members list.
-    {% endtrans %}
-  </p>
-  <p>
-    {% trans trimmed %}
-      On this page, you can edit their name and description, as well as their order.
-      You can also drag roles from a category to another
-      (e.g. a board role can be made into a presidency role).
-    {% endtrans %}
-  </p>
-  <form
-    method="post"
-    x-data="clubRoleList({ userRoleId: {{ user_role or "null" }} })"
-    @submit="confirmSubmission"
-  >
-    {% csrf_token %}
-    {{ form.management_form }}
-    {{ form.non_form_errors() }}
-    <h3>{% trans %}Presidency{% endtrans %}</h3>
-    <a class="btn btn-grey margin-bottom" href="{{ url("club:new_role_president", club_id=club.id) }}">
-      <i class="fa fa-plus"></i> {% trans %}add role{% endtrans %}
-    </a>
-    <details class="clickable margin-bottom">
-      <summary>{% trans %}Help{% endtrans %}</summary>
-      {# The style we use for markdown rendering is quite nice for what we want to display,
-         so we are just gonna reuse it. #}
-      <div class="markdown">
-        <p>{% trans %}Users with a presidency role can :{% endtrans %}</p>
-        <ul>
-          <li>{% trans %}create new club roles and edit existing ones{% endtrans %}</li>
-          <li>{% trans %}manage the club counters{% endtrans %}</li>
-          <li>{% trans %}add new members with any active role and end any membership{% endtrans %}</li>
-        </ul>
-        <p>{% trans %}They also have all the rights of the club board.{% endtrans %}</p>
-      </div>
-    </details>
-    <div
-      x-sort="reorder($item, { isBoard: true, isPresidency: true })"
-      x-sort:group="roles"
-    >
-      {% for subform in form %}
-        {% if subform.is_presidency.value() %}
-          {{ display_subform(subform) }}
-        {% endif %}
-      {% endfor %}
-    </div>
-    <br>
-    <h3>{% trans %}Board{% endtrans %}</h3>
-    <a class="btn btn-grey margin-bottom" href="{{ url("club:new_role_board", club_id=club.id) }}">
-      <i class="fa fa-plus"></i> {% trans %}add role{% endtrans %}
-    </a>
-    <details class="clickable margin-bottom">
-      <summary>{% trans %}Help{% endtrans %}</summary>
-      <div class="markdown">
-        <p>
-          {% trans trimmed %}
-            Board members can do most administrative actions in the club, including :
-          {% endtrans %}
-        </p>
-        <ul>
-          <li>{% trans %}manage the club posters{% endtrans %}</li>
-          <li>{% trans %}create news for the club{% endtrans %}</li>
-          <li>{% trans %}click users on the club's counters{% endtrans %}</li>
-          <li>
-            {% trans trimmed %}
-              add new members and end active memberships
-              for roles that are lower than their own.
-            {% endtrans %}
-          </li>
-        </ul>
-      </div>
-    </details>
-    <div
-      x-sort="reorder($item, { isBoard: true, isPresidency: false })"
-      x-sort:group="roles"
-    >
-      {% for subform in form %}
-        {% if subform.is_board.value() and not subform.is_presidency.value() %}
-          {{ display_subform(subform) }}
-        {% endif %}
-      {% endfor %}
-    </div>
-    <br>
-    <h3>{% trans %}Members{% endtrans %}</h3>
-    <a class="btn btn-grey margin-bottom" href="{{ url("club:new_role_member", club_id=club.id) }}">
-      <i class="fa fa-plus"></i> {% trans %}add role{% endtrans %}
-    </a>
-    <details class="clickable margin-bottom">
-      <summary>{% trans %}Help{% endtrans %}</summary>
-      <div class="markdown">
-        <p>{% trans %}Simple members cannot perform administrative actions.{% endtrans %}</p>
-      </div>
-    </details>
-    <div
-      x-sort="reorder($item, { isBoard: false, isPresidency: false })"
-      x-sort:group="roles"
-    >
-      {% for subform in form %}
-        {% if not subform.is_board.value() %}
-          {{ display_subform(subform) }}
-        {% endif %}
-      {% endfor %}
-    </div>
-    <br>
-    <p>
-      <button type="submit" class="btn btn-blue">
-        <i class="fa fa-check"></i>{% trans %}Save{% endtrans %}
-      </button>
-    </p>
-  </form>
-{% endblock content %}

club/templates/club/club_sellings.jinja

@@ -6,11 +6,11 @@ because it works with a somewhat dynamic form,
 but was written before Alpine was introduced in the project.
 TODO : rewrite the pagination used in this template an Alpine one
 #}
-{% macro paginate(page_obj, paginator) %}
-  {% set js = "formPagination(this)" %}
+{% macro paginate(page_obj, paginator, js_action) %}
+  {% set js = js_action|default('') %}
   {% if page_obj.has_previous() or page_obj.has_next() %}
     {% if page_obj.has_previous() %}
-      <a type="submit" onclick="{{ js }}" href="?page={{ page_obj.previous_page_number() }}">{% trans %}Previous{% endtrans %}</a>
+      <a {% if js %} type="submit" onclick="{{ js }}" {% endif %} href="?page={{ page_obj.previous_page_number() }}">{% trans %}Previous{% endtrans %}</a>
     {% else %}
       <span class="disabled">{% trans %}Previous{% endtrans %}</span>
     {% endif %}
@@ -18,11 +18,11 @@ TODO : rewrite the pagination used in this template an Alpine one
       {% if page_obj.number == i %}
         <span class="active">{{ i }} <span class="sr-only">({% trans %}current{% endtrans %})</span></span>
       {% else %}
-        <a type="submit" onclick="{{ js }}" href="?page={{ i }}">{{ i }}</a>
+        <a {% if js %} type="submit" onclick="{{ js }}" {% endif %} href="?page={{ i }}">{{ i }}</a>
       {% endif %}
     {% endfor %}
     {% if page_obj.has_next() %}
-      <a type="submit" onclick="{{ js }}" href="?page={{ page_obj.next_page_number() }}">{% trans %}Next{% endtrans %}</a>
+      <a {% if js %} type="submit" onclick="{{ js }}" {% endif %} href="?page={{ page_obj.next_page_number() }}">{% trans %}Next{% endtrans %}</a>
     {% else %}
       <span class="disabled">{% trans %}Next{% endtrans %}</span>
     {% endif %}
@@ -35,7 +35,7 @@ TODO : rewrite the pagination used in this template an Alpine one
     {% csrf_token %}
     {{ form }}
     <p><input type="submit" value="{% trans %}Show{% endtrans %}" /></p>
-    <p><input type="submit" value="{% trans %}Download as CSV{% endtrans %}" formaction="{{ url('club:sellings_csv', club_id=object.id) }}"/></p>
+    <p><input type="submit" value="{% trans %}Download as cvs{% endtrans %}" formaction="{{ url('club:sellings_csv', club_id=object.id) }}"/></p>
   </form>
   <p>
     {% trans %}Quantity: {% endtrans %}{{ total_quantity }} {% trans %}units{% endtrans %}<br/>
@@ -81,10 +81,6 @@ TODO : rewrite the pagination used in this template an Alpine one
       {% endfor %}
     </tbody>
   </table>
-  {{ paginate(paginated_result, paginator) }}
-{% endblock %}
-
-{% block script %}
   <script type="text/javascript">
     function formPagination(link){
       const form = document.getElementById("form")
@@ -93,6 +89,7 @@ TODO : rewrite the pagination used in this template an Alpine one
       form.submit();
     }
   </script>
+  {{ paginate(paginated_result, paginator, "formPagination(this)") }}
 {% endblock %}
 
 

club/templates/club/club_tools.jinja

@@ -5,19 +5,8 @@
   <div>
     <h4>{% trans %}Communication:{% endtrans %}</h4>
     <ul>
-      <li>
-        <a href="{{ url('com:news_new') }}?club={{ object.id }}">
-          {% trans %}Create a news{% endtrans %}
-        </a>
-      </li>
-      <li>
-        <a href="{{ url('com:weekmail_article') }}?club={{ object.id }}">
-          {% trans %}Post in the Weekmail{% endtrans %}
-        </a>
-      </li>
-      {% if object.can_roles_be_edited_by(user) %}
-        <li><a href="{{ url("club:club_roles", club_id=object.id) }}"></a></li>
-      {% endif %}
+      <li> <a href="{{ url('com:news_new') }}?club={{ object.id }}">{% trans %}Create a news{% endtrans %}</a></li>
+      <li> <a href="{{ url('com:weekmail_article') }}?club={{ object.id }}">{% trans %}Post in the Weekmail{% endtrans %}</a></li>
       {% if object.trombi %}
         <li> <a href="{{ url('trombi:detail', trombi_id=object.trombi.id) }}">{% trans %}Edit Trombi{% endtrans %}</a></li>
       {% else %}

club/templates/club/page_history.jinja

@@ -1,8 +1,12 @@
 {% extends "core/base.jinja" %}
-{% from 'core/page/macros.jinja' import page_history %}
+{% from 'core/macros_pages.jinja' import page_history %}
 
 {% block content %}
-  {{ page_history(club.page) }}
+  {% if club.page %}
+    {{ page_history(club.page) }}
+  {% else %}
+    {% trans %}No page existing for this club{% endtrans %}
+  {% endif %}
 {% endblock %}
 
 

club/templates/club/pagerev_edit.jinja

@@ -1,12 +1,8 @@
 {% extends "core/base.jinja" %}
+{% from 'core/macros_pages.jinja' import page_edit_form %}
 
 {% block content %}
-  <h2>{% trans %}Edit page{% endtrans %}</h2>
-  <form action="{{ url('club:club_edit_page', club_id=page.club.id) }}" method="post">
-    {% csrf_token %}
-    {{ form.as_p() }}
-    <p><input type="submit" value="{% trans %}Save{% endtrans %}" /></p>
-  </form>
+  {{ page_edit_form(page, form, url('club:club_edit_page', club_id=page.club.id), csrf_token) }}
 {% endblock %}
 
 

club/tests/base.py

@@ -8,7 +8,7 @@ from django.utils.timezone import now
 from model_bakery import baker
 from model_bakery.recipe import Recipe
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import old_subscriber_user, subscriber_user
 from core.models import User
 
@@ -43,11 +43,6 @@ class TestClub(TestCase):
 
         cls.ae = Club.objects.get(pk=settings.SITH_MAIN_CLUB_ID)
         cls.club = baker.make(Club)
-        cls.president_role = baker.make(
-            ClubRole, club=cls.club, is_board=True, is_presidency=True, order=0
-        )
-        cls.board_role = baker.make(ClubRole, club=cls.club, is_board=True, order=1)
-        cls.member_role = baker.make(ClubRole, club=cls.club, order=2)
         cls.new_members_url = reverse(
             "club:club_new_members", kwargs={"club_id": cls.club.id}
         )
@@ -56,17 +51,12 @@ class TestClub(TestCase):
         yesterday = now() - timedelta(days=1)
         membership_recipe = Recipe(Membership, club=cls.club)
         membership_recipe.make(
-            user=cls.simple_board_member, start_date=a_month_ago, role=cls.board_role
-        )
-        membership_recipe.make(user=cls.richard, role=cls.member_role)
-        membership_recipe.make(
-            user=cls.president, start_date=a_month_ago, role=cls.president_role
+            user=cls.simple_board_member, start_date=a_month_ago, role=3
         )
+        membership_recipe.make(user=cls.richard, role=1)
+        membership_recipe.make(user=cls.president, start_date=a_month_ago, role=10)
         membership_recipe.make(  # sli was a member but isn't anymore
-            user=cls.sli,
-            start_date=a_month_ago,
-            end_date=yesterday,
-            role=cls.board_role,
+            user=cls.sli, start_date=a_month_ago, end_date=yesterday, role=2
         )
 
     def setUp(self):

club/tests/test_club.py

@@ -1,18 +1,12 @@
 from datetime import timedelta
 
 import pytest
-from django.conf import settings
-from django.db import ProgrammingError
-from django.test import Client
-from django.urls import reverse
 from django.utils.timezone import localdate
 from model_bakery import baker
 from model_bakery.recipe import Recipe
-from pytest_django.asserts import assertRedirects
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import subscriber_user
-from core.models import User
 
 
 @pytest.mark.django_db
@@ -22,106 +16,12 @@ def test_club_queryset_having_board_member():
     membership_recipe = Recipe(
         Membership, user=user, start_date=localdate() - timedelta(days=3)
     )
+    membership_recipe.make(club=clubs[0], role=1)
+    membership_recipe.make(club=clubs[1], role=3)
+    membership_recipe.make(club=clubs[2], role=7)
     membership_recipe.make(
-        club=clubs[0], role=baker.make(ClubRole, club=clubs[0], is_board=False)
-    )
-    membership_recipe.make(
-        club=clubs[1], role=baker.make(ClubRole, club=clubs[1], is_board=True)
-    )
-    membership_recipe.make(
-        club=clubs[2], role=baker.make(ClubRole, club=clubs[2], is_board=True)
-    )
-    membership_recipe.make(
-        club=clubs[3],
-        role=baker.make(ClubRole, club=clubs[3], is_board=True),
-        end_date=localdate() - timedelta(days=1),
+        club=clubs[3], role=3, end_date=localdate() - timedelta(days=1)
     )
 
     club_ids = Club.objects.having_board_member(user).values_list("id", flat=True)
     assert set(club_ids) == {clubs[1].id, clubs[2].id}
-
-
-@pytest.mark.parametrize("nb_additional_clubs", [10, 30])
-@pytest.mark.parametrize("is_fragment", [True, False])
-@pytest.mark.django_db
-def test_club_list(client: Client, nb_additional_clubs: int, is_fragment):
-    client.force_login(baker.make(User))
-    baker.make(Club, _quantity=nb_additional_clubs)
-    headers = {"HX-Request": True} if is_fragment else {}
-    res = client.get(reverse("club:club_list"), headers=headers)
-    assert res.status_code == 200
-
-
-def assert_club_created(club_name: str):
-    club = Club.objects.last()
-    assert club.name == club_name
-    assert club.board_group.name == f"{club_name} - Bureau"
-    assert club.members_group.name == f"{club_name} - Membres"
-    # default roles should be added on club creation,
-    # whether the creation happens on the admin site or on the user site
-    assert list(club.roles.values("name", "is_presidency", "is_board")) == [
-        {"name": "Président⸱e", "is_presidency": True, "is_board": True},
-        {"name": "Trésorier⸱e", "is_presidency": False, "is_board": True},
-        {"name": "Membre actif⸱ve", "is_presidency": False, "is_board": False},
-        {"name": "Curieux⸱euse", "is_presidency": False, "is_board": False},
-    ]
-
-
-@pytest.mark.django_db
-def test_create_view(admin_client: Client):
-    """Test that the club creation view works well"""
-    res = admin_client.get(reverse("club:club_new"))
-    assert res.status_code == 200
-    res = admin_client.post(
-        reverse("club:club_new"),
-        data={"name": "foo", "parent": settings.SITH_MAIN_CLUB_ID},
-    )
-    club = Club.objects.last()
-    assertRedirects(res, club.get_absolute_url())
-    assert_club_created("foo")
-
-
-@pytest.mark.django_db
-def test_default_roles_for_club_with_roles_fails():
-    """Test that an Error is raised if trying to create
-    default roles for a club that already has roles.
-    """
-    club = baker.make(Club)
-    baker.make(ClubRole, club=club)
-    with pytest.raises(ProgrammingError):
-        club.create_default_roles()
-
-
-@pytest.mark.django_db
-class TestAdminInterface:
-    def test_create(self, admin_client: Client):
-        """Test the creation of a club via the admin interface."""
-        res = admin_client.post(
-            reverse("admin:club_club_add"),
-            data={
-                "name": "foo",
-                "parent": settings.SITH_MAIN_CLUB_ID,
-                "address": "Rome",
-            },
-        )
-        assertRedirects(res, reverse("admin:club_club_changelist"))
-        assert_club_created("foo")
-
-    def test_change(self, admin_client: Client):
-        """Test the edition of a club via the admin interface."""
-        club = baker.make(Club)
-        res = admin_client.post(
-            reverse("admin:club_club_change", kwargs={"object_id": club.id}),
-            data={
-                "name": "foo",
-                "page": club.page_id,
-                "home": club.home_id,
-                "address": club.address,
-            },
-        )
-        assertRedirects(res, reverse("admin:club_club_changelist"))
-        club.refresh_from_db()
-        assert club.name == "foo"
-        # Club roles shouldn't be modified when editing the club on the admin interface
-        # This club had no roles beforehand, therefore it shouldn't have roles now.
-        assert not club.roles.exists()

club/tests/test_club_controller.py

@@ -1,66 +1,14 @@
 from datetime import date, timedelta
 
 import pytest
-from django.conf import settings
-from django.contrib.auth.models import Permission
-from django.test import Client, TestCase
+from django.test import Client
 from django.urls import reverse
 from model_bakery import baker
 from model_bakery.recipe import Recipe
 from pytest_django.asserts import assertNumQueries
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import subscriber_user
-from core.models import Group, Page, User
-
-
-class TestClubSearch(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.url = reverse("api:search_club")
-        cls.user = baker.make(
-            User, user_permissions=[Permission.objects.get(codename="access_lookup")]
-        )
-        # delete existing clubs to avoid side effect
-        groups = list(
-            Group.objects.exclude(club=None, club_board=None).values_list(
-                "id", flat=True
-            )
-        )
-        Membership.objects.all().delete()
-        ClubRole.objects.all().delete()
-        Club.objects.all().delete()
-        Page.objects.exclude(name=settings.SITH_CLUB_ROOT_PAGE).delete()
-        Group.objects.filter(id__in=groups).delete()
-
-        cls.clubs = baker.make(
-            Club,
-            _quantity=5,
-            name=iter(["AE", "ae 1", "Troll", "Dev AE", "pdf"]),
-            is_active=True,
-        )
-
-    def test_inactive_club(self):
-        self.client.force_login(self.user)
-        inactive_ids = {self.clubs[0].id, self.clubs[2].id}
-        Club.objects.filter(id__in=inactive_ids).update(is_active=False)
-        response = self.client.get(self.url, {"is_active": False})
-        assert response.status_code == 200
-        assert {d["id"] for d in response.json()["results"]} == inactive_ids
-
-    def test_excluded_id(self):
-        self.client.force_login(self.user)
-        response = self.client.get(self.url, {"exclude_ids": [self.clubs[1].id]})
-        assert response.status_code == 200
-        ids = {d["id"] for d in response.json()["results"]}
-        assert ids == {c.id for c in [self.clubs[0], *self.clubs[2:]]}
-
-    def test_club_search(self):
-        self.client.force_login(self.user)
-        response = self.client.get(self.url, {"search": "AE"})
-        assert response.status_code == 200
-        ids = {d["id"] for d in response.json()["results"]}
-        assert ids == {c.id for c in [self.clubs[0], self.clubs[1], self.clubs[3]]}
 
 
 @pytest.mark.django_db

club/tests/test_clubrole.py

@@ -1,253 +0,0 @@
-from collections.abc import Callable
-
-import pytest
-from django.contrib.auth.models import Permission
-from django.test import Client, TestCase
-from django.urls import reverse
-from model_bakery import baker, seq
-from model_bakery.recipe import Recipe
-from pytest_django.asserts import assertRedirects
-
-from club.forms import ClubRoleFormSet
-from club.models import Club, ClubRole, Membership
-from core.baker_recipes import subscriber_user
-from core.models import AnonymousUser, User
-
-
-def make_club():
-    # unittest-style tests cannot use fixture, so we create a function
-    # that will be callable either by a pytest fixture or inside
-    # a TestCase.setUpTestData method.
-    club = baker.make(Club)
-    recipe = Recipe(ClubRole, club=club, name=seq("role "))
-    recipe.make(
-        is_board=iter([True, True, False]),
-        is_presidency=iter([True, False, False]),
-        order=iter([0, 1, 2]),
-        _quantity=3,
-        _bulk_create=True,
-    )
-    return club
-
-
-@pytest.fixture
-def club(db):
-    """A club with a presidency role, a board role and a member role"""
-    return make_club()
-
-
-@pytest.mark.django_db
-def test_order_auto(club):
-    """Test that newly created roles are put in the right place."""
-    roles = list(club.roles.all())
-    # create new roles one by one (like they will be in prod)
-    # each new role should be placed at the end of its category
-    recipe = Recipe(ClubRole, club=club, name=seq("new role "))
-    role_a = recipe.make(is_board=True, is_presidency=True, order=None)
-    role_b = recipe.make(is_board=True, is_presidency=False, order=None)
-    role_c = recipe.make(is_board=False, is_presidency=False, order=None)
-    assert list(club.roles.order_by("order")) == [
-        roles[0],
-        role_a,
-        roles[1],
-        role_b,
-        roles[2],
-        role_c,
-    ]
-
-
-@pytest.mark.django_db
-@pytest.mark.parametrize(
-    ("user_factory", "is_allowed"),
-    [
-        (
-            lambda club: baker.make(
-                User,
-                user_permissions=[Permission.objects.get(codename="change_clubrole")],
-            ),
-            True,
-        ),
-        (  # user with presidency roles can edit the club roles
-            lambda club: subscriber_user.make(
-                memberships=[
-                    baker.make(
-                        Membership,
-                        club=club,
-                        role=club.roles.filter(is_presidency=True).first(),
-                    )
-                ]
-            ),
-            True,
-        ),
-        (  # user in the board but not in the presidency cannot edit roles
-            lambda club: subscriber_user.make(
-                memberships=[
-                    baker.make(
-                        Membership,
-                        club=club,
-                        role=club.roles.filter(
-                            is_presidency=False, is_board=True
-                        ).first(),
-                    )
-                ]
-            ),
-            False,
-        ),
-        (lambda _: AnonymousUser(), False),
-    ],
-)
-def test_can_roles_be_edited_by(
-    club: Club, user_factory: Callable[[Club], User], is_allowed
-):
-    """Test that `Club.can_roles_be_edited_by` return the right value"""
-    user = user_factory(club)
-    assert club.can_roles_be_edited_by(user) == is_allowed
-
-
-@pytest.mark.django_db
-@pytest.mark.parametrize(
-    ["route", "is_presidency", "is_board"],
-    [
-        ("club:new_role_president", True, True),
-        ("club:new_role_board", False, True),
-        ("club:new_role_member", False, False),
-    ],
-)
-def test_create_role_view(client: Client, route: str, is_presidency, is_board):
-    """Test that the role creation views work."""
-    club = baker.make(Club)
-    role = baker.make(ClubRole, club=club, is_presidency=True, is_board=True)
-    user = subscriber_user.make()
-    baker.make(Membership, club=club, role=role, user=user, end_date=None)
-    url = reverse(route, kwargs={"club_id": club.id})
-    client.force_login(user)
-
-    res = client.get(url)
-    assert res.status_code == 200
-
-    res = client.post(url, data={"name": "foo"})
-    assertRedirects(res, reverse("club:club_roles", kwargs={"club_id": club.id}))
-    new_role = club.roles.last()
-    assert new_role.name == "foo"
-    assert new_role.is_presidency == is_presidency
-    assert new_role.is_board == is_board
-
-
-class TestClubRoleUpdate(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.club = make_club()
-        cls.roles = list(cls.club.roles.all())
-        cls.user = subscriber_user.make()
-        baker.make(
-            Membership, club=cls.club, role=cls.roles[0], user=cls.user, end_date=None
-        )
-        cls.url = reverse("club:club_roles", kwargs={"club_id": cls.club.id})
-        cls.redirect_url = reverse("club:club_members", kwargs={"club_id": cls.club.id})
-
-    def setUp(self):
-        self.payload = {
-            "roles-TOTAL_FORMS": 3,
-            "roles-INITIAL_FORMS": 3,
-            "roles-MIN_NUM_FORMS": 0,
-            "roles-MAX_NUM_FORMS": 1000,
-            "roles-0-ORDER": 1,
-            "roles-0-id": self.roles[0].id,
-            "roles-0-club": self.club.id,
-            "roles-0-is_presidency": True,
-            "roles-0-is_board": True,
-            "roles-0-name": self.roles[0].name,
-            "roles-0-description": self.roles[0].description,
-            "roles-0-is_active": True,
-            "roles-1-ORDER": 2,
-            "roles-1-id": self.roles[1].id,
-            "roles-1-club": self.club.id,
-            "roles-1-is_presidency": False,
-            "roles-1-is_board": True,
-            "roles-1-name": self.roles[1].name,
-            "roles-1-description": self.roles[1].description,
-            "roles-1-is_active": True,
-            "roles-2-ORDER": 3,
-            "roles-2-id": self.roles[2].id,
-            "roles-2-club": self.club.id,
-            "roles-2-is_presidency": False,
-            "roles-2-is_board": False,
-            "roles-2-name": self.roles[2].name,
-            "roles-2-description": self.roles[2].description,
-            "roles-2-is_active": True,
-        }
-
-    def test_view_ok(self):
-        """Basic test to check that the view works."""
-        self.client.force_login(self.user)
-        res = self.client.get(self.url)
-        assert res.status_code == 200
-        self.payload["roles-2-name"] = "foo"
-        res = self.client.post(self.url, data=self.payload)
-        assertRedirects(res, self.redirect_url)
-        self.roles[2].refresh_from_db()
-        assert self.roles[2].name == "foo"
-
-    def test_incoherent_order(self):
-        """Test that placing a member role over a board role fails."""
-        self.payload["roles-0-ORDER"] = 4
-        formset = ClubRoleFormSet(data=self.payload, instance=self.club)
-        assert not formset.is_valid()
-        assert formset.errors == [
-            {
-                "__all__": [
-                    f"Le rôle {self.roles[0].name} ne peut pas "
-                    "être placé en-dessous d'un rôle de membre.",
-                    f"Le rôle {self.roles[0].name} ne peut pas être placé "
-                    "en-dessous d'un rôle qui n'est pas de la présidence.",
-                ]
-            },
-            {},
-            {},
-        ]
-
-    def test_change_order_ok(self):
-        """Test that changing order the intended way works"""
-        self.payload["roles-1-ORDER"] = 3
-        self.payload["roles-1-is_board"] = False
-        self.payload["roles-2-ORDER"] = 2
-        formset = ClubRoleFormSet(data=self.payload, instance=self.club)
-        assert formset.is_valid()
-        formset.save()
-        assert list(self.club.roles.order_by("order")) == [
-            self.roles[0],
-            self.roles[2],
-            self.roles[1],
-        ]
-        self.roles[1].refresh_from_db()
-        assert not self.roles[1].is_board
-
-    def test_non_board_presidency_is_forbidden(self):
-        """Test that a role cannot be in the presidency without being in the board."""
-        self.payload["roles-0-is_board"] = False
-        formset = ClubRoleFormSet(data=self.payload, instance=self.club)
-        assert not formset.is_valid()
-        assert formset.errors == [
-            {
-                "__all__": [
-                    "Un rôle ne peut pas appartenir à la présidence sans être dans le bureau",
-                ]
-            },
-            {},
-            {},
-        ]
-
-    def test_president_moves_itself_out_of_the_presidency(self):
-        """Test that if the user moves its own role out of the presidency,
-        then it's redirected to another page and loses access to the update page."""
-        self.payload["roles-0-is_presidency"] = False
-        self.client.force_login(self.user)
-        res = self.client.post(self.url, data=self.payload)
-        assertRedirects(res, self.redirect_url)
-        # When the user clicked that button, it still had the right to update roles,
-        # so the modification should be applied
-        self.roles[0].refresh_from_db()
-        assert self.roles[0].is_presidency is False
-
-        res = self.client.get(self.url)
-        assert res.status_code == 403

club/tests/test_edit.py

@@ -4,7 +4,7 @@ from django.urls import reverse
 from model_bakery import baker
 from pytest_django.asserts import assertRedirects
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import subscriber_user
 
 
@@ -12,12 +12,7 @@ from core.baker_recipes import subscriber_user
 def test_club_board_member_cannot_edit_club_properties(client: Client):
     user = subscriber_user.make()
     club = baker.make(Club, name="old name", is_active=True, address="old address")
-    baker.make(
-        Membership,
-        club=club,
-        user=user,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
+    baker.make(Membership, club=club, user=user, role=7)
     client.force_login(user)
     res = client.post(
         reverse("club:club_edit", kwargs={"club_id": club.id}),
@@ -37,12 +32,7 @@ def test_edit_club_page_doesnt_crash(client: Client):
     """crash test for club:club_edit"""
     club = baker.make(Club)
     user = subscriber_user.make()
-    baker.make(
-        Membership,
-        club=club,
-        user=user,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
+    baker.make(Membership, club=club, user=user, role=3)
     client.force_login(user)
     res = client.get(reverse("club:club_edit", kwargs={"club_id": club.id}))
     assert res.status_code == 200

club/tests/test_mailing.py

@@ -3,10 +3,9 @@ from django.test import TestCase
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.translation import gettext as _
-from model_bakery import baker
 
 from club.forms import MailingForm
-from club.models import Club, ClubRole, Mailing, Membership
+from club.models import Club, Mailing, Membership
 from core.models import User
 
 
@@ -26,7 +25,7 @@ class TestMailingForm(TestCase):
             user=cls.rbatsbak,
             club=cls.club,
             start_date=timezone.now(),
-            role=baker.make(ClubRole, club=cls.club, is_board=True),
+            role=settings.SITH_CLUB_ROLES_ID["Board member"],
         ).save()
 
     def test_mailing_list_add_no_moderation(self):

club/tests/test_membership.py

@@ -1,20 +1,20 @@
-import itertools
 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 Client, TestCase
+from django.test import TestCase
 from django.urls import reverse
 from django.utils.timezone import localdate, localtime, now
-from model_bakery import baker, seq
+from model_bakery import baker
 from pytest_django.asserts import assertRedirects
 
 from club.forms import ClubAddMemberForm, JoinClubForm
-from club.models import Club, ClubRole, Membership
+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
@@ -72,25 +72,39 @@ class TestMembershipQuerySet(TestClub):
         expected.sort(key=lambda i: i.id)
         assert members == expected
 
+    def test_update_invalidate_cache(self):
+        """Test that the `update` queryset method properly invalidate cache."""
+        mem_skia = self.simple_board_member.memberships.get(club=self.club)
+        cache.set(f"membership_{mem_skia.club_id}_{mem_skia.user_id}", mem_skia)
+        self.simple_board_member.memberships.update(end_date=localtime(now()).date())
+        assert (
+            cache.get(f"membership_{mem_skia.club_id}_{mem_skia.user_id}")
+            == "not_member"
+        )
+
+        mem_richard = self.richard.memberships.get(club=self.club)
+        cache.set(
+            f"membership_{mem_richard.club_id}_{mem_richard.user_id}", mem_richard
+        )
+        self.richard.memberships.update(role=5)
+        new_mem = self.richard.memberships.get(club=self.club)
+        assert new_mem != "not_member"
+        assert new_mem.role == 5
+
     def test_update_change_club_groups(self):
         """Test that `update` set the user groups accordingly."""
         user = baker.make(User)
-        board_role, member_role = baker.make(
-            ClubRole, is_board=iter([True, False]), _quantity=2, _bulk_create=True
-        )
-        membership = baker.make(
-            Membership, end_date=None, user=user, role=board_role, club=board_role.club
-        )
+        membership = baker.make(Membership, end_date=None, user=user, role=5)
         members_group = membership.club.members_group
         board_group = membership.club.board_group
         assert user.groups.contains(members_group)
         assert user.groups.contains(board_group)
 
-        user.memberships.update(role=member_role)  # from board to simple member
+        user.memberships.update(role=1)  # from board to simple member
         assert user.groups.contains(members_group)
         assert not user.groups.contains(board_group)
 
-        user.memberships.update(role=board_role)  # from member to board
+        user.memberships.update(role=5)  # from member to board
         assert user.groups.contains(members_group)
         assert user.groups.contains(board_group)
 
@@ -98,20 +112,28 @@ class TestMembershipQuerySet(TestClub):
         assert not user.groups.contains(members_group)
         assert not user.groups.contains(board_group)
 
+    def test_delete_invalidate_cache(self):
+        """Test that the `delete` queryset properly invalidate cache."""
+        mem_skia = self.simple_board_member.memberships.get(club=self.club)
+        mem_comptable = self.president.memberships.get(club=self.club)
+        cache.set(f"membership_{mem_skia.club_id}_{mem_skia.user_id}", mem_skia)
+        cache.set(
+            f"membership_{mem_comptable.club_id}_{mem_comptable.user_id}", mem_comptable
+        )
+
+        # should delete the subscriptions of simple_board_member and president
+        self.club.members.ongoing().board().delete()
+
+        for membership in (mem_skia, mem_comptable):
+            cached_mem = cache.get(
+                f"membership_{membership.club_id}_{membership.user_id}"
+            )
+            assert cached_mem == "not_member"
+
     def test_delete_remove_from_groups(self):
         """Test that `delete` removes from club groups"""
         user = baker.make(User)
-        club = baker.make(Club)
-        roles = baker.make(
-            ClubRole,
-            is_board=iter([False, True]),
-            club=club,
-            _quantity=2,
-            _bulk_create=True,
-        )
-        memberships = baker.make(
-            Membership, club=club, role=iter(roles), user=user, _quantity=2
-        )
+        memberships = baker.make(Membership, role=iter([1, 5]), user=user, _quantity=2)
         club_groups = {
             memberships[0].club.members_group,
             memberships[1].club.members_group,
@@ -127,20 +149,13 @@ class TestMembershipEditableBy(TestCase):
     def setUpTestData(cls):
         Membership.objects.all().delete()
         cls.club_a, cls.club_b = baker.make(Club, _quantity=2)
-        roles = baker.make(
-            ClubRole,
-            is_presidency=itertools.cycle([True, False, False, False]),
-            is_board=itertools.cycle([True, True, True, False]),
-            order=itertools.cycle(range(4)),
-            club=iter(
-                [*itertools.repeat(cls.club_a, 4), *itertools.repeat(cls.club_b, 4)]
-            ),
-            _quantity=8,
-            _bulk_create=True,
-        )
         cls.memberships = [
-            *baker.make(Membership, role=iter(roles[:4]), club=cls.club_a, _quantity=4),
-            *baker.make(Membership, role=iter(roles[4:]), club=cls.club_b, _quantity=4),
+            *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):
@@ -162,7 +177,7 @@ class TestMembershipEditableBy(TestCase):
 
 
 class TestMembership(TestClub):
-    def assert_membership_started_today(self, user: User, role: ClubRole):
+    def assert_membership_started_today(self, user: User, role: int):
         """Assert that the given membership is active and started today."""
         membership = user.memberships.ongoing().filter(club=self.club).first()
         assert membership is not None
@@ -211,27 +226,21 @@ class TestMembership(TestClub):
             "Marquer comme ancien",
         ]
         rows = table.find("tbody").find_all("tr")
-        memberships = (
-            self.club.members.ongoing()
-            .order_by("role__order")
-            .select_related("user", "role")
-        )
-        user_role = ClubRole.objects.get(members__user=self.simple_board_member)
-        for row, membership in zip(rows, memberships, strict=False):
+        memberships = self.club.members.ongoing().order_by("-role")
+        for row, membership in zip(
+            rows, memberships.select_related("user"), strict=False
+        ):
             user = membership.user
             user_url = reverse("core:user_profile", args=[user.id])
             cols = row.find_all("td")
             user_link = cols[0].find("a")
             assert user_link.attrs["href"] == user_url
             assert user_link.text == user.get_display_name()
-            assert cols[1].text == membership.role.name
+            assert cols[1].text == settings.SITH_CLUB_ROLES[membership.role]
             assert cols[2].text == membership.description
             assert cols[3].text == str(membership.start_date)
 
-            if (
-                membership.role.order > user_role.order
-                or membership.user_id == self.simple_board_member.id
-            ):
+            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 = {
@@ -247,15 +256,14 @@ class TestMembership(TestClub):
         """Test that root users can add members to clubs"""
         self.client.force_login(self.root)
         response = self.client.post(
-            self.new_members_url,
-            {"user": self.subscriber.id, "role": self.board_role.id},
+            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.subscriber.refresh_from_db()
-        self.assert_membership_started_today(self.subscriber, role=self.board_role)
+        self.assert_membership_started_today(self.subscriber, role=3)
 
     def test_add_unauthorized_members(self):
         """Test that users who are not currently subscribed
@@ -263,7 +271,7 @@ class TestMembership(TestClub):
         """
         for user in self.public, self.old_subscriber:
             form = ClubAddMemberForm(
-                data={"user": user.id, "role": self.member_role},
+                data={"user": user.id, "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
@@ -284,7 +292,7 @@ class TestMembership(TestClub):
         nb_memberships = self.simple_board_member.memberships.count()
         self.client.post(
             self.members_url,
-            {"users": self.simple_board_member.id, "role": self.member_role},
+            {"users": self.simple_board_member.id, "role": current_membership.role + 1},
         )
         self.simple_board_member.refresh_from_db()
         assert nb_memberships == self.simple_board_member.memberships.count()
@@ -303,7 +311,7 @@ class TestMembership(TestClub):
         max_id = User.objects.aggregate(id=Max("id"))["id"]
         for members in [max_id + 1], [max_id + 1, self.subscriber.id]:
             form = ClubAddMemberForm(
-                data={"user": members, "role": self.member_role},
+                data={"user": members, "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
@@ -317,6 +325,44 @@ class TestMembership(TestClub):
         self.club.refresh_from_db()
         assert self.club.members.count() == nb_memberships
 
+    def test_president_add_members(self):
+        """Test that the president of the club can add members."""
+        president = self.club.members.get(role=10).user
+        nb_club_membership = self.club.members.count()
+        nb_subscriber_memberships = self.subscriber.memberships.count()
+        self.client.force_login(president)
+        response = self.client.post(
+            self.new_members_url, {"user": self.subscriber.id, "role": 9}
+        )
+        assert response.status_code == 200
+        assert response.headers.get("HX-Redirect", "") == reverse(
+            "club:club_members", kwargs={"club_id": self.club.id}
+        )
+        self.club.refresh_from_db()
+        self.subscriber.refresh_from_db()
+        assert self.club.members.count() == nb_club_membership + 1
+        assert self.subscriber.memberships.count() == nb_subscriber_memberships + 1
+        self.assert_membership_started_today(self.subscriber, role=9)
+
+    def test_add_member_greater_role(self):
+        """Test that a member of the club member cannot create
+        a membership with a greater role than its own.
+        """
+        form = ClubAddMemberForm(
+            data={"user": self.subscriber.id, "role": 10},
+            request_user=self.simple_board_member,
+            club=self.club,
+        )
+        nb_memberships = self.club.members.count()
+
+        assert not form.is_valid()
+        assert form.errors == {
+            "role": ["Sélectionnez un choix valide. 10 n\u2019en fait pas partie."]
+        }
+        self.club.refresh_from_db()
+        assert nb_memberships == self.club.members.count()
+        assert not self.subscriber.memberships.filter(club=self.club).exists()
+
     def test_add_member_without_role(self):
         """Test that trying to add members without specifying their role fails."""
         form = ClubAddMemberForm(
@@ -327,9 +373,8 @@ class TestMembership(TestClub):
         assert form.errors == {"role": ["Ce champ est obligatoire."]}
 
     def test_add_member_already_there(self):
-        role = ClubRole.objects.get(members__user=self.simple_board_member)
         form = ClubAddMemberForm(
-            data={"user": self.simple_board_member, "role": role.id},
+            data={"user": self.simple_board_member, "role": 3},
             request_user=self.root,
             club=self.club,
         )
@@ -340,27 +385,22 @@ class TestMembership(TestClub):
 
     def test_add_other_member_forbidden(self):
         non_member = subscriber_user.make()
-        simple_member = baker.make(
-            Membership, club=self.club, role=self.member_role
-        ).user
+        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": self.member_role.id},
+                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. "
-                    "Ce choix ne fait pas partie de ceux disponibles."
-                ]
+                "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=self.member_role)
+        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
@@ -379,10 +419,9 @@ class TestMembership(TestClub):
         """Test that board members of the club can end memberships
         of users with lower roles.
         """
+        # reminder : simple_board_member has role 3
         self.client.force_login(self.simple_board_member)
-        role = baker.make(ClubRole, club=self.club, is_board=True)
-        role.below(self.board_role)
-        membership = baker.make(Membership, club=self.club, role=role)
+        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()
@@ -392,9 +431,7 @@ class TestMembership(TestClub):
         """Test that board members of the club cannot end memberships
         of users with higher roles.
         """
-        membership = self.president.memberships.filter(
-            club=self.club, end_date=None
-        ).first()
+        membership = self.president.memberships.filter(club=self.club).first()
         self.client.force_login(self.simple_board_member)
         self.client.post(self.members_url, {"members_old": [membership.id]})
         self.club.refresh_from_db()
@@ -436,9 +473,7 @@ class TestMembership(TestClub):
     def test_remove_from_club_group(self):
         """Test that when a membership ends, the user is removed from club groups."""
         user = baker.make(User)
-        baker.make(
-            Membership, user=user, club=self.club, end_date=None, role=self.board_role
-        )
+        baker.make(Membership, user=user, club=self.club, end_date=None, role=3)
         assert user.groups.contains(self.club.members_group)
         assert user.groups.contains(self.club.board_group)
         user.memberships.update(end_date=localdate())
@@ -449,20 +484,18 @@ class TestMembership(TestClub):
         """Test that when a membership begins, the user is added to the club group."""
         assert not self.subscriber.groups.contains(self.club.members_group)
         assert not self.subscriber.groups.contains(self.club.board_group)
-        baker.make(
-            Membership, club=self.club, user=self.subscriber, role=self.board_role
-        )
+        baker.make(Membership, club=self.club, user=self.subscriber, role=3)
         assert self.subscriber.groups.contains(self.club.members_group)
         assert self.subscriber.groups.contains(self.club.board_group)
 
     def test_change_position_in_club(self):
         """Test that when moving from board to members, club group change"""
         membership = baker.make(
-            Membership, club=self.club, user=self.subscriber, role=self.board_role
+            Membership, club=self.club, user=self.subscriber, role=3
         )
         assert self.subscriber.groups.contains(self.club.members_group)
         assert self.subscriber.groups.contains(self.club.board_group)
-        membership.role = self.member_role
+        membership.role = 1
         membership.save()
         assert self.subscriber.groups.contains(self.club.members_group)
         assert not self.subscriber.groups.contains(self.club.board_group)
@@ -475,11 +508,7 @@ class TestMembership(TestClub):
 
         # make sli a board member
         self.sli.memberships.all().delete()
-        Membership(
-            club=self.ae,
-            user=self.sli,
-            role=baker.make(ClubRole, club=self.ae, is_board=True),
-        ).save()
+        Membership(club=self.ae, user=self.sli, role=3).save()
         assert self.club.is_owned_by(self.sli)
 
     def test_change_club_name(self):
@@ -503,79 +532,6 @@ class TestMembership(TestClub):
         assert new_board == initial_board
 
 
-@pytest.mark.django_db
-def test_membership_set_old(client: Client):
-    membership = baker.make(Membership, end_date=None, user=subscriber_user.make())
-    client.force_login(membership.user)
-    response = client.post(
-        reverse("club:membership_set_old", kwargs={"membership_id": membership.id})
-    )
-    assertRedirects(
-        response, reverse("core:user_clubs", kwargs={"user_id": membership.user_id})
-    )
-    membership.refresh_from_db()
-    assert membership.end_date == localdate()
-
-
-@pytest.mark.django_db
-def test_membership_delete(client: Client):
-    user = baker.make(User, is_superuser=True)
-    membership = baker.make(Membership)
-    client.force_login(user)
-    url = reverse("club:membership_delete", kwargs={"membership_id": membership.id})
-    response = client.get(url)
-    assert response.status_code == 200
-    response = client.post(url)
-    assertRedirects(
-        response, reverse("core:user_clubs", kwargs={"user_id": membership.user_id})
-    )
-    assert not Membership.objects.filter(id=membership.id).exists()
-
-
-@pytest.mark.django_db
-class TestAddMemberForm(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.club = baker.make(Club)
-        cls.roles = baker.make(
-            ClubRole,
-            club=cls.club,
-            is_board=iter([True, True, True, True, False, False]),
-            is_presidency=iter([True, True, False, False, False, False]),
-            order=seq(0),
-            _quantity=6,
-            _bulk_create=True,
-        )
-        cls.roles[-1].is_active = False
-        cls.roles[-1].save()
-
-    def test_admin(self):
-        """Test that admin users can give any active role."""
-        user = baker.make(
-            User, user_permissions=[Permission.objects.get(codename="add_membership")]
-        )
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == self.roles[:-1]
-
-    def test_president(self):
-        """Test that someone with a presidency role can give any active role."""
-        user = baker.make(Membership, club=self.club, role=self.roles[0]).user
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == self.roles[:-1]
-
-    def test_board_member(self):
-        """Test that someone with a board role can give lower active role."""
-        user = baker.make(Membership, club=self.club, role=self.roles[2]).user
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == self.roles[3:-1]
-
-    def test_simple_member(self):
-        """Test that someone with a non-board role cannot give roles."""
-        user = baker.make(Membership, club=self.club, role=self.roles[4]).user
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == []
-
-
 @pytest.mark.django_db
 class TestJoinClub:
     @pytest.fixture(autouse=True)
@@ -583,64 +539,55 @@ class TestJoinClub:
         cache.clear()
 
     @pytest.mark.parametrize(
-        ("user_factory", "board_role", "errors"),
+        ("user_factory", "role", "errors"),
         [
             (
                 subscriber_user.make,
-                True,
+                2,
                 {
                     "role": [
-                        "Sélectionnez un choix valide. "
-                        "Ce choix ne fait pas partie de ceux disponibles."
+                        "Sélectionnez un choix valide. 2 n\u2019en fait pas partie."
                     ]
                 },
             ),
             (
                 lambda: baker.make(User),
-                False,
+                1,
                 {"__all__": ["Vous devez être cotisant pour faire partie d'un club"]},
             ),
         ],
     )
     def test_join_club_errors(
-        self, user_factory: Callable[[], User], board_role, errors: dict
+        self, user_factory: Callable[[], User], role: int, errors: dict
     ):
         club = baker.make(Club)
         user = user_factory()
-        role = baker.make(ClubRole, club=club, is_board=board_role)
-        form = JoinClubForm(club=club, request_user=user, data={"role": role.id})
+        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()
-        role = baker.make(ClubRole, is_board=False)
-        baker.make(Membership, user=user, club=role.club)
-        form = JoinClubForm(club=role.club, request_user=user, data={"role": role.id})
+        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()
-        role = baker.make(ClubRole, is_board=False)
-        form = JoinClubForm(club=role.club, request_user=user, data={"role": role.id})
+        form = JoinClubForm(club=club, request_user=user, data={"role": 1})
         assert form.is_valid()
         form.save()
-        assert Membership.objects.ongoing().filter(user=user, club=role.club).exists()
+        assert Membership.objects.ongoing().filter(user=user, club=club).exists()
 
 
 class TestOldMembersView(TestCase):
     @classmethod
     def setUpTestData(cls):
         club = baker.make(Club)
-        roles = baker.make(
-            ClubRole,
-            club=club,
-            is_board=itertools.cycle([True, True, False]),
-            order=seq(0),
-            _quantity=10,
-            _bulk_create=True,
-        )
+        roles = [1, 1, 1, 2, 2, 4, 4, 5, 7, 9, 10]
         cls.memberships = baker.make(
             Membership,
             role=iter(roles),
@@ -665,11 +612,3 @@ class TestOldMembersView(TestCase):
         self.client.force_login(baker.make(User))
         res = self.client.get(self.url)
         assert res.status_code == 403
-
-    def test_context_data(self):
-        # mark a membership as not ended, to make sure it is excluded from the result
-        self.memberships[0].end_date = None
-        self.memberships[0].save()
-        self.client.force_login(subscriber_user.make())
-        res = self.client.get(self.url)
-        assert list(res.context_data.get("old_members")) == self.memberships[1:]

club/tests/test_page.py

@@ -3,10 +3,9 @@ from bs4 import BeautifulSoup
 from django.test import Client
 from django.urls import reverse
 from model_bakery import baker
-from pytest_django.asserts import assertHTMLEqual, assertRedirects
+from pytest_django.asserts import assertHTMLEqual
 
-from club.models import Club, ClubRole, Membership
-from core.baker_recipes import subscriber_user
+from club.models import Club
 from core.markdown import markdown
 from core.models import PageRev, User
 
@@ -17,6 +16,7 @@ def test_page_display_on_club_main_page(client: Client):
     club = baker.make(Club)
     content = "# foo\nLorem ipsum dolor sit amet"
     baker.make(PageRev, page=club.page, revision=1, content=content)
+    client.force_login(baker.make(User))
     res = client.get(reverse("club:club_view", kwargs={"club_id": club.id}))
 
     assert res.status_code == 200
@@ -30,47 +30,10 @@ def test_club_main_page_without_content(client: Client):
     """Test the club view works, even if the club page is empty"""
     club = baker.make(Club)
     club.page.revisions.all().delete()
+    client.force_login(baker.make(User))
     res = client.get(reverse("club:club_view", kwargs={"club_id": club.id}))
 
     assert res.status_code == 200
     soup = BeautifulSoup(res.text, "lxml")
     detail_html = soup.find(id="club_detail")
     assert detail_html.find_all("markdown") == []
-
-
-@pytest.mark.django_db
-def test_page_revision(client: Client):
-    club = baker.make(Club)
-    revisions = baker.make(
-        PageRev, page=club.page, _quantity=3, content=iter(["foo", "bar", "baz"])
-    )
-    client.force_login(baker.make(User))
-    url = reverse(
-        "club:club_view_rev", kwargs={"club_id": club.id, "rev_id": revisions[1].id}
-    )
-    res = client.get(url)
-    assert res.status_code == 200
-    soup = BeautifulSoup(res.text, "lxml")
-    detail_html = soup.find(class_="markdown")
-    assertHTMLEqual(detail_html.decode_contents(), markdown(revisions[1].content))
-
-
-@pytest.mark.django_db
-def test_edit_page(client: Client):
-    club = baker.make(Club)
-    user = subscriber_user.make()
-    baker.make(
-        Membership,
-        user=user,
-        club=club,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
-    client.force_login(user)
-    url = reverse("club:club_edit_page", kwargs={"club_id": club.id})
-    content = "# foo\nLorem ipsum dolor sit amet"
-
-    res = client.get(url)
-    assert res.status_code == 200
-    res = client.post(url, data={"content": content})
-    assertRedirects(res, reverse("club:club_view", kwargs={"club_id": club.id}))
-    assert club.page.revisions.last().content == content

club/tests/test_sales.py

@@ -1,6 +1,3 @@
-import csv
-import itertools
-
 import pytest
 from django.test import Client
 from django.urls import reverse
@@ -10,20 +7,16 @@ from club.forms import SellingsForm
 from club.models import Club
 from core.models import User
 from counter.baker_recipes import product_recipe, sale_recipe
-from counter.models import Counter, Customer, Product, Selling
+from counter.models import Counter, Customer
 
 
 @pytest.mark.django_db
 def test_sales_page_doesnt_crash(client: Client):
-    """Basic crashtest on club sales view."""
     club = baker.make(Club)
-    product = baker.make(Product, club=club)
     admin = baker.make(User, is_superuser=True)
     client.force_login(admin)
-    url = reverse("club:club_sellings", kwargs={"club_id": club.id})
-    assert client.get(url).status_code == 200
-    assert client.post(url).status_code == 200
-    assert client.post(url, data={"products": [product.id]}).status_code == 200
+    response = client.get(reverse("club:club_sellings", kwargs={"club_id": club.id}))
+    assert response.status_code == 200
 
 
 @pytest.mark.django_db
@@ -43,62 +36,3 @@ def test_sales_form_counter_filter():
     form = SellingsForm(club)
     form_counters = list(form.fields["counters"].queryset)
     assert form_counters == [counters[1], counters[2], counters[0]]
-
-
-@pytest.mark.django_db
-def test_club_sales_csv(client: Client):
-    client.force_login(baker.make(User, is_superuser=True))
-    club = baker.make(Club)
-    counter = baker.make(Counter, club=club)
-    product = product_recipe.make(club=club, counters=[counter], purchase_price=0.5)
-    customers = baker.make(Customer, amount=100, _quantity=2, _bulk_create=True)
-    sales: list[Selling] = sale_recipe.make(
-        club=club,
-        counter=counter,
-        quantity=2,
-        unit_price=1.5,
-        product=iter([product, product, None]),
-        customer=itertools.cycle(customers),
-        _quantity=3,
-    )
-    url = reverse("club:sellings_csv", kwargs={"club_id": club.id})
-    response = client.post(url, data={"counters": [counter.id]})
-    assert response.status_code == 200
-    reader = csv.reader(s.decode() for s in response.streaming_content)
-    data = list(reader)
-    sale_rows = [
-        [
-            str(s.date),
-            str(counter),
-            str(s.seller),
-            s.customer.user.get_display_name(),
-            s.label,
-            "2",
-            "1.50",
-            "3.00",
-            "Compte utilisateur",
-        ]
-        for s in sales[::-1]
-    ]
-    sale_rows[2].extend(["0.50", "1.00"])
-    sale_rows[1].extend(["0.50", "1.00"])
-    sale_rows[0].extend(["", ""])
-    assert data == [
-        ["Quantité", "6"],
-        ["Total", "9"],
-        ["Bénéfice", "1"],
-        [
-            "Date",
-            "Comptoir",
-            "Barman",
-            "Client",
-            "Étiquette",
-            "Quantité",
-            "Prix unitaire",
-            "Total",
-            "Méthode de paiement",
-            "Prix d'achat",
-            "Bénéfice",
-        ],
-        *sale_rows,
-    ]

club/tests/test_user_club_controller.py

@@ -1,53 +0,0 @@
-from datetime import timedelta
-
-from django.test import TestCase
-from django.urls import reverse
-from django.utils.timezone import localdate
-from model_bakery import baker
-from model_bakery.recipe import Recipe
-
-from club.models import Club, ClubRole, Membership
-from club.schemas import UserMembershipSchema
-from core.baker_recipes import subscriber_user
-from core.models import Page
-
-
-class TestFetchClub(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.user = subscriber_user.make()
-        pages = baker.make(Page, _quantity=3, _bulk_create=True)
-        clubs = baker.make(Club, page=iter(pages), _quantity=3, _bulk_create=True)
-        recipe = Recipe(
-            Membership,
-            user=cls.user,
-            start_date=localdate() - timedelta(days=2),
-            role=baker.make(ClubRole),
-        )
-        cls.members = Membership.objects.bulk_create(
-            [
-                recipe.prepare(club=clubs[0]),
-                recipe.prepare(club=clubs[1], end_date=localdate() - timedelta(days=1)),
-                recipe.prepare(club=clubs[1]),
-            ]
-        )
-
-    def test_fetch_memberships(self):
-        self.client.force_login(subscriber_user.make())
-        res = self.client.get(
-            reverse("api:fetch_user_clubs", kwargs={"user_id": self.user.id})
-        )
-        assert res.status_code == 200
-        assert [UserMembershipSchema.model_validate(m) for m in res.json()] == [
-            UserMembershipSchema.from_orm(m) for m in (self.members[0], self.members[2])
-        ]
-
-    def test_fetch_club_nb_queries(self):
-        self.client.force_login(subscriber_user.make())
-        with self.assertNumQueries(6):
-            # - 5 queries for authentication
-            # - 1 query for the actual data
-            res = self.client.get(
-                reverse("api:fetch_user_clubs", kwargs={"user_id": self.user.id})
-            )
-            assert res.status_code == 200

club/urls.py

@@ -35,10 +35,6 @@ from club.views import (
     ClubPageEditView,
     ClubPageHistView,
     ClubRevView,
-    ClubRoleBoardCreateView,
-    ClubRoleMemberCreateView,
-    ClubRolePresidencyCreateView,
-    ClubRoleUpdateView,
     ClubSellingCSVView,
     ClubSellingView,
     ClubToolsView,
@@ -75,22 +71,6 @@ urlpatterns = [
         ClubOldMembersView.as_view(),
         name="club_old_members",
     ),
-    path("<int:club_id>/role/", ClubRoleUpdateView.as_view(), name="club_roles"),
-    path(
-        "<int:club_id>/role/new/president/",
-        ClubRolePresidencyCreateView.as_view(),
-        name="new_role_president",
-    ),
-    path(
-        "<int:club_id>/role/new/board/",
-        ClubRoleBoardCreateView.as_view(),
-        name="new_role_board",
-    ),
-    path(
-        "<int:club_id>/role/new/member/",
-        ClubRoleMemberCreateView.as_view(),
-        name="new_role_member",
-    ),
     path("<int:club_id>/sellings/", ClubSellingView.as_view(), name="club_sellings"),
     path(
         "<int:club_id>/sellings/csv/", ClubSellingCSVView.as_view(), name="sellings_csv"

club/views.py

@@ -22,51 +22,45 @@
 #
 #
 
-from __future__ import annotations
-
 import csv
-import itertools
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
-from django.contrib.auth.mixins import (
-    LoginRequiredMixin,
-    PermissionRequiredMixin,
-    UserPassesTestMixin,
-)
+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 F, Q, Sum
-from django.http import Http404, 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
+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.detail import SingleObjectMixin
-from django.views.generic.edit import (
-    CreateView,
-    DeleteView,
-    FormMixin,
-    UpdateView,
-)
+from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
 from club.forms import (
     ClubAddMemberForm,
     ClubAdminEditForm,
     ClubEditForm,
     ClubOldMemberForm,
-    ClubRoleCreateForm,
-    ClubRoleFormSet,
-    ClubSearchForm,
     JoinClubForm,
     MailingForm,
     SellingsForm,
 )
-from club.models import Club, ClubRole, Mailing, MailingSubscription, Membership
+from club.models import (
+    Club,
+    Mailing,
+    MailingSubscription,
+    Membership,
+)
 from com.models import Poster
 from com.views import (
     PosterCreateBaseView,
@@ -74,20 +68,14 @@ from com.views import (
     PosterEditBaseView,
     PosterListBaseView,
 )
-from core.auth.mixins import CanEditMixin, PermissionOrClubBoardRequiredMixin
-from core.models import Page, PageRev
-from core.views import BasePageEditView, DetailFormView, UseFragmentsMixin
-from core.views.mixins import (
-    AllowFragment,
-    FragmentMixin,
-    FragmentRenderer,
-    TabedViewMixin,
+from core.auth.mixins import (
+    CanEditMixin,
 )
+from core.models import PageRev
+from core.views import DetailFormView, PageEditViewBase, UseFragmentsMixin
+from core.views.mixins import FragmentMixin, FragmentRenderer, TabedViewMixin
 from counter.models import Selling
 
-if TYPE_CHECKING:
-    from django.utils.safestring import SafeString
-
 
 class ClubTabsMixin(TabedViewMixin):
     def get_tabs_title(self):
@@ -97,8 +85,6 @@ class ClubTabsMixin(TabedViewMixin):
             self.object = self.object.page.club
         elif isinstance(self.object, Poster):
             self.object = self.object.club
-        elif hasattr(self, "club"):
-            self.object = self.club
         return self.object.get_display_name()
 
     def get_list_of_tabs(self):
@@ -196,41 +182,15 @@ class ClubTabsMixin(TabedViewMixin):
         return tab_list
 
 
-class ClubListView(AllowFragment, FormMixin, ListView):
-    """List the clubs of the AE, with a form to perform basic search.
-
-    Notes:
-        This view is fully public, because we want to advertise as much as possible
-        the cultural life of the AE.
-        In accordance with that matter, searching and listing the clubs is done
-        entirely server-side (no AlpineJS involved) ;
-        this is done this way in order to be sure the page is the most accessible
-        and SEO-friendly possible, even if it makes the UX slightly less smooth.
-    """
+class ClubListView(ListView):
+    """List the Clubs."""
 
+    model = Club
     template_name = "club/club_list.jinja"
-    form_class = ClubSearchForm
-    queryset = Club.objects.order_by("name")
-    paginate_by = 20
-
-    def get_form_kwargs(self):
-        res = super().get_form_kwargs()
-        if self.request.method == "GET":
-            res |= {"data": self.request.GET, "initial": self.request.GET}
-        return res
-
-    def get_queryset(self):
-        form: ClubSearchForm = self.get_form()
-        qs = self.queryset
-        if not form.is_bound:
-            return qs.filter(is_active=True)
-        if not form.is_valid():
-            return qs.none()
-        if name := form.cleaned_data.get("name"):
-            qs = qs.filter(name__icontains=name)
-        if (is_active := form.cleaned_data.get("club_status")) is not None:
-            qs = qs.filter(is_active=is_active)
-        return qs
+    queryset = (
+        Club.objects.filter(parent=None).order_by("name").prefetch_related("children")
+    )
+    context_object_name = "club_list"
 
 
 class ClubView(ClubTabsMixin, DetailView):
@@ -252,7 +212,7 @@ class ClubView(ClubTabsMixin, DetailView):
         return kwargs
 
 
-class ClubRevView(LoginRequiredMixin, ClubView):
+class ClubRevView(ClubView):
     """Display a specific page revision."""
 
     def dispatch(self, request, *args, **kwargs):
@@ -266,26 +226,26 @@ class ClubRevView(LoginRequiredMixin, ClubView):
         return kwargs
 
 
-class ClubPageEditView(ClubTabsMixin, BasePageEditView):
+class ClubPageEditView(ClubTabsMixin, PageEditViewBase):
     template_name = "club/pagerev_edit.jinja"
     current_tab = "page_edit"
 
-    @cached_property
-    def club(self):
-        return get_object_or_404(Club, pk=self.kwargs["club_id"])
+    def dispatch(self, request, *args, **kwargs):
+        self.club = get_object_or_404(Club, pk=kwargs["club_id"])
+        if not self.club.page:
+            raise Http404
+        return super().dispatch(request, *args, **kwargs)
 
-    @cached_property
-    def page(self) -> Page:
-        page = self.club.page
-        page.set_lock(self.request.user)
-        return page
+    def get_object(self):
+        self.page = self.club.page
+        return self._get_revision()
 
     def get_success_url(self, **kwargs):
         return reverse_lazy("club:club_view", kwargs={"club_id": self.club.id})
 
 
 class ClubPageHistView(ClubTabsMixin, PermissionRequiredMixin, DetailView):
-    """Modification history of the page."""
+    """Modification hostory of the page."""
 
     model = Club
     pk_url_kwarg = "club_id"
@@ -360,7 +320,7 @@ class ClubMembersView(
         membership = self.object.get_membership_for(self.request.user)
         if (
             membership
-            and not membership.role.is_board
+            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.
@@ -385,8 +345,8 @@ class ClubMembersView(
         kwargs["members"] = list(
             self.object.members.ongoing()
             .annotate(is_editable=Q(id__in=editable))
-            .order_by("role__order")
-            .select_related("user", "role")
+            .order_by("-role")
+            .select_related("user")
         )
         kwargs["can_end_membership"] = len(editable) > 0
         return kwargs
@@ -414,127 +374,14 @@ class ClubOldMembersView(ClubTabsMixin, PermissionRequiredMixin, DetailView):
         return super().get_context_data(**kwargs) | {
             "old_members": (
                 self.object.members.exclude(end_date=None)
-                .order_by("role__order", "description", "-end_date")
-                .select_related("user", "role")
+                .order_by("-role", "description", "-end_date")
+                .select_related("user")
             )
         }
 
 
-class ClubRoleUpdateView(
-    ClubTabsMixin, UserPassesTestMixin, SuccessMessageMixin, UpdateView
-):
-    form_class = ClubRoleFormSet
-    model = Club
-    template_name = "club/club_roles.jinja"
-    pk_url_kwarg = "club_id"
-    current_tab = "members"
-    success_message = _("Club roles updated")
-
-    @cached_property
-    def club(self) -> Club:
-        return self.get_object()
-
-    def test_func(self):
-        return self.club.can_roles_be_edited_by(self.request.user)
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"form_kwargs": {"label_suffix": ""}}
-
-    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) | {
-            "user_role": ClubRole.objects.filter(
-                club=self.club,
-                members__user=self.request.user,
-                members__end_date=None,
-            )
-            .values_list("id", flat=True)
-            .first()
-        }
-
-
-class ClubRoleBaseCreateView(UserPassesTestMixin, SuccessMessageMixin, CreateView):
-    """View to create a new Club Role, using [][club.forms.ClubRoleCreateForm].
-
-    This view isn't meant to be called directly, but rather subclassed for each
-    type of role that can exist :
-
-    - `[ClubRolePresidencyCreateView][club.views.ClubRolePresidencyCreateView]`
-      to create a presidency role
-    - `[ClubRoleBoardCreateView][club.views.ClubRoleBoardCreateView]`
-      to create a board role
-    - `[ClubRoleMemberCreateView][club.views.ClubRoleMemberCreateView]`
-      to create a member role
-
-    Each subclass have to override the following variables :
-
-    - `is_presidency` and `is_board`, indicating what type of role
-      the view creates.
-    - `role_description`, which is the title of the page, indication
-       the user what kind of role is being created.
-
-    This way, we are making sure the correct type of role will
-    be created, without bothering the user with the implementation details.
-    """
-
-    form_class = ClubRoleCreateForm
-    model = ClubRole
-    template_name = "core/create.jinja"
-    success_message = _("Role %(name)s created")
-    role_description = ""
-    is_presidency: bool
-    is_board: bool
-
-    @cached_property
-    def club(self):
-        return get_object_or_404(Club, id=self.kwargs["club_id"])
-
-    def test_func(self):
-        return self.request.user.is_authenticated and (
-            self.request.user.has_perm("club.add_clubrole")
-            or self.club.members.filter(
-                user=self.request.user, role__is_presidency=True
-            ).exists()
-        )
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "club": self.club,
-            "is_presidency": self.is_presidency,
-            "is_board": self.is_board,
-        }
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "object_name": self.role_description
-        }
-
-    def get_success_url(self):
-        return reverse("club:club_roles", kwargs={"club_id": self.club.id})
-
-
-class ClubRolePresidencyCreateView(ClubRoleBaseCreateView):
-    is_presidency = True
-    is_board = True
-    role_description = _("club role \u2013 presidency")
-
-
-class ClubRoleBoardCreateView(ClubRoleBaseCreateView):
-    is_presidency = False
-    is_board = True
-    role_description = _("club role \u2013 board")
-
-
-class ClubRoleMemberCreateView(ClubRoleBaseCreateView):
-    is_presidency = False
-    is_board = False
-    role_description = _("club role \u2013 member")
-
-
 class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
-    """Sales of a club."""
+    """Sellings of a club."""
 
     model = Club
     pk_url_kwarg = "club_id"
@@ -560,28 +407,47 @@ class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
 
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)
+        qs = Selling.objects.filter(club=self.object)
 
-        kwargs["result"] = Selling.objects.none()
+        kwargs["result"] = qs[:0]
+        kwargs["paginated_result"] = kwargs["result"]
         kwargs["total"] = 0
         kwargs["total_quantity"] = 0
         kwargs["benefit"] = 0
 
-        form: SellingsForm = self.get_form()
-        if form.is_valid() and any(v for v in form.cleaned_data.values()):
-            filters = form.to_filter_schema()
-            qs = filters.filter(Selling.objects.filter(club=self.object))
-            kwargs["total"] = qs.annotate(
-                price=F("quantity") * F("unit_price")
-            ).aggregate(total=Sum("price", default=0))["total"]
+        form = self.get_form()
+        if form.is_valid():
+            if not len([v for v in form.cleaned_data.values() if v is not None]):
+                qs = Selling.objects.none()
+            if form.cleaned_data["begin_date"]:
+                qs = qs.filter(date__gte=form.cleaned_data["begin_date"])
+            if form.cleaned_data["end_date"]:
+                qs = qs.filter(date__lte=form.cleaned_data["end_date"])
+
+            if form.cleaned_data["counters"]:
+                qs = qs.filter(counter__in=form.cleaned_data["counters"])
+
+            selected_products = []
+            if form.cleaned_data["products"]:
+                selected_products.extend(form.cleaned_data["products"])
+            if form.cleaned_data["archived_products"]:
+                selected_products.extend(form.cleaned_data["archived_products"])
+
+            if len(selected_products) > 0:
+                qs = qs.filter(product__in=selected_products)
+
             kwargs["result"] = qs.select_related(
                 "counter", "counter__club", "customer", "customer__user", "seller"
             ).order_by("-id")
-            kwargs["total_quantity"] = qs.aggregate(total=Sum("quantity", default=0))[
-                "total"
-            ]
-            kwargs["benefit"] = qs.exclude(product=None).aggregate(
-                res=Sum("product__purchase_price", default=0)
-            )["res"]
+            kwargs["total"] = sum([s.quantity * s.unit_price for s in kwargs["result"]])
+            total_quantity = qs.all().aggregate(Sum("quantity"))
+            if total_quantity["quantity__sum"]:
+                kwargs["total_quantity"] = total_quantity["quantity__sum"]
+            benefit = (
+                qs.exclude(product=None).all().aggregate(Sum("product__purchase_price"))
+            )
+            if benefit["product__purchase_price__sum"]:
+                kwargs["benefit"] = benefit["product__purchase_price__sum"]
 
         kwargs["paginator"] = Paginator(kwargs["result"], self.paginate_by)
         try:
@@ -616,15 +482,15 @@ class ClubSellingCSVView(ClubSellingView):
             *row,
             selling.label,
             selling.quantity,
-            selling.unit_price,
             selling.quantity * selling.unit_price,
             selling.get_payment_method_display(),
         ]
         if selling.product:
+            row.append(selling.product.selling_price)
             row.append(selling.product.purchase_price)
-            row.append(selling.unit_price - selling.product.purchase_price)
+            row.append(selling.product.selling_price - selling.product.purchase_price)
         else:
-            row = [*row, "", ""]
+            row = [*row, "", "", ""]
         return row
 
     def get(self, request, *args, **kwargs):
@@ -632,40 +498,40 @@ class ClubSellingCSVView(ClubSellingView):
         kwargs = self.get_context_data(**kwargs)
 
         # Use the StreamWriter class instead of request for streaming
-        writer = csv.writer(self.StreamWriter())
+        pseudo_buffer = self.StreamWriter()
+        writer = csv.writer(
+            pseudo_buffer, delimiter=";", lineterminator="\n", quoting=csv.QUOTE_ALL
+        )
 
-        first_rows = [
-            [gettext("Quantity"), kwargs["total_quantity"]],
-            [gettext("Total"), kwargs["total"]],
-            [gettext("Benefit"), kwargs["benefit"]],
+        writer.writerow([_t("Quantity"), kwargs["total_quantity"]])
+        writer.writerow([_t("Total"), kwargs["total"]])
+        writer.writerow([_t("Benefit"), kwargs["benefit"]])
+        writer.writerow(
             [
-                gettext("Date"),
-                gettext("Counter"),
-                gettext("Barman"),
-                gettext("Customer"),
-                gettext("Label"),
-                gettext("Quantity"),
-                gettext("Unit price"),
-                gettext("Total"),
-                gettext("Payment method"),
-                gettext("Purchase price"),
-                gettext("Benefit"),
-            ],
-        ]
+                _t("Date"),
+                _t("Counter"),
+                _t("Barman"),
+                _t("Customer"),
+                _t("Label"),
+                _t("Quantity"),
+                _t("Total"),
+                _t("Payment method"),
+                _t("Selling price"),
+                _t("Purchase price"),
+                _t("Benefit"),
+            ]
+        )
 
         # Stream response
         response = StreamingHttpResponse(
-            itertools.chain(
-                (writer.writerow(r) for r in first_rows),
-                (
-                    writer.writerow(self.write_selling(selling))
-                    for selling in kwargs["result"]
-                ),
+            (
+                writer.writerow(self.write_selling(selling))
+                for selling in kwargs["result"]
             ),
             content_type="text/csv",
         )
-        name = f"{gettext('Sellings')}_{self.object.name}.csv"
-        response["Content-Disposition"] = f"attachment; filename={name}"
+        name = _("Sellings") + "_" + self.object.name + ".csv"
+        response["Content-Disposition"] = "filename=" + name
 
         return response
 
@@ -699,23 +565,34 @@ class ClubCreateView(PermissionRequiredMixin, CreateView):
     template_name = "core/create.jinja"
     permission_required = "club.add_club"
 
-    def form_valid(self, form):
-        res = super().form_valid(form)
-        self.object.create_default_roles()
-        return res
 
-
-class MembershipSetOldView(CanEditMixin, SingleObjectMixin, View):
-    """Set a membership as being old."""
+class MembershipSetOldView(CanEditMixin, DetailView):
+    """Set a membership as beeing old."""
 
     model = Membership
     pk_url_kwarg = "membership_id"
 
-    def post(self, *_args, **_kwargs):
+    def get(self, request, *args, **kwargs):
         self.object = self.get_object()
         self.object.end_date = timezone.now()
         self.object.save()
-        return redirect("core:user_clubs", user_id=self.object.user_id)
+        return HttpResponseRedirect(
+            reverse(
+                "club:club_members",
+                args=self.args,
+                kwargs={"club_id": self.object.club.id},
+            )
+        )
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        return HttpResponseRedirect(
+            reverse(
+                "club:club_members",
+                args=self.args,
+                kwargs={"club_id": self.object.club.id},
+            )
+        )
 
 
 class MembershipDeleteView(PermissionRequiredMixin, DeleteView):
@@ -727,7 +604,7 @@ class MembershipDeleteView(PermissionRequiredMixin, DeleteView):
     permission_required = "club.delete_membership"
 
     def get_success_url(self):
-        return reverse_lazy("core:user_clubs", kwargs={"user_id": self.object.user_id})
+        return reverse_lazy("core:user_clubs", kwargs={"user_id": self.object.user.id})
 
 
 class ClubMailingView(ClubTabsMixin, CanEditMixin, DetailFormView):
@@ -884,19 +761,19 @@ class MailingAutoGenerationView(View):
     def get(self, request, *args, **kwargs):
         club = self.mailing.club
         self.mailing.subscriptions.all().delete()
-        members = club.members.ongoing().filter(role__is_board=True)
+        members = club.members.filter(
+            role__gte=settings.SITH_CLUB_ROLES_ID["Board member"]
+        ).exclude(end_date__lte=timezone.now())
         for member in members.all():
             MailingSubscription(user=member.user, mailing=self.mailing).save()
         return redirect("club:mailing", club_id=club.id)
 
 
-class PosterListView(
-    PermissionOrClubBoardRequiredMixin, ClubTabsMixin, PosterListBaseView
-):
+class PosterListView(ClubTabsMixin, PosterListBaseView):
     """List communication posters."""
 
     current_tab = "posters"
-    permission_required = "com.view_poster"
+    extra_context = {"app": "club"}
 
     def get_queryset(self):
         return super().get_queryset().filter(club=self.club.id)
@@ -904,17 +781,6 @@ class PosterListView(
     def get_object(self):
         return self.club
 
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "create_url": reverse_lazy(
-                "club:poster_create", kwargs={"club_id": self.club.id}
-            ),
-            "get_edit_url": lambda poster: reverse(
-                "club:poster_edit",
-                kwargs={"club_id": self.club.id, "poster_id": poster.id},
-            ),
-        }
-
 
 class PosterCreateView(ClubTabsMixin, PosterCreateBaseView):
     """Create communication poster."""

com/api.py

@@ -5,6 +5,7 @@ from django.utils.cache import add_never_cache_headers
 from ninja import Query
 from ninja_extra import ControllerBase, api_controller, paginate, route
 from ninja_extra.pagination import PageNumberPaginationExtra
+from ninja_extra.permissions import IsAuthenticated
 from ninja_extra.schemas import PaginatedResponseSchema
 
 from api.permissions import HasPerm
@@ -16,13 +17,17 @@ from core.views.files import send_raw_file
 
 @api_controller("/calendar")
 class CalendarController(ControllerBase):
-    @route.get("/internal.ics", auth=None, url_name="calendar_internal")
+    @route.get("/internal.ics", url_name="calendar_internal")
     def calendar_internal(self):
         response = send_raw_file(IcsCalendar.get_internal())
         add_never_cache_headers(response)
         return response
 
-    @route.get("/unpublished.ics", url_name="calendar_unpublished")
+    @route.get(
+        "/unpublished.ics",
+        permissions=[IsAuthenticated],
+        url_name="calendar_unpublished",
+    )
     def calendar_unpublished(self):
         response = HttpResponse(
             IcsCalendar.get_unpublished(self.context.request.user),
@@ -69,7 +74,6 @@ class NewsController(ControllerBase):
 
     @route.get(
         "/date",
-        auth=None,
         url_name="fetch_news_dates",
         response=PaginatedResponseSchema[NewsDateSchema],
     )

com/ics_calendar.py

@@ -4,16 +4,15 @@ from dateutil.relativedelta import relativedelta
 from django.conf import settings
 from django.contrib.sites.models import Site
 from django.contrib.syndication.views import add_domain
-from django.db.models import Count, OuterRef, QuerySet, Subquery
+from django.db.models import F, QuerySet
 from django.http import HttpRequest
 from django.urls import reverse
 from django.utils import timezone
 from ical.calendar import Calendar
 from ical.calendar_stream import IcsCalendarStream
 from ical.event import Event
-from ical.types import Frequency, Recur
 
-from com.models import News, NewsDate
+from com.models import NewsDate
 from core.models import User
 
 
@@ -43,9 +42,9 @@ class IcsCalendar:
         with open(cls._INTERNAL_CALENDAR, "wb") as f:
             _ = f.write(
                 cls.ics_from_queryset(
-                    News.objects.filter(
-                        is_published=True,
-                        dates__end_date__gte=timezone.now() - relativedelta(months=6),
+                    NewsDate.objects.filter(
+                        news__is_published=True,
+                        end_date__gte=timezone.now() - (relativedelta(months=6)),
                     )
                 )
             )
@@ -54,35 +53,24 @@ class IcsCalendar:
     @classmethod
     def get_unpublished(cls, user: User) -> bytes:
         return cls.ics_from_queryset(
-            News.objects.viewable_by(user).filter(
-                is_published=False,
-                dates__end_date__gte=timezone.now() - relativedelta(months=6),
-            )
+            NewsDate.objects.viewable_by(user).filter(
+                news__is_published=False,
+                end_date__gte=timezone.now() - (relativedelta(months=6)),
+            ),
         )
 
     @classmethod
-    def ics_from_queryset(cls, queryset: QuerySet[News]) -> bytes:
+    def ics_from_queryset(cls, queryset: QuerySet[NewsDate]) -> bytes:
         calendar = Calendar()
-        date_subquery = NewsDate.objects.filter(news=OuterRef("pk")).order_by(
-            "start_date"
-        )
-        queryset = queryset.annotate(
-            start=Subquery(date_subquery.values("start_date")[:1]),
-            end=Subquery(date_subquery.values("end_date")[:1]),
-            nb_dates=Count("dates"),
-        )
-        for news in queryset:
+        for news_date in queryset.annotate(news_title=F("news__title")):
             event = Event(
-                summary=news.title,
-                description=news.summary,
-                dtstart=news.start,
-                dtend=news.end,
+                summary=news_date.news_title,
+                start=news_date.start_date,
+                end=news_date.end_date,
                 url=as_absolute_url(
-                    reverse("com:news_detail", kwargs={"news_id": news.id})
+                    reverse("com:news_detail", kwargs={"news_id": news_date.news_id})
                 ),
             )
-            if news.nb_dates > 1:
-                event.rrule = Recur(freq=Frequency.WEEKLY, count=news.nb_dates)
             calendar.events.append(event)
 
         return IcsCalendarStream.calendar_to_ics(calendar).encode("utf-8")

com/models.py

@@ -144,7 +144,7 @@ class News(models.Model):
                 ),
                 groups__id=settings.SITH_GROUP_COM_ADMIN_ID,
             )
-            notif_url = reverse("com:news_admin_list", fragment="moderation")
+            notif_url = reverse("com:news_admin_list")
             new_notifs = [
                 Notification(user=user, url=notif_url, type="NEWS_MODERATION")
                 for user in admins_without_notif
@@ -402,7 +402,9 @@ class Poster(models.Model):
                 groups__id__in=[settings.SITH_GROUP_COM_ADMIN_ID]
             ):
                 Notification.objects.create(
-                    user=user, url=reverse("com:poster_list"), type="POSTER_MODERATION"
+                    user=user,
+                    url=reverse("com:poster_moderate_list"),
+                    type="POSTER_MODERATION",
                 )
         return super().save(*args, **kwargs)
 

com/schemas.py

@@ -1,9 +1,9 @@
 from datetime import datetime
-from typing import Annotated
 
-from ninja import FilterLookup, FilterSchema, ModelSchema
+from ninja import FilterSchema, ModelSchema
 from ninja_extra import service_resolver
 from ninja_extra.context import RouteContext
+from pydantic import Field
 
 from club.schemas import ClubProfileSchema
 from com.models import News, NewsDate
@@ -11,12 +11,12 @@ from core.markdown import markdown
 
 
 class NewsDateFilterSchema(FilterSchema):
-    before: Annotated[datetime | None, FilterLookup("end_date__lt")] = None
-    after: Annotated[datetime | None, FilterLookup("start_date__gt")] = None
-    club_id: Annotated[int | None, FilterLookup("news__club_id")] = None
+    before: datetime | None = Field(None, q="end_date__lt")
+    after: datetime | None = Field(None, q="start_date__gt")
+    club_id: int | None = Field(None, q="news__club_id")
     news_id: int | None = None
-    is_published: Annotated[bool | None, FilterLookup("news__is_published")] = None
-    title: Annotated[str | None, FilterLookup("news__title__icontains")] = None
+    is_published: bool | None = Field(None, q="news__is_published")
+    title: str | None = Field(None, q="news__title__icontains")
 
 
 class NewsSchema(ModelSchema):

com/static/bundled/com/components/ics-calendar-index.ts

@@ -1,4 +1,6 @@
-import { Calendar, type EventClickArg, type EventContentArg } from "@fullcalendar/core";
+import { makeUrl } from "#core:utils/api";
+import { inheritHtmlElement, registerComponent } from "#core:utils/web-components";
+import { Calendar, type EventClickArg } from "@fullcalendar/core";
 import type { EventImpl } from "@fullcalendar/core/internal";
 import enLocale from "@fullcalendar/core/locales/en-gb";
 import frLocale from "@fullcalendar/core/locales/fr";
@@ -6,8 +8,6 @@ import dayGridPlugin from "@fullcalendar/daygrid";
 import iCalendarPlugin from "@fullcalendar/icalendar";
 import listPlugin from "@fullcalendar/list";
 import { type HTMLTemplateResult, html, render } from "lit-html";
-import { makeUrl } from "#core:utils/api.ts";
-import { inheritHtmlElement, registerComponent } from "#core:utils/web-components.ts";
 import {
   calendarCalendarInternal,
   calendarCalendarUnpublished,
@@ -25,11 +25,6 @@ export class IcsCalendar extends inheritHtmlElement("div") {
   private canDelete = false;
   private helpUrl = "";
 
-  // Hack variable to detect recurring events
-  // The underlying ics library doesn't include any info about rrules
-  // That's why we have to detect those events ourselves
-  private recurrenceMap: Map<string, EventImpl> = new Map();
-
   attributeChangedCallback(name: string, _oldValue?: string, newValue?: string) {
     if (name === "locale") {
       this.locale = newValue;
@@ -95,13 +90,11 @@ export class IcsCalendar extends inheritHtmlElement("div") {
         .split("/")
         .filter((s) => s) // Remove blank characters
         .pop(),
-      10,
     );
   }
 
   refreshEvents() {
     this.click(); // Remove focus from popup
-    this.recurrenceMap.clear(); // Avoid double detection of the same non recurring event
     this.calendar.refetchEvents();
   }
 
@@ -160,24 +153,12 @@ export class IcsCalendar extends inheritHtmlElement("div") {
   }
 
   async getEventSources() {
-    const tagRecurringEvents = (eventData: EventImpl) => {
-      // This functions tags events with a similar event url
-      // We rely on the fact that the event url is always the same
-      // for recurring events and always different for single events
-      const firstEvent = this.recurrenceMap.get(eventData.url);
-      if (firstEvent !== undefined) {
-        eventData.extendedProps.isRecurring = true;
-        firstEvent.extendedProps.isRecurring = true; // Don't forget the first event
-      }
-      this.recurrenceMap.set(eventData.url, eventData);
-    };
     return [
       {
         url: `${await makeUrl(calendarCalendarInternal)}`,
         format: "ics",
         className: "internal",
         cache: false,
-        eventDataTransform: tagRecurringEvents,
       },
       {
         url: `${await makeUrl(calendarCalendarUnpublished)}`,
@@ -185,7 +166,6 @@ export class IcsCalendar extends inheritHtmlElement("div") {
         color: "red",
         className: "unpublished",
         cache: false,
-        eventDataTransform: tagRecurringEvents,
       },
     ];
   }
@@ -381,14 +361,6 @@ export class IcsCalendar extends inheritHtmlElement("div") {
         event.jsEvent.preventDefault();
         this.createEventDetailPopup(event);
       },
-      eventClassNames: (classNamesEvent: EventContentArg) => {
-        const classes: string[] = [];
-        if (classNamesEvent.event.extendedProps?.isRecurring) {
-          classes.push("recurring");
-        }
-
-        return classes;
-      },
     });
     this.calendar.render();
 

com/static/bundled/com/moderation-alert-index.ts

@@ -1,4 +1,4 @@
-import { exportToHtml } from "#core:utils/globals.ts";
+import { exportToHtml } from "#core:utils/globals";
 import { newsDeleteNews, newsFetchNewsDates, newsPublishNews } from "#openapi";
 
 // This will be used in jinja templates,

com/static/com/components/ics-calendar.scss

@@ -18,8 +18,6 @@
   --event-details-border-radius: 4px;
   --event-details-box-shadow: 0px 6px 20px 4px rgb(0 0 0 / 16%);
   --event-details-max-width: 600px;
-  --event-recurring-internal-color: #6f69cd;
-  --event-recurring-unpublished-color: orange;
 }
 
 ics-calendar {
@@ -149,28 +147,3 @@ ics-calendar {
   opacity: 0;
   transition: opacity 500ms ease-out;
 }
-
-// We have to override the color set by the lib in the html
-// Hence the !important tag everywhere
-.internal.recurring {
-  .fc-daygrid-event-dot {
-    border-color: var(--event-recurring-internal-color) !important;
-  }
-
-  &.fc-daygrid-block-event {
-    background-color: var(--event-recurring-internal-color) !important;
-    border-color: var(--event-recurring-internal-color) !important;
-  }
-
-}
-
-.unpublished.recurring {
-  .fc-daygrid-event-dot {
-    border-color: var(--event-recurring-unpublished-color) !important;
-  }
-
-  &.fc-daygrid-block-event {
-    background-color: var(--event-recurring-unpublished-color) !important;
-    border-color: var(--event-recurring-unpublished-color) !important;
-  }
-}

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

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

com/static/com/css/posters.scss

@@ -20,7 +20,33 @@
       position: absolute;
       display: flex;
       bottom: 5px;
-      left: 0;
+
+      &.left {
+        left: 0;
+      }
+
+      &.right {
+        right: 0;
+      }
+
+      .link {
+        padding: 5px;
+        padding-left: 20px;
+        padding-right: 20px;
+        margin-left: 5px;
+        border-radius: 20px;
+        background-color: hsl(40, 100%, 50%);
+        color: black;
+
+        &:hover {
+          color: black;
+          background-color: hsl(40, 58%, 50%);
+        }
+
+        &.delete {
+          background-color: hsl(0, 100%, 40%);
+        }
+      }
     }
   }
 
@@ -117,15 +143,43 @@
         }
       }
 
-      .actions {
-        display: flex;
-        flex-direction: column;
-        align-items: stretch;
-        form {
-          margin: unset;
-          padding: unset;
-          button {
-            width: 100%;
+      .edit,
+      .moderate,
+      .slideshow {
+        padding: 5px;
+        border-radius: 20px;
+        background-color: hsl(40, 100%, 50%);
+        color: black;
+
+        &:hover {
+          color: black;
+          background-color: hsl(40, 58%, 50%);
+        }
+
+        &:nth-child(2n) {
+          margin-top: 5px;
+          margin-bottom: 5px;
+        }
+      }
+
+      .tooltip {
+        visibility: hidden;
+        width: 120px;
+        background-color: hsl(210, 20%, 98%);
+        color: hsl(0, 0%, 0%);
+        text-align: center;
+        padding: 5px 0;
+        border-radius: 6px;
+        position: absolute;
+        z-index: 10;
+
+        ul {
+          margin-left: 0;
+          display: inline-block;
+
+          li {
+            display: list-item;
+            list-style-type: none;
           }
         }
       }

com/templates/com/macros.jinja

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

com/templates/com/news_admin_list.jinja

@@ -131,7 +131,7 @@
       {% endfor %}
     </tbody>
   </table>
-  <h5 id="moderation">{% trans %}Events to moderate{% endtrans %}</h5>
+  <h5>{% trans %}Events to moderate{% endtrans %}</h5>
   <table>
     <thead>
       <tr>
@@ -165,3 +165,6 @@
     </tbody>
   </table>
 {% endblock %}
+
+
+

com/templates/com/news_detail.jinja

@@ -1,20 +1,15 @@
 {% extends "core/base.jinja" %}
-{% from 'core/macros.jinja' import user_profile_link, link_news_logo %}
+{% from 'core/macros.jinja' import user_profile_link, facebook_share, tweet, link_news_logo, gen_news_metatags %}
 {% from "com/macros.jinja" import news_moderation_alert %}
 
 {% block title %}
-  {% trans %}News{% endtrans %} - {{ object.title }}
+  {% trans %}News{% endtrans %} -
+  {{ object.title }}
 {% endblock %}
 
-{% block description %}{{ news.summary }}{% endblock %}
-
-{% block metatags %}
-  <meta property="og:url" content="{{ news.get_full_url() }}" />
-  <meta property="og:type" content="article" />
-  <meta property="article:section" content="{% trans %}News{% endtrans %}" />
-  <meta property="og:title" content="{{ news.title }}" />
-  <meta property="og:description" content="{{ news.summary }}" />
-  <meta property="og:image" content="{{ request.build_absolute_uri(link_news_logo(news)) }}" />
+{% block head %}
+  {{ super() }}
+  {{ gen_news_metatags(news) }}
 {% endblock %}
 
 
@@ -49,14 +44,8 @@
         <div><em>{{ news.summary|markdown }}</em></div>
         <br/>
         <div>{{ news.content|markdown }}</div>
-        <a
-          rel="nofollow"
-          target="#"
-          class="share_button facebook"
-          href="https://www.facebook.com/sharer/sharer.php?u={{ news.get_full_url() }}"
-        >
-          {% trans %}Share on Facebook{% endtrans %}
-        </a>
+        {{ facebook_share(news) }}
+        {{ tweet(news) }}
         <div class="news_meta">
           <p>{% trans %}Author: {% endtrans %}{{ user_profile_link(news.author) }}</p>
           {% if news.moderator %}

com/templates/com/news_list.jinja

@@ -203,15 +203,11 @@
           <ul>
             <li>
               <i class="fa-solid fa-graduation-cap fa-xl"></i>
-              <a href="{{ url("pedagogy:guide") }}">{% trans %}UE Guide{% endtrans %}</a>
-            </li>
-            <li>
-              <i class="fa-solid fa-calendar-days fa-xl"></i>
-              <a href="{{ url("timetable:generator") }}">{% trans %}Timetable{% endtrans %}</a>
+              <a href="{{ url("pedagogy:guide") }}">{% trans %}UV Guide{% endtrans %}</a>
             </li>
             <li>
               <i class="fa-solid fa-magnifying-glass fa-xl"></i>
-              <a href="{{ url("matmat:search") }}">{% trans %}Matmatronch{% endtrans %}</a>
+              <a href="{{ url("matmat:search_clear") }}">{% trans %}Matmatronch{% endtrans %}</a>
             </li>
             <li>
               <i class="fa-solid fa-check-to-slot fa-xl"></i>

com/templates/com/poster_list.jinja

@@ -13,53 +13,53 @@
 
     <div id="title">
       <h3>{% trans %}Posters{% endtrans %}</h3>
-      <div id="links">
-        <a id="create" class="btn btn-blue" href="{{ create_url }}">
-          <i class="fa fa-plus"></i>
-          {% trans %}Create{% endtrans %}
-        </a>
+      <div id="links" class="right">
+        {% if app == "com" %}
+          <a id="create" class="link" href="{{ url(app + ":poster_create") }}">{% trans %}Create{% endtrans %}</a>
+          <a id="moderation" class="link" href="{{ url("com:poster_moderate_list") }}">{% trans %}Moderation{% endtrans %}</a>
+        {% elif app == "club" %}
+          <a id="create" class="link" href="{{ url(app + ":poster_create", club.id) }}">{% trans %}Create{% endtrans %}</a>
+        {% endif %}
       </div>
     </div>
 
     <div id="posters">
-      {% for poster in poster_list %}
-        <div class="poster{% if not poster.is_moderated %} not_moderated{% endif %}">
-          <div class="name">{{ poster.name }}</div>
-          <div
-            class="image"
-            hover="{% trans %}Click to expand{% endtrans %}"
-            @click="active = $el.firstElementChild"
-            tooltip="{%- for screen in poster.screens.all() -%}
-                       {{ screen }}
-                     {% endfor %}"
-          >
-            <img src="{{ poster.file.url }}" alt="{{ poster.name }}">
-          </div>
-          <div class="dates">
-            <div class="begin">{{ poster.date_begin | localtime | date("d/M/Y H:m") }}</div>
-            <div class="end">{{ poster.date_end | localtime | date("d/M/Y H:m") }}</div>
-          </div>
-          <div class="actions">
-            {% if poster.is_editable %}
-              <a class="btn btn-blue" href="{{ get_edit_url(poster) }}">
-                <i class="fa fa-pen-to-square"></i>
-                {% trans %}Edit{% endtrans %}
-              </a>
-            {% endif %}
-            {% if not poster.is_moderated and user.has_perm("com.moderate_poster") %}
-              <form action="{{ url("com:poster_moderate", object_id=poster.id) }}" method="post">
-                {% csrf_token %}
-                <button type="submit" class="btn btn-green">
-                  <i class="fa fa-check"></i>
-                  {% trans %}Moderate{% endtrans %}
-                </button>
-              </form>
-            {% endif %}
-          </div>
-        </div>
-      {% else %}
+
+      {% if poster_list.count() == 0 %}
         <div id="no-posters">{% trans %}No posters{% endtrans %}</div>
-      {% endfor %}
+      {% else %}
+
+        {% for poster in poster_list %}
+          <div class="poster{% if not poster.is_moderated %} not_moderated{% endif %}">
+            <div class="name">{{ poster.name }}</div>
+            <div
+              class="image"
+              hover="{% trans %}Click to expand{% endtrans %}"
+              @click="active = $el.firstElementChild"
+            >
+              <img src="{{ poster.file.url }}"></img>
+            </div>
+            <div class="dates">
+              <div class="begin">{{ poster.date_begin | localtime | date("d/M/Y H:m") }}</div>
+              <div class="end">{{ poster.date_end | localtime | date("d/M/Y H:m") }}</div>
+            </div>
+            {% if app == "com" %}
+              <a class="edit" href="{{ url(app + ":poster_edit", poster.id) }}">{% trans %}Edit{% endtrans %}</a>
+            {% elif app == "club" %}
+              <a class="edit" href="{{ url(app + ":poster_edit", club.id, poster.id) }}">{% trans %}Edit{% endtrans %}</a>
+            {% endif %}
+            <div class="tooltip">
+              <ul>
+                {% for screen in poster.screens.all() %}
+                  <li>{{ screen }}</li>
+                {% endfor %}
+              </ul>
+            </div>
+          </div>
+        {% endfor %}
+
+      {% endif %}
+
     </div>
 
     <div
@@ -68,9 +68,7 @@
       @click="active = null"
       :class="{active: active !== null}"
     >
-      <div id="placeholder">
-        <img :src="active?.src" :alt="active?.name">
-      </div>
+      <div id="placeholder"><img :src="active?.src"></div>
     </div>
 
   </div>

com/templates/com/poster_moderate.jinja

@@ -0,0 +1,43 @@
+{% extends "core/base.jinja" %}
+
+{% block script %}
+  {{ super() }}
+  <script src="{{ static('com/js/poster_list.js') }}"></script>
+{% endblock %}
+
+{% block additional_css %}
+  <link rel="stylesheet" href="{{ static('com/css/posters.scss') }}">
+{% endblock %}
+
+{% block content %}
+  <div id="poster_list">
+
+    <div id="title">
+      <div id="links" class="left">
+        <a id="list" class="link" href="{{ url("com:poster_list") }}">{% trans %}List{% endtrans %}</a>
+      </div>
+      <h3>{% trans %}Posters - moderation{% endtrans %}</h3>
+    </div>
+
+    <div id="posters">
+
+      {% if object_list.count == 0 %}
+        <div id="no-posters">{% trans %}No objects{% endtrans %}</div>
+      {% else %}
+
+        {% for poster in object_list %}
+          <div class="poster{% if not poster.is_moderated %} not_moderated{% endif %}">
+            <div class="name"> {{ poster.name }} </div>
+            <div class="image"> <img src="{{ poster.file.url }}"></img> </div>
+            <a class="moderate" href="{{ url("com:poster_moderate", object_id=poster.id) }}">Moderate</a>
+          </div>
+        {% endfor %}
+
+      {% endif %}
+
+    </div>
+
+    <div id="view"><div id="placeholder"></div></div>
+
+  </div>
+{% endblock %}

com/tests/test_api.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from datetime import timedelta
 from pathlib import Path
 
@@ -17,6 +18,16 @@ from core.markdown import markdown
 from core.models import User
 
 
+@dataclass
+class MockResponse:
+    ok: bool
+    value: str
+
+    @property
+    def content(self):
+        return self.value.encode("utf8")
+
+
 def accel_redirect_to_file(response: HttpResponse) -> Path | None:
     redirect = Path(response.headers.get("X-Accel-Redirect", ""))
     if not redirect.is_relative_to(Path("/") / settings.MEDIA_ROOT.stem):

com/tests/test_views.py

@@ -17,9 +17,7 @@ from unittest.mock import patch
 
 import pytest
 from django.conf import settings
-from django.contrib.auth.models import Permission
 from django.contrib.sites.models import Site
-from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import Client, TestCase
 from django.urls import reverse
 from django.utils import html
@@ -28,11 +26,10 @@ from django.utils.translation import gettext as _
 from model_bakery import baker
 from pytest_django.asserts import assertNumQueries, assertRedirects
 
-from club.models import Club, ClubRole, Membership
-from com.models import News, NewsDate, Poster, Sith, Weekmail, WeekmailArticle
+from club.models import Club, Membership
+from com.models import News, NewsDate, Sith, Weekmail, WeekmailArticle
 from core.baker_recipes import subscriber_user
 from core.models import AnonymousUser, Group, User
-from core.utils import RED_PIXEL_PNG
 
 
 @pytest.fixture()
@@ -214,8 +211,7 @@ class TestNewsCreation(TestCase):
     def setUpTestData(cls):
         cls.club = baker.make(Club)
         cls.user = subscriber_user.make()
-        role = baker.make(ClubRole, club=cls.club, is_board=True)
-        baker.make(Membership, user=cls.user, club=cls.club, role=role)
+        baker.make(Membership, user=cls.user, club=cls.club, role=5)
 
     def setUp(self):
         self.client.force_login(self.user)
@@ -318,6 +314,7 @@ def test_feed(client: Client):
     [
         reverse("com:poster_list"),
         reverse("com:poster_create"),
+        reverse("com:poster_moderate_list"),
     ],
 )
 def test_poster_management_views_crash_test(client: Client, url: str):
@@ -328,37 +325,3 @@ def test_poster_management_views_crash_test(client: Client, url: str):
     client.force_login(user)
     res = client.get(url)
     assert res.status_code == 200
-
-
-@pytest.mark.django_db
-@pytest.mark.parametrize(
-    "referer",
-    [
-        None,
-        reverse("com:poster_list"),
-        reverse("club:poster_list", kwargs={"club_id": settings.SITH_MAIN_CLUB_ID}),
-    ],
-)
-def test_moderate_poster(client: Client, referer: str | None):
-    poster = baker.make(
-        Poster,
-        is_moderated=False,
-        file=SimpleUploadedFile("test.png", content=RED_PIXEL_PNG),
-        club_id=settings.SITH_MAIN_CLUB_ID,
-    )
-    user = baker.make(
-        User,
-        user_permissions=Permission.objects.filter(
-            codename__in=["view_poster", "moderate_poster"]
-        ),
-    )
-    client.force_login(user)
-    headers = {"REFERER": f"https://{settings.SITH_URL}{referer}"} if referer else {}
-    response = client.post(
-        reverse("com:poster_moderate", kwargs={"object_id": poster.id}), headers=headers
-    )
-    result_url = referer or reverse("com:poster_list")
-    assertRedirects(response, result_url)
-    poster.refresh_from_db()
-    assert poster.is_moderated
-    assert poster.moderator == user

com/urls.py

@@ -33,6 +33,7 @@ from com.views import (
     PosterDeleteView,
     PosterEditView,
     PosterListView,
+    PosterModerateListView,
     PosterModerateView,
     ScreenCreateView,
     ScreenDeleteView,
@@ -101,6 +102,11 @@ urlpatterns = [
         PosterDeleteView.as_view(),
         name="poster_delete",
     ),
+    path(
+        "poster/moderate/",
+        PosterModerateListView.as_view(),
+        name="poster_moderate_list",
+    ),
     path(
         "poster/<int:object_id>/moderate/",
         PosterModerateView.as_view(),

com/views.py

@@ -25,7 +25,6 @@ import itertools
 from datetime import date, timedelta
 from smtplib import SMTPRecipientsRefused
 from typing import Any
-from urllib.parse import urlparse
 
 from dateutil.relativedelta import relativedelta
 from django.conf import settings
@@ -35,7 +34,7 @@ from django.contrib.auth.mixins import (
 )
 from django.contrib.syndication.views import Feed
 from django.core.exceptions import PermissionDenied, ValidationError
-from django.db.models import Exists, Max, OuterRef, Value
+from django.db.models import Max
 from django.forms.models import modelform_factory
 from django.http import HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect
@@ -46,7 +45,7 @@ from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView, TemplateView, View
 from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
-from club.models import Club, Mailing, Membership
+from club.models import Club, Mailing
 from com.forms import NewsDateForm, NewsForm, PosterForm
 from com.ics_calendar import IcsCalendar
 from com.models import News, NewsDate, Poster, Screen, Sith, Weekmail, WeekmailArticle
@@ -240,12 +239,12 @@ class NewsListView(TemplateView):
         if not self.request.user.has_perm("core.view_user"):
             return []
         return itertools.groupby(
-            User.objects.viewable_by(self.request.user)
-            .filter(
+            User.objects.filter(
                 date_of_birth__month=localdate().month,
                 date_of_birth__day=localdate().day,
-                role__in=["STUDENT", "FORMER STUDENT"],
+                is_subscriber_viewable=True,
             )
+            .filter(role__in=["STUDENT", "FORMER STUDENT"])
             .order_by("-date_of_birth"),
             key=lambda u: u.date_of_birth.year,
         )
@@ -503,7 +502,7 @@ class WeekmailArticleCreateView(CreateView):
         self.object = form.instance
         form.is_valid()  # Valid a first time to populate club field
         m = form.instance.club.get_membership_for(request.user)
-        if m is None or not m.role.is_board:
+        if m is None or m.role <= settings.SITH_MAXIMUM_FREE_ROLE:
             form.add_error(
                 "club",
                 ValidationError(
@@ -562,26 +561,16 @@ class MailingModerateView(View):
         raise PermissionDenied
 
 
-class PosterListBaseView(ListView):
+class PosterListBaseView(PermissionOrClubBoardRequiredMixin, ListView):
     """List communication posters."""
 
     model = Poster
     template_name = "com/poster_list.jinja"
     permission_required = "com.view_poster"
+    ordering = ["-date_begin"]
 
-    def get_queryset(self):
-        qs = Poster.objects.prefetch_related("screens")
-        if self.request.user.has_perm("com.edit_poster"):
-            qs = qs.annotate(is_editable=Value(value=True))
-        else:
-            qs = qs.annotate(
-                is_editable=Exists(
-                    Membership.objects.ongoing()
-                    .board()
-                    .filter(user=self.request.user, club=OuterRef("club_id"))
-                )
-            )
-        return qs.order_by("-date_begin")
+    def get_context_data(self, **kwargs):
+        return super().get_context_data(**kwargs) | {"club": self.club}
 
 
 class PosterCreateBaseView(PermissionOrClubBoardRequiredMixin, CreateView):
@@ -644,17 +633,21 @@ class PosterDeleteBaseView(
     permission_required = "com.delete_poster"
 
 
-class PosterListView(PermissionRequiredMixin, ComTabsMixin, PosterListBaseView):
+class PosterListView(ComTabsMixin, PosterListBaseView):
     """List communication posters."""
 
     current_tab = "posters"
-    extra_context = {
-        "create_url": reverse_lazy("com:poster_create"),
-        "get_edit_url": lambda poster: reverse(
-            "com:poster_edit", kwargs={"poster_id": poster.id}
-        ),
-    }
-    permission_required = "com.view_poster"
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        if self.request.user.has_perm("com.view_poster"):
+            return qs
+        return qs.filter(club=self.club.id)
+
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
 class PosterCreateView(ComTabsMixin, PosterCreateBaseView):
@@ -679,6 +672,17 @@ class PosterDeleteView(PosterDeleteBaseView):
     success_url = reverse_lazy("com:poster_list")
 
 
+class PosterModerateListView(PermissionRequiredMixin, ComTabsMixin, ListView):
+    """Moderate list communication poster."""
+
+    current_tab = "posters"
+    model = Poster
+    template_name = "com/poster_moderate.jinja"
+    queryset = Poster.objects.filter(is_moderated=False).all()
+    permission_required = "com.moderate_poster"
+    extra_context = {"app": "com"}
+
+
 class PosterModerateView(PermissionRequiredMixin, ComTabsMixin, View):
     """Moderate communication poster."""
 
@@ -686,21 +690,12 @@ class PosterModerateView(PermissionRequiredMixin, ComTabsMixin, View):
     permission_required = "com.moderate_poster"
     extra_context = {"app": "com"}
 
-    def post(self, request, *args, **kwargs):
+    def get(self, request, *args, **kwargs):
         obj = get_object_or_404(Poster, pk=kwargs["object_id"])
         obj.is_moderated = True
         obj.moderator = request.user
         obj.save()
-        # The moderation request may be originated from a club context (/club/poster)
-        # or a global context (/com/poster),
-        # so the redirection URL will be the URL of the page that called this view,
-        # as long as the latter belongs to the sith.
-        referer = self.request.META.get("HTTP_REFERER")
-        if referer:
-            parsed = urlparse(referer)
-            if parsed.netloc == settings.SITH_URL:
-                return redirect(parsed.path)
-        return redirect("com:poster_list")
+        return redirect("com:poster_moderate_list")
 
 
 class ScreenListView(PermissionRequiredMixin, ComTabsMixin, ListView):

core/admin.py

@@ -63,7 +63,6 @@ class UserAdmin(admin.ModelAdmin):
         "scrub_pict",
         "user_permissions",
         "groups",
-        "whitelisted_users",
     )
     inlines = (UserBanInline,)
     search_fields = ["first_name", "last_name", "username"]
@@ -75,19 +74,9 @@ class UserBanAdmin(admin.ModelAdmin):
     autocomplete_fields = ("user", "ban_group")
 
 
-class GroupInline(admin.TabularInline):
-    model = Group.permissions.through
-    readonly_fields = ("group",)
-    extra = 0
-
-    def has_add_permission(self, request, obj):
-        return False
-
-
 @admin.register(Permission)
 class PermissionAdmin(admin.ModelAdmin):
     search_fields = ("codename",)
-    inlines = (GroupInline,)
 
 
 @admin.register(Page)

core/api.py

@@ -1,6 +1,6 @@
 from typing import Annotated, Any, Literal
 
-from annotated_types import Ge, Le, MinLen
+import annotated_types
 from django.conf import settings
 from django.db.models import F
 from django.http import HttpResponse
@@ -28,7 +28,6 @@ from core.schemas import (
     UserSchema,
 )
 from core.templatetags.renderer import markdown
-from counter.utils import is_logged_in_counter
 
 
 @api_controller("/markdown")
@@ -73,9 +72,9 @@ class MailingListController(ControllerBase):
 
 @api_controller("/user")
 class UserController(ControllerBase):
-    @route.get("", response=list[UserProfileSchema])
+    @route.get("", response=list[UserProfileSchema], permissions=[CanAccessLookup])
     def fetch_profiles(self, pks: Query[set[int]]):
-        return User.objects.viewable_by(self.context.request.user).filter(pk__in=pks)
+        return User.objects.filter(pk__in=pks)
 
     @route.get("/{int:user_id}", response=UserSchema, permissions=[CanView])
     def fetch_user(self, user_id: int):
@@ -86,18 +85,13 @@ class UserController(ControllerBase):
         "/search",
         response=PaginatedResponseSchema[UserProfileSchema],
         url_name="search_users",
-        # logged in barmen aren't authenticated stricto sensu, so no auth here
-        auth=None,
+        permissions=[CanAccessLookup],
     )
     @paginate(PageNumberPaginationExtra, page_size=20)
     def search_users(self, filters: Query[UserFilterSchema]):
-        qs = User.objects
-        # the logged in barmen can see all users (even the hidden one),
-        # because they have a temporary administrative function during
-        # which they may have to deal with hidden users
-        if not is_logged_in_counter(self.context.request):
-            qs = qs.viewable_by(self.context.request.user)
-        return filters.filter(qs.order_by(F("last_login").desc(nulls_last=True)))
+        return filters.filter(
+            User.objects.order_by(F("last_login").desc(nulls_last=True))
+        )
 
 
 @api_controller("/file")
@@ -105,11 +99,11 @@ class SithFileController(ControllerBase):
     @route.get(
         "/search",
         response=PaginatedResponseSchema[SithFileSchema],
-        auth=[ApiKeyAuth(), SessionAuth()],
+        auth=[SessionAuth(), ApiKeyAuth()],
         permissions=[CanAccessLookup],
     )
     @paginate(PageNumberPaginationExtra, page_size=50)
-    def search_files(self, search: Annotated[str, MinLen(1)]):
+    def search_files(self, search: Annotated[str, annotated_types.MinLen(1)]):
         return SithFile.objects.filter(is_in_sas=False).filter(name__icontains=search)
 
 
@@ -118,15 +112,15 @@ class GroupController(ControllerBase):
     @route.get(
         "/search",
         response=PaginatedResponseSchema[GroupSchema],
-        auth=[ApiKeyAuth(), SessionAuth()],
+        auth=[SessionAuth(), ApiKeyAuth()],
         permissions=[CanAccessLookup],
     )
     @paginate(PageNumberPaginationExtra, page_size=50)
-    def search_group(self, search: Annotated[str, MinLen(1)]):
+    def search_group(self, search: Annotated[str, annotated_types.MinLen(1)]):
         return Group.objects.filter(name__icontains=search).values()
 
 
-DepthValue = Annotated[int, Ge(0), Le(10)]
+DepthValue = Annotated[int, annotated_types.Ge(0), annotated_types.Le(10)]
 DEFAULT_DEPTH = 4
 
 

core/auth/mixins.py

@@ -24,6 +24,7 @@
 from __future__ import annotations
 
 import types
+import warnings
 from typing import TYPE_CHECKING, Any, LiteralString
 
 from django.contrib.auth.mixins import AccessMixin, PermissionRequiredMixin
@@ -146,6 +147,45 @@ class GenericContentPermissionMixinBuilder(View):
         return super().dispatch(request, *arg, **kwargs)
 
 
+class CanCreateMixin(View):
+    """Protect any child view that would create an object.
+
+    Raises:
+        PermissionDenied:
+            If the user has not the necessary permission
+            to create the object of the view.
+    """
+
+    def __init_subclass__(cls, **kwargs):
+        warnings.warn(
+            f"{cls.__name__} is deprecated and should be replaced "
+            "by other permission verification mecanism.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init_subclass__(**kwargs)
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            f"{self.__class__.__name__} is deprecated and should be replaced "
+            "by other permission verification mecanism.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
+
+    def dispatch(self, request, *arg, **kwargs):
+        if not request.user.is_authenticated:
+            raise PermissionDenied
+        return super().dispatch(request, *arg, **kwargs)
+
+    def form_valid(self, form):
+        obj = form.instance
+        if can_edit_prop(obj, self.request.user):
+            return super().form_valid(form)
+        raise PermissionDenied
+
+
 class CanEditPropMixin(GenericContentPermissionMixinBuilder):
     """Ensure the user has owner permissions on the child view object.
 
@@ -307,7 +347,6 @@ class PermissionOrClubBoardRequiredMixin(PermissionRequiredMixin):
             return False
         if super().has_permission():
             return True
-        return (
-            self.club is not None
-            and self.club.board_group_id in self.request.user.all_groups
+        return self.club is not None and any(
+            g.id == self.club.board_group_id for g in self.request.user.cached_groups
         )

core/baker_recipes.py

@@ -4,9 +4,9 @@ from dateutil.relativedelta import relativedelta
 from django.conf import settings
 from django.utils.timezone import localdate, now
 from model_bakery import seq
-from model_bakery.recipe import Recipe, foreign_key, related
+from model_bakery.recipe import Recipe, related
 
-from club.models import ClubRole, Membership
+from club.models import Membership
 from core.models import Group, User
 from subscription.models import Subscription
 
@@ -52,9 +52,7 @@ ae_board_membership = Recipe(
     Membership,
     start_date=now() - timedelta(days=30),
     club_id=settings.SITH_MAIN_CLUB_ID,
-    role=foreign_key(
-        Recipe(ClubRole, club_id=settings.SITH_MAIN_CLUB_ID, is_board=True)
-    ),
+    role=settings.SITH_CLUB_ROLES_ID["Board member"],
 )
 
 board_user = Recipe(

core/management/commands/check_fs.py

@@ -0,0 +1,40 @@
+#
+# Copyright 2018
+# - Skia <skia@libskia.so>
+#
+# Ce fichier fait partie du site de l'Association des Étudiants de l'UTBM,
+# http://ae.utbm.fr.
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License a published by the Free Software
+# Foundation; either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Sofware Foundation, Inc., 59 Temple
+# Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+#
+
+from django.core.management.base import BaseCommand
+
+from core.models import SithFile
+
+
+class Command(BaseCommand):
+    help = "Recursively check the file system with respect to the DB"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "ids", metavar="ID", type=int, nargs="+", help="The file IDs to process"
+        )
+
+    def handle(self, *args, **options):
+        files = SithFile.objects.filter(id__in=options["ids"]).all()
+        for f in files:
+            f._check_fs()

core/management/commands/install_xapian.py

@@ -39,16 +39,12 @@ class Command(BaseCommand):
             return None
         return xapian.version_string()
 
-    def _desired_version(self) -> tuple[str, str, str]:
+    def _desired_version(self) -> str:
         with open(
             Path(__file__).parent.parent.parent.parent / "pyproject.toml", "rb"
         ) as f:
             pyproject = tomli.load(f)
-            return (
-                pyproject["tool"]["xapian"]["version"],
-                pyproject["tool"]["xapian"]["core-sha256"],
-                pyproject["tool"]["xapian"]["bindings-sha256"],
-            )
+            return pyproject["tool"]["xapian"]["version"]
 
     def handle(self, *args, force: bool, **options):
         if not os.environ.get("VIRTUAL_ENV", None):
@@ -57,7 +53,7 @@ class Command(BaseCommand):
             )
             return
 
-        desired, core_checksum, bindings_checksum = self._desired_version()
+        desired = self._desired_version()
         if desired == self._current_version():
             if not force:
                 self.stdout.write(
@@ -69,12 +65,7 @@ class Command(BaseCommand):
             f"Installing xapian version {desired} at {os.environ['VIRTUAL_ENV']}"
         )
         subprocess.run(
-            [
-                str(Path(__file__).parent / "install_xapian.sh"),
-                desired,
-                core_checksum,
-                bindings_checksum,
-            ],
+            [str(Path(__file__).parent / "install_xapian.sh"), desired],
             env=dict(os.environ),
             check=True,
         )

core/management/commands/install_xapian.sh

@@ -1,11 +1,7 @@
 #!/usr/bin/env bash
 # Originates from https://gist.github.com/jorgecarleitao/ab6246c86c936b9c55fd
 # first argument of the script is Xapian version (e.g. 1.2.19)
-# second argument of the script is core sha256
-# second argument of the script is binding sha256
 VERSION="$1"
-CORE_SHA256="$2"
-BINDINGS_SHA256="$3"
 
 # Cleanup env vars for auto discovery mechanism
 unset CPATH
@@ -25,15 +21,9 @@ BINDINGS=xapian-bindings-$VERSION
 
 # download
 echo "Downloading source..."
-curl -O "https://oligarchy.co.uk/xapian/$VERSION/${CORE}.tar.xz" || exit 1
-
-echo "${CORE_SHA256}  ${CORE}.tar.xz" | sha256sum -c - || exit 1
-
+curl -O "https://oligarchy.co.uk/xapian/$VERSION/${CORE}.tar.xz"
 curl -O "https://oligarchy.co.uk/xapian/$VERSION/${BINDINGS}.tar.xz"
 
-echo "${BINDINGS_SHA256}  ${BINDINGS}.tar.xz" | sha256sum -c - || exit 1
-
-
 # extract
 echo "Extracting source..."
 tar xf "${CORE}.tar.xz"

core/management/commands/populate.py

@@ -16,7 +16,7 @@
 # details.
 #
 # You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# this program; if not, write to the Free Sofware Foundation, Inc., 59 Temple
 # Place - Suite 330, Boston, MA 02111-1307, USA.
 #
 #
@@ -36,7 +36,7 @@ from django.utils import timezone
 from django.utils.timezone import localdate
 from PIL import Image
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from com.ics_calendar import IcsCalendar
 from com.models import News, NewsDate, Sith, Weekmail
 from core.models import BanGroup, Group, Page, PageRev, SithFile, User
@@ -44,7 +44,7 @@ from core.utils import resize_image
 from counter.models import Counter, Product, ProductType, ReturnableProduct, StudentCard
 from election.models import Candidature, Election, ElectionList, Role
 from forum.models import Forum
-from pedagogy.models import UE
+from pedagogy.models import UV
 from sas.models import Album, PeoplePictureRelation, Picture
 from subscription.models import Subscription
 
@@ -62,13 +62,6 @@ class PopulatedGroups(NamedTuple):
     campus_admin: Group
 
 
-class PopulatedClubs(NamedTuple):
-    ae: Club
-    troll: Club
-    pdf: Club
-    refound: Club
-
-
 class Command(BaseCommand):
     ROOT_PATH: ClassVar[Path] = Path(__file__).parent.parent.parent.parent
     SAS_FIXTURE_PATH: ClassVar[Path] = (
@@ -117,17 +110,29 @@ class Command(BaseCommand):
         p.save(force_lock=True)
 
         club_root = SithFile.objects.create(name="clubs", owner=root)
-        sas = SithFile.objects.create(name="SAS", owner=root, is_in_sas=True)
-        clubs = self._create_clubs()
+        sas = SithFile.objects.create(name="SAS", owner=root)
+        main_club = Club.objects.create(
+            id=1, name="AE", address="6 Boulevard Anatole France, 90000 Belfort"
+        )
+        main_club.board_group.permissions.add(
+            *Permission.objects.filter(
+                codename__in=["view_subscription", "add_subscription"]
+            )
+        )
+        bar_club = Club.objects.create(
+            id=settings.SITH_PDF_CLUB_ID,
+            name="PdF",
+            address="6 Boulevard Anatole France, 90000 Belfort",
+        )
 
         self.reset_index("club")
         for bar_id, bar_name in settings.SITH_COUNTER_BARS:
-            Counter(id=bar_id, name=bar_name, club=clubs.pdf, type="BAR").save()
+            Counter(id=bar_id, name=bar_name, club=bar_club, type="BAR").save()
         self.reset_index("counter")
         counters = [
-            Counter(name="Eboutic", club=clubs.ae, type="EBOUTIC"),
-            Counter(name="AE", club=clubs.ae, type="OFFICE"),
-            Counter(name="Vidage comptes AE", club=clubs.ae, type="OFFICE"),
+            Counter(name="Eboutic", club=main_club, type="EBOUTIC"),
+            Counter(name="AE", club=main_club, type="OFFICE"),
+            Counter(name="Vidage comptes AE", club=main_club, type="OFFICE"),
         ]
         Counter.objects.bulk_create(counters)
         bar_groups = []
@@ -145,8 +150,7 @@ class Command(BaseCommand):
 
         Weekmail().save()
 
-        # Here we add a lot of test datas, that are not necessary for the Sith,
-        # but that provide a basic development environment
+        # Here we add a lot of test datas, that are not necessary for the Sith, but that provide a basic development environment
         self.now = timezone.now().replace(hour=12, second=0)
 
         skia = User.objects.create_user(
@@ -310,41 +314,54 @@ class Command(BaseCommand):
         self._create_subscription(tutu)
         StudentCard(uid="9A89B82018B0A0", customer=sli.customer).save()
 
-        Membership.objects.create(
-            user=skia, club=clubs.ae, role=clubs.ae.roles.get(name="Respo Info")
+        # Clubs
+        Club.objects.create(
+            name="Bibo'UT", address="46 de la Boustifaille", parent=main_club
         )
+        guyut = Club.objects.create(
+            name="Guy'UT", address="42 de la Boustifaille", parent=main_club
+        )
+        Club.objects.create(name="Woenzel'UT", address="Woenzel", parent=guyut)
+        troll = Club.objects.create(
+            name="Troll Penché", address="Terre Du Milieu", parent=main_club
+        )
+        refound = Club.objects.create(
+            name="Carte AE", address="Jamais imprimée", parent=main_club
+        )
+
+        Membership.objects.create(user=skia, club=main_club, role=3)
         Membership.objects.create(
             user=comunity,
-            club=clubs.pdf,
+            club=bar_club,
             start_date=localdate(),
-            role=clubs.pdf.roles.get(name="Membre du bureau"),
+            role=settings.SITH_CLUB_ROLES_ID["Board member"],
         )
         Membership.objects.create(
             user=sli,
-            club=clubs.troll,
-            role=clubs.troll.roles.get(name="Vice-Président⸱e"),
+            club=troll,
+            role=9,
             description="Padawan Troll",
             start_date=localdate() - timedelta(days=17),
         )
         Membership.objects.create(
             user=krophil,
-            club=clubs.troll,
-            role=clubs.troll.roles.get(name="Président⸱e"),
+            club=troll,
+            role=10,
             description="Maitre Troll",
             start_date=localdate() - timedelta(days=200),
         )
         Membership.objects.create(
             user=skia,
-            club=clubs.troll,
-            role=clubs.troll.roles.get(name="Membre du bureau"),
+            club=troll,
+            role=2,
             description="Grand Ancien Troll",
             start_date=localdate() - timedelta(days=400),
             end_date=localdate() - timedelta(days=86),
         )
         Membership.objects.create(
             user=richard,
-            club=clubs.troll,
-            role=clubs.troll.roles.get(name="Membre du bureau"),
+            club=troll,
+            role=2,
             description="",
             start_date=localdate() - timedelta(days=200),
             end_date=localdate() - timedelta(days=100),
@@ -361,7 +378,7 @@ class Command(BaseCommand):
             purchase_price="15",
             selling_price="15",
             special_selling_price="15",
-            club=clubs.ae,
+            club=main_club,
         )
         cotis2 = Product.objects.create(
             name="Cotis 2 semestres",
@@ -370,7 +387,7 @@ class Command(BaseCommand):
             purchase_price="28",
             selling_price="28",
             special_selling_price="28",
-            club=clubs.ae,
+            club=main_club,
         )
         refill = Product.objects.create(
             name="Rechargement 15 €",
@@ -379,7 +396,7 @@ class Command(BaseCommand):
             purchase_price="15",
             selling_price="15",
             special_selling_price="15",
-            club=clubs.ae,
+            club=main_club,
         )
         barb = Product.objects.create(
             name="Barbar",
@@ -388,7 +405,7 @@ class Command(BaseCommand):
             purchase_price="1.50",
             selling_price="1.7",
             special_selling_price="1.6",
-            club=clubs.ae,
+            club=main_club,
             limit_age=18,
         )
         cble = Product.objects.create(
@@ -398,7 +415,7 @@ class Command(BaseCommand):
             purchase_price="1.50",
             selling_price="1.7",
             special_selling_price="1.6",
-            club=clubs.ae,
+            club=main_club,
             limit_age=18,
         )
         cons = Product.objects.create(
@@ -408,7 +425,7 @@ class Command(BaseCommand):
             purchase_price="1",
             selling_price="1",
             special_selling_price="1",
-            club=clubs.ae,
+            club=main_club,
         )
         dcons = Product.objects.create(
             name="Déconsigne Eco-cup",
@@ -417,7 +434,7 @@ class Command(BaseCommand):
             purchase_price="-1",
             selling_price="-1",
             special_selling_price="-1",
-            club=clubs.ae,
+            club=main_club,
         )
         cors = Product.objects.create(
             name="Corsendonk",
@@ -426,7 +443,7 @@ class Command(BaseCommand):
             purchase_price="1.50",
             selling_price="1.7",
             special_selling_price="1.6",
-            club=clubs.ae,
+            club=main_club,
             limit_age=18,
         )
         carolus = Product.objects.create(
@@ -436,7 +453,7 @@ class Command(BaseCommand):
             purchase_price="1.50",
             selling_price="1.7",
             special_selling_price="1.6",
-            club=clubs.ae,
+            club=main_club,
             limit_age=18,
         )
         Product.objects.create(
@@ -445,7 +462,7 @@ class Command(BaseCommand):
             purchase_price="0",
             selling_price="0",
             special_selling_price="0",
-            club=clubs.refound,
+            club=refound,
         )
         groups.subscribers.products.add(
             cotis, cotis2, refill, barb, cble, cors, carolus
@@ -458,7 +475,7 @@ class Command(BaseCommand):
         eboutic = Counter.objects.get(name="Eboutic")
         eboutic.products.add(barb, cotis, cotis2, refill)
 
-        Counter.objects.create(name="Carte AE", club=clubs.refound, type="OFFICE")
+        Counter.objects.create(name="Carte AE", club=refound, type="OFFICE")
 
         ReturnableProduct.objects.create(
             product=cons, returned_product=dcons, max_return=3
@@ -482,7 +499,7 @@ class Command(BaseCommand):
             end_date="7942-06-12 10:28:45+01",
         )
         el.view_groups.add(groups.public)
-        el.edit_groups.add(clubs.ae.board_group)
+        el.edit_groups.add(main_club.board_group)
         el.candidature_groups.add(groups.subscribers)
         el.vote_groups.add(groups.subscribers)
         liste = ElectionList.objects.create(title="Candidature Libre", election=el)
@@ -555,7 +572,7 @@ class Command(BaseCommand):
             title="Apero barman",
             summary="Viens boire un coup avec les barmans",
             content="Glou glou glou glou glou glou glou",
-            club=clubs.pdf,
+            club=bar_club,
             author=subscriber,
             is_published=True,
             moderator=skia,
@@ -573,7 +590,7 @@ class Command(BaseCommand):
             content=(
                 "Viens donc t'enjailler avec les autres barmans aux frais du BdF! \\o/"
             ),
-            club=clubs.pdf,
+            club=bar_club,
             author=subscriber,
             is_published=True,
             moderator=skia,
@@ -589,7 +606,7 @@ class Command(BaseCommand):
             title="Repas fromager",
             summary="Wien manger du l'bon fromeug'",
             content="Fô viendre mangey d'la bonne fondue!",
-            club=clubs.pdf,
+            club=bar_club,
             author=subscriber,
             is_published=True,
             moderator=skia,
@@ -605,7 +622,7 @@ class Command(BaseCommand):
             title="SdF",
             summary="Enjoy la fin des finaux!",
             content="Viens faire la fête avec tout plein de gens!",
-            club=clubs.pdf,
+            club=bar_club,
             author=subscriber,
             is_published=True,
             moderator=skia,
@@ -623,7 +640,7 @@ class Command(BaseCommand):
             summary="Viens jouer!",
             content="Rejoins la fine équipe du Troll Penché et viens "
             "t'amuser le Vendredi soir!",
-            club=clubs.troll,
+            club=troll,
             author=subscriber,
             is_published=True,
             moderator=skia,
@@ -643,20 +660,20 @@ class Command(BaseCommand):
 
         # Create some data for pedagogy
 
-        UE(
+        UV(
             code="PA00",
             author=User.objects.get(id=0),
-            credit_type=settings.SITH_PEDAGOGY_UE_TYPE[3][0],
+            credit_type=settings.SITH_PEDAGOGY_UV_TYPE[3][0],
             manager="Laurent HEYBERGER",
-            semester=settings.SITH_PEDAGOGY_UE_SEMESTER[3][0],
-            language=settings.SITH_PEDAGOGY_UE_LANGUAGE[0][0],
+            semester=settings.SITH_PEDAGOGY_UV_SEMESTER[3][0],
+            language=settings.SITH_PEDAGOGY_UV_LANGUAGE[0][0],
             department=settings.SITH_PROFILE_DEPARTMENTS[-2][0],
             credits=5,
             title="Participation dans une association étudiante",
             objectives="* Permettre aux étudiants de réaliser, pendant un semestre, un projet culturel ou associatif et de le valoriser.",
             program="""* Semestre précédent proposition d'un projet et d'un cahier des charges
 * Evaluation par un jury de six membres
-* Si accord réalisation dans le cadre de l'UE
+* Si accord réalisation dans le cadre de l'UV
 * Compte-rendu de l'expérience
 * Présentation""",
             skills="""* Gérer un projet associatif ou une action éducative en autonomie:
@@ -760,57 +777,6 @@ class Command(BaseCommand):
         )
         s.save()
 
-    def _create_clubs(self) -> PopulatedClubs:
-        ae = Club.objects.create(
-            id=1, name="AE", address="6 Boulevard Anatole France, 90000 Belfort"
-        )
-        ae.board_group.permissions.add(
-            *Permission.objects.filter(
-                codename__in=[
-                    "view_subscription",
-                    "add_subscription",
-                    "add_membership",
-                    "view_hidden_user",
-                ]
-            )
-        )
-        pdf = Club.objects.create(
-            id=settings.SITH_PDF_CLUB_ID,
-            name="PdF",
-            address="6 Boulevard Anatole France, 90000 Belfort",
-        )
-        troll = Club.objects.create(
-            name="Troll Penché", address="Terre Du Milieu", parent=ae
-        )
-        refound = Club.objects.create(
-            name="Carte AE", address="Jamais imprimée", parent=ae
-        )
-        roles = []
-        presidency_roles = ["Président⸱e", "Vice-Président⸱e"]
-        board_roles = [
-            "Trésorier⸱e",
-            "Secrétaire",
-            "Respo Info",
-            "Respo Com",
-            "Membre du bureau",
-        ]
-        simple_roles = ["Membre actif⸱ve", "Curieux⸱euse"]
-        for club in ae, pdf, troll, refound:
-            for i, role in enumerate(presidency_roles):
-                roles.append(
-                    ClubRole(
-                        club=club, order=i, name=role, is_presidency=True, is_board=True
-                    )
-                )
-            for i, role in enumerate(board_roles, start=len(presidency_roles)):
-                roles.append(ClubRole(club=club, order=i, name=role, is_board=True))
-            for i, role in enumerate(
-                simple_roles, start=len(presidency_roles) + len(board_roles)
-            ):
-                roles.append(ClubRole(club=club, order=i, name=role))
-        ClubRole.objects.bulk_create(roles)
-        return PopulatedClubs(ae=ae, troll=troll, pdf=pdf, refound=refound)
-
     def _create_groups(self) -> PopulatedGroups:
         perms = Permission.objects.all()
 
@@ -823,16 +789,16 @@ class Command(BaseCommand):
 
         subscribers = Group.objects.create(name="Cotisants")
         subscribers.permissions.add(
-            *list(perms.filter(codename__in=["add_news", "add_uecomment"]))
+            *list(perms.filter(codename__in=["add_news", "add_uvcomment"]))
         )
         old_subscribers = Group.objects.create(name="Anciens cotisants")
         old_subscribers.permissions.add(
             *list(
                 perms.filter(
                     codename__in=[
-                        "view_ue",
-                        "view_uecomment",
-                        "add_uecommentreport",
+                        "view_uv",
+                        "view_uvcomment",
+                        "add_uvcommentreport",
                         "view_user",
                         "view_picture",
                         "view_album",
@@ -908,7 +874,7 @@ class Command(BaseCommand):
         pedagogy_admin.permissions.add(
             *list(
                 perms.filter(content_type__app_label="pedagogy")
-                .exclude(codename__in=["change_uecomment"])
+                .exclude(codename__in=["change_uvcomment"])
                 .values_list("pk", flat=True)
             )
         )

core/management/commands/populate_more.py

@@ -11,8 +11,8 @@ from django.db.models import Count, Exists, Min, OuterRef, Subquery
 from django.utils.timezone import localdate, make_aware, now
 from faker import Faker
 
-from club.models import Club, ClubRole, Membership
-from core.models import Group, User, UserBan
+from club.models import Club, Membership
+from core.models import Group, User
 from counter.models import (
     Counter,
     Customer,
@@ -23,7 +23,7 @@ from counter.models import (
     Selling,
 )
 from forum.models import Forum, ForumMessage, ForumTopic
-from pedagogy.models import UE
+from pedagogy.models import UV
 from subscription.models import Subscription
 
 
@@ -40,7 +40,6 @@ class Command(BaseCommand):
 
         self.stdout.write("Creating users...")
         users = self.create_users()
-        self.create_bans(random.sample(users, k=len(users) // 200))  # 0.5% of users
         subscribers = random.sample(users, k=int(0.8 * len(users)))
         self.stdout.write("Creating subscriptions...")
         self.create_subscriptions(subscribers)
@@ -75,7 +74,7 @@ class Command(BaseCommand):
             random.sample(old_subscribers, k=min(80, len(old_subscribers))),
         )
         self.stdout.write("Creating uvs...")
-        self.create_ues()
+        self.create_uvs()
         self.stdout.write("Creating products...")
         self.create_products()
         self.stdout.write("Creating sales and refills...")
@@ -89,8 +88,6 @@ class Command(BaseCommand):
         self.stdout.write("Done")
 
     def create_users(self) -> list[User]:
-        # Create a single password hash for all users to make it faster.
-        # It's insecure as hell, but it's ok since it's only for dev purposes.
         password = make_password("plop")
         users = [
             User(
@@ -117,33 +114,14 @@ class Command(BaseCommand):
         public_group.users.add(*users)
         return users
 
-    def create_bans(self, users: list[User]):
-        ban_groups = [
-            settings.SITH_GROUP_BANNED_COUNTER_ID,
-            settings.SITH_GROUP_BANNED_SUBSCRIPTION_ID,
-            settings.SITH_GROUP_BANNED_ALCOHOL_ID,
-        ]
-        UserBan.objects.bulk_create(
-            [
-                UserBan(
-                    user=user,
-                    ban_group_id=i,
-                    reason=self.faker.sentence(),
-                    expires_at=make_aware(self.faker.future_datetime("+1y")),
-                )
-                for user in users
-                for i in random.sample(ban_groups, k=random.randint(1, len(ban_groups)))
-            ]
-        )
-
     def create_subscriptions(self, users: list[User]):
         def prepare_subscription(_user: User, start_date: date) -> Subscription:
             payment_method = random.choice(settings.SITH_SUBSCRIPTION_PAYMENT_METHOD)[0]
             duration = random.randint(1, 4)
-            s = Subscription(member=_user, payment_method=payment_method)
-            s.subscription_start = s.compute_start(d=start_date, duration=duration)
-            s.subscription_end = s.compute_end(duration)
-            return s
+            sub = Subscription(member=_user, payment_method=payment_method)
+            sub.subscription_start = sub.compute_start(d=start_date, duration=duration)
+            sub.subscription_end = sub.compute_end(duration)
+            return sub
 
         subscriptions = []
         customers = []
@@ -172,25 +150,20 @@ class Command(BaseCommand):
         Customer.objects.bulk_create(customers, ignore_conflicts=True)
 
     def make_club(self, club: Club, members: list[User], old_members: list[User]):
-        roles: list[ClubRole] = list(club.roles.all())
-
-        def zip_roles(users: list[User]) -> Iterator[tuple[User, ClubRole]]:
-            important_roles = [r for r in roles if r.is_board]
-            important_roles.sort(key=lambda r: r.order)
-            simple_board_role = important_roles.pop()
-            member_roles = [r for r in roles if not r.is_board]
+        def zip_roles(users: list[User]) -> Iterator[tuple[User, int]]:
+            roles = iter(sorted(settings.SITH_CLUB_ROLES.keys(), reverse=True))
             user_idx = 0
-            for _role in important_roles:
+            while (role := next(roles)) > 2:
                 # one member for each major role
-                yield users[user_idx], _role
+                yield users[user_idx], role
                 user_idx += 1
             for _ in range(int(0.3 * (len(users) - user_idx))):
                 # 30% of the remaining in the board
-                yield users[user_idx], simple_board_role
+                yield users[user_idx], 2
                 user_idx += 1
             for remaining in users[user_idx + 1 :]:
                 # everything else is a simple member
-                yield remaining, random.choices(member_roles, weights=(0.8, 0.2))[0]
+                yield remaining, 1
 
         memberships = []
         old_members = old_members.copy()
@@ -202,19 +175,24 @@ class Command(BaseCommand):
                     start_date=start,
                     end_date=self.faker.past_date(start),
                     user=old,
-                    role=random.choice(roles),
+                    role=random.choice(list(settings.SITH_CLUB_ROLES.keys())),
                     club=club,
                 )
             )
         for member, role in zip_roles(members):
             start = self.faker.past_date("-1y")
             memberships.append(
-                Membership(start_date=start, user=member, role=role, club=club)
+                Membership(
+                    start_date=start,
+                    user=member,
+                    role=role,
+                    club=club,
+                )
             )
         memberships = Membership.objects.bulk_create(memberships)
         Membership._add_club_groups(memberships)
 
-    def create_ues(self):
+    def create_uvs(self):
         root = User.objects.get(username="root")
         categories = ["CS", "TM", "OM", "QC", "EC"]
         branches = ["TC", "GMC", "GI", "EDIM", "E", "IMSI", "HUMA"]
@@ -229,7 +207,7 @@ class Command(BaseCommand):
                 + str(random.randint(10, 90))
             )
             uvs.append(
-                UE(
+                UV(
                     code=code,
                     author=root,
                     manager=random.choice(teachers),
@@ -251,7 +229,7 @@ class Command(BaseCommand):
                     hours_TE=random.randint(15, 40),
                 )
             )
-        UE.objects.bulk_create(uvs, ignore_conflicts=True)
+        UV.objects.bulk_create(uvs, ignore_conflicts=True)
 
     def create_products(self):
         categories = [
@@ -372,6 +350,7 @@ class Command(BaseCommand):
                         date=make_aware(
                             self.faker.date_time_between(customer.since, localdate())
                         ),
+                        is_validated=True,
                     )
                 )
             sales.extend(this_customer_sales)

core/management/commands/repair_fs.py

@@ -0,0 +1,41 @@
+#
+# Copyright 2018
+# - Skia <skia@libskia.so>
+#
+# Ce fichier fait partie du site de l'Association des Étudiants de l'UTBM,
+# http://ae.utbm.fr.
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License a published by the Free Software
+# Foundation; either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Sofware Foundation, Inc., 59 Temple
+# Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+#
+
+
+from django.core.management.base import BaseCommand
+
+from core.models import SithFile
+
+
+class Command(BaseCommand):
+    help = "Recursively repair the file system with respect to the DB"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "ids", metavar="ID", type=int, nargs="+", help="The file IDs to process"
+        )
+
+    def handle(self, *args, **options):
+        files = SithFile.objects.filter(id__in=options["ids"]).all()
+        for f in files:
+            f._repair_fs()

core/migrations/0048_alter_user_options.py

@@ -1,33 +0,0 @@
-# Generated by Django 5.2.8 on 2025-11-09 15:20
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [("core", "0047_alter_notification_date_alter_notification_type")]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name="user",
-            options={
-                "permissions": [("view_hidden_user", "Can view hidden users")],
-                "verbose_name": "user",
-                "verbose_name_plural": "users",
-            },
-        ),
-        migrations.RenameField(
-            model_name="user", old_name="is_subscriber_viewable", new_name="is_viewable"
-        ),
-        migrations.AlterField(
-            model_name="user",
-            name="is_viewable",
-            field=models.BooleanField(
-                default=True,
-                verbose_name="Profile visible by subscribers",
-                help_text=(
-                    "If you disable this option, only admin users "
-                    "will be able to see your profile."
-                ),
-            ),
-        ),
-    ]

core/migrations/0049_user_whitelisted_users.py

@@ -1,37 +0,0 @@
-# Generated by Django 5.2.12 on 2026-03-14 08:39
-
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [("core", "0048_alter_user_options")]
-
-    operations = [
-        migrations.AddField(
-            model_name="user",
-            name="whitelisted_users",
-            field=models.ManyToManyField(
-                blank=True,
-                help_text=(
-                    "Even if this profile is hidden, "
-                    "the users in this list will still be able to see it."
-                ),
-                related_name="visible_by_whitelist",
-                to=settings.AUTH_USER_MODEL,
-                verbose_name="whitelisted users",
-            ),
-        ),
-        migrations.AlterField(
-            model_name="preferences",
-            name="show_my_stats",
-            field=models.BooleanField(
-                default=False,
-                help_text=(
-                    "Allow subscribers (or whitelisted users "
-                    "if your profile is hidden) to access your AE account stats."
-                ),
-                verbose_name="show your stats to others",
-            ),
-        ),
-    ]

core/models.py

@@ -23,13 +23,14 @@
 #
 from __future__ import annotations
 
-import difflib
+import logging
+import os
 import string
 import unicodedata
 from datetime import timedelta
 from io import BytesIO
 from pathlib import Path
-from typing import TYPE_CHECKING, Final, Self
+from typing import TYPE_CHECKING, Optional, Self
 from uuid import uuid4
 
 from django.conf import settings
@@ -38,6 +39,7 @@ from django.contrib.auth.models import AnonymousUser as AuthAnonymousUser
 from django.contrib.auth.models import Group as AuthGroup
 from django.contrib.staticfiles.storage import staticfiles_storage
 from django.core import validators
+from django.core.cache import cache
 from django.core.exceptions import PermissionDenied, ValidationError
 from django.core.files import File
 from django.core.files.base import ContentFile
@@ -54,8 +56,6 @@ from django.utils.translation import gettext_lazy as _
 from phonenumber_field.modelfields import PhoneNumberField
 from PIL import Image, ImageOps
 
-from core.utils import get_last_promo
-
 if TYPE_CHECKING:
     from django.core.files.uploadedfile import UploadedFile
     from pydantic import NonNegativeInt
@@ -76,16 +76,69 @@ class Group(AuthGroup):
     def get_absolute_url(self) -> str:
         return reverse("core:group_list")
 
+    def save(self, *args, **kwargs) -> None:
+        super().save(*args, **kwargs)
+        cache.set(f"sith_group_{self.id}", self)
+        cache.set(f"sith_group_{self.name.replace(' ', '_')}", self)
+
+    def delete(self, *args, **kwargs) -> None:
+        super().delete(*args, **kwargs)
+        cache.delete(f"sith_group_{self.id}")
+        cache.delete(f"sith_group_{self.name.replace(' ', '_')}")
+
 
 def validate_promo(value: int) -> None:
-    last_promo = get_last_promo()
-    if not 0 < value <= last_promo:
+    start_year = settings.SITH_SCHOOL_START_YEAR
+    delta = (localdate() + timedelta(days=180)).year - start_year
+    if value < 0 or delta < value:
         raise ValidationError(
             _("%(value)s is not a valid promo (between 0 and %(end)s)"),
-            params={"value": value, "end": last_promo},
+            params={"value": value, "end": delta},
         )
 
 
+def get_group(*, pk: int | None = None, name: str | None = None) -> Group | None:
+    """Search for a group by its primary key or its name.
+    Either one of the two must be set.
+
+    The result is cached for the default duration (should be 5 minutes).
+
+    Args:
+        pk: The primary key of the group
+        name: The name of the group
+
+    Returns:
+        The group if it exists, else None
+
+    Raises:
+        ValueError: If no group matches the criteria
+    """
+    if pk is None and name is None:
+        raise ValueError("Either pk or name must be set")
+
+    # replace space characters to hide warnings with memcached backend
+    pk_or_name: str | int = pk if pk is not None else name.replace(" ", "_")
+    group = cache.get(f"sith_group_{pk_or_name}")
+
+    if group == "not_found":
+        # Using None as a cache value is a little bit tricky,
+        # so we use a special string to represent None
+        return None
+    elif group is not None:
+        return group
+    # if this point is reached, the group is not in cache
+    if pk is not None:
+        group = Group.objects.filter(pk=pk).first()
+    else:
+        group = Group.objects.filter(name=name).first()
+    if group is not None:
+        name = group.name.replace(" ", "_")
+        cache.set_many({f"sith_group_{group.id}": group, f"sith_group_{name}": group})
+    else:
+        cache.set(f"sith_group_{pk_or_name}", "not_found")
+    return group
+
+
 class BanGroup(AuthGroup):
     """An anti-group, that removes permissions instead of giving them.
 
@@ -127,15 +180,6 @@ class UserQuerySet(models.QuerySet):
             Q(Exists(subscriptions)) | Q(Exists(refills)) | Q(Exists(purchases))
         )
 
-    def viewable_by(self, user: User) -> Self:
-        if user.has_perm("core.view_hidden_user"):
-            return self
-        if user.has_perm("core.view_user"):
-            return self.filter(Q(is_viewable=True) | Q(whitelisted_users=user))
-        if user.is_anonymous:
-            return self.none()
-        return self.filter(id=user.id)
-
 
 class CustomUserManager(UserManager.from_queryset(UserQuerySet)):
     # see https://docs.djangoproject.com/fr/stable/topics/migrations/#model-managers
@@ -271,34 +315,13 @@ class User(AbstractUser):
     parent_address = models.CharField(
         _("parent address"), max_length=128, blank=True, default=""
     )
-    is_viewable = models.BooleanField(
-        _("Profile visible by subscribers"),
-        help_text=_(
-            "If you disable this option, only admin users "
-            "will be able to see your profile."
-        ),
-        default=True,
-    )
-    whitelisted_users = models.ManyToManyField(
-        "User",
-        related_name="visible_by_whitelist",
-        verbose_name=_("whitelisted users"),
-        help_text=_(
-            "Even if this profile is hidden, "
-            "the users in this list will still be able to see it."
-        ),
-        blank=True,
+    is_subscriber_viewable = models.BooleanField(
+        _("is subscriber viewable"), default=True
     )
     godfathers = models.ManyToManyField("User", related_name="godchildren", blank=True)
 
     objects = CustomUserManager()
 
-    class Meta(AbstractUser.Meta):
-        abstract = False
-        permissions = [
-            ("view_hidden_user", "Can view hidden users"),
-        ]
-
     def __str__(self):
         return self.get_display_name()
 
@@ -359,34 +382,31 @@ class User(AbstractUser):
         Returns:
              True if the user is the group, else False
         """
-        if not pk and not name:
+        if pk is not None:
+            group: Optional[Group] = get_group(pk=pk)
+        elif name is not None:
+            group: Optional[Group] = get_group(name=name)
+        else:
             raise ValueError("You must either provide the id or the name of the group")
-        group_id: int | None = (
-            pk or Group.objects.filter(name=name).values_list("id", flat=True).first()
-        )
-        if group_id is None:
+        if group is None:
             return False
-        return group_id in self.all_groups
+        if group.id == settings.SITH_GROUP_SUBSCRIBERS_ID:
+            return self.is_subscribed
+        if group.id == settings.SITH_GROUP_ROOT_ID:
+            return self.is_root
+        return group in self.cached_groups
 
     @cached_property
-    def all_groups(self) -> dict[int, Group]:
+    def cached_groups(self) -> list[Group]:
         """Get the list of groups this user is in."""
-        additional_groups = []
-        if self.is_subscribed:
-            additional_groups.append(settings.SITH_GROUP_SUBSCRIBERS_ID)
-        if self.is_superuser:
-            additional_groups.append(settings.SITH_GROUP_ROOT_ID)
-        qs = self.groups.all()
-        if additional_groups:
-            # This is somewhat counter-intuitive, but this query runs way faster with
-            # a UNION rather than a OR (in average, 0.25ms vs 14ms).
-            # For the why, cf. https://dba.stackexchange.com/questions/293836/why-is-an-or-statement-slower-than-union
-            qs = qs.union(Group.objects.filter(id__in=additional_groups))
-        return {g.id: g for g in qs}
+        return list(self.groups.all())
 
     @cached_property
     def is_root(self) -> bool:
-        return self.is_superuser or settings.SITH_GROUP_ROOT_ID in self.all_groups
+        if self.is_superuser:
+            return True
+        root_id = settings.SITH_GROUP_ROOT_ID
+        return any(g.id == root_id for g in self.cached_groups)
 
     @cached_property
     def is_board_member(self) -> bool:
@@ -434,6 +454,14 @@ class User(AbstractUser):
         else:
             raise ValidationError(_("A user with that username already exists"))
 
+    def get_profile(self):
+        return {
+            "last_name": self.last_name,
+            "first_name": self.first_name,
+            "nick_name": self.nick_name,
+            "date_of_birth": self.date_of_birth,
+        }
+
     def get_short_name(self):
         """Returns the short name for the user."""
         if self.nick_name:
@@ -528,7 +556,7 @@ class User(AbstractUser):
         self.username = user_name
         return user_name
 
-    def is_owner(self, obj: models.Model):
+    def is_owner(self, obj):
         """Determine if the object is owned by the user."""
         if hasattr(obj, "is_owned_by") and obj.is_owned_by(self):
             return True
@@ -536,7 +564,7 @@ class User(AbstractUser):
             return True
         return self.is_root
 
-    def can_edit(self, obj: models.Model):
+    def can_edit(self, obj):
         """Determine if the object can be edited by the user."""
         if hasattr(obj, "can_be_edited_by") and obj.can_be_edited_by(self):
             return True
@@ -550,9 +578,11 @@ class User(AbstractUser):
                 pks = list(obj.edit_groups.values_list("id", flat=True))
             if any(self.is_in_group(pk=pk) for pk in pks):
                 return True
+        if isinstance(obj, User) and obj == self:
+            return True
         return self.is_owner(obj)
 
-    def can_view(self, obj: models.Model):
+    def can_view(self, obj):
         """Determine if the object can be viewed by the user."""
         if hasattr(obj, "can_be_viewed_by") and obj.can_be_viewed_by(self):
             return True
@@ -571,36 +601,11 @@ class User(AbstractUser):
                 return True
         return self.can_edit(obj)
 
-    def can_be_edited_by(self, user: User):
-        return user == self or user.is_root or user.is_board_member
+    def can_be_edited_by(self, user):
+        return user.is_root or user.is_board_member
 
-    def can_be_viewed_by(self, user: User) -> bool:
-        """Check if the given user can be viewed by this user.
-
-        Given users A and B. A can be viewed by B if :
-
-        - A and B are the same user
-        - or B has the permission to view hidden users
-        - or B can view users in general and A didn't hide its profile
-        - or B is in A's whitelist.
-        """
-
-        def is_in_whitelist(u: User):
-            if (
-                hasattr(self, "_prefetched_objects_cache")
-                and "whitelisted_users" in self._prefetched_objects_cache
-            ):
-                return u in self.whitelisted_users.all()
-            return self.whitelisted_users.contains(u)
-
-        return (
-            user.id == self.id
-            or user.has_perm("core.view_hidden_user")
-            or (
-                user.has_perm("core.view_user")
-                and (self.is_viewable or is_in_whitelist(user))
-            )
-        )
+    def can_be_viewed_by(self, user):
+        return (user.was_subscribed and self.is_subscriber_viewable) or user.is_root
 
     def get_mini_item(self):
         return """
@@ -646,6 +651,9 @@ class User(AbstractUser):
 
 
 class AnonymousUser(AuthAnonymousUser):
+    def __init__(self):
+        super().__init__()
+
     @property
     def was_subscribed(self):
         return False
@@ -654,6 +662,10 @@ class AnonymousUser(AuthAnonymousUser):
     def is_subscribed(self):
         return False
 
+    @property
+    def subscribed(self):
+        return False
+
     @property
     def is_root(self):
         return False
@@ -684,8 +696,8 @@ class AnonymousUser(AuthAnonymousUser):
         if pk is not None:
             return pk == allowed_id
         elif name is not None:
-            group = Group.objects.get(id=allowed_id)
-            return group.name == name
+            group = get_group(name=name)
+            return group is not None and group.id == allowed_id
         else:
             raise ValueError("You must either provide the id or the name of the group")
 
@@ -779,14 +791,7 @@ class Preferences(models.Model):
         User, related_name="_preferences", on_delete=models.CASCADE
     )
     receive_weekmail = models.BooleanField(_("receive the Weekmail"), default=False)
-    show_my_stats = models.BooleanField(
-        _("show your stats to others"),
-        help_text=_(
-            "Allow subscribers (or whitelisted users "
-            "if your profile is hidden) to access your AE account stats."
-        ),
-        default=False,
-    )
+    show_my_stats = models.BooleanField(_("show your stats to others"), default=False)
     notify_on_click = models.BooleanField(
         _("get a notification for every click"), default=False
     )
@@ -1018,6 +1023,63 @@ class SithFile(models.Model):
         self.clean()
         self.save()
 
+    def _repair_fs(self):
+        """Rebuilds recursively the filesystem as it should be regarding the DB tree."""
+        if self.is_folder:
+            for c in self.children.all():
+                c._repair_fs()
+            return
+        elif not self._check_path_consistence():
+            # First get future parent path and the old file name
+            # Prepend "." so that we match all relative handling of Django's
+            # file storage
+            parent_path = "." + self.parent.get_full_path()
+            parent_full_path = settings.MEDIA_ROOT + parent_path
+            os.makedirs(parent_full_path, exist_ok=True)
+            old_path = self.file.name  # Should be relative: "./users/skia/bleh.jpg"
+            new_path = "." + self.get_full_path()
+            try:
+                # Make this atomic, so that a FS problem rolls back the DB change
+                with transaction.atomic():
+                    # Set the new filesystem path
+                    self.file.name = new_path
+                    self.save()
+                    # Really move at the FS level
+                    if os.path.exists(parent_full_path):
+                        os.rename(
+                            settings.MEDIA_ROOT + old_path,
+                            settings.MEDIA_ROOT + new_path,
+                        )
+                        # Empty directories may remain, but that's not really a
+                        # problem, and that can be solved with a simple shell
+                        # command: `find . -type d -empty -delete`
+            except Exception as e:
+                logging.error(e)
+
+    def _check_path_consistence(self):
+        file_path = str(self.file)
+        file_full_path = settings.MEDIA_ROOT + file_path
+        db_path = ".%s" % self.get_full_path()
+        if not os.path.exists(file_full_path):
+            print("%s: WARNING: real file does not exists!" % self.id)  # noqa T201
+            print("file path: %s" % file_path, end="")  # noqa T201
+            print("  db path: %s" % db_path)  # noqa T201
+            return False
+        if file_path != db_path:
+            print("%s: " % self.id, end="")  # noqa T201
+            print("file path: %s" % file_path, end="")  # noqa T201
+            print("  db path: %s" % db_path)  # noqa T201
+            return False
+        return True
+
+    def _check_fs(self):
+        if self.is_folder:
+            for c in self.children.all():
+                c._check_fs()
+            return
+        else:
+            self._check_path_consistence()
+
     @property
     def is_file(self):
         return not self.is_folder
@@ -1102,6 +1164,8 @@ class QuickUploadImage(models.Model):
         identifier = str(uuid4())
         name = Path(image.name).stem[: cls.IMAGE_NAME_SIZE - 1]
         file = File(convert_image(image), name=f"{identifier}.webp")
+        width, height = Image.open(file).size
+
         return cls.objects.create(
             uuid=identifier,
             name=name,
@@ -1139,7 +1203,10 @@ class PageQuerySet(models.QuerySet):
             return self.filter(view_groups=settings.SITH_GROUP_PUBLIC_ID)
         if user.has_perm("core.view_page"):
             return self.all()
-        return self.filter(view_groups__in=user.all_groups)
+        groups_ids = [g.id for g in user.cached_groups]
+        if user.is_subscribed:
+            groups_ids.append(settings.SITH_GROUP_SUBSCRIBERS_ID)
+        return self.filter(view_groups__in=groups_ids)
 
 
 # This function prevents generating migration upon settings change
@@ -1371,9 +1438,6 @@ class PageRev(models.Model):
     The content is in PageRev.title and PageRev.content .
     """
 
-    MERGE_TIME_THRESHOLD: Final[timedelta] = timedelta(minutes=20)
-    MERGE_DIFF_THRESHOLD: Final[float] = 0.2
-
     revision = models.IntegerField(_("revision"))
     title = models.CharField(_("page title"), max_length=255, blank=True)
     content = models.TextField(_("page content"), blank=True)
@@ -1413,33 +1477,7 @@ class PageRev(models.Model):
         return self.page.can_be_edited_by(user)
 
     def is_owned_by(self, user: User) -> bool:
-        return self.page.owner_group_id in user.all_groups
-
-    def similarity_ratio(self, text: str) -> float:
-        """Similarity ratio between this revision's content and the given text.
-
-        The result is a float in [0; 1], 0 meaning the contents are entirely different,
-        and 1 they are strictly the same.
-        """
-        # cf. https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.ratio
-        return difflib.SequenceMatcher(None, self.content, text).quick_ratio()
-
-    def should_merge(self, other: Self) -> bool:
-        """Return True if `other` should be merged into `self`, else False.
-
-        It's considered the other revision should be merged into this one if :
-
-        - it was made less than 20 minutes after
-        - by the same author
-        - with a similarity ratio higher than 80%
-        """
-        return (
-            not self._state.adding  # cannot merge if the original rev doesn't exist
-            and self.author == other.author
-            and (other.date - self.date) < self.MERGE_TIME_THRESHOLD
-            and (not other._state.adding or other.revision == self.revision + 1)
-            and self.similarity_ratio(other.content) >= (1 - other.MERGE_DIFF_THRESHOLD)
-        )
+        return any(g.id == self.page.owner_group_id for g in user.cached_groups)
 
 
 def get_notification_types():

core/schemas.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from pathlib import Path
 from typing import Annotated, Any
 
@@ -9,14 +8,12 @@ from django.urls import reverse
 from django.utils.text import slugify
 from django.utils.translation import gettext as _
 from haystack.query import SearchQuerySet
-from ninja import FilterLookup, FilterSchema, ModelSchema, Schema, UploadedFile
-from pydantic import AliasChoices, Field, field_validator
+from ninja import FilterSchema, ModelSchema, Schema, UploadedFile
+from pydantic import AliasChoices, Field
 from pydantic_core.core_schema import ValidationInfo
 
 from core.models import Group, QuickUploadImage, SithFile, User
-from core.utils import get_last_promo, is_image
-
-NonEmptyStr = Annotated[str, MinLen(1)]
+from core.utils import is_image
 
 
 class UploadedImage(UploadedFile):
@@ -110,11 +107,7 @@ class GroupSchema(ModelSchema):
 
 
 class UserFilterSchema(FilterSchema):
-    search: Annotated[str, MinLen(1)] | None = None
-    role: Annotated[str, FilterLookup("role__icontains")] | None = None
-    department: str | None = None
-    promo: int | None = None
-    date_of_birth: datetime | None = None
+    search: Annotated[str, MinLen(1)]
     exclude: list[int] | None = Field(
         None, validation_alias=AliasChoices("exclude", "exclude[]")
     )
@@ -143,13 +136,6 @@ class UserFilterSchema(FilterSchema):
             return Q()
         return ~Q(id__in=value)
 
-    @field_validator("promo", mode="after")
-    @classmethod
-    def validate_promo(cls, value: int) -> int:
-        if not 0 < value <= get_last_promo():
-            raise ValueError(f"{value} is not a valid promo")
-        return value
-
 
 class MarkdownSchema(Schema):
     text: str

core/static/bundled/alpine-index.js

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

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, 10);
-          if (maxChoices < previousValue) {
-            // The maximum number of selectable items has been lowered.
-            // Some currently selected elements may need to be removed
-            manageDequeue();
-          }
-        });
-      });
-    },
-  );
-}

core/static/bundled/core/components/ajax-select-base.ts

@@ -1,3 +1,4 @@
+import { inheritHtmlElement } from "#core:utils/web-components";
 import TomSelect from "tom-select";
 import type {
   RecursivePartial,
@@ -6,7 +7,6 @@ import type {
   TomSettings,
 } from "tom-select/dist/types/types";
 import type { escape_html } from "tom-select/dist/types/utils";
-import { inheritHtmlElement } from "#core:utils/web-components.ts";
 
 export class AutoCompleteSelectBase extends inheritHtmlElement("select") {
   static observedAttributes = [
@@ -29,7 +29,7 @@ export class AutoCompleteSelectBase extends inheritHtmlElement("select") {
   ) {
     switch (name) {
       case "delay": {
-        this.delay = Number.parseInt(newValue, 10) ?? null;
+        this.delay = Number.parseInt(newValue) ?? null;
         break;
       }
       case "placeholder": {
@@ -37,11 +37,11 @@ export class AutoCompleteSelectBase extends inheritHtmlElement("select") {
         break;
       }
       case "max": {
-        this.max = Number.parseInt(newValue, 10) ?? null;
+        this.max = Number.parseInt(newValue) ?? null;
         break;
       }
       case "min-characters-for-search": {
-        this.minCharNumberForSearch = Number.parseInt(newValue, 10) ?? 0;
+        this.minCharNumberForSearch = Number.parseInt(newValue) ?? 0;
         break;
       }
       default: {

core/static/bundled/core/components/ajax-select-index.ts

@@ -1,20 +1,21 @@
 import "tom-select/dist/css/tom-select.default.css";
+import { registerComponent } from "#core:utils/web-components";
 import type { TomOption } from "tom-select/dist/types/types";
 import type { escape_html } from "tom-select/dist/types/utils";
-import {
-  AjaxSelect,
-  AutoCompleteSelectBase,
-} from "#core:core/components/ajax-select-base.ts";
-import { registerComponent } from "#core:utils/web-components.ts";
 import {
   type GroupSchema,
-  groupSearchGroup,
   type SithFileSchema,
-  sithfileSearchFiles,
   type UserProfileSchema,
+  groupSearchGroup,
+  sithfileSearchFiles,
   userSearchUsers,
 } from "#openapi";
 
+import {
+  AjaxSelect,
+  AutoCompleteSelectBase,
+} from "#core:core/components/ajax-select-base";
+
 @registerComponent("autocomplete-select")
 export class AutoCompleteSelect extends AutoCompleteSelectBase {}
 

core/static/bundled/core/components/easymde-index.ts

@@ -1,14 +1,14 @@
 // biome-ignore lint/correctness/noUndeclaredDependencies: shipped by easymde
 import "codemirror/lib/codemirror.css";
 import "easymde/src/css/easymde.css";
+import { inheritHtmlElement, registerComponent } from "#core:utils/web-components";
 // biome-ignore lint/correctness/noUndeclaredDependencies: Imported by EasyMDE
 import type CodeMirror from "codemirror";
 // biome-ignore lint/style/useNamingConvention: This is how they called their namespace
 import EasyMDE from "easymde";
-import { inheritHtmlElement, registerComponent } from "#core:utils/web-components.ts";
 import {
-  markdownRenderMarkdown,
   type UploadUploadImageErrors,
+  markdownRenderMarkdown,
   uploadUploadImage,
 } from "#openapi";
 

core/static/bundled/core/components/include-index.ts

@@ -1,136 +1,18 @@
-import {
-  type InheritedHtmlElement,
-  inheritHtmlElement,
-  registerComponent,
-} from "#core:utils/web-components.ts";
-
-/**
- * ElementOnce web components
- *
- * Those elements ensures that their content is always included only once on a document
- * They are compatible with elements that are not managed with our Web Components
- **/
-export interface ElementOnce<K extends keyof HTMLElementTagNameMap>
-  extends InheritedHtmlElement<K> {
-  getElementQuerySelector(): string;
-  refresh(): void;
-}
-
-/**
- * Create an abstract class for ElementOnce types Web Components
- **/
-export function elementOnce<K extends keyof HTMLElementTagNameMap>(tagName: K) {
-  abstract class ElementOnceImpl
-    extends inheritHtmlElement(tagName)
-    implements ElementOnce<K>
-  {
-    abstract getElementQuerySelector(): string;
-
-    clearNode() {
-      while (this.firstChild) {
-        this.removeChild(this.lastChild);
-      }
-    }
-
-    refresh() {
-      this.clearNode();
-      if (document.querySelectorAll(this.getElementQuerySelector()).length === 0) {
-        this.appendChild(this.node);
-      }
-    }
-
-    connectedCallback() {
-      super.connectedCallback(false);
-      this.refresh();
-    }
-
-    disconnectedCallback() {
-      // The MutationObserver can't see web components being removed
-      // It also can't see if something is removed inside after the component gets deleted
-      // We need to manually clear the containing node to trigger the observer
-      this.clearNode();
-    }
-  }
-  return ElementOnceImpl;
-}
-
-// Set of ElementOnce type components to refresh with the observer
-const registeredComponents: Set<string> = new Set();
-
-/**
- * Helper to register ElementOnce types Web Components
- * It's a wrapper around registerComponent that registers that component on
- * a MutationObserver that activates a refresh on them when elements are removed
- *
- * You are not supposed to unregister an element
- **/
-export function registerElementOnce(name: string, options?: ElementDefinitionOptions) {
-  registeredComponents.add(name);
-  return registerComponent(name, options);
-}
-
-// Refresh all ElementOnce components on the document based on the tag name of the removed element
-const refreshElement = <
-  T extends keyof HTMLElementTagNameMap,
-  K extends keyof HTMLElementTagNameMap,
->(
-  components: HTMLCollectionOf<ElementOnce<T>>,
-  removedTagName: K,
-) => {
-  for (const element of components) {
-    // We can't guess if an element is compatible before we get one
-    // We exit the function completely if it's not compatible
-    if (element.inheritedTagName.toUpperCase() !== removedTagName.toUpperCase()) {
-      return;
-    }
-
-    element.refresh();
-  }
-};
-
-// Since we need to pause the observer, we make an helper to start it with consistent arguments
-const startObserver = (observer: MutationObserver) => {
-  observer.observe(document, {
-    // We want to also listen for elements contained in the header (eg: link)
-    subtree: true,
-    childList: true,
-  });
-};
-
-// Refresh ElementOnce components when changes happens
-const observer = new MutationObserver((mutations: MutationRecord[]) => {
-  // To avoid infinite recursion, we need to pause the observer while manipulation nodes
-  observer.disconnect();
-  for (const mutation of mutations) {
-    for (const node of mutation.removedNodes) {
-      if (node.nodeType !== node.ELEMENT_NODE) {
-        continue;
-      }
-      for (const registered of registeredComponents) {
-        refreshElement(
-          document.getElementsByTagName(registered) as HTMLCollectionOf<
-            ElementOnce<"html"> // The specific tag doesn't really matter
-          >,
-          (node as HTMLElement).tagName as keyof HTMLElementTagNameMap,
-        );
-      }
-    }
-  }
-  // We then resume the observer
-  startObserver(observer);
-});
-
-startObserver(observer);
+import { inheritHtmlElement, registerComponent } from "#core:utils/web-components";
 
 /**
  * Web component used to import css files only once
  * If called multiple times or the file was already imported, it does nothing
  **/
-@registerElementOnce("link-once")
-export class LinkOnce extends elementOnce("link") {
-  getElementQuerySelector(): string {
+@registerComponent("link-once")
+export class LinkOnce extends inheritHtmlElement("link") {
+  connectedCallback() {
+    super.connectedCallback(false);
     // We get href from node.attributes instead of node.href to avoid getting the domain part
-    return `link[href='${this.node.attributes.getNamedItem("href").nodeValue}']`;
+    const href = this.node.attributes.getNamedItem("href").nodeValue;
+    if (document.querySelectorAll(`link[href='${href}']`).length === 0) {
+      this.appendChild(this.node);
+    }
   }
 }
 
@@ -138,10 +20,14 @@ export class LinkOnce extends elementOnce("link") {
  * Web component used to import javascript files only once
  * If called multiple times or the file was already imported, it does nothing
  **/
-@registerElementOnce("script-once")
+@registerComponent("script-once")
 export class ScriptOnce extends inheritHtmlElement("script") {
-  getElementQuerySelector(): string {
-    // We get href from node.attributes instead of node.src to avoid getting the domain part
-    return `script[src='${this.node.attributes.getNamedItem("src").nodeValue}']`;
+  connectedCallback() {
+    super.connectedCallback(false);
+    // We get src from node.attributes instead of node.src to avoid getting the domain part
+    const src = this.node.attributes.getNamedItem("src").nodeValue;
+    if (document.querySelectorAll(`script[src='${src}']`).length === 0) {
+      this.appendChild(this.node);
+    }
   }
 }

core/static/bundled/core/components/nfc-input-index.ts

@@ -1,4 +1,4 @@
-import { inheritHtmlElement, registerComponent } from "#core:utils/web-components.ts";
+import { inheritHtmlElement, registerComponent } from "#core:utils/web-components";
 
 @registerComponent("nfc-input")
 export class NfcInput extends inheritHtmlElement("input") {
@@ -26,6 +26,7 @@ export class NfcInput extends inheritHtmlElement("input") {
         window.alert(gettext("Unsupported NFC card"));
       });
 
+      // biome-ignore lint/correctness/noUndeclaredVariables: browser API
       ndef.addEventListener("reading", (event: NDEFReadingEvent) => {
         this.removeAttribute("scan");
         this.node.value = event.serialNumber.replace(/:/g, "").toUpperCase();

core/static/bundled/core/components/tabs-index.ts

@@ -1,6 +1,6 @@
+import { registerComponent } from "#core:utils/web-components";
 import { html, render } from "lit-html";
 import { unsafeHTML } from "lit-html/directives/unsafe-html.js";
-import { registerComponent } from "#core:utils/web-components.ts";
 
 @registerComponent("ui-tab")
 export class Tab extends HTMLElement {

core/static/bundled/core/dynamic-formset-index.ts

@@ -1,77 +0,0 @@
-interface Config {
-  /**
-   * The prefix of the formset, in case it has been changed.
-   * See https://docs.djangoproject.com/fr/stable/topics/forms/formsets/#customizing-a-formset-s-prefix
-   */
-  prefix?: string;
-}
-
-// biome-ignore lint/style/useNamingConvention: It's the DOM API naming
-type HTMLFormInputElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
-
-document.addEventListener("alpine:init", () => {
-  /**
-   * Alpine data element to allow the dynamic addition of forms to a formset.
-   *
-   * To use this, you need :
-   * - an HTML element containing the existing forms, noted by `x-ref="formContainer"`
-   * - a template containing the empty form
-   *   (that you can obtain jinja-side with `{{ formset.empty_form }}`),
-   *   noted by `x-ref="formTemplate"`
-   * - a button with `@click="addForm"`
-   * - you may also have one or more buttons with `@click="removeForm(element)"`,
-   *   where `element` is the HTML element containing the form.
-   *
-   * For an example of how this is used, you can have a look to
-   * `counter/templates/counter/product_form.jinja`
-   */
-  Alpine.data("dynamicFormSet", (config?: Config) => ({
-    init() {
-      this.formContainer = this.$refs.formContainer as HTMLElement;
-      this.nbForms = this.formContainer.children.length as number;
-      this.template = this.$refs.formTemplate as HTMLTemplateElement;
-      const prefix = config?.prefix ?? "form";
-      this.$root
-        .querySelector(`#id_${prefix}-TOTAL_FORMS`)
-        .setAttribute(":value", "nbForms");
-    },
-
-    addForm() {
-      this.formContainer.appendChild(document.importNode(this.template.content, true));
-      const newForm = this.formContainer.lastElementChild;
-      const inputs: NodeListOf<HTMLFormInputElement> = newForm.querySelectorAll(
-        "input, select, textarea",
-      );
-      for (const el of inputs) {
-        el.name = el.name.replace("__prefix__", this.nbForms.toString());
-        el.id = el.id.replace("__prefix__", this.nbForms.toString());
-      }
-      const labels: NodeListOf<HTMLLabelElement> = newForm.querySelectorAll("label");
-      for (const el of labels) {
-        el.htmlFor = el.htmlFor.replace("__prefix__", this.nbForms.toString());
-      }
-      inputs[0].focus();
-      this.nbForms += 1;
-    },
-
-    removeForm(container: HTMLDivElement) {
-      container.remove();
-      this.nbForms -= 1;
-      // adjust the id of remaining forms
-      for (let i = 0; i < this.nbForms; i++) {
-        const form: HTMLDivElement = this.formContainer.children[i];
-        const inputs: NodeListOf<HTMLFormInputElement> = form.querySelectorAll(
-          "input, select, textarea",
-        );
-        for (const el of inputs) {
-          el.name = el.name.replace(/\d+/, i.toString());
-          el.id = el.id.replace(/\d+/, i.toString());
-        }
-        const labels: NodeListOf<HTMLLabelElement> = form.querySelectorAll("label");
-        for (const el of labels) {
-          el.htmlFor = el.htmlFor.replace(/\d+/, i.toString());
-        }
-      }
-    },
-  }));
-});

core/static/bundled/core/navbar-index.ts

@@ -1,4 +1,4 @@
-import { exportToHtml } from "#core:utils/globals.ts";
+import { exportToHtml } from "#core:utils/globals";
 
 exportToHtml("showMenu", () => {
   const navbar = document.getElementById("navbar-content");

core/static/bundled/core/read-more-index.ts

@@ -26,7 +26,7 @@ function showMore(element: HTMLElement) {
   const fullContent = element.innerHTML;
   const clippedContent = clip(
     element.innerHTML,
-    Number.parseInt(element.getAttribute("show-more") as string, 10),
+    Number.parseInt(element.getAttribute("show-more") as string),
     {
       html: true,
     },

core/static/bundled/core/tooltips-index.ts

@@ -1,9 +1,9 @@
 import {
+  type Placement,
   autoPlacement,
   computePosition,
   flip,
   offset,
-  type Placement,
   size,
 } from "@floating-ui/dom";
 

core/static/bundled/htmx-index.js

@@ -1,11 +1,11 @@
 import htmx from "htmx.org";
 
 document.body.addEventListener("htmx:beforeRequest", (event) => {
-  event.detail.target.ariaBusy = true;
+  event.target.ariaBusy = true;
 });
 
-document.body.addEventListener("htmx:beforeSwap", (event) => {
-  event.detail.target.ariaBusy = null;
+document.body.addEventListener("htmx:afterRequest", (event) => {
+  event.originalTarget.ariaBusy = null;
 });
 
 Object.assign(window, { htmx });

core/static/bundled/sentry-popup-index.ts

@@ -1,6 +1,6 @@
-// biome-ignore lint/performance/noNamespaceImport: this is the recommended way from the documentation
+import { exportToHtml } from "#core:utils/globals";
+// biome-ignore lint/style/noNamespaceImport: this is the recommended way from the documentation
 import * as Sentry from "@sentry/browser";
-import { exportToHtml } from "#core:utils/globals.ts";
 
 interface LoggedUser {
   name: string;

core/static/bundled/types/web-nfc.d.ts

@@ -8,6 +8,7 @@
 
 // This has been modified to not trigger biome linting
 
+// biome-ignore lint/correctness/noUnusedVariables: this is the official definition
 interface Window {
   // biome-ignore lint/style/useNamingConvention: this is the official API name
   NDEFMessage: NDEFMessage;
@@ -27,6 +28,7 @@ declare interface NDEFMessageInit {
 // biome-ignore lint/style/useNamingConvention: this is the official API name
 declare type NDEFRecordDataSource = string | BufferSource | NDEFMessageInit;
 
+// biome-ignore lint/correctness/noUnusedVariables: this is the official definition
 interface Window {
   // biome-ignore lint/style/useNamingConvention: this is the official API name
   NDEFRecord: NDEFRecord;
@@ -72,6 +74,7 @@ declare class NDEFReader extends EventTarget {
   makeReadOnly: (options?: NDEFMakeReadOnlyOptions) => Promise<void>;
 }
 
+// biome-ignore lint/correctness/noUnusedVariables: this is the official definition
 interface Window {
   // biome-ignore lint/style/useNamingConvention: this is the official API name
   NDEFReadingEvent: NDEFReadingEvent;

core/static/bundled/user/family-graph-index.ts

@@ -1,3 +1,4 @@
+import { History, initialUrlParams, updateQueryString } from "#core:utils/history";
 import cytoscape, {
   type ElementDefinition,
   type NodeSingular,
@@ -5,8 +6,7 @@ import cytoscape, {
 } from "cytoscape";
 import cxtmenu from "cytoscape-cxtmenu";
 import klay, { type KlayLayoutOptions } from "cytoscape-klay";
-import { History, initialUrlParams, updateQueryString } from "#core:utils/history.ts";
-import { familyGetFamilyGraph, type UserProfileSchema } from "#openapi";
+import { type UserProfileSchema, familyGetFamilyGraph } from "#openapi";
 
 cytoscape.use(klay);
 cytoscape.use(cxtmenu);
@@ -200,7 +200,7 @@ document.addEventListener("alpine:init", () => {
     isZoomEnabled: !isMobile(),
 
     getInitialDepth(prop: string) {
-      const value = Number.parseInt(initialUrlParams.get(prop), 10);
+      const value = Number.parseInt(initialUrlParams.get(prop));
       if (Number.isNaN(value) || value < config.depthMin || value > config.depthMax) {
         return defaultDepth;
       }

core/static/bundled/utils/api.ts

@@ -1,5 +1,5 @@
-import { client, type Options } from "#openapi";
 import type { Client, RequestResult, TDataShape } from "#openapi:client";
+import { type Options, client } from "#openapi";
 
 export interface PaginatedResponse<T> {
   count: number;

core/static/bundled/utils/csv.ts

@@ -1,4 +1,4 @@
-import type { NestedKeyOf } from "#core:utils/types.ts";
+import type { NestedKeyOf } from "#core:utils/types";
 
 interface StringifyOptions<T extends object> {
   /** The columns to include in the resulting CSV. */

core/static/bundled/utils/web-components.ts

@@ -10,6 +10,7 @@ export function registerComponent(name: string, options?: ElementDefinitionOptio
       window.customElements.define(name, component, options);
     } catch (e) {
       if (e instanceof DOMException) {
+        // biome-ignore lint/suspicious/noConsole: it's handy to troobleshot
         console.warn(e.message);
         return;
       }
@@ -23,17 +24,10 @@ export function registerComponent(name: string, options?: ElementDefinitionOptio
  * The technique is to:
  *  create a new web component
  *  create the desired type inside
- *  move all attributes to the child component
+ *  pass all attributes to the child component
  *  store is at as `node` inside the parent
- **/
-export interface InheritedHtmlElement<K extends keyof HTMLElementTagNameMap>
-  extends HTMLElement {
-  readonly inheritedTagName: K;
-  node: HTMLElementTagNameMap[K];
-}
-
-/**
- * Generator function that creates an InheritedHtmlElement compatible class
+ *
+ * Since we can't use the generic type to instantiate the node, we create a generator function
  *
  * ```js
  * class MyClass extends inheritHtmlElement("select") {
@@ -42,15 +36,11 @@ export interface InheritedHtmlElement<K extends keyof HTMLElementTagNameMap>
  * ```
  **/
 export function inheritHtmlElement<K extends keyof HTMLElementTagNameMap>(tagName: K) {
-  return class InheritedHtmlElementImpl
-    extends HTMLElement
-    implements InheritedHtmlElement<K>
-  {
-    readonly inheritedTagName = tagName;
-    node: HTMLElementTagNameMap[K];
+  return class Inherited extends HTMLElement {
+    protected node: HTMLElementTagNameMap[K];
 
     connectedCallback(autoAddNode?: boolean) {
-      this.node = document.createElement(this.inheritedTagName);
+      this.node = document.createElement(tagName);
       const attributes: Attr[] = []; // We need to make a copy to delete while iterating
       for (const attr of this.attributes) {
         if (attr.name in this.node) {
@@ -58,10 +48,6 @@ export function inheritHtmlElement<K extends keyof HTMLElementTagNameMap>(tagNam
         }
       }
 
-      // We move compatible attributes to the child element
-      // This avoids weird inconsistencies between attributes
-      // when we manipulate the dom in the future
-      // This is especially important when using attribute based reactivity
       for (const attr of attributes) {
         this.removeAttributeNode(attr);
         this.node.setAttributeNode(attr);

core/static/core/accordion.scss

@@ -53,7 +53,7 @@ details.accordion>.accordion-content {
     opacity: 0;
 
     @supports (max-height: calc-size(max-content, size)) {
-      max-height: 0;
+      max-height: 0px;
     }
   }
 
@@ -71,12 +71,11 @@ details.accordion>.accordion-content {
   }
 }
 
-// ::details-content is available on firefox only since september 2025
-// (and wasn't available when this code was initially written)
+// ::details-content isn't available on firefox yet
 // we use .accordion-content as a workaround
 // But we need to use ::details-content for chrome because it's
 // not working correctly otherwise
-// it only happens in chrome, not safari or firefox
+// it only happen in chrome, not safari or firefox
 // Note: `selector` is not supported by scss so we comment it out to
 // avoid compiling it and sending it straight to the css
 // This is a trick that comes from here :

core/static/core/base.css

@@ -115,6 +115,7 @@ blockquote:before,
 blockquote:after,
 q:before,
 q:after {
+  content: "";
   content: none;
 }
 table {

core/static/core/colors.scss

@@ -21,8 +21,6 @@ $secondary-neutral-dark-color: hsl(40, 57.6%, 17%);
 
 $white-color: hsl(219.6, 20.8%, 98%);
 $black-color: hsl(0, 0%, 17%);
-$red-text-color: #eb2f06;
-$hovered-red-text-color: #ff4d4d;
 
 $faceblue: hsl(221, 44%, 41%);
 $twitblue: hsl(206, 82%, 63%);

core/static/core/forms.scss

@@ -143,29 +143,21 @@ form {
   line-height: 1;
   white-space: nowrap;
 
-  .fields-centered {
-    padding: 10px 10px 0;
-    display: flex;
-    flex-direction: row;
-    flex-wrap: wrap;
-    gap: var(--nf-input-size) 10px;
-    justify-content: center;
-  }
-
   .helptext {
     margin-top: .25rem;
     margin-bottom: .25rem;
     font-size: 80%;
     display: block;
-    max-width: calc(100% - calc(var(--nf-input-size) * 2))
   }
 
   fieldset {
     margin-bottom: 1rem;
   }
 
-  .row > label {
-    margin: unset;
+  .row {
+    label {
+      margin: unset;
+    }
   }
 
   // ------------- LABEL
@@ -755,32 +747,4 @@ form {
     background-repeat: no-repeat;
     background-size: var(--nf-input-size);
   }
-
-  &.no-margin {
-    margin:0;
-  }
-
-  // a submit input that should look like a regular <a>
-  input[type="submit"], button {
-    &.link-like {
-      color: $primary-dark-color;
-      &:hover {
-        color: $primary-light-color;
-      }
-
-      &.link-red {
-        color: $red-text-color;
-        &:hover {
-          color: $hovered-red-text-color;
-        }
-      }
-      font-weight: normal;
-      font-size: 100%;
-      margin: auto;
-      background: none;
-      border: none;
-      cursor: pointer;
-      padding: 0;
-    }
-  }
 }

core/static/core/header.scss

@@ -5,6 +5,9 @@ $text-color: white;
 
 $background-color-hovered: #283747;
 
+$red-text-color: #eb2f06;
+$hovered-red-text-color: #ff4d4d;
+
 .header {
   box-sizing: border-box;
   background-color: $deepblue;
@@ -248,15 +251,12 @@ $background-color-hovered: #283747;
               justify-content: flex-start;
             }
 
-            a {
-              color: $text-color;
-            }
-
             a,
             button {
               font-size: 100%;
               margin: 0;
               text-align: right;
+              color: $text-color;
               margin-top: auto;
 
               &:hover {
@@ -268,6 +268,19 @@ $background-color-hovered: #283747;
               margin: 0;
               display: inline;
             }
+
+            #logout-form button {
+              color: $red-text-color;
+
+              &:hover {
+                color: $hovered-red-text-color;
+              }
+
+              background: none;
+              border: none;
+              cursor: pointer;
+              padding: 0;
+            }
           }
         }
       }

core/static/core/js/shorten.min.js

@@ -0,0 +1,124 @@
+// Copyright 2013 Viral Patel and other contributors
+// http://viralpatel.net
+
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+!(function (e) {
+	e.fn.shorten = function (s) {
+		"use strict";
+		var t = {
+			showChars: 100,
+			minHideChars: 10,
+			ellipsesText: "...",
+			moreText: "more",
+			lessText: "less",
+			onLess: function () {},
+			onMore: function () {},
+			errMsg: null,
+			force: !1,
+		};
+		return (
+			s && e.extend(t, s),
+			(!e(this).data("jquery.shorten") || !!t.force) &&
+				(e(this).data("jquery.shorten", !0),
+				e(document).off("click", ".morelink"),
+				e(document).on(
+					{
+						click: function () {
+							var s = e(this);
+							return (
+								s.hasClass("less")
+									? (s.removeClass("less"),
+										s.html(t.moreText),
+										s
+											.parent()
+											.prev()
+											.animate({}, function () {
+												s.parent().prev().prev().show();
+											})
+											.hide("fast", function () {
+												t.onLess();
+											}))
+									: (s.addClass("less"),
+										s.html(t.lessText),
+										s
+											.parent()
+											.prev()
+											.animate({}, function () {
+												s.parent().prev().prev().hide();
+											})
+											.show("fast", function () {
+												t.onMore();
+											})),
+								!1
+							);
+						},
+					},
+					".morelink",
+				),
+				this.each(function () {
+					var s = e(this),
+						n = s.html();
+					if (s.text().length > t.showChars + t.minHideChars) {
+						var r = n.substr(0, t.showChars);
+						if (r.indexOf("<") >= 0) {
+							for (
+								var a = !1, o = "", i = 0, l = [], h = null, c = 0, f = 0;
+								f <= t.showChars;
+								c++
+							)
+								if (
+									("<" != n[c] ||
+										a ||
+										((a = !0),
+										"/" == (h = n.substring(c + 1, n.indexOf(">", c)))[0]
+											? h != "/" + l[0]
+												? (t.errMsg =
+														"ERROR en HTML: the top of the stack should be the tag that closes")
+												: l.shift()
+											: "br" != h.toLowerCase() && l.unshift(h)),
+									a && ">" == n[c] && (a = !1),
+									a)
+								)
+									o += n.charAt(c);
+								else if ((f++, i <= t.showChars)) (o += n.charAt(c)), i++;
+								else if (l.length > 0) {
+									for (j = 0; j < l.length; j++) o += "</" + l[j] + ">";
+									break;
+								}
+							r = e("<div/>")
+								.html(o + '<span class="ellip">' + t.ellipsesText + "</span>")
+								.html();
+						} else r += t.ellipsesText;
+						var p =
+							'<div class="shortcontent">' +
+							r +
+							'</div><div class="allcontent">' +
+							n +
+							'</div><span><a href="javascript://nop/" class="morelink">' +
+							t.moreText +
+							"</a></span>";
+						s.html(p),
+							s.find(".allcontent").hide(),
+							e(".shortcontent p:last", s).css("margin-bottom", 0);
+					}
+				}))
+		);
+	};
+})(jQuery);

core/static/core/style.scss

@@ -503,10 +503,6 @@ th {
   text-align: center;
   padding: 5px 10px;
 
-  >input[type="checkbox"] {
-    padding: unset;
-  }
-
   >ul {
     margin-top: 0;
   }
@@ -519,6 +515,7 @@ th {
 td {
   margin: 5px;
   border-collapse: collapse;
+  vertical-align: top;
   overflow: hidden;
   text-overflow: ellipsis;
 

core/static/user/user_edit.scss

@@ -5,6 +5,14 @@
 }
 
 .profile {
+  &-visible {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 5px;
+    padding-top: 10px;
+  }
+
   &-pictures {
     box-sizing: border-box;
     display: flex;
@@ -103,15 +111,28 @@
     }
   }
 
+  &-fields {
+    padding: 10px 10px 0;
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    gap: 10px;
+    justify-content: center;
+  }
+
   &-field {
     display: flex;
+    flex-direction: row;
+    align-items: center;
     flex-wrap: wrap;
     justify-content: center;
+    gap: 10px;
     width: 100%;
     max-width: 330px;
     min-width: 300px;
 
     @media (max-width: 750px) {
+      gap: 4px;
       max-width: 100%;
     }
 
@@ -124,6 +145,22 @@
       }
     }
 
+    &-label {
+      text-align: left !important;
+    }
+
+    &-content {
+      > * {
+        box-sizing: border-box;
+        text-align: left !important;
+        margin: 0;
+
+        > * {
+          text-align: left !important;
+        }
+      }
+    }
+
     textarea {
       height: 7rem;
     }