docs: more details on AI guideline rationals

.github/actions/setup_project/action.yml

@@ -12,7 +12,7 @@ runs:
   steps:
     - name: Install apt packages
       if: ${{ inputs.full == 'true' }}
-      uses: awalsh128/cache-apt-pkgs-action@v1.6.0
+      uses: awalsh128/cache-apt-pkgs-action@v1.4.3
       with:
         packages: gettext
         version: 1.0  # increment to reset cache
@@ -23,29 +23,26 @@ runs:
       with:
         redis-version: "7.x"
 
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: "0.5.14"
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+
     - name: "Set up Python"
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v5
       with:
         python-version-file: ".python-version"
 
-    - name: Install uv
-      uses: astral-sh/setup-uv@v8.1.0
-      with:
-        version: "0.11.8"
-        enable-cache: false
-        cache-dependency-glob: "uv.lock"
-
     - name: Restore cached virtualenv
-      uses: actions/cache@v5
+      uses: actions/cache/restore@v4
       with:
+        key: venv-${{ runner.os }}-${{ hashFiles('.python-version') }}-${{ hashFiles('pyproject.toml') }}-${{ env.CACHE_SUFFIX }}
         path: .venv
-        key: uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
-        restore-keys: |
-          uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
-          uv-${{ runner.os }}
 
     - name: Install dependencies
-      run: uv sync --locked
+      run: uv sync
       shell: bash
 
     - name: Install Xapian
@@ -53,6 +50,15 @@ runs:
       run: uv run ./manage.py install_xapian
       shell: bash
 
+    # compiling xapian accounts for almost the entirety of the virtualenv setup,
+    # so we save the virtual environment only on workflows where it has been installed
+    - name: Save cached virtualenv
+      if: ${{ inputs.full == 'true' }}
+      uses: actions/cache/save@v4
+      with:
+        key: venv-${{ runner.os }}-${{ hashFiles('.python-version') }}-${{ hashFiles('pyproject.toml') }}-${{ env.CACHE_SUFFIX }}
+        path: .venv
+
     - name: Compile gettext messages
       if: ${{ inputs.full == 'true' }}
       run: uv run ./manage.py compilemessages

.github/auto_assign.yml

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

.github/dependabot.yml

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

.github/workflows/ci.yml

@@ -18,8 +18,8 @@ jobs:
     name: Launch pre-commits checks (ruff)
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
-    - uses: actions/setup-python@v6
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       with:
         python-version-file: ".python-version"
     - uses: pre-commit/action@v3.0.1
@@ -35,7 +35,7 @@ jobs:
         pytest-mark: [not slow]
     steps:
       - name: Check out repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - uses: ./.github/actions/setup_project
         with:
           full: true
@@ -49,7 +49,7 @@ jobs:
           uv run coverage report
           uv run coverage html
       - name: Archive code coverage results
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: coverage-report-${{ matrix.pytest-mark }}
           path: coverage_report

.github/workflows/deploy.yml

@@ -14,7 +14,7 @@ jobs:
   
     steps:
     - name: SSH Remote Commands
-      uses: appleboy/ssh-action@v1.2.5
+      uses: appleboy/ssh-action@v1.1.0
       with:
         # Proxy
         proxy_host : ${{secrets.PROXY_HOST}}
@@ -29,6 +29,8 @@ jobs:
         username : ${{secrets.USER}}
         key: ${{secrets.KEY}}
 
+        script_stop: true
+
         # See https://github.com/ae-utbm/sith/wiki/GitHub-Actions#deployment-action
         script: |
           cd ${{secrets.SITH_PATH}}

.github/workflows/deploy_docs.yml

@@ -9,10 +9,10 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - uses: ./.github/actions/setup_project
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
-      - uses: actions/cache@v5
+      - uses: actions/cache@v3
         with:
           key: mkdocs-material-${{ env.cache_id }}
           path: .cache

.github/workflows/taiste.yml

@@ -13,7 +13,7 @@ jobs:
 
     steps:
     - name: SSH Remote Commands
-      uses: appleboy/ssh-action@v1.2.5
+      uses: appleboy/ssh-action@v1.1.0
       with:
         # Proxy
         proxy_host : ${{secrets.PROXY_HOST}}
@@ -28,6 +28,8 @@ jobs:
         username : ${{secrets.USER}}
         key: ${{secrets.KEY}}
 
+        script_stop: true
+
         # See https://github.com/ae-utbm/sith/wiki/GitHub-Actions#deployment-action
         script: |
           cd ${{secrets.SITH_PATH}}

.gitignore

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

.pre-commit-config.yaml

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

api/admin.py

@@ -17,15 +17,6 @@ class ApiClientAdmin(admin.ModelAdmin):
         "owner__nick_name",
     )
     autocomplete_fields = ("owner", "groups", "client_permissions")
-    readonly_fields = ("hmac_key",)
-    actions = ("reset_hmac_key",)
-
-    @admin.action(permissions=["change"], description=_("Reset HMAC key"))
-    def reset_hmac_key(self, _request: HttpRequest, queryset: QuerySet[ApiClient]):
-        objs = list(queryset)
-        for obj in objs:
-            obj.reset_hmac(commit=False)
-        ApiClient.objects.bulk_update(objs, fields=["hmac_key"])
 
 
 @admin.register(ApiKey)

api/api.py

@@ -1,16 +0,0 @@
-from ninja_extra import ControllerBase, api_controller, route
-
-from api.auth import ApiKeyAuth
-from api.schemas import ApiClientSchema
-
-
-@api_controller("/client")
-class ApiClientController(ControllerBase):
-    @route.get(
-        "/me",
-        auth=[ApiKeyAuth()],
-        response=ApiClientSchema,
-        url_name="api-client-infos",
-    )
-    def get_client_info(self):
-        return self.context.request.auth

api/auth.py

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

api/forms.py

@@ -1,35 +0,0 @@
-from django import forms
-from django.forms import HiddenInput
-from django.utils.translation import gettext_lazy as _
-
-
-class ThirdPartyAuthForm(forms.Form):
-    """Form to complete to authenticate on the sith from a third-party app.
-
-    For the form to be valid, the user approve the EULA (french: CGU)
-    and give its username from the third-party app.
-    """
-
-    cgu_accepted = forms.BooleanField(
-        required=True,
-        label=_("I have read and I accept the terms and conditions of use"),
-        error_messages={
-            "required": _("You must approve the terms and conditions of use.")
-        },
-    )
-    is_username_valid = forms.BooleanField(
-        required=True,
-        error_messages={"required": _("You must confirm that this is your username.")},
-    )
-    client_id = forms.IntegerField(widget=HiddenInput())
-    third_party_app = forms.CharField(widget=HiddenInput())
-    privacy_link = forms.URLField(widget=HiddenInput())
-    username = forms.CharField(widget=HiddenInput())
-    callback_url = forms.URLField(widget=HiddenInput())
-    signature = forms.CharField(widget=HiddenInput())
-
-    def __init__(self, *args, label_suffix: str = "", initial, **kwargs):
-        super().__init__(*args, label_suffix=label_suffix, initial=initial, **kwargs)
-        self.fields["is_username_valid"].label = _(
-            "I confirm that %(username)s is my username on %(app)s"
-        ) % {"username": initial.get("username"), "app": initial.get("third_party_app")}

api/hashers.py

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

api/migrations/0002_apiclient_hmac_key.py

@@ -1,19 +0,0 @@
-# Generated by Django 5.2.3 on 2025-10-26 10:15
-
-from django.db import migrations, models
-
-import api.models
-
-
-class Migration(migrations.Migration):
-    dependencies = [("api", "0001_initial")]
-
-    operations = [
-        migrations.AddField(
-            model_name="apiclient",
-            name="hmac_key",
-            field=models.CharField(
-                default=api.models.get_hmac_key, max_length=128, verbose_name="HMAC Key"
-            ),
-        ),
-    ]

api/models.py

@@ -1,20 +1,13 @@
-import secrets
 from typing import Iterable
 
 from django.contrib.auth.models import Permission
 from django.db import models
-from django.db.models import Q
-from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 from django.utils.translation import pgettext_lazy
 
 from core.models import Group, User
 
 
-def get_hmac_key():
-    return secrets.token_hex(64)
-
-
 class ApiClient(models.Model):
     name = models.CharField(_("name"), max_length=64)
     owner = models.ForeignKey(
@@ -33,10 +26,11 @@ class ApiClient(models.Model):
         help_text=_("Specific permissions for this api client."),
         related_name="clients",
     )
-    hmac_key = models.CharField(_("HMAC Key"), max_length=128, default=get_hmac_key)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 
+    _perm_cache: set[str] | None = None
+
     class Meta:
         verbose_name = _("api client")
         verbose_name_plural = _("api clients")
@@ -44,38 +38,33 @@ class ApiClient(models.Model):
     def __str__(self):
         return self.name
 
-    @cached_property
-    def all_permissions(self) -> set[str]:
-        permissions = (
-            Permission.objects.filter(
-                Q(group__group__in=self.groups.all()) | Q(clients=self)
-            )
+    def has_perm(self, perm: str):
+        """Return True if the client has the specified permission."""
+
+        if self._perm_cache is None:
+            group_permissions = (
+                Permission.objects.filter(group__group__in=self.groups.all())
                 .values_list("content_type__app_label", "codename")
                 .order_by()
             )
-        return {f"{content_type}.{name}" for content_type, name in permissions}
+            client_permissions = self.client_permissions.values_list(
+                "content_type__app_label", "codename"
+            ).order_by()
+            self._perm_cache = {
+                f"{content_type}.{name}"
+                for content_type, name in (*group_permissions, *client_permissions)
+            }
+        return perm in self._perm_cache
 
-    def has_perm(self, perm: str):
-        """Return True if the client has the specified permission."""
-        return perm in self.all_permissions
-
-    def has_perms(self, perm_list: Iterable[str]) -> bool:
-        """Return True if the client has each of the specified permissions."""
+    def has_perms(self, perm_list):
+        """
+        Return True if the client has each of the specified permissions. If
+        object is passed, check if the client has all required perms for it.
+        """
         if not isinstance(perm_list, Iterable) or isinstance(perm_list, str):
             raise ValueError("perm_list must be an iterable of permissions.")
         return all(self.has_perm(perm) for perm in perm_list)
 
-    def reset_hmac(self, *, commit: bool = True) -> str:
-        """Reset and return the HMAC key for this client.
-
-        Args:
-            commit: if True (the default), persist the new hmac in db.
-        """
-        self.hmac_key = get_hmac_key()
-        if commit:
-            self.save()
-        return self.hmac_key
-
 
 class ApiKey(models.Model):
     PREFIX_LENGTH = 5

api/schemas.py

@@ -1,23 +0,0 @@
-from ninja import ModelSchema, Schema
-from pydantic import Field, HttpUrl
-
-from api.models import ApiClient
-from core.schemas import SimpleUserSchema
-
-
-class ApiClientSchema(ModelSchema):
-    class Meta:
-        model = ApiClient
-        fields = ["id", "name"]
-
-    owner: SimpleUserSchema
-    permissions: list[str] = Field(alias="all_permissions")
-
-
-class ThirdPartyAuthParamsSchema(Schema):
-    client_id: int
-    third_party_app: str
-    privacy_link: HttpUrl
-    username: str
-    callback_url: HttpUrl
-    signature: str

api/templates/api/third_party/auth.jinja

@@ -1,32 +0,0 @@
-{% extends "core/base.jinja" %}
-
-{% block content %}
-  <form method="post">
-    {% csrf_token %}
-    <h3>{% trans %}Confidentiality{% endtrans %}</h3>
-    <p>
-      {% trans trimmed app=third_party_app %}
-        By ticking this box and clicking on the send button, you
-        acknowledge and agree to provide {{ app }} with your
-        first name, last name, nickname and any other information
-        that was the third party app was explicitly authorized to fetch
-        and that it must have acknowledged to you, in a complete and accurate manner.
-      {% endtrans %}
-    </p>
-    <p class="margin-bottom">
-      {% trans trimmed app=third_party_app, privacy_link=third_party_cgu, sith_cgu_link=sith_cgu %}
-        The privacy policies of <a href="{{ privacy_link }}">{{ app }}</a>
-        and of <a href="{{ sith_cgu_link }}">the Students' Association</a>
-        applies as soon as the form is submitted.
-      {% endtrans %}
-    </p>
-    <div class="row">{{ form.cgu_accepted }} {{ form.cgu_accepted.label_tag() }}</div>
-    <br>
-    <h3 class="margin-bottom">{% trans %}Confirmation of identity{% endtrans %}</h3>
-    <div class="row margin-bottom">
-      {{ form.is_username_valid }} {{ form.is_username_valid.label_tag() }}
-    </div>
-    {% for field in form.hidden_fields() %}{{ field }}{% endfor %}
-    <input type="submit" class="btn btn-blue">
-  </form>
-{% endblock %}

api/tests/test_admin.py

@@ -1,24 +0,0 @@
-import pytest
-from django.contrib.admin import AdminSite
-from django.http import HttpRequest
-from model_bakery import baker
-from pytest_django.asserts import assertNumQueries
-
-from api.admin import ApiClientAdmin
-from api.models import ApiClient
-
-
-@pytest.mark.django_db
-def test_reset_hmac_action():
-    client_admin = ApiClientAdmin(ApiClient, AdminSite())
-    api_clients = baker.make(ApiClient, _quantity=4, _bulk_create=True)
-    old_hmac_keys = [c.hmac_key for c in api_clients]
-    with assertNumQueries(2):
-        qs = ApiClient.objects.filter(id__in=[c.id for c in api_clients[2:4]])
-        client_admin.reset_hmac_key(HttpRequest(), qs)
-    for c in api_clients:
-        c.refresh_from_db()
-    assert api_clients[0].hmac_key == old_hmac_keys[0]
-    assert api_clients[1].hmac_key == old_hmac_keys[1]
-    assert api_clients[2].hmac_key != old_hmac_keys[2]
-    assert api_clients[3].hmac_key != old_hmac_keys[3]

api/tests/test_api_client_controller.py

@@ -1,18 +0,0 @@
-import pytest
-from django.test import Client
-from django.urls import reverse
-from model_bakery import baker
-
-from api.hashers import generate_key
-from api.models import ApiClient, ApiKey
-from api.schemas import ApiClientSchema
-
-
-@pytest.mark.django_db
-def test_api_client_controller(client: Client):
-    key, hashed = generate_key()
-    api_client = baker.make(ApiClient)
-    baker.make(ApiKey, client=api_client, hashed_key=hashed)
-    res = client.get(reverse("api:api-client-infos"), headers={"X-APIKey": key})
-    assert res.status_code == 200
-    assert res.json() == ApiClientSchema.from_orm(api_client).model_dump()

api/tests/test_client.py

@@ -1,59 +0,0 @@
-import pytest
-from django.contrib.auth.models import Permission
-from django.test import TestCase
-from model_bakery import baker
-
-from api.models import ApiClient
-from core.models import Group
-
-
-class TestClientPermissions(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.api_client = baker.make(ApiClient)
-        cls.perms = baker.make(Permission, _quantity=10, _bulk_create=True)
-        cls.api_client.groups.set(
-            [
-                baker.make(Group, permissions=cls.perms[0:3]),
-                baker.make(Group, permissions=cls.perms[3:5]),
-            ]
-        )
-        cls.api_client.client_permissions.set(
-            [cls.perms[3], cls.perms[5], cls.perms[6], cls.perms[7]]
-        )
-
-    def test_all_permissions(self):
-        assert self.api_client.all_permissions == {
-            f"{p.content_type.app_label}.{p.codename}" for p in self.perms[0:8]
-        }
-
-    def test_has_perm(self):
-        assert self.api_client.has_perm(
-            f"{self.perms[1].content_type.app_label}.{self.perms[1].codename}"
-        )
-        assert not self.api_client.has_perm(
-            f"{self.perms[9].content_type.app_label}.{self.perms[9].codename}"
-        )
-
-    def test_has_perms(self):
-        assert self.api_client.has_perms(
-            [
-                f"{self.perms[1].content_type.app_label}.{self.perms[1].codename}",
-                f"{self.perms[2].content_type.app_label}.{self.perms[2].codename}",
-            ]
-        )
-        assert not self.api_client.has_perms(
-            [
-                f"{self.perms[1].content_type.app_label}.{self.perms[1].codename}",
-                f"{self.perms[9].content_type.app_label}.{self.perms[9].codename}",
-            ],
-        )
-
-
-@pytest.mark.django_db
-def test_reset_hmac_key():
-    client = baker.make(ApiClient)
-    original_key = client.hmac_key
-    client.reset_hmac(commit=True)
-    assert len(client.hmac_key) == len(original_key)
-    assert client.hmac_key != original_key

api/tests/test_mixed_auth.py

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

api/tests/test_third_party_auth.py

@@ -1,134 +0,0 @@
-from unittest import mock
-from unittest.mock import Mock
-
-from django.contrib.messages import Message, get_messages
-from django.db.models import Max
-from django.test import TestCase
-from django.urls import reverse
-from model_bakery import baker
-from pytest_django.asserts import assertRedirects
-
-from api.models import ApiClient, get_hmac_key
-from core.baker_recipes import subscriber_user
-from core.schemas import UserProfileSchema
-from core.utils import hmac_hexdigest
-
-
-def mocked_post(*, ok: bool):
-    class MockedResponse(Mock):
-        @property
-        def ok(self):
-            return ok
-
-    def mocked():
-        return MockedResponse()
-
-    return mocked
-
-
-class TestThirdPartyAuth(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.user = subscriber_user.make()
-        cls.api_client = baker.make(ApiClient)
-
-    def setUp(self):
-        self.query = {
-            "client_id": self.api_client.id,
-            "third_party_app": "app",
-            "privacy_link": "https://foobar.fr/",
-            "username": "bibou",
-            "callback_url": "https://callback.fr/",
-        }
-        self.query["signature"] = hmac_hexdigest(self.api_client.hmac_key, self.query)
-        self.callback_data = {
-            "user": UserProfileSchema.from_orm(self.user).model_dump()
-        }
-        self.callback_data["signature"] = hmac_hexdigest(
-            self.api_client.hmac_key, self.callback_data["user"]
-        )
-
-    def test_auth_ok(self):
-        self.client.force_login(self.user)
-        res = self.client.get(reverse("api-link:third-party-auth", query=self.query))
-        assert res.status_code == 200
-        with mock.patch("requests.post", new_callable=mocked_post(ok=True)) as mocked:
-            res = self.client.post(
-                reverse("api-link:third-party-auth"),
-                data={"cgu_accepted": True, "is_username_valid": True, **self.query},
-            )
-            mocked.assert_called_once_with(
-                self.query["callback_url"], json=self.callback_data
-            )
-        assertRedirects(
-            res,
-            reverse("api-link:third-party-auth-result", kwargs={"result": "success"}),
-        )
-
-    def test_callback_error(self):
-        """Test that the user see the failure page if the callback request failed."""
-        self.client.force_login(self.user)
-        with mock.patch("requests.post", new_callable=mocked_post(ok=False)) as mocked:
-            res = self.client.post(
-                reverse("api-link:third-party-auth"),
-                data={"cgu_accepted": True, "is_username_valid": True, **self.query},
-            )
-            mocked.assert_called_once_with(
-                self.query["callback_url"], json=self.callback_data
-            )
-        assertRedirects(
-            res,
-            reverse("api-link:third-party-auth-result", kwargs={"result": "failure"}),
-        )
-
-    def test_wrong_signature(self):
-        """Test that a 403 is raised if the signature of the query is wrong."""
-        self.client.force_login(subscriber_user.make())
-        new_key = get_hmac_key()
-        del self.query["signature"]
-        self.query["signature"] = hmac_hexdigest(new_key, self.query)
-        res = self.client.get(reverse("api-link:third-party-auth", query=self.query))
-        assert list(get_messages(res.wsgi_request)) == [
-            Message(
-                level=40,
-                message=(
-                    "La signature est incorrecte. "
-                    "Nous ne pouvons pas garantir l'authenticité de la requête."
-                ),
-            )
-        ]
-
-    def test_cgu_not_accepted(self):
-        self.client.force_login(self.user)
-        res = self.client.get(reverse("api-link:third-party-auth", query=self.query))
-        assert res.status_code == 200
-        res = self.client.post(reverse("api-link:third-party-auth"), data=self.query)
-        assert res.status_code == 200  # no redirect means invalid form
-        res = self.client.post(
-            reverse("api-link:third-party-auth"),
-            data={"cgu_accepted": False, "is_username_valid": False, **self.query},
-        )
-        assert res.status_code == 200
-
-    def test_invalid_client(self):
-        self.client.force_login(self.user)
-        self.query["client_id"] = ApiClient.objects.aggregate(res=Max("id"))["res"] + 1
-        res = self.client.get(reverse("api-link:third-party-auth", query=self.query))
-        assert list(get_messages(res.wsgi_request)) == [
-            Message(
-                level=40,
-                message="Les données fournies pour l'authentification sont incorrectes.",
-            )
-        ]
-
-    def test_missing_parameter(self):
-        self.client.force_login(self.user)
-        del self.query["username"]
-        self.query["signature"] = hmac_hexdigest(self.api_client.hmac_key, self.query)
-        res = self.client.get(reverse("api-link:third-party-auth", query=self.query))
-        assert list(get_messages(res.wsgi_request)) == [
-            Message(
-                level=40,
-                message="Les données fournies pour l'authentification sont incorrectes.",
-            )
-        ]

api/urls.py

@@ -1,26 +1,10 @@
-from django.urls import path, register_converter
-from ninja.security import SessionAuth
 from ninja_extra import NinjaExtraAPI
 
-from api.views import ThirdPartyAuthResultView, ThirdPartyAuthView
-from core.converters import ResultConverter
-
 api = NinjaExtraAPI(
     title="PICON",
     description="Portail Interactif de Communication avec les Outils Numériques",
     version="0.2.0",
     urls_namespace="api",
-    auth=[SessionAuth()],
+    csrf=True,
 )
 api.auto_discover_controllers()
-
-register_converter(ResultConverter, "res")
-
-urlpatterns = [
-    path("auth/", ThirdPartyAuthView.as_view(), name="third-party-auth"),
-    path(
-        "auth/<res:result>/",
-        ThirdPartyAuthResultView.as_view(),
-        name="third-party-auth-result",
-    ),
-]

api/views.py

@@ -1,146 +0,0 @@
-import hmac
-from urllib.parse import unquote
-
-import pydantic
-import requests
-import sentry_sdk
-from django.conf import settings
-from django.contrib import messages
-from django.contrib.auth.mixins import AccessMixin, LoginRequiredMixin
-from django.shortcuts import render
-from django.urls import reverse, reverse_lazy
-from django.utils.translation import gettext as _
-from django.views.generic import FormView, TemplateView
-from ninja_extra.shortcuts import get_object_or_none
-
-from api.forms import ThirdPartyAuthForm
-from api.models import ApiClient
-from api.schemas import ThirdPartyAuthParamsSchema
-from core.models import SithFile
-from core.schemas import UserProfileSchema
-from core.utils import hmac_hexdigest
-
-
-class ThirdPartyAuthView(AccessMixin, FormView):
-    form_class = ThirdPartyAuthForm
-    template_name = "api/third_party/auth.jinja"
-    success_url = reverse_lazy("core:index")
-
-    def parse_params(self) -> ThirdPartyAuthParamsSchema | None:
-        """Parse and check the authentication parameters.
-
-        If parsing fails, messages will be created using the django message
-        infrastructure.
-
-        Returns:
-            The parses parameters, or None if the parsing failed.
-        """
-        # This is here rather than in ThirdPartyAuthForm because
-        # the given parameters and their signature are checked during both
-        # POST (for obvious reasons) and GET (in order not to make
-        # the user fill a form just to get an error he won't understand)
-        params = self.request.GET or self.request.POST
-        params = {key: unquote(val) for key, val in params.items()}
-        try:
-            params = ThirdPartyAuthParamsSchema(**params)
-        except pydantic.ValidationError:
-            messages.error(
-                self.request, _("The data provided for authentication is incorrect")
-            )
-            return None
-        client: ApiClient = get_object_or_none(ApiClient, id=params.client_id)
-        if not client:
-            messages.error(
-                self.request, _("The data provided for authentication is incorrect")
-            )
-            return None
-        if not hmac.compare_digest(
-            hmac_hexdigest(client.hmac_key, params.model_dump(exclude={"signature"})),
-            params.signature,
-        ):
-            messages.error(
-                self.request,
-                _(
-                    "The signature is incorrect. "
-                    "We cannot ensure the provenance of the request."
-                ),
-            )
-            return None
-        return params
-
-    def dispatch(self, request, *args, **kwargs):
-        if not request.user.is_authenticated:
-            return self.handle_no_permission()
-        self.params = self.parse_params()
-        if not self.params:
-            # if parameters parsing failed, shortcut the operation and display
-            # an empty page with just the error messages.
-            return render(request, "core/base.jinja")
-        return super().dispatch(request, *args, **kwargs)
-
-    def get(self, *args, **kwargs):
-        messages.warning(
-            self.request,
-            _(
-                "You are going to link your AE account and your %(app)s account. "
-                "Continue only if this page was opened from %(app)s."
-            )
-            % {"app": self.params.third_party_app},
-        )
-        return super().get(*args, **kwargs)
-
-    def get_initial(self):
-        return self.params.model_dump()
-
-    def form_valid(self, form):
-        client = ApiClient.objects.get(id=form.cleaned_data["client_id"])
-        user = UserProfileSchema.from_orm(self.request.user).model_dump()
-        data = {"user": user, "signature": hmac_hexdigest(client.hmac_key, user)}
-        try:
-            ok = requests.post(form.cleaned_data["callback_url"], json=data).ok
-        except requests.RequestException as e:
-            sentry_sdk.capture_exception(e)
-            ok = False
-        self.success_url = reverse(
-            "api-link:third-party-auth-result",
-            kwargs={"result": "success" if ok else "failure"},
-        )
-        return super().form_valid(form)
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "third_party_app": self.params.third_party_app,
-            "third_party_cgu": self.params.privacy_link,
-            "sith_cgu": SithFile.objects.get(id=settings.SITH_CGU_FILE_ID),
-        }
-
-
-class ThirdPartyAuthResultView(LoginRequiredMixin, TemplateView):
-    """View that the user will see if its authentication on sith was successful.
-
-    This can show either a success or a failure message :
-    - success : everything is good, the user is successfully authenticated
-      and can close the page
-    - failure : the authentication has been processed on the sith side,
-      but the request to the callback url received an error.
-      In such a case, there is nothing much we can do but to advice
-      the user to contact the developers of the third-party app.
-    """
-
-    template_name = "core/base.jinja"
-    success_message = _(
-        "You have been successfully authenticated. You can now close this page."
-    )
-    error_message = _(
-        "Your authentication on the AE website was successful, "
-        "but an error happened during the interaction "
-        "with the third-party application. "
-        "Please contact the managers of the latter."
-    )
-
-    def get(self, request, *args, **kwargs):
-        if self.kwargs.get("result") == "success":
-            messages.success(request, self.success_message)
-        else:
-            messages.error(request, self.error_message)
-        return super().get(request, *args, **kwargs)

biome.json

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

club/admin.py

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

club/api.py

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

club/forms.py

@@ -23,47 +23,16 @@
 #
 
 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,
-    ClubLink,
-    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 (
-    AutoCompleteSelectMultipleUser,
-    AutoCompleteSelectUser,
-)
+from core.views.forms import SelectDate, SelectDateTime
+from core.views.widgets.ajax_select import AutoCompleteSelectMultipleUser
 from counter.models import Counter, Selling
-from counter.schemas import SaleFilterSchema
-
-
-class ClubLinkForm(forms.ModelForm):
-    error_css_class = "error"
-    required_css_class = "required"
-
-    class Meta:
-        model = ClubLink
-        fields = ["url", "name", "link_type"]
-        widgets = {
-            "url": forms.URLInput(
-                {"pattern": "https://.*", "placeholder": "https://monlien.com"}
-            ),
-            "link_type": forms.HiddenInput(),
-        }
-
-
-ClubLinkFormSet = forms.inlineformset_factory(
-    Club, ClubLink, ClubLinkForm, extra=0, can_delete_extra=False
-)
 
 
 class ClubEditForm(forms.ModelForm):
@@ -75,20 +44,6 @@ class ClubEditForm(forms.ModelForm):
         fields = ["address", "logo", "short_description"]
         widgets = {"short_description": forms.Textarea()}
 
-    def __init__(self, *args, prefix: str | None = None, instance=None, **kwargs):
-        super().__init__(*args, prefix=prefix, instance=instance, **kwargs)
-        self.link_formset = ClubLinkFormSet(
-            *args, instance=self.instance, prefix="link", **kwargs
-        )
-
-    def is_valid(self):
-        return super().is_valid() and self.link_formset.is_valid()
-
-    def save(self, commit=True):  # noqa: FBT002
-        res = super().save(commit=commit)
-        self.link_formset.save(commit=commit)
-        return res
-
 
 class ClubAdminEditForm(ClubEditForm):
     admin_fields = ["name", "parent", "is_active"]
@@ -232,88 +187,71 @@ class SellingsForm(forms.Form):
             required=False,
         )
 
-    def to_filter_schema(self) -> SaleFilterSchema:
-        products = (
-            *self.cleaned_data["products"],
-            *self.cleaned_data["archived_products"],
-        )
-        return SaleFilterSchema(
-            after=self.cleaned_data["begin_date"],
-            before=self.cleaned_data["end_date"],
-            counters={c.id for c in self.cleaned_data["counters"]} or None,
-            products={p.id for p in products} or None,
-        )
 
-
-class ClubOldMemberForm(forms.Form):
-    members_old = forms.ModelMultipleChoiceField(
-        Membership.objects.none(),
-        label=_("Mark as old"),
-        widget=forms.CheckboxSelectMultiple,
-        required=False,
-    )
-
-    def __init__(self, *args, user: User, club: Club, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.fields["members_old"].queryset = club.members.ongoing().editable_by(user)
-
-
-class ClubMemberForm(forms.ModelForm):
-    """Form to add a member to the club, as a board member."""
+class ClubMemberForm(forms.Form):
+    """Form handling the members of a club."""
 
     error_css_class = "error"
     required_css_class = "required"
 
-    class Meta:
-        model = Membership
-        fields = ["role", "description"]
+    users = forms.ModelMultipleChoiceField(
+        label=_("Users to add"),
+        help_text=_("Search users to add (one or more)."),
+        required=False,
+        widget=AutoCompleteSelectMultipleUser,
+        queryset=User.objects.all(),
+    )
 
-    def __init__(self, *args, club: Club, request_user: User, **kwargs):
-        self.club = club
-        self.request_user = request_user
+    def __init__(self, *args, **kwargs):
+        self.club = kwargs.pop("club")
+        self.request_user = kwargs.pop("request_user")
+        self.club_members = kwargs.pop("club_members", None)
+        if not self.club_members:
+            self.club_members = self.club.members.ongoing().order_by("-role").all()
         self.request_user_membership = self.club.get_membership_for(self.request_user)
         super().__init__(*args, **kwargs)
-        self.fields["role"].queryset = self.available_roles
-        self.instance.club = club
 
-    @property
-    def available_roles(self) -> QuerySet[ClubRole]:
-        """The roles that will be obtainable with this form."""
-        # this is unreachable, because it will be overridden by subclasses
-        return ClubRole.objects.none()  # pragma: no cover
+        # Using a ModelForm binds too much the form with the model and we don't want that
+        # We want the view to process the model creation since they are multiple users
+        # We also want the form to handle bulk deletion
+        self.fields.update(
+            forms.fields_for_model(
+                Membership,
+                fields=("role", "start_date", "description"),
+                widgets={"start_date": SelectDate},
+            )
+        )
 
+        # Role is required only if users is specified
+        self.fields["role"].required = False
 
-class ClubAddMemberForm(ClubMemberForm):
-    """Form to add a member to the club, as a board member."""
+        # Start date and description are never really required
+        self.fields["start_date"].required = False
+        self.fields["description"].required = False
 
-    class Meta(ClubMemberForm.Meta):
-        fields = ["user", *ClubMemberForm.Meta.fields]
-        widgets = {"user": AutoCompleteSelectUser}
+        self.fields["users_old"] = forms.ModelMultipleChoiceField(
+            User.objects.filter(
+                id__in=[
+                    ms.user.id
+                    for ms in self.club_members
+                    if ms.can_be_edited_by(self.request_user)
+                ]
+            ).all(),
+            label=_("Mark as old"),
+            required=False,
+            widget=forms.CheckboxSelectMultiple,
+        )
+        if not self.request_user.is_root:
+            self.fields.pop("start_date")
 
-    @cached_property
-    def available_roles(self):
-        """The roles that will be obtainable with this form.
-
-        Admins and the club president can attribute any role.
-        Board members can attribute roles lower than their own.
-        Other users cannot attribute roles with this form
-        """
-        qs = self.club.roles.filter(is_active=True)
-        if self.request_user.has_perm("club.add_membership"):
-            return qs.all()
-        membership = self.request_user_membership
-        if membership is None or not membership.role.is_board:
-            return ClubRole.objects.none()
-        if membership.role.is_presidency:
-            return qs.all()
-        return qs.above_instance(membership.role)
-
-    def clean_user(self):
-        """Check that the user is not trying to add a user already in the club.
+    def clean_users(self):
+        """Check that the user is not trying to add an user already in the club.
 
         Also check that the user is valid and has a valid subscription.
         """
-        user = self.cleaned_data["user"]
+        cleaned_data = super().clean()
+        users = []
+        for user in cleaned_data["users"]:
             if not user.is_subscribed:
                 raise forms.ValidationError(
                     _("User must be subscriber to take part to a club"), code="invalid"
@@ -322,113 +260,33 @@ class ClubAddMemberForm(ClubMemberForm):
                 raise forms.ValidationError(
                     _("You can not add the same user twice"), code="invalid"
                 )
-        return user
-
-
-class JoinClubForm(ClubMemberForm):
-    """Form to join a club."""
-
-    def __init__(self, *args, club: Club, request_user: User, **kwargs):
-        super().__init__(*args, club=club, request_user=request_user, **kwargs)
-        self.instance.user = self.request_user
-
-    @cached_property
-    def available_roles(self):
-        return self.club.roles.filter(is_board=False, is_active=True)
-
-    def clean(self):
-        """Check that the user is subscribed and isn't already in the club."""
-        if not self.request_user.is_subscribed:
-            raise forms.ValidationError(
-                _("You must be subscribed to join a club"), code="invalid"
-            )
-        if self.club.get_membership_for(self.request_user):
-            raise forms.ValidationError(
-                _("You are already a member of this club"), code="invalid"
-            )
-        return super().clean()
-
-
-class ClubSearchForm(forms.ModelForm):
-    class Meta:
-        model = Club
-        fields = ["name"]
-        widgets = {"name": forms.SearchInput(attrs={"autocomplete": "off"})}
-
-    club_status = forms.NullBooleanField(
-        label=_("Club status"),
-        widget=forms.RadioSelect(
-            choices=[(True, _("Active")), (False, _("Inactive")), ("", _("All clubs"))],
-        ),
-        initial=True,
-    )
-
-    def __init__(self, *args, data: dict | None = None, **kwargs):
-        super().__init__(*args, data=data, **kwargs)
-        if data is not None and "club_status" not in data:
-            # if the key is missing, it is considered as None,
-            # even though we want the default True value to be applied in such a case
-            # so we enforce it.
-            self.fields["club_status"].value = True
-        self.fields["name"].required = False
-
-
-class ClubRoleForm(forms.ModelForm):
-    error_css_class = "error"
-    required_css_class = "required"
-
-    class Meta:
-        model = ClubRole
-        fields = ["name", "description", "is_presidency", "is_board", "is_active"]
-        widgets = {
-            "is_presidency": forms.HiddenInput(),
-            "is_board": forms.HiddenInput(),
-            "is_active": forms.CheckboxInput(attrs={"class": "switch"}),
-        }
+            users.append(user)
+        return users
 
     def clean(self):
+        """Check user rights for adding an user."""
         cleaned_data = super().clean()
-        if "ORDER" in cleaned_data:
-            self.instance.order = cleaned_data["ORDER"] - 1
+
+        if "start_date" in cleaned_data and not cleaned_data["start_date"]:
+            # Drop start_date if allowed to edition but not specified
+            cleaned_data.pop("start_date")
+
+        if not cleaned_data.get("users"):
+            # No user to add equals no check needed
             return cleaned_data
 
+        if cleaned_data.get("role", "") == "":
+            # Role is required if users exists
+            self.add_error("role", _("You should specify a role"))
+            return cleaned_data
 
-class ClubRoleCreateForm(forms.ModelForm):
-    """Form to create a club role.
-
-    Notes:
-        For UX purposes, users are not meant to fill `is_presidency`
-        and `is_board`, so those values are required by the form constructor
-        in order to initialize the instance properly.
-    """
-
-    error_css_class = "error"
-    required_css_class = "required"
-
-    class Meta:
-        model = ClubRole
-        fields = ["name", "description"]
-
-    def __init__(
-        self, *args, club: Club, is_presidency: bool, is_board: bool, **kwargs
+        request_user = self.request_user
+        membership = self.request_user_membership
+        if not (
+            cleaned_data["role"] <= settings.SITH_MAXIMUM_FREE_ROLE
+            or (membership is not None and membership.role >= cleaned_data["role"])
+            or request_user.is_board_member
+            or request_user.is_root
         ):
-        super().__init__(*args, **kwargs)
-        self.instance.club = club
-        self.instance.is_presidency = is_presidency
-        self.instance.is_board = is_board
-
-
-class ClubRoleBaseFormSet(forms.BaseInlineFormSet):
-    ordering_widget = forms.HiddenInput()
-
-
-ClubRoleFormSet = forms.inlineformset_factory(
-    Club,
-    ClubRole,
-    ClubRoleForm,
-    ClubRoleBaseFormSet,
-    can_delete=False,
-    can_order=True,
-    edit_only=True,
-    extra=0,
-)
+            raise forms.ValidationError(_("You do not have the permission to do that"))
+        return cleaned_data

club/migrations/0012_club_board_group_club_members_group.py

@@ -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.
@@ -37,10 +34,12 @@ def migrate_meta_groups(apps: StateApps, schema_editor):
     clubs = list(Club.objects.all())
     for club in clubs:
         club.board_group = meta_groups.get_or_create(
-            name=f"{club.unix_name}-bureau", defaults={"is_meta": True}
+            name=club.unix_name + settings.SITH_BOARD_SUFFIX,
+            defaults={"is_meta": True},
         )[0]
         club.members_group = meta_groups.get_or_create(
-            name=f"{club.unix_name}-membres", defaults={"is_meta": True}
+            name=club.unix_name + settings.SITH_MEMBER_SUFFIX,
+            defaults={"is_meta": True},
         )[0]
         club.save()
         club.refresh_from_db()
@@ -49,7 +48,10 @@ def migrate_meta_groups(apps: StateApps, schema_editor):
         ).select_related("user")
         club.members_group.users.set([m.user for m in memberships])
         club.board_group.users.set(
-            [m.user for m in memberships.filter(role__gt=MAXIMUM_FREE_ROLE)]
+            [
+                m.user
+                for m in memberships.filter(role__gt=settings.SITH_MAXIMUM_FREE_ROLE)
+            ]
         )
 
 

club/migrations/0015_clubrole_alter_membership_role.py

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

club/migrations/0016_clubrole_alter_membership_role.py

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

club/migrations/0017_linktype_clublink.py

@@ -1,105 +0,0 @@
-# Generated by Django 5.2.12 on 2026-04-27 07:39
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [("club", "0016_clubrole_alter_membership_role")]
-
-    operations = [
-        migrations.CreateModel(
-            name="LinkType",
-            fields=[
-                (
-                    "id",
-                    models.AutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=40, verbose_name="name")),
-                (
-                    "url_base",
-                    models.URLField(
-                        help_text=(
-                            "The base url that links with this type "
-                            "must respect (e.g. `https://www.instagram.com`)"
-                        ),
-                        unique=True,
-                        verbose_name="url base",
-                    ),
-                ),
-                (
-                    "icon",
-                    models.CharField(
-                        help_text=(
-                            "The fontawesome class to use "
-                            "(e.g. `fa-brands fa-instagram`)"
-                        ),
-                        max_length=40,
-                        verbose_name="icon",
-                    ),
-                ),
-            ],
-            options={"verbose_name": "link type", "verbose_name_plural": "link types"},
-        ),
-        migrations.CreateModel(
-            name="ClubLink",
-            fields=[
-                (
-                    "id",
-                    models.AutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "name",
-                    models.CharField(blank=True, max_length=40, verbose_name="name"),
-                ),
-                ("url", models.URLField(verbose_name="link url")),
-                (
-                    "created_at",
-                    models.DateTimeField(auto_now_add=True, verbose_name="created at"),
-                ),
-                (
-                    "updated_at",
-                    models.DateTimeField(auto_now=True, verbose_name="updated at"),
-                ),
-                (
-                    "club",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="links",
-                        to="club.club",
-                        verbose_name="club",
-                    ),
-                ),
-                (
-                    "link_type",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="links",
-                        to="club.linktype",
-                        verbose_name="link type",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "club link",
-                "verbose_name_plural": "club links",
-                "constraints": [
-                    models.UniqueConstraint(
-                        fields=["club", "url"],
-                        name="club_clublink_unique_club_url",
-                        violation_error_message="Duplicated url",
-                    )
-                ],
-            },
-        ),
-    ]

club/models.py

@@ -26,9 +26,10 @@ from __future__ import annotations
 from typing import Iterable, Self
 
 from django.conf import settings
+from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.core.validators import RegexValidator, validate_email
-from django.db import ProgrammingError, models, transaction
+from django.db import models, transaction
 from django.db.models import Exists, F, OuterRef, Q
 from django.urls import reverse
 from django.utils import timezone
@@ -36,19 +37,11 @@ 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
 
 
-class ClubQuerySet(models.QuerySet):
-    def having_board_member(self, user: User) -> Self:
-        """Filter all club in which the given user is a board member."""
-        active_memberships = user.memberships.board().ongoing()
-        return self.filter(Exists(active_memberships.filter(club=OuterRef("pk"))))
-
-
 class Club(models.Model):
     """The Club class, made as a tree to allow nice tidy organization."""
 
@@ -89,17 +82,15 @@ class Club(models.Model):
         on_delete=models.SET_NULL,
     )
     page = models.OneToOneField(
-        Page, related_name="club", blank=True, on_delete=models.PROTECT
+        Page, related_name="club", blank=True, on_delete=models.CASCADE
     )
     members_group = models.OneToOneField(
-        Group, related_name="club", on_delete=models.PROTECT, editable=False
+        Group, related_name="club", on_delete=models.PROTECT
     )
     board_group = models.OneToOneField(
-        Group, related_name="club_board", on_delete=models.PROTECT, editable=False
+        Group, related_name="club_board", on_delete=models.PROTECT
     )
 
-    objects = ClubQuerySet.as_manager()
-
     class Meta:
         ordering = ["name"]
 
@@ -138,7 +129,9 @@ class Club(models.Model):
     @cached_property
     def president(self) -> Membership | None:
         """Fetch the membership of the current president of this club."""
-        return self.members.filter(end_date=None).order_by("role__order").first()
+        return self.members.filter(
+            role=settings.SITH_CLUB_ROLES_ID["President"], end_date=None
+        ).first()
 
     def check_loop(self):
         """Raise a validation error when a loop is found within the parent list."""
@@ -183,41 +176,10 @@ class Club(models.Model):
             self.page.parent = self.parent.page
         self.page.save(force_lock=True)
 
-    def create_default_roles(self):
-        """Create some roles that should exist by default for this club.
-
-        The created roles are : president, treasurer, active member and curious.
-
-        Warnings:
-            When calling this method, no club must exist yet for this club.
-        """
-        if self.roles.exists():
-            raise ProgrammingError(
-                "Default roles can be created only for clubs "
-                "that don't have associated roles yet"
-            )
-        # The names are written in French, because there is no gettext involved
-        # for strings stored in database, and the majority of users are french.
-        roles = [
-            ClubRole(name="Président⸱e", is_board=True, is_presidency=True),
-            ClubRole(name="Trésorier⸱e", is_board=True, is_presidency=False),
-            ClubRole(name="Membre actif⸱ve", is_board=False, is_presidency=False),
-            ClubRole(
-                name="Curieux⸱euse",
-                description=(
-                    "Les gens qui suivent l'activité "
-                    "du club sans forcément y participer"
-                ),
-                is_board=False,
-                is_presidency=False,
-            ),
-        ]
-        for i, role in enumerate(roles):
-            role.club = self
-            role.order = i
-        ClubRole.objects.bulk_create(roles)
-
     def delete(self, *args, **kwargs) -> tuple[int, dict[str, int]]:
+        # Invalidate the cache of this club and of its memberships
+        for membership in self.members.ongoing().select_related("user"):
+            cache.delete(f"membership_{self.id}_{membership.user.id}")
         self.board_group.delete()
         self.members_group.delete()
         return super().delete(*args, **kwargs)
@@ -238,120 +200,33 @@ class Club(models.Model):
         """Method to see if that object can be edited by the given user."""
         return self.has_rights_in_club(user)
 
-    def can_roles_be_edited_by(self, user: User) -> bool:
-        """Return True if the given user can edit the roles of this club"""
-        return user.is_authenticated and (
-            user.has_perm("club.change_clubrole")
-            or self.members.ongoing()
-            .filter(user=user, role__is_presidency=True)
-            .exists()
-        )
-
-    @cached_property
-    def current_members(self) -> list[Membership]:
-        return list(
-            self.members.ongoing().select_related("user", "role").order_by("-role")
-        )
+    def can_be_viewed_by(self, user: User) -> bool:
+        """Method to see if that object can be seen by the given user."""
+        return user.was_subscribed
 
     def get_membership_for(self, user: User) -> Membership | None:
-        """Return the current membership of the given user."""
+        """Return the current membership the given user.
+
+        Note:
+            The result is cached.
+        """
         if user.is_anonymous:
             return None
-        return next((m for m in self.current_members if m.user_id == user.id), None)
+        membership = cache.get(f"membership_{self.id}_{user.id}")
+        if membership == "not_member":
+            return None
+        if membership is None:
+            membership = self.members.filter(user=user, end_date=None).first()
+            if membership is None:
+                cache.set(f"membership_{self.id}_{user.id}", "not_member")
+            else:
+                cache.set(f"membership_{self.id}_{user.id}", membership)
+        return membership
 
     def has_rights_in_club(self, user: User) -> bool:
         return user.is_in_group(pk=self.board_group_id)
 
 
-class ClubRole(OrderedModel):
-    club = models.ForeignKey(
-        Club,
-        verbose_name=_("club"),
-        help_text=_("The club with which this role is associated"),
-        related_name="roles",
-        on_delete=models.CASCADE,
-    )
-    name = models.CharField(_("name"), max_length=50)
-    description = models.TextField(_("description"), blank=True, default="")
-    is_board = models.BooleanField(_("Board role"), default=False)
-    is_presidency = models.BooleanField(_("Presidency role"), default=False)
-    is_active = models.BooleanField(
-        _("is active"),
-        default=True,
-        help_text=_(
-            "If the role is inactive, people joining the club won't be able to get it."
-        ),
-    )
-
-    order_with_respect_to = "club"
-
-    class Meta(OrderedModel.Meta):
-        verbose_name = _("club role")
-        verbose_name_plural = _("club roles")
-        constraints = [
-            # presidency IMPLIES board <=> NOT presidency OR board
-            # cf. MT1 :)
-            models.CheckConstraint(
-                condition=Q(is_presidency=False) | Q(is_board=True),
-                name="clubrole_presidency_implies_board",
-                violation_error_message=_(
-                    "A role cannot be in the presidency while not being in the board"
-                ),
-            )
-        ]
-
-    def __str__(self):
-        return self.name
-
-    def get_display_name(self):
-        return f"{self.name} - {self.club.name}"
-
-    def clean(self):
-        errors = []
-        roles = list(self.club.roles.all())
-        if (
-            self.is_board
-            and self.order
-            and any(r.order < self.order and not r.is_board for r in roles)
-        ):
-            errors.append(
-                ValidationError(
-                    _("Role %(role)s cannot be placed below a member role")
-                    % {"role": self.name}
-                )
-            )
-        if (
-            self.is_presidency
-            and self.order
-            and any(r.order < self.order and not r.is_presidency for r in roles)
-        ):
-            errors.append(
-                ValidationError(
-                    _("Role %(role)s cannot be placed below a non-presidency role")
-                    % {"role": self.name}
-                )
-            )
-        if errors:
-            raise ValidationError(errors)
-        return super().clean()
-
-    def save(self, *args, **kwargs):
-        auto_order = self.order is None and self.is_board
-        if not auto_order:
-            super().save(*args, **kwargs)
-            return
-        # get the role that should be placed after the role we are dealing with.
-        # So, if this is role is presidency, get the first board role ;
-        # if it is a board role, get the first member role ;
-        # and if it is a member role, get nothing (OrderedModel.save will
-        # automatically put it in the last position anyway)
-        filters = {"is_board": self.is_presidency, "is_presidency": False}
-        next_role = self.club.roles.filter(**filters).order_by("order").first()
-        super().save(*args, **kwargs)
-        if next_role:
-            self.above(next_role)
-
-
 class MembershipQuerySet(models.QuerySet):
     def ongoing(self) -> Self:
         """Filter all memberships which are not finished yet."""
@@ -364,68 +239,47 @@ class MembershipQuerySet(models.QuerySet):
         are included, even if there are no more members.
 
         If you want to get the users who are currently in the board,
-        mind combining this with the [MembershipQuerySet.ongoing][]
-        queryset method
+        mind combining this with the :meth:`ongoing` queryset method
         """
-        return self.filter(role__is_board=True)
-
-    def editable_by(self, user: User) -> Self:
-        """Filter Memberships that this user can edit.
-
-        Users with the `club.change_membership` permission can edit all Membership.
-        The other users can edit :
-        - their own membership
-        - if they are board members, ongoing memberships with a role lower than their own
-
-        For example, let's suppose the following users :
-        - A : board member
-        - B : board member
-        - C : simple member
-        - D : curious
-        - E : old member
-
-        A will be able to edit the memberships of A, C and D ;
-        C and D will be able to edit only their own membership ;
-        nobody will be able to edit E's membership.
-        """
-        if user.has_perm("club.change_membership"):
-            return self.all()
-        return self.ongoing().filter(
-            Q(user=user)
-            | Exists(
-                Membership.objects.ongoing().filter(
-                    user=user,
-                    club=OuterRef("club"),
-                    role__is_board=True,
-                    role__order__lt=OuterRef("role__order"),
-                )
-            )
-        )
+        return self.filter(role__gt=settings.SITH_MAXIMUM_FREE_ROLE)
 
     def update(self, **kwargs) -> int:
-        """Remove users from club groups they are no more in
+        """Refresh the cache and edit group ownership.
+
+        Update the cache, when necessary, remove
+        users from club groups they are no more in
         and add them in the club groups they should be in.
 
         Be aware that this adds three db queries :
-
-        - one to retrieve the updated memberships
-        - one to perform group removal
-        - and one to perform group attribution.
+        one to retrieve the updated memberships,
+        one to perform group removal and one to perform
+        group attribution.
         """
         nb_rows = super().update(**kwargs)
         if nb_rows == 0:
-            # if no row was affected, no need to edit club groups
+            # if no row was affected, no need to refresh the cache
             return 0
 
+        cache_memberships = {}
         memberships = set(self.select_related("club"))
         # delete all User-Group relations and recreate the necessary ones
+        # It's more concise to write and more reliable
         Membership._remove_club_groups(memberships)
         Membership._add_club_groups(memberships)
+        for member in memberships:
+            cache_key = f"membership_{member.club_id}_{member.user_id}"
+            if member.end_date is None:
+                cache_memberships[cache_key] = member
+            else:
+                cache_memberships[cache_key] = "not_member"
+        cache.set_many(cache_memberships)
         return nb_rows
 
     def delete(self) -> tuple[int, dict[str, int]]:
         """Work just like the default Django's delete() method,
-        but also remove the concerned users from the club groups.
+        but add a cache invalidation for the elements of the queryset
+        before the deletion,
+        and a removal of the user from the club groups.
 
         Be aware that this adds some db queries :
 
@@ -441,6 +295,12 @@ class MembershipQuerySet(models.QuerySet):
         nb_rows, rows_counts = super().delete()
         if nb_rows > 0:
             Membership._remove_club_groups(memberships)
+            cache.set_many(
+                {
+                    f"membership_{m.club_id}_{m.user_id}": "not_member"
+                    for m in memberships
+                }
+            )
         return nb_rows, rows_counts
 
 
@@ -459,21 +319,24 @@ class Membership(models.Model):
         User,
         verbose_name=_("user"),
         related_name="memberships",
+        null=False,
+        blank=False,
         on_delete=models.CASCADE,
     )
     club = models.ForeignKey(
         Club,
         verbose_name=_("club"),
         related_name="members",
+        null=False,
+        blank=False,
         on_delete=models.CASCADE,
     )
     start_date = models.DateField(_("start date"), default=timezone.now)
     end_date = models.DateField(_("end date"), null=True, blank=True)
-    role = models.ForeignKey(
-        ClubRole,
-        verbose_name=_("role"),
-        related_name="members",
-        on_delete=models.PROTECT,
+    role = models.IntegerField(
+        _("role"),
+        choices=sorted(settings.SITH_CLUB_ROLES.items()),
+        default=sorted(settings.SITH_CLUB_ROLES.items())[0][0],
     )
     description = models.CharField(
         _("description"), max_length=128, null=False, blank=True
@@ -491,7 +354,7 @@ class Membership(models.Model):
     def __str__(self):
         return (
             f"{self.club.name} - {self.user.username} "
-            f"- {self.role.name} "
+            f"- {settings.SITH_CLUB_ROLES[self.role]} "
             f"- {str(_('past member')) if self.end_date is not None else ''}"
         )
 
@@ -505,6 +368,9 @@ class Membership(models.Model):
         self._remove_club_groups([self])
         if self.end_date is None:
             self._add_club_groups([self])
+            cache.set(f"membership_{self.club_id}_{self.user_id}", self)
+        else:
+            cache.set(f"membership_{self.club_id}_{self.user_id}", "not_member")
 
     def get_absolute_url(self):
         return reverse("club:club_members", kwargs={"club_id": self.club_id})
@@ -520,15 +386,12 @@ class Membership(models.Model):
         if user.is_root or user.is_board_member:
             return True
         membership = self.club.get_membership_for(user)
-        if not membership:
-            return False
-        return membership.user_id == user.id or (
-            membership.is_board and membership.role.order < self.role.order
-        )
+        return membership is not None and membership.role >= self.role
 
     def delete(self, *args, **kwargs):
         self._remove_club_groups([self])
         super().delete(*args, **kwargs)
+        cache.delete(f"membership_{self.club_id}_{self.user_id}")
 
     @staticmethod
     def _remove_club_groups(
@@ -600,7 +463,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,
@@ -773,81 +636,3 @@ class MailingSubscription(models.Model):
 
     def fetch_format(self):
         return self.get_email + " "
-
-
-class LinkType(models.Model):
-    """A link type, in order to group links and give them icons.
-
-    Notes:
-        Among all club links, there is a special one, with an empty base url
-        and a default link icon.
-        It is use as a fallback item when no actual link type can be found.
-
-    Danger:
-        LinkType.icon is content that will be raw-rendered in the template.
-        It is NOT safe to allow users to give it.
-        The edition of this field must be reserved to trusted admins.
-    """
-
-    name = models.CharField(_("name"), max_length=40)
-    url_base = models.URLField(
-        "url base",
-        unique=True,
-        help_text=_(
-            "The base url that links with this type must respect (e.g. `%(url)s`)"
-        )
-        % {"url": "https://www.instagram.com"},
-    )
-    icon = models.CharField(
-        _("icon"),
-        max_length=40,
-        help_text=_("The fontawesome class to use (e.g. `fa-brands fa-instagram`)"),
-    )
-
-    class Meta:
-        verbose_name = _("link type")
-        verbose_name_plural = _("link types")
-
-    def __str__(self):
-        return self.name
-
-
-class ClubLink(models.Model):
-    link_type = models.ForeignKey(
-        LinkType,
-        verbose_name=_("link type"),
-        on_delete=models.CASCADE,
-        related_name="links",
-    )
-    name = models.CharField(_("name"), max_length=40, blank=True)
-    url = models.URLField(_("link url"))
-    club = models.ForeignKey(
-        Club, verbose_name=_("club"), on_delete=models.CASCADE, related_name="links"
-    )
-    created_at = models.DateTimeField(_("created at"), auto_now_add=True)
-    updated_at = models.DateTimeField(_("updated at"), auto_now=True)
-
-    class Meta:
-        verbose_name = _("club link")
-        verbose_name_plural = _("club links")
-        constraints = [
-            models.UniqueConstraint(
-                fields=["club", "url"],
-                name="club_clublink_unique_club_url",
-                violation_error_message=_("Duplicated url"),
-            )
-        ]
-
-    def __str__(self):
-        return self.url
-
-    def save(self, **kwargs):
-        if not self.name:
-            self.name = self.link_type.name
-        return super().save(**kwargs)
-
-    def clean(self):
-        if not self.url.startswith(self.link_type.url_base):
-            raise ValidationError(
-                _("This link doesn't match with the url base of its type.")
-            )

club/schemas.py

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

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

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

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

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

club/static/club/detail.scss

@@ -1,66 +0,0 @@
-#club-detail {
-  img.club-logo {
-    display: block;
-    max-height: 200px;
-    max-width: 200px;
-  }
-  #club-attributes {
-    ul {
-      list-style: none;
-      margin-left: 0;
-      display: flex;
-      flex-direction: column;
-      gap: .75rem;
-
-      li i {
-        margin-right: .5rem;
-      }
-    }
-  }
-
-  &:not(.has-links) {
-    #club-attributes {
-      float: right;
-      margin: 1em 0 1em 2em;
-
-      @media screen and (max-width: 650px) {
-        margin-left: 1em;
-      }
-      @media screen and (max-width: 400px) {
-        float: unset;
-        img.club-logo {
-          margin: auto;
-        }
-      }
-    }
-  }
-
-  &.has-links {
-    display: flex;
-    flex-direction: row-reverse;
-    gap: 2em;
-
-    @media screen and (max-width: 650px) {
-      flex-direction: column;
-      gap: 1em;
-    }
-
-    #club-attributes {
-      display: flex;
-      flex-direction: column;
-      gap: 1em;
-      min-width: 200px;
-      @media screen and (max-width: 650px) {
-        margin-top: 1em;
-        flex-direction: row-reverse;
-        justify-content: flex-end;
-        h4 {
-          margin: 0;
-        }
-        img.club-logo {
-          margin-left: auto;
-        }
-      }
-    }
-  }
-}

club/static/club/list.scss

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

club/static/club/members.scss

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

club/static/club/roles.scss

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

club/templates/club/club_detail.jinja

@@ -9,56 +9,17 @@
   {{ club.short_description }}
 {%- endblock %}
 
-{% block metatags %}
-  <meta property="og:url" content="{{ request.build_absolute_uri(club.get_absolute_url()) }}" />
-  <meta property="og:type" content="website" />
-  <meta property="og:title" content="{{ club.name }}" />
-  <meta property="og:description" content="{{ club.short_description }}" />
-  {% if club.logo %}
-    <meta property="og:image" content="{{ request.build_absolute_uri(club.logo.url) }}" />
-  {% else %}
-    <meta property="og:image" content="{{ request.build_absolute_uri(static("core/img/logo_no_text.png")) }}" />
-  {% endif %}
-{% endblock %}
-
-{% block additional_css %}
-  <link rel="stylesheet" href="{{ static("club/detail.scss") }}">
-{% endblock %}
-
 {% block content %}
-  <h3>{{ club.name }}</h3>
-  <div id="club-detail" {% if links %}class="has-links"{% endif %}>
-    <div id="club-attributes">
+  <div id="club_detail">
     {% if club.logo %}
-        <img
-          class="club-logo"
-          src="{{ club.logo.url }}"
-          alt="{{ club.name }}"
-          width="{{ club.logo.width }}"
-          height="{{ club.logo.height }}"
-        >
+      <div class="club_logo"><img src="{{ club.logo.url }}" alt="{{ club.name }}"></div>
     {% endif %}
-      {% if links %}
-        <div id="club-links">
-          <h4>{% trans %}Links{% endtrans %}</h4>
-          <ul>
-            {% for link in links %}
-              <li>
-                <a href="{{ link.url }}" rel="noopener external" target="_blank">
-                  <i class="{{ link.link_type.icon }} fa-xl"></i>{{ link.name }}
-                </a>
-              </li>
-            {% endfor %}
-          </ul>
-        </div>
-      {% endif %}
-    </div>
-    <div id="club-page">
     {% if page_revision %}
       {{ page_revision|markdown }}
+    {% else %}
+      <h3>{% trans %}Club{% endtrans %}</h3>
     {% endif %}
   </div>
-  </div>
 {% endblock %}
 
 

club/templates/club/club_list.jinja

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

club/templates/club/club_members.jinja

@@ -1,38 +1,15 @@
 {% extends "core/base.jinja" %}
 {% from 'core/macros.jinja' import user_profile_link, select_all_checkbox %}
 
-{% block additional_css %}
-  <link rel="stylesheet" href="{{ static("club/members.scss") }}">
-{% endblock %}
-
 {% block content %}
-  {% block notifications %}
-    {# Notifications are moved a little bit below #}
-  {% endblock %}
-
   <h2>{% trans %}Club members{% endtrans %}</h2>
-
-  {% if club.can_roles_be_edited_by(user) %}
-    <a
-      href="{{ url("club:club_roles", club_id=object.id) }}"
-      class="btn btn-blue margin-bottom"
-    >
-      <i class="fa fa-users-gear"></i> {% trans %}Manage roles{% endtrans %}
-    </a>
-  {% endif %}
-
-  {% if add_member_fragment %}
-    <br />
-    {{ add_member_fragment }}
-    <br />
-  {% endif %}
-  {% include "core/base/notifications.jinja" %}
   {% if members %}
-    <form action="{{ url('club:club_members', club_id=club.id) }}" id="members_old" method="post">
+    <form action="{{ url('club:club_members', club_id=club.id) }}" id="users_old" method="post">
       {% csrf_token %}
-      {% if can_end_membership %}
-        {{ select_all_checkbox("members_old") }}
-        <br />
+      {% set users_old = dict(form.users_old | groupby("choice_label")) %}
+      {% if users_old %}
+        {{ select_all_checkbox("users_old") }}
+        <p></p>
       {% endif %}
       <table id="club_members_table">
         <thead>
@@ -41,7 +18,7 @@
             <td>{% trans %}Role{% endtrans %}</td>
             <td>{% trans %}Description{% endtrans %}</td>
             <td>{% trans %}Since{% endtrans %}</td>
-            {% if can_end_membership %}
+            {% if users_old %}
               <td>{% trans %}Mark as old{% endtrans %}</td>
             {% endif %}
           </tr>
@@ -50,27 +27,23 @@
           {% 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 -%}
+              {% if users_old %}
                 <td>
-                  {%- if m.is_editable -%}
-                    <label for="id_members_old_{{ loop.index }}"></label>
-                    <input
-                      type="checkbox"
-                      name="members_old"
-                      value="{{ m.id }}"
-                      id="id_members_old_{{ loop.index }}"
-                    >
-                  {%- endif -%}
+                  {% set user_old = users_old[m.user.get_display_name()] %}
+                  {% if user_old %}
+                    {{ user_old[0].tag() }}
+                  {% endif %}
                 </td>
-              {%- endif -%}
+              {% endif %}
             </tr>
           {% endfor %}
         </tbody>
       </table>
-      {% if can_end_membership %}
+      {{ form.users_old.errors }}
+      {% if users_old %}
         <p></p>
         <input type="submit" name="submit" value="{% trans %}Mark as old{% endtrans %}">
       {% endif %}
@@ -78,4 +51,32 @@
   {% else %}
     <p>{% trans %}There are no members in this club.{% endtrans %}</p>
   {% endif %}
+  <form action="{{ url('club:club_members', club_id=club.id) }}" id="add_users" method="post">
+    {% csrf_token %}
+    {{ form.non_field_errors() }}
+    <p>
+      {{ form.users.errors }}
+      <label for="{{ form.users.id_for_label }}">{{ form.users.label }} :</label>
+      {{ form.users }}
+      <span class="helptext">{{ form.users.help_text }}</span>
+    </p>
+    <p>
+      {{ form.role.errors }}
+      <label for="{{ form.role.id_for_label }}">{{ form.role.label }} :</label>
+      {{ form.role }}
+    </p>
+    {% if form.start_date %}
+      <p>
+        {{ form.start_date.errors }}
+        <label for="{{ form.start_date.id_for_label }}">{{ form.start_date.label }} :</label>
+        {{ form.start_date }}
+      </p>
+    {% endif %}
+    <p>
+      {{ form.description.errors }}
+      <label for="{{ form.description.id_for_label }}">{{ form.description.label }} :</label>
+      {{ form.description }}
+    </p>
+    <p><input type="submit" value="{% trans %}Add{% endtrans %}" /></p>
+  </form>
 {% endblock %}

club/templates/club/club_old_members.jinja

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

club/templates/club/club_roles.jinja

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

club/templates/club/club_sellings.jinja

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

club/templates/club/club_tools.jinja

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

club/templates/club/edit_club.jinja

@@ -1,63 +1,9 @@
 {% extends "core/base.jinja" %}
 
-{% block additional_js %}
-  <script type="module" src="{{ static("bundled/core/dynamic-formset-index.ts") }}"></script>
-{% endblock %}
-
 {% block title %}
   {% trans name=object %}Edit {{ name }}{% endtrans %}
 {% endblock %}
 
-{% macro link_form(form) %}
-  <fieldset
-    {# set url in x-init rather than in x-data,
-       in order to trigger the $watch on initial load #}
-    x-data="{ url: '', linkType: { icon: '', id: 0 } }"
-    x-init="() => {
-            $watch('url', (u) => linkType = linkTypes.find((t) => u.startsWith(t.url)));
-            url = '{{ form.url.value() or "" }}';
-            }"
-  >
-    {{ form.non_field_errors() }}
-    <div class="form-group row gap-2x">
-      <div>
-        {{ form.url.label_tag() }}
-        {{ form.url.errors }}
-        <span>
-          {# we change the icon when the user change it and leave the input,
-             or when it is pasted from the clipboard #}
-          {{ form.url|add_attr("x-model.change=url,@paste.prevent=url = $event.clipboardData.getData('text')") }}
-          <i
-            :class="linkType.icon || 'fa fa-link'"
-            tooltip="{% trans %}This icon will change according to the given url.{% endtrans %}"
-          ></i>
-        </span>
-      </div>
-      <div>{{ form.name.as_field_group() }}</div>
-    </div>
-    {%- if form.DELETE -%}
-      <div class="form-group row gap">
-        {{ form.DELETE.as_field_group() }}
-      </div>
-    {%- else -%}
-      <br>
-      <button
-        class="btn btn-grey"
-        @click.prevent="removeForm($event.target.closest('fieldset'))"
-      >
-        <i class="fa fa-minus"></i> {% trans %}Remove link{% endtrans %}
-      </button>
-    {%- endif -%}
-    {{ form.link_type|add_attr(":value=linkType.id") }}
-    {%- for field in form.hidden_fields() -%}
-      {%- if field != form.link_type -%}
-        {{ field }}
-      {%- endif -%}
-    {%- endfor -%}
-  </fieldset>
-{% endmacro %}
-
-
 {% block content %}
   <h2>{% trans name=object %}Edit {{ name }}{% endtrans %}</h2>
 
@@ -71,7 +17,7 @@
          and explicitly separate them from the non-admin ones,
          with some help text.
          Non-admin users will only see the regular form fields,
-         so they don't need those explanations #}
+         so they don't need thoses explanations #}
       <h3>{% trans %}Club properties{% endtrans %}</h3>
       <p class="helptext">
         {% trans trimmed %}
@@ -79,7 +25,7 @@
           Only admin users can see and edit them.
         {% endtrans %}
       </p>
-      <fieldset class="margin-bottom">
+      <fieldset class="required margin-bottom">
         {% for field_name in form.admin_fields %}
           {% set field = form[field_name] %}
           <div class="form-group">
@@ -90,13 +36,11 @@
           {# Remove the the admin fields from the form.
              The remaining non-admin fields will be rendered
              at once with a simple {{ form.as_p() }} #}
-          {% do form.fields.pop(field_name) %}
+          {% set _ = form.fields.pop(field_name) %}
         {% endfor %}
       </fieldset>
-    {% endif %}
 
       <h3>{% trans %}Club informations{% endtrans %}</h3>
-    {% if form.admin_fields %}
       <p class="helptext">
         {% trans trimmed %}
           The following form fields are linked to the basic description of a club.
@@ -104,45 +48,7 @@
         {% endtrans %}
       </p>
     {% endif %}
-    <fieldset class="margin-bottom">
     {{ form.as_p() }}
-    </fieldset>
-
-    <h3>{% trans %}Club links{% endtrans %}</h3>
-    <div x-data="dynamicFormSet({ prefix: '{{ form.link_formset.prefix }}' })" class="margin-bottom">
-      {{ form.link_formset.management_form }}
-      <div x-ref="formContainer">
-        {%- for f in form.link_formset.forms -%}
-          {{ link_form(f) }}
-        {%- endfor -%}
-      </div>
-      <template x-ref="formTemplate">
-        {{ link_form(form.link_formset.empty_form) }}
-      </template>
-      <p>
-        <i>{% trans trimmed %}
-          Note: if the icon of one of your links doesn't exist yet,
-          you can ask the info team to add it.
-        {% endtrans %}</i>
-      </p>
-      <br>
-      <button @click.prevent="addForm()" class="btn btn-grey">
-        <i class="fa fa-plus"></i>{% trans %}Add link{% endtrans %}
-      </button>
-    </div>
-    <hr>
-    <button type="submit" class="btn btn-blue">
-      <i class="fa fa-check"></i>{% trans %}Save{% endtrans %}
-    </button>
+    <p><input type="submit" value="{% trans %}Save{% endtrans %}" /></p>
   </form>
 {% endblock content %}
-
-{% block script %}
-  <script>
-    const linkTypes = [
-      {%- for t in link_types -%}
-        { id: {{ t.id }}, url: '{{ t.url_base }}', icon: '{{ t.icon }}' },
-      {%- endfor -%}
-    ];
-  </script>
-{% endblock %}

club/templates/club/fragments/add_member.jinja

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

club/templates/club/page_history.jinja

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

club/templates/club/pagerev_edit.jinja

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

club/tests/base.py

@@ -8,7 +8,7 @@ from django.utils.timezone import now
 from model_bakery import baker
 from model_bakery.recipe import Recipe
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import old_subscriber_user, subscriber_user
 from core.models import User
 
@@ -43,30 +43,17 @@ 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}
-        )
         cls.members_url = reverse("club:club_members", kwargs={"club_id": cls.club.id})
         a_month_ago = now() - timedelta(days=30)
         yesterday = now() - timedelta(days=1)
         membership_recipe = Recipe(Membership, club=cls.club)
         membership_recipe.make(
-            user=cls.simple_board_member, start_date=a_month_ago, role=cls.board_role
-        )
-        membership_recipe.make(user=cls.richard, role=cls.member_role)
-        membership_recipe.make(
-            user=cls.president, start_date=a_month_ago, role=cls.president_role
+            user=cls.simple_board_member, start_date=a_month_ago, role=3
         )
+        membership_recipe.make(user=cls.richard, role=1)
+        membership_recipe.make(user=cls.president, start_date=a_month_ago, role=10)
         membership_recipe.make(  # sli was a member but isn't anymore
-            user=cls.sli,
-            start_date=a_month_ago,
-            end_date=yesterday,
-            role=cls.board_role,
+            user=cls.sli, start_date=a_month_ago, end_date=yesterday, role=2
         )
 
     def setUp(self):

club/tests/test_club.py

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

club/tests/test_club_controller.py

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

club/tests/test_clubrole.py

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

club/tests/test_edit.py

@@ -4,7 +4,7 @@ from django.urls import reverse
 from model_bakery import baker
 from pytest_django.asserts import assertRedirects
 
-from club.models import Club, ClubRole, Membership
+from club.models import Club, Membership
 from core.baker_recipes import subscriber_user
 
 
@@ -12,22 +12,11 @@ from core.baker_recipes import subscriber_user
 def test_club_board_member_cannot_edit_club_properties(client: Client):
     user = subscriber_user.make()
     club = baker.make(Club, name="old name", is_active=True, address="old address")
-    baker.make(
-        Membership,
-        club=club,
-        user=user,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
+    baker.make(Membership, club=club, user=user, role=7)
     client.force_login(user)
     res = client.post(
         reverse("club:club_edit", kwargs={"club_id": club.id}),
-        {
-            "name": "new name",
-            "is_active": False,
-            "address": "new address",
-            "link-TOTAL_FORMS": 0,
-            "link-INITIAL_FORMS": 0,
-        },
+        {"name": "new name", "is_active": False, "address": "new address"},
     )
     # The request should success,
     # but admin-only fields shouldn't be taken into account
@@ -43,12 +32,7 @@ def test_edit_club_page_doesnt_crash(client: Client):
     """crash test for club:club_edit"""
     club = baker.make(Club)
     user = subscriber_user.make()
-    baker.make(
-        Membership,
-        club=club,
-        user=user,
-        role=baker.make(ClubRole, club=club, is_board=True),
-    )
+    baker.make(Membership, club=club, user=user, role=3)
     client.force_login(user)
     res = client.get(reverse("club:club_edit", kwargs={"club_id": club.id}))
     assert res.status_code == 200

club/tests/test_mailing.py

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

club/tests/test_membership.py

@@ -1,20 +1,13 @@
-import itertools
-from collections.abc import Callable
-from datetime import timedelta
-
-import pytest
 from bs4 import BeautifulSoup
-from django.contrib.auth.models import Permission
+from django.conf import settings
 from django.core.cache import cache
 from django.db.models import Max
-from django.test import Client, TestCase
 from django.urls import reverse
 from django.utils.timezone import localdate, localtime, now
-from model_bakery import baker, seq
-from pytest_django.asserts import assertRedirects
+from model_bakery import baker
 
-from club.forms import ClubAddMemberForm, JoinClubForm
-from club.models import Club, ClubRole, Membership
+from club.forms import ClubMemberForm
+from club.models import Membership
 from club.tests.base import TestClub
 from core.baker_recipes import subscriber_user
 from core.models import AnonymousUser, User
@@ -72,25 +65,39 @@ class TestMembershipQuerySet(TestClub):
         expected.sort(key=lambda i: i.id)
         assert members == expected
 
+    def test_update_invalidate_cache(self):
+        """Test that the `update` queryset method properly invalidate cache."""
+        mem_skia = self.simple_board_member.memberships.get(club=self.club)
+        cache.set(f"membership_{mem_skia.club_id}_{mem_skia.user_id}", mem_skia)
+        self.simple_board_member.memberships.update(end_date=localtime(now()).date())
+        assert (
+            cache.get(f"membership_{mem_skia.club_id}_{mem_skia.user_id}")
+            == "not_member"
+        )
+
+        mem_richard = self.richard.memberships.get(club=self.club)
+        cache.set(
+            f"membership_{mem_richard.club_id}_{mem_richard.user_id}", mem_richard
+        )
+        self.richard.memberships.update(role=5)
+        new_mem = self.richard.memberships.get(club=self.club)
+        assert new_mem != "not_member"
+        assert new_mem.role == 5
+
     def test_update_change_club_groups(self):
         """Test that `update` set the user groups accordingly."""
         user = baker.make(User)
-        board_role, member_role = baker.make(
-            ClubRole, is_board=iter([True, False]), _quantity=2, _bulk_create=True
-        )
-        membership = baker.make(
-            Membership, end_date=None, user=user, role=board_role, club=board_role.club
-        )
+        membership = baker.make(Membership, end_date=None, user=user, role=5)
         members_group = membership.club.members_group
         board_group = membership.club.board_group
         assert user.groups.contains(members_group)
         assert user.groups.contains(board_group)
 
-        user.memberships.update(role=member_role)  # from board to simple member
+        user.memberships.update(role=1)  # from board to simple member
         assert user.groups.contains(members_group)
         assert not user.groups.contains(board_group)
 
-        user.memberships.update(role=board_role)  # from member to board
+        user.memberships.update(role=5)  # from member to board
         assert user.groups.contains(members_group)
         assert user.groups.contains(board_group)
 
@@ -98,20 +105,28 @@ class TestMembershipQuerySet(TestClub):
         assert not user.groups.contains(members_group)
         assert not user.groups.contains(board_group)
 
+    def test_delete_invalidate_cache(self):
+        """Test that the `delete` queryset properly invalidate cache."""
+        mem_skia = self.simple_board_member.memberships.get(club=self.club)
+        mem_comptable = self.president.memberships.get(club=self.club)
+        cache.set(f"membership_{mem_skia.club_id}_{mem_skia.user_id}", mem_skia)
+        cache.set(
+            f"membership_{mem_comptable.club_id}_{mem_comptable.user_id}", mem_comptable
+        )
+
+        # should delete the subscriptions of simple_board_member and president
+        self.club.members.ongoing().board().delete()
+
+        for membership in (mem_skia, mem_comptable):
+            cached_mem = cache.get(
+                f"membership_{membership.club_id}_{membership.user_id}"
+            )
+            assert cached_mem == "not_member"
+
     def test_delete_remove_from_groups(self):
         """Test that `delete` removes from club groups"""
         user = baker.make(User)
-        club = baker.make(Club)
-        roles = baker.make(
-            ClubRole,
-            is_board=iter([False, True]),
-            club=club,
-            _quantity=2,
-            _bulk_create=True,
-        )
-        memberships = baker.make(
-            Membership, club=club, role=iter(roles), user=user, _quantity=2
-        )
+        memberships = baker.make(Membership, role=iter([1, 5]), user=user, _quantity=2)
         club_groups = {
             memberships[0].club.members_group,
             memberships[1].club.members_group,
@@ -122,47 +137,8 @@ class TestMembershipQuerySet(TestClub):
         assert set(user.groups.all()).isdisjoint(club_groups)
 
 
-class TestMembershipEditableBy(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        Membership.objects.all().delete()
-        cls.club_a, cls.club_b = baker.make(Club, _quantity=2)
-        roles = baker.make(
-            ClubRole,
-            is_presidency=itertools.cycle([True, False, False, False]),
-            is_board=itertools.cycle([True, True, True, False]),
-            order=itertools.cycle(range(4)),
-            club=iter(
-                [*itertools.repeat(cls.club_a, 4), *itertools.repeat(cls.club_b, 4)]
-            ),
-            _quantity=8,
-            _bulk_create=True,
-        )
-        cls.memberships = [
-            *baker.make(Membership, role=iter(roles[:4]), club=cls.club_a, _quantity=4),
-            *baker.make(Membership, role=iter(roles[4:]), club=cls.club_b, _quantity=4),
-        ]
-
-    def test_admin_user(self):
-        perm = Permission.objects.get(codename="change_membership")
-        user = baker.make(User, user_permissions=[perm])
-        qs = Membership.objects.editable_by(user).values_list("id", flat=True)
-        assert set(qs) == set(Membership.objects.values_list("id", flat=True))
-
-    def test_simple_subscriber_user(self):
-        user = subscriber_user.make()
-        assert not Membership.objects.editable_by(user).exists()
-
-    def test_board_member(self):
-        # a board member can end lower memberships and its own one
-        user = self.memberships[2].user
-        qs = Membership.objects.editable_by(user).values_list("id", flat=True)
-        expected = {self.memberships[2].id, self.memberships[3].id}
-        assert set(qs) == expected
-
-
 class TestMembership(TestClub):
-    def assert_membership_started_today(self, user: User, role: 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
@@ -175,7 +151,7 @@ class TestMembership(TestClub):
 
     def assert_membership_ended_today(self, user: User):
         """Assert that the given user have a membership which ended today."""
-        today = localdate()
+        today = localtime(now()).date()
         assert user.memberships.filter(club=self.club, end_date=today).exists()
         assert self.club.get_membership_for(user) is None
 
@@ -184,9 +160,7 @@ class TestMembership(TestClub):
         cannot see the page.
         """
         response = self.client.post(self.members_url)
-        assertRedirects(
-            response, reverse("core:login", query={"next": self.members_url})
-        )
+        assert response.status_code == 403
 
         self.client.force_login(self.public)
         response = self.client.post(self.members_url)
@@ -197,9 +171,7 @@ class TestMembership(TestClub):
         information are displayed.
         """
         self.client.force_login(self.simple_board_member)
-        response = self.client.get(
-            reverse("club:club_members", kwargs={"club_id": self.club.id})
-        )
+        response = self.client.get(self.members_url)
         assert response.status_code == 200
         soup = BeautifulSoup(response.text, "lxml")
         table = soup.find("table", id="club_members_table")
@@ -211,66 +183,73 @@ class TestMembership(TestClub):
             "Marquer comme ancien",
         ]
         rows = table.find("tbody").find_all("tr")
-        memberships = (
-            self.club.members.ongoing()
-            .order_by("role__order")
-            .select_related("user", "role")
-        )
-        user_role = ClubRole.objects.get(members__user=self.simple_board_member)
-        for row, membership in zip(rows, memberships, strict=False):
+        memberships = self.club.members.ongoing().order_by("-role")
+        for row, membership in zip(
+            rows, memberships.select_related("user"), strict=False
+        ):
             user = membership.user
             user_url = reverse("core:user_profile", args=[user.id])
             cols = row.find_all("td")
             user_link = cols[0].find("a")
             assert user_link.attrs["href"] == user_url
             assert user_link.text == user.get_display_name()
-            assert cols[1].text == membership.role.name
+            assert cols[1].text == settings.SITH_CLUB_ROLES[membership.role]
             assert cols[2].text == membership.description
             assert cols[3].text == str(membership.start_date)
 
-            if (
-                membership.role.order > user_role.order
-                or membership.user_id == self.simple_board_member.id
-            ):
-                # 3 is the role of simple_board_member
+            if membership.role <= 3:  # 3 is the role of simple_board_member
                 form_input = cols[4].find("input")
                 expected_attrs = {
                     "type": "checkbox",
-                    "name": "members_old",
-                    "value": str(membership.id),
+                    "name": "users_old",
+                    "value": str(user.id),
                 }
                 assert form_input.attrs.items() >= expected_attrs.items()
             else:
                 assert cols[4].find_all() == []
 
     def test_root_add_one_club_member(self):
-        """Test that root users can add members to clubs"""
+        """Test that root users can add members to clubs, one at a time."""
         self.client.force_login(self.root)
         response = self.client.post(
-            self.new_members_url,
-            {"user": self.subscriber.id, "role": 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.members_url,
+            {"users": [self.subscriber.id], "role": 3},
         )
+        self.assertRedirects(response, self.members_url)
         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_root_add_multiple_club_member(self):
+        """Test that root users can add multiple members at once to clubs."""
+        self.client.force_login(self.root)
+        response = self.client.post(
+            self.members_url,
+            {
+                "users": (self.subscriber.id, self.krophil.id),
+                "role": 3,
+            },
+        )
+        self.assertRedirects(response, self.members_url)
+        self.subscriber.refresh_from_db()
+        self.assert_membership_started_today(self.subscriber, role=3)
+        self.assert_membership_started_today(self.krophil, role=3)
 
     def test_add_unauthorized_members(self):
         """Test that users who are not currently subscribed
         cannot be members of clubs.
         """
         for user in self.public, self.old_subscriber:
-            form = ClubAddMemberForm(
-                data={"user": user.id, "role": self.member_role},
+            form = ClubMemberForm(
+                data={"users": [user.id], "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
 
             assert not form.is_valid()
             assert form.errors == {
-                "user": ["L'utilisateur doit être cotisant pour faire partie d'un club"]
+                "users": [
+                    "L'utilisateur doit être cotisant pour faire partie d'un club"
+                ]
             }
 
     def test_add_members_already_members(self):
@@ -284,7 +263,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()
@@ -302,16 +281,16 @@ class TestMembership(TestClub):
         nb_memberships = self.club.members.count()
         max_id = User.objects.aggregate(id=Max("id"))["id"]
         for members in [max_id + 1], [max_id + 1, self.subscriber.id]:
-            form = ClubAddMemberForm(
-                data={"user": members, "role": self.member_role},
+            form = ClubMemberForm(
+                data={"users": members, "role": 1},
                 request_user=self.root,
                 club=self.club,
             )
             assert not form.is_valid()
             assert form.errors == {
-                "user": [
+                "users": [
                     "Sélectionnez un choix valide. "
-                    "Ce choix ne fait pas partie de ceux disponibles."
+                    f"{max_id + 1} n\u2019en fait pas partie."
                 ]
             }
         self.club.refresh_from_db()
@@ -319,33 +298,27 @@ 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,
-            {"user": self.subscriber.id, "role": self.president_role.id},
-        )
-        assert response.status_code == 200
-        assert response.headers.get("HX-Redirect", "") == reverse(
-            "club:club_members", kwargs={"club_id": self.club.id}
+            self.members_url,
+            {"users": self.subscriber.id, "role": 9},
         )
+        self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
         self.subscriber.refresh_from_db()
         assert self.club.members.count() == nb_club_membership + 1
         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},
+        form = ClubMemberForm(
+            data={"users": [self.subscriber.id], "role": 10},
             request_user=self.simple_board_member,
             club=self.club,
         )
@@ -353,10 +326,7 @@ class TestMembership(TestClub):
 
         assert not form.is_valid()
         assert form.errors == {
-            "role": [
-                "Sélectionnez un choix valide. "
-                "Ce choix ne fait pas partie de ceux disponibles."
-            ]
+            "__all__": ["Vous n'avez pas la permission de faire cela"]
         }
         self.club.refresh_from_db()
         assert nb_memberships == self.club.members.count()
@@ -364,59 +334,23 @@ class TestMembership(TestClub):
 
     def test_add_member_without_role(self):
         """Test that trying to add members without specifying their role fails."""
-        form = ClubAddMemberForm(
-            data={"user": self.subscriber.id}, request_user=self.root, club=self.club
-        )
-
-        assert not form.is_valid()
-        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},
-            request_user=self.root,
+        self.client.force_login(self.root)
+        form = ClubMemberForm(
+            data={"users": [self.subscriber.id]},
+            request_user=self.simple_board_member,
             club=self.club,
         )
-        assert not form.is_valid()
-        assert form.errors == {
-            "user": ["Vous ne pouvez pas ajouter deux fois le même utilisateur"]
-        }
 
-    def test_add_other_member_forbidden(self):
-        non_member = subscriber_user.make()
-        simple_member = baker.make(
-            Membership, club=self.club, role=self.member_role
-        ).user
-        for user in non_member, simple_member:
-            form = ClubAddMemberForm(
-                data={"user": subscriber_user.make(), "role": self.member_role.id},
-                request_user=user,
-                club=self.club,
-            )
         assert not form.is_valid()
-            assert form.errors == {
-                "role": [
-                    "Sélectionnez un choix valide. "
-                    "Ce choix ne fait pas partie de ceux disponibles."
-                ]
-            }
-
-    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)
-        self.client.force_login(user)
-        res = self.client.get(self.members_url)
-        assert res.status_code == 200
-        soup = BeautifulSoup(res.text, "lxml")
-        assert not soup.find(id="add_club_members_form")
+        assert form.errors == {"role": ["Vous devez choisir un rôle"]}
 
     def test_end_membership_self(self):
         """Test that a member can end its own membership."""
         self.client.force_login(self.simple_board_member)
-        membership = self.club.members.get(end_date=None, user=self.simple_board_member)
-        self.client.post(self.members_url, {"members_old": [membership.id]})
+        self.client.post(
+            self.members_url,
+            {"users_old": self.simple_board_member.id},
+        )
         self.simple_board_member.refresh_from_db()
         self.assert_membership_ended_today(self.simple_board_member)
 
@@ -424,47 +358,62 @@ class TestMembership(TestClub):
         """Test that board members of the club can end memberships
         of users with lower roles.
         """
+        # remainder : simple_board_member has role 3, president has role 10, richard has role 1
         self.client.force_login(self.simple_board_member)
-        role = baker.make(ClubRole, club=self.club, is_board=True)
-        role.below(self.board_role)
-        membership = baker.make(Membership, club=self.club, role=role)
-        response = self.client.post(self.members_url, {"members_old": [membership.id]})
+        response = self.client.post(
+            self.members_url,
+            {"users_old": self.richard.id},
+        )
         self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
-        self.assert_membership_ended_today(membership.user)
+        self.assert_membership_ended_today(self.richard)
 
     def test_end_membership_higher_role(self):
         """Test that board members of the club cannot end memberships
         of users with higher roles.
         """
-        membership = self.president.memberships.filter(
-            club=self.club, end_date=None
-        ).first()
+        membership = self.president.memberships.filter(club=self.club).first()
         self.client.force_login(self.simple_board_member)
-        self.client.post(self.members_url, {"members_old": [membership.id]})
+        self.client.post(
+            self.members_url,
+            {"users_old": self.president.id},
+        )
         self.club.refresh_from_db()
         new_membership = self.club.get_membership_for(self.president)
         assert new_membership is not None
         assert new_membership == membership
 
-        membership.refresh_from_db()
+        membership = self.president.memberships.filter(club=self.club).first()
         assert membership.end_date is None
 
-    def test_end_membership_with_permission(self):
-        """Test that users with permission can end any membership."""
+    def test_end_membership_as_main_club_board(self):
+        """Test that board members of the main club can end the membership
+        of anyone.
+        """
         # make subscriber a board member
+        subscriber = subscriber_user.make()
+        Membership.objects.create(club=self.ae, user=subscriber, role=3)
+
         nb_memberships = self.club.members.ongoing().count()
-        self.client.force_login(
-            subscriber_user.make(
-                user_permissions=[Permission.objects.get(codename="change_membership")]
-            )
-        )
-        president_membership = self.club.president
+        self.client.force_login(subscriber)
         response = self.client.post(
-            self.members_url, {"members_old": [president_membership.id]}
+            self.members_url,
+            {"users_old": self.president.id},
         )
         self.assertRedirects(response, self.members_url)
-        self.assert_membership_ended_today(president_membership.user)
+        self.assert_membership_ended_today(self.president)
+        assert self.club.members.ongoing().count() == nb_memberships - 1
+
+    def test_end_membership_as_root(self):
+        """Test that root users can end the membership of anyone."""
+        nb_memberships = self.club.members.ongoing().count()
+        self.client.force_login(self.root)
+        response = self.client.post(
+            self.members_url,
+            {"users_old": [self.president.id]},
+        )
+        self.assertRedirects(response, self.members_url)
+        self.assert_membership_ended_today(self.president)
         assert self.club.members.ongoing().count() == nb_memberships - 1
 
     def test_end_membership_as_foreigner(self):
@@ -472,18 +421,19 @@ class TestMembership(TestClub):
         nb_memberships = self.club.members.count()
         membership = self.richard.memberships.filter(club=self.club).first()
         self.client.force_login(self.subscriber)
-        self.client.post(self.members_url, {"members_old": [self.richard.id]})
+        self.client.post(
+            self.members_url,
+            {"users_old": [self.richard.id]},
+        )
         # nothing should have changed
-        membership.refresh_from_db()
+        new_mem = self.club.get_membership_for(self.richard)
         assert self.club.members.count() == nb_memberships
-        assert membership.end_date is None
+        assert membership == new_mem
 
     def test_remove_from_club_group(self):
         """Test that when a membership ends, the user is removed from club groups."""
         user = baker.make(User)
-        baker.make(
-            Membership, user=user, club=self.club, end_date=None, role=self.board_role
-        )
+        baker.make(Membership, user=user, club=self.club, end_date=None, role=3)
         assert user.groups.contains(self.club.members_group)
         assert user.groups.contains(self.club.board_group)
         user.memberships.update(end_date=localdate())
@@ -494,20 +444,18 @@ class TestMembership(TestClub):
         """Test that when a membership begins, the user is added to the club group."""
         assert not self.subscriber.groups.contains(self.club.members_group)
         assert not self.subscriber.groups.contains(self.club.board_group)
-        baker.make(
-            Membership, club=self.club, user=self.subscriber, role=self.board_role
-        )
+        baker.make(Membership, club=self.club, user=self.subscriber, role=3)
         assert self.subscriber.groups.contains(self.club.members_group)
         assert self.subscriber.groups.contains(self.club.board_group)
 
     def test_change_position_in_club(self):
         """Test that when moving from board to members, club group change"""
         membership = baker.make(
-            Membership, club=self.club, user=self.subscriber, role=self.board_role
+            Membership, club=self.club, user=self.subscriber, role=3
         )
         assert self.subscriber.groups.contains(self.club.members_group)
         assert self.subscriber.groups.contains(self.club.board_group)
-        membership.role = self.member_role
+        membership.role = 1
         membership.save()
         assert self.subscriber.groups.contains(self.club.members_group)
         assert not self.subscriber.groups.contains(self.club.board_group)
@@ -520,11 +468,7 @@ class TestMembership(TestClub):
 
         # make sli a board member
         self.sli.memberships.all().delete()
-        Membership(
-            club=self.ae,
-            user=self.sli,
-            role=baker.make(ClubRole, club=self.ae, is_board=True),
-        ).save()
+        Membership(club=self.ae, user=self.sli, role=3).save()
         assert self.club.is_owned_by(self.sli)
 
     def test_change_club_name(self):
@@ -546,175 +490,3 @@ class TestMembership(TestClub):
         new_board = set(self.club.board_group.users.values_list("id", flat=True))
         assert new_members == initial_members
         assert new_board == initial_board
-
-
-@pytest.mark.django_db
-def test_membership_set_old(client: Client):
-    membership = baker.make(Membership, end_date=None, user=subscriber_user.make())
-    client.force_login(membership.user)
-    response = client.post(
-        reverse("club:membership_set_old", kwargs={"membership_id": membership.id})
-    )
-    assertRedirects(
-        response, reverse("core:user_clubs", kwargs={"user_id": membership.user_id})
-    )
-    membership.refresh_from_db()
-    assert membership.end_date == localdate()
-
-
-@pytest.mark.django_db
-def test_membership_delete(client: Client):
-    user = baker.make(User, is_superuser=True)
-    membership = baker.make(Membership)
-    client.force_login(user)
-    url = reverse("club:membership_delete", kwargs={"membership_id": membership.id})
-    response = client.get(url)
-    assert response.status_code == 200
-    response = client.post(url)
-    assertRedirects(
-        response, reverse("core:user_clubs", kwargs={"user_id": membership.user_id})
-    )
-    assert not Membership.objects.filter(id=membership.id).exists()
-
-
-@pytest.mark.django_db
-class TestAddMemberForm(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.club = baker.make(Club)
-        cls.roles = baker.make(
-            ClubRole,
-            club=cls.club,
-            is_board=iter([True, True, True, True, False, False]),
-            is_presidency=iter([True, True, False, False, False, False]),
-            order=seq(0),
-            _quantity=6,
-            _bulk_create=True,
-        )
-        cls.roles[-1].is_active = False
-        cls.roles[-1].save()
-
-    def test_admin(self):
-        """Test that admin users can give any active role."""
-        user = baker.make(
-            User, user_permissions=[Permission.objects.get(codename="add_membership")]
-        )
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == self.roles[:-1]
-
-    def test_president(self):
-        """Test that someone with a presidency role can give any active role."""
-        user = baker.make(Membership, club=self.club, role=self.roles[0]).user
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == self.roles[:-1]
-
-    def test_board_member(self):
-        """Test that someone with a board role can give lower active role."""
-        user = baker.make(Membership, club=self.club, role=self.roles[2]).user
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == self.roles[3:-1]
-
-    def test_simple_member(self):
-        """Test that someone with a non-board role cannot give roles."""
-        user = baker.make(Membership, club=self.club, role=self.roles[4]).user
-        form = ClubAddMemberForm(request_user=user, club=self.club)
-        assert list(form.fields["role"].queryset) == []
-
-
-@pytest.mark.django_db
-class TestJoinClub:
-    @pytest.fixture(autouse=True)
-    def clear_cache(self):
-        cache.clear()
-
-    @pytest.mark.parametrize(
-        ("user_factory", "board_role", "errors"),
-        [
-            (
-                subscriber_user.make,
-                True,
-                {
-                    "role": [
-                        "Sélectionnez un choix valide. "
-                        "Ce choix ne fait pas partie de ceux disponibles."
-                    ]
-                },
-            ),
-            (
-                lambda: baker.make(User),
-                False,
-                {"__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
-    ):
-        club = baker.make(Club)
-        user = user_factory()
-        role = baker.make(ClubRole, club=club, is_board=board_role)
-        form = JoinClubForm(club=club, request_user=user, data={"role": role.id})
-        assert not form.is_valid()
-        assert form.errors == errors
-
-    def test_user_already_in_club(self):
-        user = subscriber_user.make()
-        role = baker.make(ClubRole, is_board=False)
-        baker.make(Membership, user=user, club=role.club)
-        form = JoinClubForm(club=role.club, request_user=user, data={"role": role.id})
-        assert not form.is_valid()
-        assert form.errors == {"__all__": ["Vous êtes déjà membre de ce club."]}
-
-    def test_ok(self):
-        user = subscriber_user.make()
-        role = baker.make(ClubRole, is_board=False)
-        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()
-
-
-class TestOldMembersView(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        club = baker.make(Club)
-        roles = baker.make(
-            ClubRole,
-            club=club,
-            is_board=itertools.cycle([True, True, False]),
-            order=seq(0),
-            _quantity=10,
-            _bulk_create=True,
-        )
-        cls.memberships = baker.make(
-            Membership,
-            role=iter(roles),
-            club=club,
-            start_date=now() - timedelta(days=14),
-            end_date=now() - timedelta(days=7),
-            _quantity=len(roles),
-            _bulk_create=True,
-        )
-        cls.url = reverse("club:club_old_members", kwargs={"club_id": club.id})
-
-    def test_ok(self):
-        user = subscriber_user.make()
-        self.client.force_login(user)
-        res = self.client.get(self.url)
-        assert res.status_code == 200
-
-    def test_access_forbidden(self):
-        res = self.client.get(self.url)
-        assertRedirects(res, reverse("core:login", query={"next": self.url}))
-
-        self.client.force_login(baker.make(User))
-        res = self.client.get(self.url)
-        assert res.status_code == 403
-
-    def test_context_data(self):
-        # mark a membership as not ended, to make sure it is excluded from the result
-        self.memberships[0].end_date = None
-        self.memberships[0].save()
-        self.client.force_login(subscriber_user.make())
-        res = self.client.get(self.url)
-        assert list(res.context_data.get("old_members")) == self.memberships[1:]

club/tests/test_page.py

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

club/tests/test_posters.py

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

club/tests/test_sales.py

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

club/tests/test_user_club_controller.py

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

club/urls.py

@@ -25,7 +25,6 @@
 from django.urls import path
 
 from club.views import (
-    ClubAddMembersFragment,
     ClubCreateView,
     ClubEditView,
     ClubListView,
@@ -35,10 +34,6 @@ from club.views import (
     ClubPageEditView,
     ClubPageHistView,
     ClubRevView,
-    ClubRoleBoardCreateView,
-    ClubRoleMemberCreateView,
-    ClubRolePresidencyCreateView,
-    ClubRoleUpdateView,
     ClubSellingCSVView,
     ClubSellingView,
     ClubToolsView,
@@ -65,32 +60,11 @@ urlpatterns = [
     path("<int:club_id>/edit/", ClubEditView.as_view(), name="club_edit"),
     path("<int:club_id>/edit/page/", ClubPageEditView.as_view(), name="club_edit_page"),
     path("<int:club_id>/members/", ClubMembersView.as_view(), name="club_members"),
-    path(
-        "fragment/<int:club_id>/members/",
-        ClubAddMembersFragment.as_view(),
-        name="club_new_members",
-    ),
     path(
         "<int:club_id>/elderlies/",
         ClubOldMembersView.as_view(),
         name="club_old_members",
     ),
-    path("<int:club_id>/role/", ClubRoleUpdateView.as_view(), name="club_roles"),
-    path(
-        "<int:club_id>/role/new/president/",
-        ClubRolePresidencyCreateView.as_view(),
-        name="new_role_president",
-    ),
-    path(
-        "<int:club_id>/role/new/board/",
-        ClubRoleBoardCreateView.as_view(),
-        name="new_role_board",
-    ),
-    path(
-        "<int:club_id>/role/new/member/",
-        ClubRoleMemberCreateView.as_view(),
-        name="new_role_member",
-    ),
     path("<int:club_id>/sellings/", ClubSellingView.as_view(), name="club_sellings"),
     path(
         "<int:club_id>/sellings/csv/", ClubSellingCSVView.as_view(), name="sellings_csv"

club/views.py

@@ -22,87 +22,53 @@
 #
 #
 
-from __future__ import annotations
-
 import csv
-import itertools
-from typing import TYPE_CHECKING, Any
 
-from django.contrib.auth.mixins import (
-    LoginRequiredMixin,
-    PermissionRequiredMixin,
-    UserPassesTestMixin,
-)
-from django.contrib.messages.views import SuccessMessageMixin
+from django.conf import settings
+from django.contrib.auth.mixins import PermissionRequiredMixin
 from django.core.exceptions import NON_FIELD_ERRORS, PermissionDenied, ValidationError
 from django.core.paginator import InvalidPage, Paginator
-from django.db.models import F, Prefetch, Q, Sum
-from django.db.models.functions import Length
-from django.http import Http404, StreamingHttpResponse
+from django.db.models import Sum
+from django.http import (
+    Http404,
+    HttpResponseRedirect,
+    StreamingHttpResponse,
+)
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse, reverse_lazy
 from django.utils import timezone
 from django.utils.functional import cached_property
-from django.utils.timezone import now
-from django.utils.translation import gettext
+from django.utils.translation import gettext as _t
 from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView, View
-from django.views.generic.detail import SingleObjectMixin
-from django.views.generic.edit import CreateView, DeleteView, FormMixin, UpdateView
+from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
 from club.forms import (
-    ClubAddMemberForm,
     ClubAdminEditForm,
     ClubEditForm,
-    ClubOldMemberForm,
-    ClubRoleCreateForm,
-    ClubRoleFormSet,
-    ClubSearchForm,
-    JoinClubForm,
+    ClubMemberForm,
     MailingForm,
     SellingsForm,
 )
-from club.models import (
-    Club,
-    ClubLink,
-    ClubRole,
-    LinkType,
-    Mailing,
-    MailingSubscription,
-    Membership,
-)
-from com.models import Poster
+from club.models import Club, Mailing, MailingSubscription, Membership
 from com.views import (
     PosterCreateBaseView,
     PosterDeleteBaseView,
     PosterEditBaseView,
     PosterListBaseView,
 )
-from core.auth.mixins import CanEditMixin, PermissionOrClubBoardRequiredMixin
-from core.models import Page, PageRev
-from core.views import BasePageEditView, DetailFormView, UseFragmentsMixin
-from core.views.mixins import (
-    AllowFragment,
-    FragmentMixin,
-    FragmentRenderer,
-    TabedViewMixin,
-)
+from core.auth.mixins import CanCreateMixin, CanEditMixin, CanViewMixin
+from core.models import PageRev
+from core.views import DetailFormView, PageEditViewBase
+from core.views.mixins import TabedViewMixin
 from counter.models import Selling
 
-if TYPE_CHECKING:
-    from django.utils.safestring import SafeString
-
 
 class ClubTabsMixin(TabedViewMixin):
     def get_tabs_title(self):
-        if not hasattr(self, "object") or not self.object:
-            self.object = self.get_object()
-        if isinstance(self.object, PageRev):
-            self.object = self.object.page.club
-        elif isinstance(self.object, Poster):
-            self.object = self.object.club
-        elif hasattr(self, "club"):
-            self.object = self.club
+        obj = self.get_object()
+        if isinstance(obj, PageRev):
+            self.object = obj.page.club
         return self.object.get_display_name()
 
     def get_list_of_tabs(self):
@@ -113,7 +79,7 @@ class ClubTabsMixin(TabedViewMixin):
                 "name": _("Infos"),
             }
         ]
-        if self.request.user.has_perm("club.view_club"):
+        if self.request.user.can_view(self.object):
             tab_list.extend(
                 [
                     {
@@ -193,50 +159,22 @@ class ClubTabsMixin(TabedViewMixin):
                             "club:poster_list", kwargs={"club_id": self.object.id}
                         ),
                         "slug": "posters",
-                        "name": _("Posters"),
+                        "name": _("Posters list"),
                     },
                 ]
             )
         return tab_list
 
 
-class ClubListView(AllowFragment, FormMixin, ListView):
-    """List the clubs of the AE, with a form to perform basic search.
-
-    Notes:
-        This view is fully public, because we want to advertise as much as possible
-        the cultural life of the AE.
-        In accordance with that matter, searching and listing the clubs is done
-        entirely server-side (no AlpineJS involved) ;
-        this is done this way in order to be sure the page is the most accessible
-        and SEO-friendly possible, even if it makes the UX slightly less smooth.
-    """
+class ClubListView(ListView):
+    """List the Clubs."""
 
+    model = Club
     template_name = "club/club_list.jinja"
-    form_class = ClubSearchForm
-    queryset = Club.objects.prefetch_related(
-        Prefetch("links", queryset=ClubLink.objects.select_related("link_type"))
-    ).order_by("name")
-    paginate_by = 20
-
-    def get_form_kwargs(self):
-        res = super().get_form_kwargs()
-        # if request.GET is empty, the form will interpret club_status as None,
-        # even though we want it to be initially True,
-        # so we force a defaut True value.
-        res["data"] = {"club_status": True} | self.request.GET.dict()
-        return res
-
-    def get_queryset(self):
-        form: ClubSearchForm = self.get_form()
-        qs = self.queryset
-        if not form.is_valid():
-            return qs.none()
-        if name := form.cleaned_data.get("name"):
-            qs = qs.filter(name__icontains=name)
-        if (is_active := form.cleaned_data.get("club_status")) is not None:
-            qs = qs.filter(is_active=is_active)
-        return qs
+    queryset = (
+        Club.objects.filter(parent=None).order_by("name").prefetch_related("children")
+    )
+    context_object_name = "club_list"
 
 
 class ClubView(ClubTabsMixin, DetailView):
@@ -255,11 +193,10 @@ class ClubView(ClubTabsMixin, DetailView):
             .values_list("content", flat=True)
             .first()
         )
-        kwargs["links"] = list(self.object.links.select_related("link_type").all())
         return kwargs
 
 
-class ClubRevView(LoginRequiredMixin, ClubView):
+class ClubRevView(ClubView):
     """Display a specific page revision."""
 
     def dispatch(self, request, *args, **kwargs):
@@ -273,32 +210,31 @@ class ClubRevView(LoginRequiredMixin, ClubView):
         return kwargs
 
 
-class ClubPageEditView(ClubTabsMixin, BasePageEditView):
+class ClubPageEditView(ClubTabsMixin, PageEditViewBase):
     template_name = "club/pagerev_edit.jinja"
     current_tab = "page_edit"
 
-    @cached_property
-    def club(self):
-        return get_object_or_404(Club, pk=self.kwargs["club_id"])
+    def dispatch(self, request, *args, **kwargs):
+        self.club = get_object_or_404(Club, pk=kwargs["club_id"])
+        if not self.club.page:
+            raise Http404
+        return super().dispatch(request, *args, **kwargs)
 
-    @cached_property
-    def page(self) -> Page:
-        page = self.club.page
-        page.set_lock(self.request.user)
-        return page
+    def get_object(self):
+        self.page = self.club.page
+        return self._get_revision()
 
     def get_success_url(self, **kwargs):
         return reverse_lazy("club:club_view", kwargs={"club_id": self.club.id})
 
 
-class ClubPageHistView(ClubTabsMixin, PermissionRequiredMixin, DetailView):
-    """Modification history of the page."""
+class ClubPageHistView(ClubTabsMixin, CanViewMixin, DetailView):
+    """Modification hostory of the page."""
 
     model = Club
     pk_url_kwarg = "club_id"
     template_name = "club/page_history.jinja"
     current_tab = "history"
-    permission_required = "club.view_club"
 
 
 class ClubToolsView(ClubTabsMixin, CanEditMixin, DetailView):
@@ -310,238 +246,61 @@ class ClubToolsView(ClubTabsMixin, CanEditMixin, DetailView):
     current_tab = "tools"
 
 
-class ClubAddMembersFragment(
-    FragmentMixin, PermissionRequiredMixin, SuccessMessageMixin, CreateView
-):
-    template_name = "club/fragments/add_member.jinja"
-    model = Membership
-    object = None
-    reload_on_redirect = True
-    permission_required = "club.view_club"
-
-    def dispatch(self, *args, **kwargs):
-        self.club = get_object_or_404(Club, pk=kwargs.get("club_id"))
-        return super().dispatch(*args, **kwargs)
-
-    def get_form_class(self):
-        user = self.request.user
-        if user.has_perm("club.add_membership") or self.club.get_membership_for(user):
-            return ClubAddMemberForm
-        return JoinClubForm
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "request_user": self.request.user,
-            "club": self.club,
-        }
-
-    def render_fragment(self, request, **kwargs) -> SafeString:
-        self.club = kwargs.get("club")
-        return super().render_fragment(request, **kwargs)
-
-    def get_success_url(self):
-        return reverse("club:club_members", kwargs={"club_id": self.club.id})
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
-
-    def get_success_message(self, cleaned_data):
-        if "user" not in cleaned_data or cleaned_data["user"] == self.request.user:
-            return _("You are now a member of this club.")
-        return _("%(user)s has been added to club.") % cleaned_data
-
-
-class ClubMembersView(
-    ClubTabsMixin, UseFragmentsMixin, PermissionRequiredMixin, DetailFormView
-):
+class ClubMembersView(ClubTabsMixin, CanViewMixin, DetailFormView):
     """View of a club's members."""
 
     model = Club
     pk_url_kwarg = "club_id"
-    form_class = ClubOldMemberForm
+    form_class = ClubMemberForm
     template_name = "club/club_members.jinja"
     current_tab = "members"
-    permission_required = "club.view_club"
 
-    def get_fragments(self) -> dict[str, type[FragmentMixin] | FragmentRenderer]:
-        membership = self.object.get_membership_for(self.request.user)
-        if (
-            membership
-            and not membership.role.is_board
-            and not self.request.user.has_perm("club.add_membership")
-        ):
-            # Simple club members won't see the form anymore.
-            # Even if they saw it, they couldn't add anyone to the club anyway
-            return {}
-        return {"add_member_fragment": ClubAddMembersFragment}
-
-    def get_fragment_data(self) -> dict[str, Any]:
-        return {"add_member_fragment": {"club": self.object}}
+    @cached_property
+    def members(self) -> list[Membership]:
+        return list(self.object.members.ongoing().order_by("-role"))
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "user": self.request.user,
-            "club": self.object,
-        }
+        kwargs = super().get_form_kwargs()
+        kwargs["request_user"] = self.request.user
+        kwargs["club"] = self.object
+        kwargs["club_members"] = self.members
+        return kwargs
 
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)
-        editable = list(
-            kwargs["form"].fields["members_old"].queryset.values_list("id", flat=True)
-        )
-        kwargs["members"] = list(
-            self.object.members.ongoing()
-            .annotate(is_editable=Q(id__in=editable))
-            .order_by("role__order")
-            .select_related("user", "role")
-        )
-        kwargs["can_end_membership"] = len(editable) > 0
+        kwargs["members"] = self.members
         return kwargs
 
     def form_valid(self, form):
-        for membership in form.cleaned_data.get("members_old"):
-            membership.end_date = now()
+        """Check user rights."""
+        resp = super().form_valid(form)
+
+        data = form.clean()
+        users = data.pop("users", [])
+        users_old = data.pop("users_old", [])
+        for user in users:
+            Membership(club=self.object, user=user, **data).save()
+        for user in users_old:
+            membership = self.object.get_membership_for(user)
+            membership.end_date = timezone.now()
             membership.save()
-        return super().form_valid(form)
+        return resp
 
     def get_success_url(self, **kwargs):
         return self.request.path
 
 
-class ClubOldMembersView(ClubTabsMixin, PermissionRequiredMixin, DetailView):
+class ClubOldMembersView(ClubTabsMixin, CanViewMixin, DetailView):
     """Old members of a club."""
 
     model = Club
     pk_url_kwarg = "club_id"
     template_name = "club/club_old_members.jinja"
     current_tab = "elderlies"
-    permission_required = "club.view_club"
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "old_members": (
-                self.object.members.exclude(end_date=None)
-                .order_by("role__order", "description", "-end_date")
-                .select_related("user", "role")
-            )
-        }
-
-
-class ClubRoleUpdateView(
-    ClubTabsMixin, UserPassesTestMixin, SuccessMessageMixin, UpdateView
-):
-    form_class = ClubRoleFormSet
-    model = Club
-    template_name = "club/club_roles.jinja"
-    pk_url_kwarg = "club_id"
-    current_tab = "members"
-    success_message = _("Club roles updated")
-
-    @cached_property
-    def club(self) -> Club:
-        return self.get_object()
-
-    def test_func(self):
-        return self.club.can_roles_be_edited_by(self.request.user)
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"form_kwargs": {"label_suffix": ""}}
-
-    def get_success_url(self):
-        return reverse("club:club_members", kwargs={"club_id": self.club.id})
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "user_role": ClubRole.objects.filter(
-                club=self.club,
-                members__user=self.request.user,
-                members__end_date=None,
-            )
-            .values_list("id", flat=True)
-            .first()
-        }
-
-
-class ClubRoleBaseCreateView(UserPassesTestMixin, SuccessMessageMixin, CreateView):
-    """View to create a new Club Role, using [][club.forms.ClubRoleCreateForm].
-
-    This view isn't meant to be called directly, but rather subclassed for each
-    type of role that can exist :
-
-    - `[ClubRolePresidencyCreateView][club.views.ClubRolePresidencyCreateView]`
-      to create a presidency role
-    - `[ClubRoleBoardCreateView][club.views.ClubRoleBoardCreateView]`
-      to create a board role
-    - `[ClubRoleMemberCreateView][club.views.ClubRoleMemberCreateView]`
-      to create a member role
-
-    Each subclass have to override the following variables :
-
-    - `is_presidency` and `is_board`, indicating what type of role
-      the view creates.
-    - `role_description`, which is the title of the page, indication
-       the user what kind of role is being created.
-
-    This way, we are making sure the correct type of role will
-    be created, without bothering the user with the implementation details.
-    """
-
-    form_class = ClubRoleCreateForm
-    model = ClubRole
-    template_name = "core/create.jinja"
-    success_message = _("Role %(name)s created")
-    role_description = ""
-    is_presidency: bool
-    is_board: bool
-
-    @cached_property
-    def club(self):
-        return get_object_or_404(Club, id=self.kwargs["club_id"])
-
-    def test_func(self):
-        return self.request.user.is_authenticated and (
-            self.request.user.has_perm("club.add_clubrole")
-            or self.club.members.filter(
-                user=self.request.user, role__is_presidency=True
-            ).exists()
-        )
-
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {
-            "club": self.club,
-            "is_presidency": self.is_presidency,
-            "is_board": self.is_board,
-        }
-
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "object_name": self.role_description
-        }
-
-    def get_success_url(self):
-        return reverse("club:club_roles", kwargs={"club_id": self.club.id})
-
-
-class ClubRolePresidencyCreateView(ClubRoleBaseCreateView):
-    is_presidency = True
-    is_board = True
-    role_description = _("club role \u2013 presidency")
-
-
-class ClubRoleBoardCreateView(ClubRoleBaseCreateView):
-    is_presidency = False
-    is_board = True
-    role_description = _("club role \u2013 board")
-
-
-class ClubRoleMemberCreateView(ClubRoleBaseCreateView):
-    is_presidency = False
-    is_board = False
-    role_description = _("club role \u2013 member")
 
 
 class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
-    """Sales of a club."""
+    """Sellings of a club."""
 
     model = Club
     pk_url_kwarg = "club_id"
@@ -567,28 +326,45 @@ class ClubSellingView(ClubTabsMixin, CanEditMixin, DetailFormView):
 
     def get_context_data(self, **kwargs):
         kwargs = super().get_context_data(**kwargs)
+        qs = Selling.objects.filter(club=self.object)
 
-        kwargs["result"] = Selling.objects.none()
+        kwargs["result"] = qs[:0]
+        kwargs["paginated_result"] = kwargs["result"]
         kwargs["total"] = 0
         kwargs["total_quantity"] = 0
         kwargs["benefit"] = 0
 
-        form: SellingsForm = self.get_form()
-        if form.is_valid() and any(v for v in form.cleaned_data.values()):
-            filters = form.to_filter_schema()
-            qs = filters.filter(Selling.objects.filter(club=self.object))
-            kwargs["total"] = qs.annotate(
-                price=F("quantity") * F("unit_price")
-            ).aggregate(total=Sum("price", default=0))["total"]
-            kwargs["result"] = qs.select_related(
-                "counter", "counter__club", "customer", "customer__user", "seller"
-            ).order_by("-id")
-            kwargs["total_quantity"] = qs.aggregate(total=Sum("quantity", default=0))[
-                "total"
-            ]
-            kwargs["benefit"] = qs.exclude(product=None).aggregate(
-                res=Sum("product__purchase_price", default=0)
-            )["res"]
+        form = self.get_form()
+        if form.is_valid():
+            if not len([v for v in form.cleaned_data.values() if v is not None]):
+                qs = Selling.objects.filter(id=-1)
+            if form.cleaned_data["begin_date"]:
+                qs = qs.filter(date__gte=form.cleaned_data["begin_date"])
+            if form.cleaned_data["end_date"]:
+                qs = qs.filter(date__lte=form.cleaned_data["end_date"])
+
+            if form.cleaned_data["counters"]:
+                qs = qs.filter(counter__in=form.cleaned_data["counters"])
+
+            selected_products = []
+            if form.cleaned_data["products"]:
+                selected_products.extend(form.cleaned_data["products"])
+            if form.cleaned_data["archived_products"]:
+                selected_products.extend(form.cleaned_data["archived_products"])
+
+            if len(selected_products) > 0:
+                qs = qs.filter(product__in=selected_products)
+
+            kwargs["result"] = qs.all().order_by("-id")
+            kwargs["total"] = sum([s.quantity * s.unit_price for s in kwargs["result"]])
+            total_quantity = qs.all().aggregate(Sum("quantity"))
+            if total_quantity["quantity__sum"]:
+                kwargs["total_quantity"] = total_quantity["quantity__sum"]
+            benefit = (
+                qs.exclude(product=None).all().aggregate(Sum("product__purchase_price"))
+            )
+            if benefit["product__purchase_price__sum"]:
+                kwargs["benefit"] = benefit["product__purchase_price__sum"]
 
         kwargs["paginator"] = Paginator(kwargs["result"], self.paginate_by)
         try:
@@ -623,15 +399,15 @@ class ClubSellingCSVView(ClubSellingView):
             *row,
             selling.label,
             selling.quantity,
-            selling.unit_price,
             selling.quantity * selling.unit_price,
             selling.get_payment_method_display(),
         ]
         if selling.product:
+            row.append(selling.product.selling_price)
             row.append(selling.product.purchase_price)
-            row.append(selling.unit_price - selling.product.purchase_price)
+            row.append(selling.product.selling_price - selling.product.purchase_price)
         else:
-            row = [*row, "", ""]
+            row = [*row, "", "", ""]
         return row
 
     def get(self, request, *args, **kwargs):
@@ -639,40 +415,40 @@ class ClubSellingCSVView(ClubSellingView):
         kwargs = self.get_context_data(**kwargs)
 
         # Use the StreamWriter class instead of request for streaming
-        writer = csv.writer(self.StreamWriter())
+        pseudo_buffer = self.StreamWriter()
+        writer = csv.writer(
+            pseudo_buffer, delimiter=";", lineterminator="\n", quoting=csv.QUOTE_ALL
+        )
 
-        first_rows = [
-            [gettext("Quantity"), kwargs["total_quantity"]],
-            [gettext("Total"), kwargs["total"]],
-            [gettext("Benefit"), kwargs["benefit"]],
+        writer.writerow([_t("Quantity"), kwargs["total_quantity"]])
+        writer.writerow([_t("Total"), kwargs["total"]])
+        writer.writerow([_t("Benefit"), kwargs["benefit"]])
+        writer.writerow(
             [
-                gettext("Date"),
-                gettext("Counter"),
-                gettext("Barman"),
-                gettext("Customer"),
-                gettext("Label"),
-                gettext("Quantity"),
-                gettext("Unit price"),
-                gettext("Total"),
-                gettext("Payment method"),
-                gettext("Purchase price"),
-                gettext("Benefit"),
-            ],
+                _t("Date"),
+                _t("Counter"),
+                _t("Barman"),
+                _t("Customer"),
+                _t("Label"),
+                _t("Quantity"),
+                _t("Total"),
+                _t("Payment method"),
+                _t("Selling price"),
+                _t("Purchase price"),
+                _t("Benefit"),
             ]
+        )
 
         # Stream response
         response = StreamingHttpResponse(
-            itertools.chain(
-                (writer.writerow(r) for r in first_rows),
             (
                 writer.writerow(self.write_selling(selling))
                 for selling in kwargs["result"]
             ),
-            ),
             content_type="text/csv",
         )
-        name = f"{gettext('Sellings')}_{self.object.name}.csv"
-        response["Content-Disposition"] = f"attachment; filename={name}"
+        name = _("Sellings") + "_" + self.object.name + ".csv"
+        response["Content-Disposition"] = "filename=" + name
 
         return response
 
@@ -696,11 +472,6 @@ class ClubEditView(ClubTabsMixin, CanEditMixin, UpdateView):
             return ClubAdminEditForm
         return ClubEditForm
 
-    def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "link_types": list(LinkType.objects.order_by(Length("url_base").desc()))
-        }
-
 
 class ClubCreateView(PermissionRequiredMixin, CreateView):
     """Create a club (for the Sith admin)."""
@@ -711,23 +482,34 @@ class ClubCreateView(PermissionRequiredMixin, CreateView):
     template_name = "core/create.jinja"
     permission_required = "club.add_club"
 
-    def form_valid(self, form):
-        res = super().form_valid(form)
-        self.object.create_default_roles()
-        return res
 
-
-class MembershipSetOldView(CanEditMixin, SingleObjectMixin, View):
-    """Set a membership as being old."""
+class MembershipSetOldView(CanEditMixin, DetailView):
+    """Set a membership as beeing old."""
 
     model = Membership
     pk_url_kwarg = "membership_id"
 
-    def post(self, *_args, **_kwargs):
+    def get(self, request, *args, **kwargs):
         self.object = self.get_object()
         self.object.end_date = timezone.now()
         self.object.save()
-        return redirect("core:user_clubs", user_id=self.object.user_id)
+        return HttpResponseRedirect(
+            reverse(
+                "club:club_members",
+                args=self.args,
+                kwargs={"club_id": self.object.club.id},
+            )
+        )
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        return HttpResponseRedirect(
+            reverse(
+                "club:club_members",
+                args=self.args,
+                kwargs={"club_id": self.object.club.id},
+            )
+        )
 
 
 class MembershipDeleteView(PermissionRequiredMixin, DeleteView):
@@ -739,7 +521,7 @@ class MembershipDeleteView(PermissionRequiredMixin, DeleteView):
     permission_required = "club.delete_membership"
 
     def get_success_url(self):
-        return reverse_lazy("core:user_clubs", kwargs={"user_id": self.object.user_id})
+        return reverse_lazy("core:user_clubs", kwargs={"user_id": self.object.user.id})
 
 
 class ClubMailingView(ClubTabsMixin, CanEditMixin, DetailFormView):
@@ -896,64 +678,56 @@ class MailingAutoGenerationView(View):
     def get(self, request, *args, **kwargs):
         club = self.mailing.club
         self.mailing.subscriptions.all().delete()
-        members = club.members.ongoing().filter(role__is_board=True)
+        members = club.members.filter(
+            role__gte=settings.SITH_CLUB_ROLES_ID["Board member"]
+        ).exclude(end_date__lte=timezone.now())
         for member in members.all():
             MailingSubscription(user=member.user, mailing=self.mailing).save()
         return redirect("club:mailing", club_id=club.id)
 
 
-class PosterListView(
-    PermissionOrClubBoardRequiredMixin, ClubTabsMixin, PosterListBaseView
-):
+class PosterListView(ClubTabsMixin, PosterListBaseView, CanViewMixin):
     """List communication posters."""
 
-    current_tab = "posters"
-    permission_required = "com.view_poster"
-
-    def get_queryset(self):
-        return super().get_queryset().filter(club=self.club.id)
-
     def get_object(self):
         return self.club
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "create_url": reverse_lazy(
-                "club:poster_create", kwargs={"club_id": self.club.id}
-            ),
-            "get_edit_url": lambda poster: reverse(
-                "club:poster_edit",
-                kwargs={"club_id": self.club.id, "poster_id": poster.id},
-            ),
-        }
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "club"
+        kwargs["club"] = self.club
+        return kwargs
 
 
-class PosterCreateView(ClubTabsMixin, PosterCreateBaseView):
+class PosterCreateView(PosterCreateBaseView, CanCreateMixin):
     """Create communication poster."""
 
-    current_tab = "posters"
+    pk_url_kwarg = "club_id"
+
+    def get_object(self):
+        obj = super().get_object()
+        if not obj:
+            return self.club
+        return obj
 
     def get_success_url(self, **kwargs):
         return reverse_lazy("club:poster_list", kwargs={"club_id": self.club.id})
 
-    def get_object(self, *args, **kwargs):
-        return self.club
 
-
-class PosterEditView(ClubTabsMixin, PosterEditBaseView):
+class PosterEditView(ClubTabsMixin, PosterEditBaseView, CanEditMixin):
     """Edit communication poster."""
 
-    current_tab = "posters"
-    extra_context = {"app": "club"}
-
     def get_success_url(self):
         return reverse_lazy("club:poster_list", kwargs={"club_id": self.club.id})
 
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "club"
+        return kwargs
 
-class PosterDeleteView(ClubTabsMixin, PosterDeleteBaseView):
+
+class PosterDeleteView(PosterDeleteBaseView, ClubTabsMixin, CanEditMixin):
     """Delete communication poster."""
 
-    current_tab = "posters"
-
     def get_success_url(self):
         return reverse_lazy("club:poster_list", kwargs={"club_id": self.club.id})

com/api.py

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

com/forms.py

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

com/ics_calendar.py

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

com/models.py

@@ -144,7 +144,7 @@ class News(models.Model):
                 ),
                 groups__id=settings.SITH_GROUP_COM_ADMIN_ID,
             )
-            notif_url = reverse("com:news_admin_list", fragment="moderation")
+            notif_url = reverse("com:news_admin_list")
             new_notifs = [
                 Notification(user=user, url=notif_url, type="NEWS_MODERATION")
                 for user in admins_without_notif
@@ -402,7 +402,9 @@ class Poster(models.Model):
                 groups__id__in=[settings.SITH_GROUP_COM_ADMIN_ID]
             ):
                 Notification.objects.create(
-                    user=user, url=reverse("com:poster_list"), type="POSTER_MODERATION"
+                    user=user,
+                    url=reverse("com:poster_moderate_list"),
+                    type="POSTER_MODERATION",
                 )
         return super().save(*args, **kwargs)
 
@@ -410,5 +412,17 @@ class Poster(models.Model):
         if self.date_end and self.date_begin > self.date_end:
             raise ValidationError(_("Begin date should be before end date"))
 
+    def is_owned_by(self, user):
+        if user.is_anonymous:
+            return False
+        return user.is_com_admin or len(user.clubs_with_rights) > 0
+
+    def can_be_moderated_by(self, user):
+        return user.is_com_admin
+
     def get_display_name(self):
         return self.club.get_display_name()
+
+    @property
+    def page(self):
+        return self.club.page

com/schemas.py

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

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

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

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

@@ -1,3 +1,4 @@
+import { exportToHtml } from "#core:utils/globals";
 import { newsDeleteNews, newsFetchNewsDates, newsPublishNews } from "#openapi";
 
 // This will be used in jinja templates,
@@ -12,8 +13,7 @@ const AlertState = {
   // biome-ignore lint/style/useNamingConvention: this feels more like an enum
   DISPLAYED: 4, // When published at page generation
 };
-// biome-ignore lint/style/useNamingConvention: it's an enum, PascalCase is better
-Object.assign(window, { AlertState });
+exportToHtml("AlertState", AlertState);
 
 document.addEventListener("alpine:init", () => {
   Alpine.data("moderationAlert", (newsId: number) => ({

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

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

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

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

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

@@ -3,7 +3,6 @@
 
 #news {
   display: flex;
-  gap: 1em;
 
   @media (max-width: 800px) {
     flex-direction: column;
@@ -16,13 +15,9 @@
   #right_column {
     flex: 20%;
     margin: 3.2px;
+
     display: inline-block;
     vertical-align: top;
-
-    @media screen and (min-width: 800px) {
-      max-width: 20%;
-      min-width: 200px;
-    }
   }
 
   #left_column {
@@ -31,14 +26,12 @@
   }
 
   h3 {
-    --box-shadow: rgb(60 64 67 / 30%) 0 1px 3px 0, rgb(60 64 67 / 15%) 0 3px 7px 2px;
-    background: lighten($second-color, 5%);
-    box-shadow: var(--box-shadow);
-    padding: .75rem;
+    background: $second-color;
+    box-shadow: $shadow-color 1px 1px 1px;
+    padding: 0.4em;
     margin: 0 0 0.5em 0;
     text-transform: uppercase;
     font-size: 17px;
-    border-radius: 10px;
 
     &:not(:first-of-type) {
       margin: 2em 0 1em 0;
@@ -46,11 +39,12 @@
 
     .feed {
       float: right;
-      color: #e25512;
+      color: #f26522;
     }
   }
 
-  @media screen and (max-width: 800px) {
+  @media screen and (max-width: $small-devices) {
+
     #left_column,
     #right_column {
       flex: 100%;
@@ -63,7 +57,6 @@
     max-height: 600px;
     overflow-y: scroll;
     overflow-x: clip;
-    margin-top: 1em;
 
     #load-more-news-button {
       text-align: center;
@@ -80,14 +73,17 @@
     display: block;
     width: 100%;
     background: white;
+    font-size: 70%;
     margin-bottom: 1em;
-    font-size: 85%;
+
+    h3 {
+      margin-bottom: 0;
+    }
 
     #links_content {
       overflow: auto;
       box-shadow: $shadow-color 1px 1px 1px;
-      min-height: 20em;
-      padding: 1em;
+      height: 20em;
 
       h4 {
         margin-left: 5px;
@@ -100,10 +96,23 @@
         li {
           margin: 10px;
 
+          .fa-facebook {
+            color: $faceblue;
+          }
+
+          .fa-discord {
+            color: $discordblurple;
+          }
+
+          .fa-square-instagram::before {
+            background: $instagradient;
+            background-clip: text;
+            -webkit-text-fill-color: transparent;
+          }
+
           i {
             width: 25px;
             text-align: center;
-            margin-right: .5rem;
           }
         }
       }
@@ -111,15 +120,12 @@
     }
 
     #birthdays_content {
-      box-shadow: $shadow-color 1px 1px 1px;
-      padding: 1em;
-
       ul.birthdays_year {
         margin: 0;
         list-style-type: none;
         font-weight: bold;
 
-        > li {
+        >li {
           padding: 0.5em;
 
           &:nth-child(even) {
@@ -128,7 +134,8 @@
         }
 
         ul {
-          margin: .5em 0 0 1em;
+          margin: 0;
+          margin-left: 1em;
           list-style-type: square;
           list-style-position: inside;
           font-weight: normal;
@@ -142,13 +149,9 @@
   /* EVENTS TODAY AND NEXT FEW DAYS */
   .news_events_group {
     box-shadow: $shadow-color 1px 1px 1px;
-    margin-left: 0;
+    margin-left: 1em;
     margin-bottom: 0.5em;
 
-    @media screen and (max-width: $small-devices) {
-      margin-left: 3px;
-    }
-
     .news_events_group_date {
       display: table-cell;
       padding: 0.6em;

com/static/com/css/posters.scss

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

com/static/com/js/poster_list.js

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

com/static/com/js/slideshow.js

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

com/static/css/slideshow.scss

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

com/templates/com/macros.jinja

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

com/templates/com/news_admin_list.jinja

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

com/templates/com/news_detail.jinja

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

com/templates/com/news_list.jinja

@@ -23,7 +23,7 @@
         <a target="#" href="{{ url("com:news_feed") }}"><i class="fa fa-rss feed"></i></a>
       </h3>
       {% if user.is_authenticated and (user.is_com_admin or user.memberships.board().ongoing().exists()) %}
-        <a class="btn btn-blue" href="{{ url("com:news_new") }}">
+        <a class="btn btn-blue margin-bottom" href="{{ url("com:news_new") }}">
           <i class="fa fa-plus"></i>
           {% trans %}Create news{% endtrans %}
         </a>
@@ -203,15 +203,11 @@
           <ul>
             <li>
               <i class="fa-solid fa-graduation-cap fa-xl"></i>
-              <a href="{{ url("pedagogy:guide") }}">{% trans %}UE Guide{% endtrans %}</a>
-            </li>
-            <li>
-              <i class="fa-solid fa-calendar-days fa-xl"></i>
-              <a href="{{ url("timetable:generator") }}">{% trans %}Timetable{% endtrans %}</a>
+              <a href="{{ url("pedagogy:guide") }}">{% trans %}UV Guide{% endtrans %}</a>
             </li>
             <li>
               <i class="fa-solid fa-magnifying-glass fa-xl"></i>
-              <a href="{{ url("matmat:search") }}">{% trans %}Matmatronch{% endtrans %}</a>
+              <a href="{{ url("matmat:search_clear") }}">{% trans %}Matmatronch{% endtrans %}</a>
             </li>
             <li>
               <i class="fa-solid fa-check-to-slot fa-xl"></i>

com/templates/com/poster_list.jinja

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

com/templates/com/poster_moderate.jinja

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

com/templates/com/screen_slideshow.jinja

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

com/templates/com/weekmail.jinja

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

com/tests/test_api.py

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

com/tests/test_notifications.py

@@ -7,7 +7,7 @@ from model_bakery import baker
 
 from com.models import News, NewsDate
 from core.baker_recipes import subscriber_user
-from core.models import Group, Notification, SithFile, User
+from core.models import Group, Notification, User
 
 
 @pytest.mark.django_db
@@ -18,7 +18,6 @@ def test_notification_created():
     past_news = baker.make(News, is_published=False)
     baker.make(NewsDate, news=past_news, start_date=now() - timedelta(days=1))
     com_admin_group = Group.objects.get(pk=settings.SITH_GROUP_COM_ADMIN_ID)
-    SithFile.objects.filter(owner__in=com_admin_group.users.all()).delete()
     com_admin_group.users.all().delete()
     Notification.objects.all().delete()
     com_admin = baker.make(User, groups=[com_admin_group])

com/tests/test_views.py

@@ -17,22 +17,20 @@ from unittest.mock import patch
 
 import pytest
 from django.conf import settings
-from django.contrib.auth.models import Permission
 from django.contrib.sites.models import Site
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import Client, TestCase
 from django.urls import reverse
 from django.utils import html
-from django.utils.timezone import now
+from django.utils.timezone import localtime, now
 from django.utils.translation import gettext as _
 from model_bakery import baker
 from pytest_django.asserts import assertNumQueries, assertRedirects
 
-from club.models import Club, 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
-from core.utils import RED_PIXEL_PNG
 
 
 @pytest.fixture()
@@ -209,13 +207,37 @@ class TestWeekmailArticle(TestCase):
         assert not self.article.is_owned_by(self.sli)
 
 
+class TestPoster(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.com_admin = User.objects.get(username="comunity")
+        cls.poster = Poster.objects.create(
+            name="dummy",
+            file=SimpleUploadedFile("dummy.jpg", b"azertyuiop"),
+            club=Club.objects.first(),
+            date_begin=localtime(now()),
+        )
+        cls.sli = User.objects.get(username="sli")
+        cls.sli.memberships.all().delete()
+        Membership(user=cls.sli, club=Club.objects.first(), role=5).save()
+        cls.susbcriber = User.objects.get(username="subscriber")
+        cls.anonymous = AnonymousUser()
+
+    def test_poster_owner(self):
+        """Test that poster are owned by com admins and board members in clubs."""
+        assert self.poster.is_owned_by(self.com_admin)
+        assert not self.poster.is_owned_by(self.anonymous)
+
+        assert not self.poster.is_owned_by(self.susbcriber)
+        assert self.poster.is_owned_by(self.sli)
+
+
 class TestNewsCreation(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.club = baker.make(Club)
         cls.user = subscriber_user.make()
-        role = baker.make(ClubRole, club=cls.club, is_board=True)
-        baker.make(Membership, user=cls.user, club=cls.club, role=role)
+        baker.make(Membership, user=cls.user, club=cls.club, role=5)
 
     def setUp(self):
         self.client.force_login(self.user)
@@ -318,6 +340,7 @@ def test_feed(client: Client):
     [
         reverse("com:poster_list"),
         reverse("com:poster_create"),
+        reverse("com:poster_moderate_list"),
     ],
 )
 def test_poster_management_views_crash_test(client: Client, url: str):
@@ -328,37 +351,3 @@ def test_poster_management_views_crash_test(client: Client, url: str):
     client.force_login(user)
     res = client.get(url)
     assert res.status_code == 200
-
-
-@pytest.mark.django_db
-@pytest.mark.parametrize(
-    "referer",
-    [
-        None,
-        reverse("com:poster_list"),
-        reverse("club:poster_list", kwargs={"club_id": settings.SITH_MAIN_CLUB_ID}),
-    ],
-)
-def test_moderate_poster(client: Client, referer: str | None):
-    poster = baker.make(
-        Poster,
-        is_moderated=False,
-        file=SimpleUploadedFile("test.png", content=RED_PIXEL_PNG),
-        club_id=settings.SITH_MAIN_CLUB_ID,
-    )
-    user = baker.make(
-        User,
-        user_permissions=Permission.objects.filter(
-            codename__in=["view_poster", "moderate_poster"]
-        ),
-    )
-    client.force_login(user)
-    headers = {"REFERER": f"https://{settings.SITH_URL}{referer}"} if referer else {}
-    response = client.post(
-        reverse("com:poster_moderate", kwargs={"object_id": poster.id}), headers=headers
-    )
-    result_url = referer or reverse("com:poster_list")
-    assertRedirects(response, result_url)
-    poster.refresh_from_db()
-    assert poster.is_moderated
-    assert poster.moderator == user

com/urls.py

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

com/views.py

@@ -25,17 +25,13 @@ import itertools
 from datetime import date, timedelta
 from smtplib import SMTPRecipientsRefused
 from typing import Any
-from urllib.parse import urlparse
 
 from dateutil.relativedelta import relativedelta
 from django.conf import settings
-from django.contrib import messages
-from django.contrib.auth.mixins import (
-    PermissionRequiredMixin,
-)
+from django.contrib.auth.mixins import AccessMixin, PermissionRequiredMixin
 from django.contrib.syndication.views import Feed
 from django.core.exceptions import PermissionDenied, ValidationError
-from django.db.models import Exists, Max, OuterRef, Value
+from django.db.models import Max
 from django.forms.models import modelform_factory
 from django.http import HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect
@@ -46,7 +42,7 @@ from django.utils.translation import gettext_lazy as _
 from django.views.generic import DetailView, ListView, TemplateView, View
 from django.views.generic.edit import CreateView, DeleteView, UpdateView
 
-from club.models import Club, Mailing, Membership
+from club.models import Club, Mailing
 from com.forms import NewsDateForm, NewsForm, PosterForm
 from com.ics_calendar import IcsCalendar
 from com.models import News, NewsDate, Poster, Screen, Sith, Weekmail, WeekmailArticle
@@ -54,10 +50,9 @@ from core.auth.mixins import (
     CanEditPropMixin,
     CanViewMixin,
     PermissionOrAuthorRequiredMixin,
-    PermissionOrClubBoardRequiredMixin,
 )
 from core.models import User
-from core.views.mixins import TabedViewMixin
+from core.views.mixins import QuickNotifMixin, TabedViewMixin
 from core.views.widgets.markdown import MarkdownInput
 
 # Sith object
@@ -104,6 +99,13 @@ class ComTabsMixin(TabedViewMixin):
         ]
 
 
+class IsComAdminMixin(AccessMixin):
+    def dispatch(self, request, *args, **kwargs):
+        if not request.user.is_com_admin:
+            raise PermissionDenied
+        return super().dispatch(request, *args, **kwargs)
+
+
 class ComEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
     model = Sith
     template_name = "core/edit.jinja"
@@ -240,12 +242,12 @@ class NewsListView(TemplateView):
         if not self.request.user.has_perm("core.view_user"):
             return []
         return itertools.groupby(
-            User.objects.viewable_by(self.request.user)
-            .filter(
+            User.objects.filter(
                 date_of_birth__month=localdate().month,
                 date_of_birth__day=localdate().day,
-                role__in=["STUDENT", "FORMER STUDENT"],
+                is_subscriber_viewable=True,
             )
+            .filter(role__in=["STUDENT", "FORMER STUDENT"])
             .order_by("-date_of_birth"),
             key=lambda u: u.date_of_birth.year,
         )
@@ -335,7 +337,7 @@ class NewsFeed(Feed):
 # Weekmail
 
 
-class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
+class WeekmailPreviewView(ComTabsMixin, QuickNotifMixin, CanEditPropMixin, DetailView):
     model = Weekmail
     template_name = "com/weekmail_preview.jinja"
     success_url = reverse_lazy("com:weekmail")
@@ -347,11 +349,12 @@ class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
 
     def post(self, request, *args, **kwargs):
         self.object = self.get_object()
-        messages.success(self.request, _("Weekmail sent successfully"))
         if request.POST["send"] == "validate":
             try:
                 self.object.send()
-                return HttpResponseRedirect(reverse("com:weekmail"))
+                return HttpResponseRedirect(
+                    reverse("com:weekmail") + "?qn_weekmail_send_success"
+                )
             except SMTPRecipientsRefused as e:
                 self.bad_recipients = e.recipients
         elif request.POST["send"] == "clean":
@@ -362,6 +365,7 @@ class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
                 for u in users:
                     u.preferences.receive_weekmail = False
                     u.preferences.save()
+                self.quick_notif_list += ["qn_success"]
         return super().get(request, *args, **kwargs)
 
     def get_object(self, queryset=None):
@@ -375,7 +379,7 @@ class WeekmailPreviewView(ComTabsMixin, CanEditPropMixin, DetailView):
         return kwargs
 
 
-class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
+class WeekmailEditView(ComTabsMixin, QuickNotifMixin, CanEditPropMixin, UpdateView):
     model = Weekmail
     template_name = "com/weekmail.jinja"
     form_class = modelform_factory(
@@ -415,10 +419,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
                 art.rank, prev_art.rank = prev_art.rank, art.rank
                 art.save()
                 prev_art.save()
-                messages.success(
-                    self.request,
-                    _("%(title)s moved up in the Weekmail") % {"title": art.title},
-                )
+                self.quick_notif_list += ["qn_success"]
         if "down_article" in request.GET:
             art = get_object_or_404(
                 WeekmailArticle, id=request.GET["down_article"], weekmail=self.object
@@ -430,10 +431,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
                 art.rank, next_art.rank = next_art.rank, art.rank
                 art.save()
                 next_art.save()
-                messages.success(
-                    self.request,
-                    _("%(title)s moved down in the Weekmail") % {"title": art.title},
-                )
+                self.quick_notif_list += ["qn_success"]
         if "add_article" in request.GET:
             art = get_object_or_404(
                 WeekmailArticle, id=request.GET["add_article"], weekmail=None
@@ -442,10 +440,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
             art.rank = self.object.articles.aggregate(Max("rank"))["rank__max"] or 0
             art.rank += 1
             art.save()
-            messages.success(
-                self.request,
-                _("%(title)s added to the Weekmail") % {"title": art.title},
-            )
+            self.quick_notif_list += ["qn_success"]
         if "del_article" in request.GET:
             art = get_object_or_404(
                 WeekmailArticle, id=request.GET["del_article"], weekmail=self.object
@@ -453,10 +448,7 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
             art.weekmail = None
             art.rank = -1
             art.save()
-            messages.success(
-                self.request,
-                _("%(title)s removed from the Weekmail") % {"title": art.title},
-            )
+            self.quick_notif_list += ["qn_success"]
         return super().get(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
@@ -466,7 +458,9 @@ class WeekmailEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
         return kwargs
 
 
-class WeekmailArticleEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
+class WeekmailArticleEditView(
+    ComTabsMixin, QuickNotifMixin, CanEditPropMixin, UpdateView
+):
     """Edit an article."""
 
     model = WeekmailArticle
@@ -478,10 +472,11 @@ class WeekmailArticleEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
     pk_url_kwarg = "article_id"
     template_name = "core/edit.jinja"
     success_url = reverse_lazy("com:weekmail")
+    quick_notif_url_arg = "qn_weekmail_article_edit"
     current_tab = "weekmail"
 
 
-class WeekmailArticleCreateView(CreateView):
+class WeekmailArticleCreateView(QuickNotifMixin, CreateView):
     """Post an article."""
 
     model = WeekmailArticle
@@ -492,6 +487,7 @@ class WeekmailArticleCreateView(CreateView):
     )
     template_name = "core/create.jinja"
     success_url = reverse_lazy("core:user_tools")
+    quick_notif_url_arg = "qn_weekmail_new_article"
 
     def get_initial(self):
         if "club" not in self.request.GET:
@@ -503,7 +499,7 @@ class WeekmailArticleCreateView(CreateView):
         self.object = form.instance
         form.is_valid()  # Valid a first time to populate club field
         m = form.instance.club.get_membership_for(request.user)
-        if m is None or not m.role.is_board:
+        if m is None or m.role <= settings.SITH_MAXIMUM_FREE_ROLE:
             form.add_error(
                 "club",
                 ValidationError(
@@ -562,115 +558,161 @@ class MailingModerateView(View):
         raise PermissionDenied
 
 
-class PosterListBaseView(ListView):
+class PosterAdminViewMixin(IsComAdminMixin, ComTabsMixin):
+    current_tab = "posters"
+
+
+class PosterListBaseView(PosterAdminViewMixin, ListView):
     """List communication posters."""
 
+    current_tab = "posters"
     model = Poster
     template_name = "com/poster_list.jinja"
-    permission_required = "com.view_poster"
+
+    def dispatch(self, request, *args, **kwargs):
+        club_id = kwargs.pop("club_id", None)
+        self.club = None
+        if club_id:
+            self.club = get_object_or_404(Club, pk=club_id)
+        return super().dispatch(request, *args, **kwargs)
 
     def get_queryset(self):
-        qs = Poster.objects.prefetch_related("screens")
-        if self.request.user.has_perm("com.edit_poster"):
-            qs = qs.annotate(is_editable=Value(value=True))
+        if self.request.user.is_com_admin:
+            return Poster.objects.all().order_by("-date_begin")
         else:
-            qs = qs.annotate(
-                is_editable=Exists(
-                    Membership.objects.ongoing()
-                    .board()
-                    .filter(user=self.request.user, club=OuterRef("club_id"))
-                )
-            )
-        return qs.order_by("-date_begin")
+            return Poster.objects.filter(club=self.club.id)
+
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        if not self.request.user.is_com_admin:
+            kwargs["club"] = self.club
+        return kwargs
 
 
-class PosterCreateBaseView(PermissionOrClubBoardRequiredMixin, CreateView):
+class PosterCreateBaseView(PosterAdminViewMixin, CreateView):
     """Create communication poster."""
 
+    current_tab = "posters"
     form_class = PosterForm
     template_name = "core/create.jinja"
-    permission_required = "com.add_poster"
 
     def get_queryset(self):
         return Poster.objects.all()
 
-    def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"user": self.request.user}
+    def dispatch(self, request, *args, **kwargs):
+        if "club_id" in kwargs:
+            self.club = get_object_or_404(Club, pk=kwargs["club_id"])
+        return super().dispatch(request, *args, **kwargs)
 
-    def get_initial(self):
-        return {"club": self.club}
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs.update({"user": self.request.user})
+        return kwargs
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
+        kwargs = super().get_context_data(**kwargs)
+        if not self.request.user.is_com_admin:
+            kwargs["club"] = self.club
+        return kwargs
 
     def form_valid(self, form):
-        if self.request.user.has_perm("com.moderate_poster"):
+        if self.request.user.is_com_admin:
             form.instance.is_moderated = True
         return super().form_valid(form)
 
 
-class PosterEditBaseView(PermissionOrClubBoardRequiredMixin, UpdateView):
+class PosterEditBaseView(PosterAdminViewMixin, UpdateView):
     """Edit communication poster."""
 
     pk_url_kwarg = "poster_id"
+    current_tab = "posters"
     form_class = PosterForm
     template_name = "com/poster_edit.jinja"
-    permission_required = "com.change_poster"
+
+    def get_initial(self):
+        return {
+            "date_begin": self.object.date_begin.strftime("%Y-%m-%d %H:%M:%S")
+            if self.object.date_begin
+            else None,
+            "date_end": self.object.date_end.strftime("%Y-%m-%d %H:%M:%S")
+            if self.object.date_end
+            else None,
+        }
+
+    def dispatch(self, request, *args, **kwargs):
+        if kwargs.get("club_id"):
+            try:
+                self.club = Club.objects.get(pk=kwargs["club_id"])
+            except Club.DoesNotExist as e:
+                raise PermissionDenied from e
+        return super().dispatch(request, *args, **kwargs)
 
     def get_queryset(self):
         return Poster.objects.all()
 
     def get_form_kwargs(self):
-        return super().get_form_kwargs() | {"user": self.request.user}
+        kwargs = super().get_form_kwargs()
+        kwargs.update({"user": self.request.user})
+        return kwargs
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {"club": self.club}
+        kwargs = super().get_context_data(**kwargs)
+        if hasattr(self, "club"):
+            kwargs["club"] = self.club
+        return kwargs
 
     def form_valid(self, form):
-        if not self.request.user.has_perm("com.moderate_poster"):
+        if self.request.user.is_com_admin:
             form.instance.is_moderated = False
         return super().form_valid(form)
 
 
-class PosterDeleteBaseView(
-    PermissionOrClubBoardRequiredMixin, ComTabsMixin, DeleteView
-):
+class PosterDeleteBaseView(PosterAdminViewMixin, DeleteView):
     """Edit communication poster."""
 
     pk_url_kwarg = "poster_id"
     current_tab = "posters"
     model = Poster
     template_name = "core/delete_confirm.jinja"
-    permission_required = "com.delete_poster"
+
+    def dispatch(self, request, *args, **kwargs):
+        if kwargs.get("club_id"):
+            try:
+                self.club = Club.objects.get(pk=kwargs["club_id"])
+            except Club.DoesNotExist as e:
+                raise PermissionDenied from e
+        return super().dispatch(request, *args, **kwargs)
 
 
-class PosterListView(PermissionRequiredMixin, ComTabsMixin, PosterListBaseView):
+class PosterListView(PosterListBaseView):
     """List communication posters."""
 
-    current_tab = "posters"
-    extra_context = {
-        "create_url": reverse_lazy("com:poster_create"),
-        "get_edit_url": lambda poster: reverse(
-            "com:poster_edit", kwargs={"poster_id": poster.id}
-        ),
-    }
-    permission_required = "com.view_poster"
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
-class PosterCreateView(ComTabsMixin, PosterCreateBaseView):
+class PosterCreateView(PosterCreateBaseView):
     """Create communication poster."""
 
-    current_tab = "posters"
     success_url = reverse_lazy("com:poster_list")
-    extra_context = {"app": "com"}
+
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
-class PosterEditView(ComTabsMixin, PosterEditBaseView):
+class PosterEditView(PosterEditBaseView):
     """Edit communication poster."""
 
-    current_tab = "posters"
     success_url = reverse_lazy("com:poster_list")
-    extra_context = {"app": "com"}
+
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
 class PosterDeleteView(PosterDeleteBaseView):
@@ -679,37 +721,44 @@ class PosterDeleteView(PosterDeleteBaseView):
     success_url = reverse_lazy("com:poster_list")
 
 
-class PosterModerateView(PermissionRequiredMixin, ComTabsMixin, View):
-    """Moderate communication poster."""
+class PosterModerateListView(PosterAdminViewMixin, ListView):
+    """Moderate list communication poster."""
 
     current_tab = "posters"
-    permission_required = "com.moderate_poster"
-    extra_context = {"app": "com"}
+    model = Poster
+    template_name = "com/poster_moderate.jinja"
+    queryset = Poster.objects.filter(is_moderated=False).all()
 
-    def post(self, request, *args, **kwargs):
+    def get_context_data(self, **kwargs):
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
+
+
+class PosterModerateView(PosterAdminViewMixin, View):
+    """Moderate communication poster."""
+
+    def get(self, request, *args, **kwargs):
         obj = get_object_or_404(Poster, pk=kwargs["object_id"])
+        if obj.can_be_moderated_by(request.user):
             obj.is_moderated = True
             obj.moderator = request.user
             obj.save()
-        # The moderation request may be originated from a club context (/club/poster)
-        # or a global context (/com/poster),
-        # so the redirection URL will be the URL of the page that called this view,
-        # as long as the latter belongs to the sith.
-        referer = self.request.META.get("HTTP_REFERER")
-        if referer:
-            parsed = urlparse(referer)
-            if parsed.netloc == settings.SITH_URL:
-                return redirect(parsed.path)
-        return redirect("com:poster_list")
+            return redirect("com:poster_moderate_list")
+        raise PermissionDenied
+
+    def get_context_data(self, **kwargs):
+        kwargs = super(PosterModerateListView, self).get_context_data(**kwargs)
+        kwargs["app"] = "com"
+        return kwargs
 
 
-class ScreenListView(PermissionRequiredMixin, ComTabsMixin, ListView):
+class ScreenListView(IsComAdminMixin, ComTabsMixin, ListView):
     """List communication screens."""
 
     current_tab = "screens"
     model = Screen
     template_name = "com/screen_list.jinja"
-    permission_required = "com.view_screen"
 
 
 class ScreenSlideshowView(DetailView):
@@ -720,12 +769,12 @@ class ScreenSlideshowView(DetailView):
     template_name = "com/screen_slideshow.jinja"
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**kwargs) | {
-            "posters": self.object.active_posters()
-        }
+        kwargs = super().get_context_data(**kwargs)
+        kwargs["posters"] = self.object.active_posters()
+        return kwargs
 
 
-class ScreenCreateView(PermissionRequiredMixin, ComTabsMixin, CreateView):
+class ScreenCreateView(IsComAdminMixin, ComTabsMixin, CreateView):
     """Create communication screen."""
 
     current_tab = "screens"
@@ -733,10 +782,9 @@ class ScreenCreateView(PermissionRequiredMixin, ComTabsMixin, CreateView):
     fields = ["name"]
     template_name = "core/create.jinja"
     success_url = reverse_lazy("com:screen_list")
-    permission_required = "com.add_screen"
 
 
-class ScreenEditView(PermissionRequiredMixin, ComTabsMixin, UpdateView):
+class ScreenEditView(IsComAdminMixin, ComTabsMixin, UpdateView):
     """Edit communication screen."""
 
     pk_url_kwarg = "screen_id"
@@ -745,10 +793,9 @@ class ScreenEditView(PermissionRequiredMixin, ComTabsMixin, UpdateView):
     fields = ["name"]
     template_name = "com/screen_edit.jinja"
     success_url = reverse_lazy("com:screen_list")
-    permission_required = "com.change_screen"
 
 
-class ScreenDeleteView(PermissionRequiredMixin, ComTabsMixin, DeleteView):
+class ScreenDeleteView(IsComAdminMixin, ComTabsMixin, DeleteView):
     """Delete communication screen."""
 
     pk_url_kwarg = "screen_id"
@@ -756,4 +803,3 @@ class ScreenDeleteView(PermissionRequiredMixin, ComTabsMixin, DeleteView):
     model = Screen
     template_name = "core/delete_confirm.jinja"
     success_url = reverse_lazy("com:screen_list")
-    permission_required = "com.delete_screen"

core/admin.py

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

core/api.py

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

core/auth/mixins.py

@@ -24,18 +24,13 @@
 from __future__ import annotations
 
 import types
+import warnings
 from typing import TYPE_CHECKING, Any, LiteralString
 
 from django.contrib.auth.mixins import AccessMixin, PermissionRequiredMixin
 from django.core.exceptions import ImproperlyConfigured, PermissionDenied
-from django.http import Http404
-from django.shortcuts import get_object_or_404
-from django.utils.functional import cached_property
-from django.utils.translation import gettext as _
 from django.views.generic.base import View
 
-from club.models import Club
-
 if TYPE_CHECKING:
     from django.db.models import Model
 
@@ -146,6 +141,45 @@ class GenericContentPermissionMixinBuilder(View):
         return super().dispatch(request, *arg, **kwargs)
 
 
+class CanCreateMixin(View):
+    """Protect any child view that would create an object.
+
+    Raises:
+        PermissionDenied:
+            If the user has not the necessary permission
+            to create the object of the view.
+    """
+
+    def __init_subclass__(cls, **kwargs):
+        warnings.warn(
+            f"{cls.__name__} is deprecated and should be replaced "
+            "by other permission verification mecanism.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init_subclass__(**kwargs)
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            f"{self.__class__.__name__} is deprecated and should be replaced "
+            "by other permission verification mecanism.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
+
+    def dispatch(self, request, *arg, **kwargs):
+        if not request.user.is_authenticated:
+            raise PermissionDenied
+        return super().dispatch(request, *arg, **kwargs)
+
+    def form_valid(self, form):
+        obj = form.instance
+        if can_edit_prop(obj, self.request.user):
+            return super().form_valid(form)
+        raise PermissionDenied
+
+
 class CanEditPropMixin(GenericContentPermissionMixinBuilder):
     """Ensure the user has owner permissions on the child view object.
 
@@ -263,51 +297,3 @@ class PermissionOrAuthorRequiredMixin(PermissionRequiredMixin):
             self.author_field += "_id"
         author_id = getattr(obj, self.author_field, None)
         return author_id == self.request.user.id
-
-
-class PermissionOrClubBoardRequiredMixin(PermissionRequiredMixin):
-    """Require that the user has the required perm or is the board of the club.
-
-    This mixin can be used in any view that is called from a url
-    having a `club_id` kwarg.
-
-    Example:
-
-        In `urls.py` :
-        ```python
-        urlpatterns = [
-            path("foo/<int:club_id>/bar/", FooView.as_view())
-        ]
-        ```
-
-        In `views.py` :
-
-        ```python
-        # this view is available to users that either have the
-        # "foo.view_foo" permission or are in the board of the club
-        # which id was given in the url
-        class FooView(PermissionOrClubBoardRequiredMixin, View):
-            permission_required = "foo.view_foo"
-        ```
-    """
-
-    club_pk_url_kwarg = "club_id"
-
-    @cached_property
-    def club(self):
-        club_id: str | int = self.kwargs.pop(self.club_pk_url_kwarg, None)
-        if club_id is None:
-            return None
-        if isinstance(club_id, int) or club_id.isdigit():
-            return get_object_or_404(Club, pk=club_id)
-        raise Http404(_("No club found with id %(id)s") % {"id": club_id})
-
-    def has_permission(self):
-        if self.request.user.is_anonymous:
-            return False
-        if super().has_permission():
-            return True
-        return (
-            self.club is not None
-            and self.club.board_group_id in self.request.user.all_groups
-        )

core/baker_recipes.py

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

core/converters.py

@@ -1,16 +1,19 @@
-from django.urls.converters import IntConverter, StringConverter
-
-
-class FourDigitYearConverter(IntConverter):
+class FourDigitYearConverter:
     regex = "[0-9]{4}"
 
+    def to_python(self, value):
+        return int(value)
+
     def to_url(self, value):
         return str(value).zfill(4)
 
 
-class TwoDigitMonthConverter(IntConverter):
+class TwoDigitMonthConverter:
     regex = "[0-9]{2}"
 
+    def to_python(self, value):
+        return int(value)
+
     def to_url(self, value):
         return str(value).zfill(2)
 
@@ -25,9 +28,3 @@ class BooleanStringConverter:
 
     def to_url(self, value):
         return str(value)
-
-
-class ResultConverter(StringConverter):
-    """Converter whose regex match either "success" or "failure"."""
-
-    regex = "(success|failure)"

core/management/commands/check_fs.py

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

core/management/commands/install_xapian.py

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

core/management/commands/install_xapian.sh

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