add tests

club/admin.py

@@ -14,7 +14,7 @@
 #
 from django.contrib import admin
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 
 
 @admin.register(Club)
@@ -30,20 +30,6 @@ class ClubAdmin(admin.ModelAdmin):
     )
 
 
-@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):
     list_display = ("user", "club", "role", "start_date", "end_date")

club/api.py

@@ -6,9 +6,10 @@ from ninja_extra.pagination import PageNumberPaginationExtra
 from ninja_extra.schemas import PaginatedResponseSchema
 
 from api.auth import ApiKeyAuth
-from api.permissions import CanAccessLookup, CanView, HasPerm
+from api.permissions import CanView, HasPerm
 from club.models import Club, Membership
 from club.schemas import (
+    ClubProfileSchema,
     ClubSchema,
     ClubSearchFilterSchema,
     SimpleClubSchema,
@@ -22,13 +23,21 @@ class ClubController(ControllerBase):
     @route.get(
         "/search",
         response=PaginatedResponseSchema[SimpleClubSchema],
-        auth=[ApiKeyAuth(), SessionAuth()],
-        permissions=[CanAccessLookup],
         url_name="search_club",
     )
     @paginate(PageNumberPaginationExtra, page_size=50)
     def search_club(self, filters: Query[ClubSearchFilterSchema]):
-        return filters.filter(Club.objects.all())
+        return filters.filter(Club.objects.order_by("name")).values()
+
+    @route.get(
+        "/search-profile",
+        response=PaginatedResponseSchema[ClubProfileSchema],
+        url_name="search_club_profile",
+    )
+    @paginate(PageNumberPaginationExtra, page_size=50)
+    def search_club_profile(self, filters: Query[ClubSearchFilterSchema]):
+        """Same as /api/club/search, but with more returned data"""
+        return filters.filter(Club.objects.order_by("name"))
 
     @route.get(
         "/{int:club_id}",
@@ -39,8 +48,7 @@ class ClubController(ControllerBase):
     )
     def fetch_club(self, club_id: int):
         prefetch = Prefetch(
-            "members",
+            "members", queryset=Membership.objects.ongoing().select_related("user")
-            queryset=Membership.objects.ongoing().select_related("user", "role"),
         )
         return self.get_object_or_exception(
             Club.objects.prefetch_related(prefetch), id=club_id
@@ -62,5 +70,5 @@ class UserClubController(ControllerBase):
         return (
             Membership.objects.ongoing()
             .filter(user=user)
-            .select_related("club", "user", "role")
+            .select_related("club", "user")
         )

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 (
@@ -214,7 +215,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 +235,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]:
+    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,7 +258,7 @@ class ClubAddMemberForm(ClubMemberForm):
         widgets = {"user": AutoCompleteSelectUser}
 
     @cached_property
-    def available_roles(self):
+    def max_available_role(self):
         """The greatest role that will be obtainable with this form.
 
         Admins and the club president can attribute any role.
@@ -258,13 +266,13 @@ class ClubAddMemberForm(ClubMemberForm):
         Other users cannot attribute roles with this form
         """
         if self.request_user.has_perm("club.add_membership"):
-            return self.club.roles.all()
+            return settings.SITH_CLUB_ROLES_ID["President"]
         membership = self.request_user_membership
-        if membership is None or not membership.role.is_board:
+        if membership is None or membership.role <= settings.SITH_MAXIMUM_FREE_ROLE:
-            return ClubRole.objects.none()
+            return -1
-        if membership.role.is_presidency:
+        if membership.role == settings.SITH_CLUB_ROLES_ID["President"]:
-            return self.club.roles.all()
+            return membership.role
-        return self.club.roles.above_instance(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.
@@ -288,11 +296,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):
+    def max_available_role(self):
-        return self.club.roles.filter(is_board=False)
+        return settings.SITH_MAXIMUM_FREE_ROLE
 
     def clean(self):
         """Check that the user is subscribed and isn't already in the club."""

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,138 +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
-
-PRESIDENT_ROLE = 10
-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 == PRESIDENT_ROLE,
-            club_id=club_id,
-            order=PRESIDENT_ROLE - 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 in which this role exists",
-                        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.AddConstraint(
-            model_name="clubrole",
-            constraint=models.CheckConstraint(
-                condition=models.Q(
-                    ("is_presidency", False), ("is_board", True), _connector="OR"
-                ),
-                name="clubrole_presidency_implies_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

@@ -29,14 +29,14 @@ from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.core.validators import RegexValidator, validate_email
 from django.db import models, transaction
-from django.db.models import Exists, F, OuterRef, Q
+from django.db.models import Exists, F, OuterRef, Q, Value
+from django.db.models.functions import Greatest
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.functional import cached_property
 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,7 +89,7 @@ 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
@@ -138,7 +138,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."""
@@ -206,9 +208,7 @@ class Club(models.Model):
 
     @cached_property
     def current_members(self) -> list[Membership]:
-        return list(
+        return list(self.members.ongoing().select_related("user").order_by("-role"))
-            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."""
@@ -220,77 +220,6 @@ class Club(models.Model):
         return user.is_in_group(pk=self.board_group_id)
 
 
-class ClubRole(OrderedModel):
-    club = models.ForeignKey(
-        Club,
-        verbose_name=_("club"),
-        help_text=_("The club in which this role exists"),
-        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")
-        abstract = False
-        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",
-            )
-        ]
-
-    def __str__(self):
-        return self.name
-
-    def get_display_name(self):
-        return f"{self.name} - {self.club.name}"
-
-    def get_absolute_url(self):
-        return reverse("club:club_roles", kwargs={"club_id": self.club_id})
-
-    def clean(self):
-        errors = []
-        if self.is_presidency and not self.is_board:
-            errors.append(
-                ValidationError(
-                    _(
-                        "Role %(name)s was declared as a presidency role "
-                        "without being a board role"
-                    )
-                    % {"name": self.name}
-                )
-            )
-        if (
-            self.is_board
-            and self.club.roles.filter(is_board=False, order__lt=self.order).exists()
-        ):
-            errors.append(
-                ValidationError(
-                    _("Board role %(role)s cannot be placed below a member role")
-                    % {"role": self.name}
-                )
-            )
-        if errors:
-            raise ValidationError(errors)
-        return super().clean()
-
-
 class MembershipQuerySet(models.QuerySet):
     def ongoing(self) -> Self:
         """Filter all memberships which are not finished yet."""
@@ -303,10 +232,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][]
+        mind combining this with the `ongoing` queryset method
-        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.
@@ -329,16 +257,21 @@ 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:
@@ -408,11 +341,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(
+    role = models.IntegerField(
-        ClubRole,
+        _("role"),
-        verbose_name=_("role"),
+        choices=sorted(settings.SITH_CLUB_ROLES.items()),
-        related_name="members",
+        default=sorted(settings.SITH_CLUB_ROLES.items())[0][0],
-        on_delete=models.PROTECT,
     )
     description = models.CharField(
         _("description"), max_length=128, null=False, blank=True
@@ -430,7 +362,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 ''}"
         )
 
@@ -459,11 +391,7 @@ 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 membership is not None and membership.role >= self.role
-            return False
-        return membership.user_id == user.id or (
-            membership.is_board and membership.role.order < self.role.order
-        )
 
     def delete(self, *args, **kwargs):
         self._remove_club_groups([self])
@@ -539,7 +467,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

@@ -3,7 +3,7 @@ from typing import Annotated
 from django.db.models import Q
 from ninja import FilterLookup, FilterSchema, ModelSchema
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.schemas import NonEmptyStr, SimpleUserSchema
 
 
@@ -30,7 +30,7 @@ class ClubProfileSchema(ModelSchema):
 
     class Meta:
         model = Club
-        fields = ["id", "name", "logo"]
+        fields = ["id", "name", "logo", "is_active", "short_description"]
 
     url: str
 
@@ -39,21 +39,14 @@ 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):
@@ -69,7 +62,6 @@ class UserMembershipSchema(ModelSchema):
 
     class Meta:
         model = Membership
-        fields = ["id", "start_date", "description"]
+        fields = ["id", "start_date", "role", "description"]
 
     club: SimpleClubSchema
-    role: ClubRoleSchema

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

@@ -0,0 +1,63 @@
+import { History, updateQueryString } from "#core:utils/history";
+import {
+  type ClubProfileSchema,
+  type ClubSearchClubData,
+  clubSearchClubProfile,
+  type Options,
+} from "#openapi";
+
+type ClubStatus = "active" | "inactive" | "both";
+const PAGE_SIZE = 50;
+
+document.addEventListener("alpine:init", () => {
+  Alpine.data("clubList", () => ({
+    clubName: "",
+    clubStatus: "active" as ClubStatus,
+    currentPage: 1,
+    nbPages: 1,
+    clubs: [] as ClubProfileSchema[],
+    loading: false,
+
+    async init() {
+      const urlParams = new URLSearchParams(window.location.search);
+      this.clubName = urlParams.get("clubName") || "";
+      this.clubStatus = urlParams.get("clubStatus") || "active";
+      this.currentPage = urlParams.get("currentPage") || 1;
+      for (const param of ["clubName", "clubStatus", "currentPage"]) {
+        this.$watch(param, async (value: number | string) => {
+          updateQueryString(param, value.toString(), History.Replace);
+          await this.loadClubs();
+        });
+      }
+      await this.loadClubs();
+    },
+    async loadClubs() {
+      this.loading = true;
+      const searchParams: Options<ClubSearchClubData> = {
+        query: { page: this.currentPage },
+      };
+      if (this.clubName) {
+        searchParams.query.search = this.clubName;
+      }
+      if (this.clubStatus === "active") {
+        searchParams.query.is_active = true;
+      } else if (this.clubStatus === "inactive") {
+        searchParams.query.is_active = false;
+      }
+      const res = await clubSearchClubProfile(searchParams);
+      this.nbPages = Math.ceil(res.data.count / PAGE_SIZE);
+      this.clubs = res.data.results;
+      this.loading = false;
+    },
+
+    getParagraphs(s: string) {
+      if (!s) {
+        return [];
+      }
+      return s
+        .split("\n")
+        .map((s) => s.trim())
+        .filter((s) => s !== "");
+    },
+  }));
+});

club/static/club/list.scss

@@ -0,0 +1,47 @@
+#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/templates/club/club_list.jinja

@@ -1,4 +1,5 @@
 {% extends "core/base.jinja" %}
+{% from "core/macros.jinja" import paginate_alpine %}
 
 {% block title -%}
   {% trans %}Club list{% endtrans %}
@@ -8,45 +9,76 @@
   {% trans %}The list of all clubs existing at UTBM.{% endtrans %}
 {%- endblock %}
 
-{% macro display_club(club) -%}
+{% block additional_js %}
+  <script type="module" src="{{ static("bundled/club/club-list-index.ts") }}"></script>
+{% endblock %}
 
-  {% if club.is_active or user.is_root %}
+{% block additional_css %}
-
+  <link rel="stylesheet" href="{{ static("club/list.scss") }}">
-    <li><a href="{{ url('club:club_view', club_id=club.id) }}">{{ club.name }}</a>
+{% endblock %}
-
-      {% 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 %}
-  {% if user.is_root %}
+  <main x-data="clubList">
-    <p><a href="{{ url('club:club_new') }}">{% trans %}New club{% endtrans %}</a></p>
+    <h3>{% trans %}Filters{% endtrans %}</h3>
-  {% endif %}
+    <form id="club-list-filters">
-  {% if club_list %}
+      <div class="row gap-4x">
+        <fieldset>
+          <label for="club-name-input">{% trans %}Name{% endtrans %}</label>
+          <input
+            id="club-name-input"
+            type="text"
+            name="club-name"
+            x-model.debounce.500ms="clubName"
+          />
+        </fieldset>
+        <fieldset class="grow">
+          <legend>{% trans %}Club state{% endtrans %}</legend>
+          <div class="row">
+            <input type="radio" id="filter-active-clubs" x-model="clubStatus" value="active">
+            <label for="filter-active-clubs">{% trans %}Active{% endtrans %}</label>
+          </div>
+          <div class="row">
+            <input type="radio" id="filter-inactive-clubs" x-model="clubStatus" value="inactive">
+            <label for="filter-inactive-clubs">{% trans %}Inactive{% endtrans %}</label>
+          </div>
+          <div class="row">
+            <input type="radio" id="filter-all-clubs" x-model="clubStatus" value="both">
+            <label for="filter-all-clubs">{% trans %}All clubs{% endtrans %}</label>
+          </div>
+        </fieldset>
+      </div>
+    </form>
     <h3>{% trans %}Club list{% endtrans %}</h3>
-    <ul>
+    {% if user.has_perm("club.add_club") %}
-      {%- for club in club_list %}
+      <br>
-        {{ display_club(club) }}
+      <a href="{{ url('club:club_new') }}" class="btn btn-blue">
-      {%- endfor %}
+        <i class="fa fa-plus"></i> {% trans %}New club{% endtrans %}
-    </ul>
+      </a>
-  {% else %}
-    {% trans %}There is no club in this website.{% endtrans %}
     {% endif %}
+    <section class="aria-busy-grow" :aria-busy="loading" id="club-list">
+      <template x-for="club of clubs" :key="club.id">
+        <div class="card">
+          <a :href="club.url">
+            <template x-if="club.logo">
+              <img class="club-image" :src="club.logo" :alt="`logo ${club.name}`">
+            </template>
+            <template x-if="!club.logo">
+              <i class="fa-regular fa-image fa-4x club-image"></i>
+            </template>
+          </a>
+          <div class="content">
+            <a :href="club.url">
+              <h4 x-text="`${club.name} ${club.is_active ? '' : '({% trans %}inactive{% endtrans %})'}`"></h4>
+            </a>
+            <template x-for="paragraph of getParagraphs(club.short_description)">
+              <p x-text="paragraph"></p>
+            </template>
+          </div>
+        </div>
+      </template>
+    </section>
+    {{ paginate_alpine("currentPage", "nbPages") }}
+  </main>
 {% endblock %}
 
 

club/templates/club/club_members.jinja

@@ -45,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/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
+            user=cls.simple_board_member, start_date=a_month_ago, role=3
-        )
-        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
         )
+        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,
+            user=cls.sli, start_date=a_month_ago, end_date=yesterday, role=2
-            start_date=a_month_ago,
-            end_date=yesterday,
-            role=cls.board_role,
         )
 
     def setUp(self):

club/tests/test_club.py

@@ -1,12 +1,15 @@
 from datetime import timedelta
 
 import pytest
+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 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
@@ -16,20 +19,19 @@ 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)
+        club=clubs[3], role=3, end_date=localdate() - timedelta(days=1)
-    )
-    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_ids = Club.objects.having_board_member(user).values_list("id", flat=True)
     assert set(club_ids) == {clubs[1].id, clubs[2].id}
+
+
+@pytest.mark.django_db
+def test_club_list(client: Client):
+    client.force_login(baker.make(User))
+    res = client.get(reverse("club:club_list"))
+    assert res.status_code == 200

club/tests/test_club_controller.py

@@ -1,7 +1,6 @@
 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.urls import reverse
@@ -9,7 +8,7 @@ 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
 
@@ -27,10 +26,8 @@ class TestClubSearch(TestCase):
                 "id", flat=True
             )
         )
-        Membership.objects.all().delete()
+        Page.objects.exclude(club=None).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(
@@ -62,6 +59,14 @@ class TestClubSearch(TestCase):
         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]]}
 
+    def test_club_search_profile(self):
+        self.client.force_login(self.user)
+        url = reverse("api:search_club_profile")
+        response = self.client.get(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
 class TestFetchClub:

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(
+    baker.make(Membership, club=club, user=user, role=7)
-        Membership,
-        club=club,
-        user=user,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
     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(
+    baker.make(Membership, club=club, user=user, role=3)
-        Membership,
-        club=club,
-        user=user,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
     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,9 +1,9 @@
-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
@@ -14,7 +14,7 @@ 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
@@ -75,22 +75,17 @@ class TestMembershipQuerySet(TestClub):
     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(
+        membership = baker.make(Membership, end_date=None, user=user, role=5)
-            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
-        )
         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)
 
@@ -101,17 +96,7 @@ class TestMembershipQuerySet(TestClub):
     def test_delete_remove_from_groups(self):
         """Test that `delete` removes from club groups"""
         user = baker.make(User)
-        club = baker.make(Club)
+        memberships = baker.make(Membership, role=iter([1, 5]), user=user, _quantity=2)
-        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
-        )
         club_groups = {
             memberships[0].club.members_group,
             memberships[1].club.members_group,
@@ -127,20 +112,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(
-            *baker.make(Membership, role=iter(roles[4:]), club=cls.club_b, _quantity=4),
+                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 +140,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 +189,21 @@ class TestMembership(TestClub):
             "Marquer comme ancien",
         ]
         rows = table.find("tbody").find_all("tr")
-        memberships = (
+        memberships = self.club.members.ongoing().order_by("-role")
-            self.club.members.ongoing()
+        for row, membership in zip(
-            .order_by("role__order")
+            rows, memberships.select_related("user"), strict=False
-            .select_related("user", "role")
+        ):
-        )
-        user_role = ClubRole.objects.get(members__user=self.simple_board_member)
-        for row, membership in zip(rows, memberships, 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 (
+            if membership.role < 3 or membership.user_id == self.simple_board_member.id:
-                membership.role.order > user_role.order
-                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 +219,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,
+            self.new_members_url, {"user": self.subscriber.id, "role": 3}
-            {"user": self.subscriber.id, "role": self.board_role.id},
         )
         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 +234,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 +255,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 +274,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,
             )
@@ -319,13 +290,12 @@ class TestMembership(TestClub):
 
     def test_president_add_members(self):
         """Test that the president of the club can add members."""
-        president = self.club.members.get(role=self.president_role).user
+        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,
+            self.new_members_url, {"user": self.subscriber.id, "role": 9}
-            {"user": self.subscriber.id, "role": self.president_role.id},
         )
         assert response.status_code == 200
         assert response.headers.get("HX-Redirect", "") == reverse(
@@ -335,17 +305,14 @@ class TestMembership(TestClub):
         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=self.president_role)
+        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.
         """
-        user_role = self.simple_board_member.memberships.first().role
-        other_role = baker.make(ClubRole, club=user_role.club, is_board=True)
-        other_role.above(user_role)
         form = ClubAddMemberForm(
-            data={"user": self.subscriber.id, "role": other_role.id},
+            data={"user": self.subscriber.id, "role": 10},
             request_user=self.simple_board_member,
             club=self.club,
         )
@@ -353,10 +320,7 @@ class TestMembership(TestClub):
 
         assert not form.is_valid()
         assert form.errors == {
-            "role": [
+            "role": ["Sélectionnez un choix valide. 10 n\u2019en fait pas partie."]
-                "Sélectionnez un choix valide. "
-                "Ce choix ne fait pas partie de ceux disponibles."
-            ]
         }
         self.club.refresh_from_db()
         assert nb_memberships == self.club.members.count()
@@ -372,9 +336,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,
         )
@@ -385,27 +348,22 @@ class TestMembership(TestClub):
 
     def test_add_other_member_forbidden(self):
         non_member = subscriber_user.make()
-        simple_member = baker.make(
+        simple_member = baker.make(Membership, club=self.club, role=1).user
-            Membership, club=self.club, role=self.member_role
-        ).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": [
+                "role": ["Sélectionnez un choix valide. 1 n\u2019en fait pas partie."]
-                    "Sélectionnez un choix valide. "
-                    "Ce choix ne fait pas partie de ceux disponibles."
-                ]
             }
 
     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
@@ -424,10 +382,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)
+        membership = baker.make(Membership, club=self.club, role=2, end_date=None)
-        role.below(self.board_role)
-        membership = baker.make(Membership, club=self.club, role=role)
         response = self.client.post(self.members_url, {"members_old": [membership.id]})
         self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
@@ -437,9 +394,7 @@ class TestMembership(TestClub):
         """Test that board members of the club cannot end memberships
         of users with higher roles.
         """
-        membership = self.president.memberships.filter(
+        membership = self.president.memberships.filter(club=self.club).first()
-            club=self.club, end_date=None
-        ).first()
         self.client.force_login(self.simple_board_member)
         self.client.post(self.members_url, {"members_old": [membership.id]})
         self.club.refresh_from_db()
@@ -481,9 +436,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(
+        baker.make(Membership, user=user, club=self.club, end_date=None, role=3)
-            Membership, user=user, club=self.club, end_date=None, role=self.board_role
-        )
         assert user.groups.contains(self.club.members_group)
         assert user.groups.contains(self.club.board_group)
         user.memberships.update(end_date=localdate())
@@ -494,20 +447,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(
+        baker.make(Membership, club=self.club, user=self.subscriber, role=3)
-            Membership, club=self.club, user=self.subscriber, role=self.board_role
-        )
         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)
@@ -520,11 +471,7 @@ class TestMembership(TestClub):
 
         # make sli a board member
         self.sli.memberships.all().delete()
-        Membership(
+        Membership(club=self.ae, user=self.sli, role=3).save()
-            club=self.ae,
-            user=self.sli,
-            role=baker.make(ClubRole, club=self.ae, is_board=True),
-        ).save()
         assert self.club.is_owned_by(self.sli)
 
     def test_change_club_name(self):
@@ -550,7 +497,7 @@ class TestMembership(TestClub):
 
 @pytest.mark.django_db
 def test_membership_set_old(client: Client):
-    membership = baker.make(Membership, end_date=None, user=subscriber_user.make())
+    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})
@@ -584,63 +531,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. "
+                        "Sélectionnez un choix valide. 2 n\u2019en fait pas partie."
-                        "Ce choix ne fait pas partie de ceux disponibles."
                     ]
                 },
             ),
             (
                 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})
-        form = JoinClubForm(club=club, request_user=user, data={"role": role.id})
         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=club)
-        baker.make(Membership, user=user, club=role.club)
+        form = JoinClubForm(club=club, request_user=user, data={"role": 1})
-        form = JoinClubForm(club=role.club, request_user=user, data={"role": role.id})
         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=club, request_user=user, data={"role": 1})
-        form = JoinClubForm(club=role.club, request_user=user, data={"role": role.id})
         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(
+        roles = [1, 1, 1, 2, 2, 4, 4, 5, 7, 9, 10]
-            ClubRole,
-            club=club,
-            is_board=itertools.cycle([True, True, False]),
-            _quantity=10,
-            _bulk_create=True,
-        )
         cls.memberships = baker.make(
             Membership,
             role=iter(roles),

club/tests/test_page.py

@@ -5,7 +5,7 @@ from django.urls import reverse
 from model_bakery import baker
 from pytest_django.asserts import assertHTMLEqual, assertRedirects
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import subscriber_user
 from core.markdown import markdown
 from core.models import PageRev, User
@@ -59,12 +59,7 @@ def test_page_revision(client: Client):
 def test_edit_page(client: Client):
     club = baker.make(Club)
     user = subscriber_user.make()
-    baker.make(
+    baker.make(Membership, user=user, club=club, role=3)
-        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"

club/tests/test_user_club_controller.py

@@ -6,7 +6,7 @@ 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.models import Club, Membership
 from club.schemas import UserMembershipSchema
 from core.baker_recipes import subscriber_user
 from core.models import Page
@@ -19,10 +19,7 @@ class TestFetchClub(TestCase):
         pages = baker.make(Page, _quantity=3, _bulk_create=True)
         clubs = baker.make(Club, page=iter(pages), _quantity=3, _bulk_create=True)
         recipe = Recipe(
-            Membership,
+            Membership, user=cls.user, start_date=localdate() - timedelta(days=2)
-            user=cls.user,
-            start_date=localdate() - timedelta(days=2),
-            role=baker.make(ClubRole),
         )
         cls.members = Membership.objects.bulk_create(
             [

club/views.py

@@ -28,6 +28,7 @@ import csv
 import itertools
 from typing import TYPE_CHECKING, Any
 
+from django.conf import settings
 from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
 from django.contrib.messages.views import SuccessMessageMixin
 from django.core.exceptions import NON_FIELD_ERRORS, PermissionDenied, ValidationError
@@ -41,7 +42,7 @@ from django.utils.functional import cached_property
 from django.utils.timezone import now
 from django.utils.translation import gettext
 from django.utils.translation import gettext_lazy as _
-from django.views.generic import DetailView, ListView, View
+from django.views.generic import DetailView, TemplateView, View
 from django.views.generic.detail import SingleObjectMixin
 from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
@@ -179,15 +180,10 @@ class ClubTabsMixin(TabedViewMixin):
         return tab_list
 
 
-class ClubListView(ListView):
+class ClubListView(TemplateView):
     """List the Clubs."""
 
-    model = Club
     template_name = "club/club_list.jinja"
-    queryset = (
-        Club.objects.filter(parent=None).order_by("name").prefetch_related("children")
-    )
-    context_object_name = "club_list"
 
 
 class ClubView(ClubTabsMixin, DetailView):
@@ -317,7 +313,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.
@@ -342,8 +338,8 @@ class ClubMembersView(
         kwargs["members"] = list(
             self.object.members.ongoing()
             .annotate(is_editable=Q(id__in=editable))
-            .order_by("role__order")
+            .order_by("-role")
-            .select_related("user", "role")
+            .select_related("user")
         )
         kwargs["can_end_membership"] = len(editable) > 0
         return kwargs
@@ -371,8 +367,8 @@ 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")
+                .order_by("-role", "description", "-end_date")
-                .select_related("user", "role")
+                .select_related("user")
             )
         }
 
@@ -723,7 +719,9 @@ 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)

com/tests/test_views.py

@@ -28,7 +28,7 @@ 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 club.models import Club, Membership
 from com.models import News, NewsDate, Poster, Sith, Weekmail, WeekmailArticle
 from core.baker_recipes import subscriber_user
 from core.models import AnonymousUser, Group, User
@@ -214,8 +214,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=5)
-        baker.make(Membership, user=cls.user, club=cls.club, role=role)
 
     def setUp(self):
         self.client.force_login(self.user)

com/views.py

@@ -504,7 +504,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(

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(
+    role=settings.SITH_CLUB_ROLES_ID["Board member"],
-        Recipe(ClubRole, club_id=settings.SITH_MAIN_CLUB_ID, is_board=True)
-    ),
 )
 
 board_user = Recipe(

core/management/commands/populate.py

@@ -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
@@ -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] = (
@@ -118,16 +111,28 @@ class Command(BaseCommand):
 
         club_root = SithFile.objects.create(name="clubs", owner=root)
         sas = SithFile.objects.create(name="SAS", owner=root)
-        clubs = self._create_clubs()
+        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="Eboutic", club=main_club, type="EBOUTIC"),
-            Counter(name="AE", club=clubs.ae, type="OFFICE"),
+            Counter(name="AE", club=main_club, type="OFFICE"),
-            Counter(name="Vidage comptes AE", club=clubs.ae, type="OFFICE"),
+            Counter(name="Vidage comptes AE", club=main_club, type="OFFICE"),
         ]
         Counter.objects.bulk_create(counters)
         bar_groups = []
@@ -310,41 +315,54 @@ class Command(BaseCommand):
         self._create_subscription(tutu)
         StudentCard(uid="9A89B82018B0A0", customer=sli.customer).save()
 
-        Membership.objects.create(
+        # Clubs
-            user=skia, club=clubs.ae, role=clubs.ae.roles.get(name="Respo Info")
+        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,
+            club=troll,
-            role=clubs.troll.roles.get(name="Vice-Président⸱e"),
+            role=9,
             description="Padawan Troll",
             start_date=localdate() - timedelta(days=17),
         )
         Membership.objects.create(
             user=krophil,
-            club=clubs.troll,
+            club=troll,
-            role=clubs.troll.roles.get(name="Président⸱e"),
+            role=10,
             description="Maitre Troll",
             start_date=localdate() - timedelta(days=200),
         )
         Membership.objects.create(
             user=skia,
-            club=clubs.troll,
+            club=troll,
-            role=clubs.troll.roles.get(name="Membre du bureau"),
+            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,
+            club=troll,
-            role=clubs.troll.roles.get(name="Membre du bureau"),
+            role=2,
             description="",
             start_date=localdate() - timedelta(days=200),
             end_date=localdate() - timedelta(days=100),
@@ -361,7 +379,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 +388,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 +397,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 +406,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 +416,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 +426,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 +435,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 +444,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 +454,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 +463,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 +476,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 +500,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 +573,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 +591,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 +607,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 +623,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 +641,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,
@@ -760,52 +778,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"]
-            )
-        )
-        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()
 

core/management/commands/populate_more.py

@@ -11,7 +11,7 @@ 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 club.models import Club, Membership
 from core.models import Group, User, UserBan
 from counter.models import (
     Counter,
@@ -172,25 +172,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, int]]:
-
+            roles = iter(sorted(settings.SITH_CLUB_ROLES.keys(), reverse=True))
-        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]
             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,14 +197,19 @@ 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)

core/templates/core/base/navbar.jinja

@@ -5,9 +5,8 @@
     <details name="navbar" class="menu">
       <summary class="head">{% trans %}Associations & Clubs{% endtrans %}</summary>
       <ul class="content">
-        <li><a href="{{ url('core:page', page_name='ae') }}">{% trans %}AE{% endtrans %}</a></li>
+        <li><a href="{{ url("core:page", page_name="ae") }}">{% trans %}AE{% endtrans %}</a></li>
-        <li><a href="{{ url('core:page', page_name='clubs') }}">{% trans %}AE's clubs{% endtrans %}</a></li>
+        <li><a href="{{ url("club:club_list") }}">{% trans %}AE's clubs{% endtrans %}</a></li>
-        <li><a href="{{ url('core:page', page_name='utbm-associations') }}">{% trans %}Others UTBM's Associations{% endtrans %}</a></li>
       </ul>
     </details>
     <details name="navbar" class="menu">

core/templates/core/user_clubs.jinja

@@ -23,10 +23,10 @@
       </tr>
     </thead>
     <tbody>
-      {% for m in profile.memberships.ongoing().select_related("role") %}
+      {% for m in profile.memberships.filter(end_date=None).all() %}
         <tr>
           <td><a href="{{ url('club:club_members', club_id=m.club.id) }}">{{ m.club }}</a></td>
-          <td>{{ m.role.name }}</td>
+          <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
           <td>{{ m.description }}</td>
           <td>{{ m.start_date }}</td>
           {% if m.can_be_edited_by(user) %}
@@ -65,10 +65,10 @@
       </tr>
     </thead>
     <tbody>
-      {% for m in profile.memberships.ongoing().select_related("role") %}
+      {% for m in profile.memberships.exclude(end_date=None).all() %}
         <tr>
           <td><a href="{{ url('club:club_members', club_id=m.club.id) }}">{{ m.club }}</a></td>
-          <td>{{ m.role.name }}</td>
+          <td>{{ settings.SITH_CLUB_ROLES[m.role] }}</td>
           <td>{{ m.description }}</td>
           <td>{{ m.start_date }}</td>
           <td>{{ m.end_date }}</td>

core/tests/test_page.py

@@ -11,7 +11,7 @@ from django.utils.timezone import now
 from model_bakery import baker
 from pytest_django.asserts import assertHTMLEqual, assertRedirects
 
-from club.models import Club, Membership
+from club.models import Club
 from core.baker_recipes import board_user, subscriber_user
 from core.markdown import markdown
 from core.models import AnonymousUser, Page, PageRev, User
@@ -122,9 +122,6 @@ def test_page_revision_club_redirection(client: Client):
 @pytest.mark.django_db
 def test_viewable_by():
     # remove existing pages to prevent side effect
-    # club pages are protected, so we must delete clubs first
-    Membership.objects.all().delete()
-    Club.objects.all().delete()
     Page.objects.all().delete()
     view_groups = [
         [settings.SITH_GROUP_PUBLIC_ID],

counter/models.py

@@ -583,7 +583,7 @@ class Counter(models.Model):
         if user.is_anonymous:
             return False
         mem = self.club.get_membership_for(user)
-        if mem and mem.role.is_presidency:
+        if mem and mem.role >= settings.SITH_CLUB_ROLES_ID["Treasurer"]:
             return True
         return user.is_in_group(pk=settings.SITH_GROUP_COUNTER_ADMIN_ID)
 

counter/tests/test_counter.py

@@ -32,7 +32,7 @@ from model_bakery import baker
 from model_bakery.recipe import Recipe
 from pytest_django.asserts import assertRedirects
 
-from club.models import ClubRole, Membership
+from club.models import Membership
 from core.baker_recipes import board_user, subscriber_user, very_old_subscriber_user
 from core.models import BanGroup, User
 from counter.baker_recipes import product_recipe, sale_recipe
@@ -88,7 +88,7 @@ class TestFullClickBase(TestCase):
             Membership,
             start_date=now() - timedelta(days=30),
             club=cls.club_counter.club,
-            role=baker.make(ClubRole, club=cls.club_counter.club, is_board=True),
+            role=settings.SITH_CLUB_ROLES_ID["Board member"],
             user=cls.club_admin,
         )
 
@@ -782,13 +782,7 @@ class TestClubCounterClickAccess(TestCase):
             "counter:click",
             kwargs={"counter_id": cls.counter.id, "user_id": cls.customer.id},
         )
-        cls.board_role, cls.member_role = baker.make(
+
-            ClubRole,
-            club=cls.counter.club,
-            is_board=iter([True, False]),
-            _quantity=2,
-            _bulk_create=True,
-        )
         cls.user = subscriber_user.make()
 
     def setUp(self):
@@ -803,17 +797,13 @@ class TestClubCounterClickAccess(TestCase):
         res = self.client.get(self.click_url)
         assert res.status_code == 403
         # being a member of the club, without being in the board, isn't enough
-        baker.make(
+        baker.make(Membership, club=self.counter.club, user=self.user, role=1)
-            Membership, club=self.counter.club, user=self.user, role=self.member_role
-        )
         res = self.client.get(self.click_url)
         assert res.status_code == 403
 
     def test_board_member(self):
         """By default, board members should be able to click on office counters"""
-        baker.make(
+        baker.make(Membership, club=self.counter.club, user=self.user, role=3)
-            Membership, club=self.counter.club, user=self.user, role=self.board_role
-        )
         self.client.force_login(self.user)
         res = self.client.get(self.click_url)
         assert res.status_code == 200
@@ -828,9 +818,7 @@ class TestClubCounterClickAccess(TestCase):
     def test_both_barman_and_board_member(self):
         """If the user is barman and board member, he should be authorized as well."""
         self.counter.sellers.add(self.user)
-        baker.make(
+        baker.make(Membership, club=self.counter.club, user=self.user, role=3)
-            Membership, club=self.counter.club, user=self.user, role=self.board_role
-        )
         self.client.force_login(self.user)
         res = self.client.get(self.click_url)
         assert res.status_code == 200

counter/tests/test_customer.py

@@ -3,13 +3,14 @@ import string
 from datetime import timedelta
 
 import pytest
+from django.conf import settings
 from django.contrib.auth.base_user import make_password
 from django.test import Client, TestCase
 from django.urls import reverse
 from django.utils.timezone import now
 from model_bakery import baker
 
-from club.models import ClubRole, Membership
+from club.models import Membership
 from core.baker_recipes import board_user, subscriber_user
 from core.models import User
 from counter.baker_recipes import product_recipe, refill_recipe, sale_recipe
@@ -41,12 +42,11 @@ class TestStudentCard(TestCase):
         cls.counter.sellers.add(cls.barmen)
 
         cls.club_counter = baker.make(Counter)
-        role = baker.make(ClubRole, club=cls.club_counter.club, is_board=True)
         baker.make(
             Membership,
             start_date=now() - timedelta(days=30),
             club=cls.club_counter.club,
-            role=role,
+            role=settings.SITH_CLUB_ROLES_ID["Board member"],
             user=cls.club_admin,
         )
 

forum/models.py

@@ -183,7 +183,7 @@ class Forum(models.Model):
                 Forum._club_memberships[self.id] = {}
                 Forum._club_memberships[self.id][user.id] = m
         if m:
-            return m.role.is_board
+            return m.role > settings.SITH_MAXIMUM_FREE_ROLE
         return False
 
     def check_loop(self):

galaxy/management/commands/generate_galaxy_test_data.py

@@ -29,9 +29,8 @@ from django.conf import settings
 from django.core.files.base import ContentFile
 from django.core.management.base import BaseCommand
 from django.utils import timezone
-from model_bakery import baker
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.models import Group, Page, SithFile, User
 from core.utils import RED_PIXEL_PNG
 from sas.models import Album, PeoplePictureRelation, Picture
@@ -218,19 +217,11 @@ class Command(BaseCommand):
                 "The `make_clubs()` method must be called before `make_club_memberships()`"
             )
         memberships = []
-        roles = {
-            r.club_id: r.id
-            for r in baker.make(
-                ClubRole,
-                club=iter(self.clubs),
-                _quantity=len(self.clubs),
-                _bulk_create=True,
-            )
-        }
         for i in range(1, 11):  # users can be in up to 20 clubs
             self.logger.info(f"Club membership, pass {i}")
-            for uid in range(i, self.NB_USERS, i):
+            for uid in range(
-                # Pass #1 will make sure every user is at least in one club
+                i, self.NB_USERS, i
+            ):  # Pass #1 will make sure every user is at least in one club
                 user = self.users[uid]
                 club = self.clubs[(uid + i**2) % self.NB_CLUBS]
 
@@ -245,7 +236,7 @@ class Command(BaseCommand):
                     Membership(
                         user=user,
                         club=club,
-                        role_id=roles[club.id],
+                        role=(uid + i) % 10 + 1,  # spread the different roles
                         start_date=start,
                         end_date=end,
                     )
@@ -268,7 +259,7 @@ class Command(BaseCommand):
                     Membership(
                         user=user,
                         club=club,
-                        role_id=roles[club.id],
+                        role=((uid // 10) + i) % 10 + 1,  # spread the different roles
                         start_date=start,
                         end_date=end,
                     )

locale/fr/LC_MESSAGES/django.po

@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-03-10 10:28+0100\n"
+"POT-Creation-Date: 2026-03-20 16:24+0100\n"
 "PO-Revision-Date: 2016-07-18\n"
 "Last-Translator: Maréchal <thomas.girod@utbm.fr\n"
 "Language-Team: AE info <ae.info@utbm.fr>\n"
@@ -310,16 +310,36 @@ msgid "The list of all clubs existing at UTBM."
 msgstr "La liste de tous les clubs existants à l'UTBM"
 
 #: club/templates/club/club_list.jinja
-msgid "inactive"
+msgid "Filters"
-msgstr "inactif"
+msgstr "Filtres"
+
+#: club/templates/club/club_list.jinja
+msgid "Name"
+msgstr "Nom"
+
+#: club/templates/club/club_list.jinja
+msgid "Club state"
+msgstr "Etat du club"
+
+#: club/templates/club/club_list.jinja
+msgid "Active"
+msgstr "Actif"
+
+#: club/templates/club/club_list.jinja
+msgid "Inactive"
+msgstr "Inactif"
+
+#: club/templates/club/club_list.jinja
+msgid "All clubs"
+msgstr "Tous les clubs"
 
 #: club/templates/club/club_list.jinja core/templates/core/user_tools.jinja
 msgid "New club"
 msgstr "Nouveau club"
 
 #: club/templates/club/club_list.jinja
-msgid "There is no club in this website."
+msgid "inactive"
-msgstr "Il n'y a pas de club dans ce site web."
+msgstr "inactif"
 
 #: club/templates/club/club_members.jinja
 msgid "Club members"
@@ -1860,10 +1880,6 @@ msgstr "L'AE"
 msgid "AE's clubs"
 msgstr "Les clubs de L'AE"
 
-#: core/templates/core/base/navbar.jinja
-msgid "Others UTBM's Associations"
-msgstr "Les autres associations de l'UTBM"
-
 #: core/templates/core/base/navbar.jinja
 msgid "Big event"
 msgstr "Grandes Activités"

sith/settings.py

@@ -574,6 +574,35 @@ SITH_SUBSCRIPTIONS = {
     # To be completed....
 }
 
+SITH_CLUB_ROLES_ID = {
+    "President": 10,
+    "Vice-President": 9,
+    "Treasurer": 7,
+    "Communication supervisor": 5,
+    "Secretary": 4,
+    "IT supervisor": 3,
+    "Board member": 2,
+    "Active member": 1,
+    "Curious": 0,
+}
+
+SITH_CLUB_ROLES = {
+    10: _("President"),
+    9: _("Vice-President"),
+    7: _("Treasurer"),
+    5: _("Communication supervisor"),
+    4: _("Secretary"),
+    3: _("IT supervisor"),
+    2: _("Board member"),
+    1: _("Active member"),
+    0: _("Curious"),
+}
+
+# This corresponds to the maximum role a user can freely subscribe to
+# In this case, SITH_MAXIMUM_FREE_ROLE=1 means that a user can
+# set himself as "Membre actif" or "Curieux", but not higher
+SITH_MAXIMUM_FREE_ROLE = 1
+
 # Minutes to timeout the logged barmen
 SITH_BARMAN_TIMEOUT = 30
 

subscription/tests/test_permissions.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
 from core.models import User
 
@@ -15,8 +15,7 @@ class TestSubscriptionPermission(TestCase):
         cls.user: User = subscriber_user.make()
         cls.admin = baker.make(User, is_superuser=True)
         cls.club = baker.make(Club)
-        role = baker.make(ClubRole, club=cls.club, is_board=True)
+        baker.make(Membership, user=cls.user, club=cls.club, role=7)
-        baker.make(Membership, user=cls.user, club=cls.club, role=role)
 
     def test_give_permission(self):
         self.client.force_login(self.admin)

trombi/models.py

@@ -23,6 +23,7 @@
 
 from datetime import date
 
+from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.urls import reverse
@@ -151,12 +152,10 @@ class TrombiUser(models.Model):
 
     def make_memberships(self):
         self.memberships.all().delete()
-        for m in (
+        for m in self.user.memberships.filter(
-            self.user.memberships.filter(role__is_board=True)
+            role__gt=settings.SITH_MAXIMUM_FREE_ROLE
-            .select_related("role")
+        ).order_by("end_date"):
-            .order_by("end_date")
+            role = str(settings.SITH_CLUB_ROLES[m.role])
-        ):
-            role = m.role.name
             if m.description:
                 role += " (%s)" % m.description
             end_date = get_semester_code(m.end_date) if m.end_date else ""