Merge branch 'no-api-error' into 'main'

fix #113 See merge request bde/nk20!253
Fix #113 . Fix regex in views.
2025-06-21 18:08:21 +02:00 · 2024-07-18 16:28:30 +02:00 · 2024-07-18 14:16:37 +02:00 · 2024-07-18 14:16:07 +02:00
32 changed files with 331 additions and 661 deletions
--- a/apps/activity/api/views.py
+++ b/apps/activity/api/views.py
@ -1,9 +1,9 @@
 # Copyright (C) 2018-2024 by BDE ENS Paris-Saclay
 # SPDX-License-Identifier: GPL-3.0-or-later

-from api.viewsets import ReadProtectedModelViewSet
 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import SearchFilter
+from api.filters import RegexSafeSearchFilter
+from api.viewsets import ReadProtectedModelViewSet

 from .serializers import ActivitySerializer, ActivityTypeSerializer, EntrySerializer, GuestSerializer
 from ..models import Activity, ActivityType, Entry, Guest
@ -29,7 +29,7 @@ class ActivityViewSet(ReadProtectedModelViewSet):
    """
    queryset = Activity.objects.order_by('id')
    serializer_class = ActivitySerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'description', 'activity_type', 'location', 'creater', 'organizer', 'attendees_club',
                        'date_start', 'date_end', 'valid', 'open', ]
    search_fields = ['$name', '$description', '$location', '$creater__last_name', '$creater__first_name',
@ -47,7 +47,7 @@ class GuestViewSet(ReadProtectedModelViewSet):
    """
    queryset = Guest.objects.order_by('id')
    serializer_class = GuestSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['activity', 'activity__name', 'last_name', 'first_name', 'inviter', 'inviter__alias__name',
                        'inviter__alias__normalized_name', ]
    search_fields = ['$activity__name', '$last_name', '$first_name', '$inviter__user__email', '$inviter__alias__name',
@ -62,7 +62,7 @@ class EntryViewSet(ReadProtectedModelViewSet):
    """
    queryset = Entry.objects.order_by('id')
    serializer_class = EntrySerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['activity', 'time', 'note', 'guest', ]
    search_fields = ['$activity__name', '$note__user__email', '$note__alias__name', '$note__alias__normalized_name',
                     '$guest__last_name', '$guest__first_name', ]
--- a/apps/activity/templates/activity/activity_list.html
+++ b/apps/activity/templates/activity/activity_list.html
@ -46,4 +46,4 @@ SPDX-License-Identifier: GPL-3.0-or-later
    </h3>
    {% render_table table %}
 </div>
-{% endblock %}
+{% endblock %}
--- a/apps/activity/views.py
+++ b/apps/activity/views.py
@ -17,8 +17,8 @@ from django.utils.translation import gettext_lazy as _
 from django.views import View
 from django.views.decorators.cache import cache_page
 from django.views.generic import DetailView, TemplateView, UpdateView
-from django.views.generic.list import ListView
-from django_tables2.views import MultiTableMixin
+from django_tables2.views import SingleTableView
+from api.viewsets import is_regex
 from note.models import Alias, NoteSpecial, NoteUser
 from permission.backends import PermissionBackend
 from permission.views import ProtectQuerysetMixin, ProtectedCreateView
@ -58,40 +58,27 @@ class ActivityCreateView(ProtectQuerysetMixin, ProtectedCreateView):
        return reverse_lazy('activity:activity_detail', kwargs={"pk": self.object.pk})


-class ActivityListView(ProtectQuerysetMixin, LoginRequiredMixin, MultiTableMixin, ListView):
+class ActivityListView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTableView):
    """
    Displays all Activities, and classify if they are on-going or upcoming ones.
    """
    model = Activity
-    tables = [ActivityTable, ActivityTable]
+    table_class = ActivityTable
+    ordering = ('-date_start',)
    extra_context = {"title": _("Activities")}

    def get_queryset(self, **kwargs):
        return super().get_queryset(**kwargs).distinct()

-    def get_tables(self):
-        tables = super().get_tables()
-
-        tables[0].prefix = "all-"
-        tables[1].prefix = "upcoming-"
-        return tables
-
-    def get_tables_data(self):
-        # first table = all activities, second table = upcoming
-        return [
-            self.get_queryset().order_by("-date_start"),
-            Activity.objects.filter(date_end__gt=timezone.now())
-                            .filter(PermissionBackend.filter_queryset(self.request, Activity, "view"))
-                            .distinct()
-                            .order_by("date_start")
-        ]
-
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

-        tables = context["tables"]
-        for name, table in zip(["table", "upcoming"], tables):
-            context[name] = table
+        upcoming_activities = Activity.objects.filter(date_end__gt=timezone.now())
+        context['upcoming'] = ActivityTable(
+            data=upcoming_activities.filter(PermissionBackend.filter_queryset(self.request, Activity, "view")),
+            prefix='upcoming-',
+            order_by='date_start',
+        )

        started_activities = self.get_queryset().filter(open=True, valid=True).distinct().all()
        context["started_activities"] = started_activities
@ -212,13 +199,16 @@ class ActivityEntryView(LoginRequiredMixin, TemplateView):

        if "search" in self.request.GET and self.request.GET["search"]:
            pattern = self.request.GET["search"]
-            if pattern[0] != "^":
-                pattern = "^" + pattern
+
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            pattern = "^" + pattern if valid_regex and pattern[0] != "^" else pattern
            guest_qs = guest_qs.filter(
-                Q(first_name__iregex=pattern)
-                | Q(last_name__iregex=pattern)
-                | Q(inviter__alias__name__iregex=pattern)
-                | Q(inviter__alias__normalized_name__iregex=Alias.normalize(pattern))
+                Q(**{f"first_name{suffix}": pattern})
+                | Q(**{f"last_name{suffix}": pattern})
+                | Q(**{f"inviter__alias__name{suffix}": pattern})
+                | Q(**{f"inviter__alias__normalized_name{suffix}": Alias.normalize(pattern)})
            )
        else:
            guest_qs = guest_qs.none()
@ -250,11 +240,15 @@ class ActivityEntryView(LoginRequiredMixin, TemplateView):

        if "search" in self.request.GET and self.request.GET["search"]:
            pattern = self.request.GET["search"]
+
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__icontains"
            note_qs = note_qs.filter(
-                Q(note__noteuser__user__first_name__iregex=pattern)
-                | Q(note__noteuser__user__last_name__iregex=pattern)
-                | Q(name__iregex=pattern)
-                | Q(normalized_name__iregex=Alias.normalize(pattern))
+                Q(**{f"note__noteuser__user__first_name{suffix}": pattern})
+                | Q(**{f"note__noteuser__user__last_name{suffix}": pattern})
+                | Q(**{f"name{suffix}": pattern})
+                | Q(**{f"normalized_name{suffix}": Alias.normalize(pattern)})
            )
        else:
            note_qs = note_qs.none()
--- a/apps/api/filters.py
+++ b/apps/api/filters.py
@ -0,0 +1,42 @@
+import re
+from functools import lru_cache
+
+from rest_framework.filters import SearchFilter
+
+
+class RegexSafeSearchFilter(SearchFilter):
+    @lru_cache
+    def validate_regex(self, search_term) -> bool:
+        try:
+            re.compile(search_term)
+            return True
+        except re.error:
+            return False
+
+    def get_search_fields(self, view, request):
+        """
+        Ensure that given regex are valid.
+        If not, we consider that the user is trying to search by substring.
+        """
+        search_fields = super().get_search_fields(view, request)
+        search_terms = self.get_search_terms(request)
+
+        for search_term in search_terms:
+            if not self.validate_regex(search_term):
+                # Invalid regex. We assume we don't query by regex but by substring.
+                search_fields = [f.replace('$', '') for f in search_fields]
+                break
+
+        return search_fields
+
+    def get_search_terms(self, request):
+        """
+        Ensure that search field is a valid regex query. If not, we remove extra characters.
+        """
+        terms = super().get_search_terms(request)
+        if not all(self.validate_regex(term) for term in terms):
+            # Invalid regex. If a ^ is prefixed to the search term, we remove it.
+            terms = [term[1:] if term[0] == '^' else term for term in terms]
+            # Same for dollars.
+            terms = [term[:-1] if term[-1] == '$' else term for term in terms]
+        return terms
--- a/apps/api/tests.py
+++ b/apps/api/tests.py
@ -12,11 +12,12 @@ from django.contrib.contenttypes.models import ContentType
 from django.db.models.fields.files import ImageFieldFile
 from django.test import TestCase
 from django_filters.rest_framework import DjangoFilterBackend
+from phonenumbers import PhoneNumber
+from rest_framework.filters import OrderingFilter
+from api.filters import RegexSafeSearchFilter
 from member.models import Membership, Club
 from note.models import NoteClub, NoteUser, Alias, Note
 from permission.models import PermissionMask, Permission, Role
-from phonenumbers import PhoneNumber
-from rest_framework.filters import SearchFilter, OrderingFilter

 from .viewsets import ContentTypeViewSet, UserViewSet

@ -87,7 +88,7 @@ class TestAPI(TestCase):
                    resp = self.client.get(url + f"?ordering=-{field}")
                    self.assertEqual(resp.status_code, 200)

-            if SearchFilter in backends:
+            if RegexSafeSearchFilter in backends:
                # Basic search
                for field in viewset.search_fields:
                    obj = self.fix_note_object(obj, field)
--- a/apps/api/viewsets.py
+++ b/apps/api/viewsets.py
@ -1,19 +1,29 @@
 # Copyright (C) 2018-2024 by BDE ENS Paris-Saclay
 # SPDX-License-Identifier: GPL-3.0-or-later

+import re
+
 from django.contrib.contenttypes.models import ContentType
 from django_filters.rest_framework import DjangoFilterBackend
 from django.db.models import Q
 from django.conf import settings
 from django.contrib.auth.models import User
-from rest_framework.filters import SearchFilter
 from rest_framework.viewsets import ReadOnlyModelViewSet, ModelViewSet
 from permission.backends import PermissionBackend
 from note.models import Alias

+from .filters import RegexSafeSearchFilter
 from .serializers import UserSerializer, ContentTypeSerializer


+def is_regex(pattern):
+    try:
+        re.compile(pattern)
+        return True
+    except (re.error, TypeError):
+        return False
+
+
 class ReadProtectedModelViewSet(ModelViewSet):
    """
    Protect a ModelViewSet by filtering the objects that the user cannot see.
@ -60,34 +70,38 @@ class UserViewSet(ReadProtectedModelViewSet):

        if "search" in self.request.GET:
            pattern = self.request.GET["search"]
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            prefix = "^" if valid_regex else ""

            # Filter with different rules
            # We use union-all to keep each filter rule sorted in result
            queryset = queryset.filter(
                # Match without normalization
-                note__alias__name__iregex="^" + pattern
+                Q(**{f"note__alias__name{suffix}": prefix + pattern})
            ).union(
                queryset.filter(
                    # Match with normalization
-                    Q(note__alias__normalized_name__iregex="^" + Alias.normalize(pattern))
-                    & ~Q(note__alias__name__iregex="^" + pattern)
+                    Q(**{f"note__alias__normalized_name{suffix}": prefix + Alias.normalize(pattern)})
+                    & ~Q(**{f"note__alias__name{suffix}": prefix + pattern})
                ),
                all=True,
            ).union(
                queryset.filter(
                    # Match on lower pattern
-                    Q(note__alias__normalized_name__iregex="^" + pattern.lower())
-                    & ~Q(note__alias__normalized_name__iregex="^" + Alias.normalize(pattern))
-                    & ~Q(note__alias__name__iregex="^" + pattern)
+                    Q(**{f"note__alias__normalized_name{suffix}": prefix + pattern.lower()})
+                    & ~Q(**{f"note__alias__normalized_name{suffix}": prefix + Alias.normalize(pattern)})
+                    & ~Q(**{f"note__alias__name{suffix}": prefix + pattern})
                ),
                all=True,
            ).union(
                queryset.filter(
                    # Match on firstname or lastname
-                    (Q(last_name__iregex="^" + pattern) | Q(first_name__iregex="^" + pattern))
-                    & ~Q(note__alias__normalized_name__iregex="^" + pattern.lower())
-                    & ~Q(note__alias__normalized_name__iregex="^" + Alias.normalize(pattern))
-                    & ~Q(note__alias__name__iregex="^" + pattern)
+                    (Q(**{f"last_name{suffix}": prefix + pattern}) | Q(**{f"first_name{suffix}": prefix + pattern}))
+                    & ~Q(**{f"note__alias__normalized_name{suffix}": prefix + pattern.lower()})
+                    & ~Q(**{f"note__alias__normalized_name{suffix}": prefix + Alias.normalize(pattern)})
+                    & ~Q(**{f"note__alias__name{suffix}": prefix + pattern})
                ),
                all=True,
            )
@ -107,6 +121,6 @@ class ContentTypeViewSet(ReadOnlyModelViewSet):
    """
    queryset = ContentType.objects.order_by('id')
    serializer_class = ContentTypeSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['id', 'app_label', 'model', ]
    search_fields = ['$app_label', '$model', ]
--- a/apps/member/api/views.py
+++ b/apps/member/api/views.py
@ -2,7 +2,8 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import OrderingFilter, SearchFilter
+from rest_framework.filters import OrderingFilter
+from api.filters import RegexSafeSearchFilter
 from api.viewsets import ReadProtectedModelViewSet

 from .serializers import ProfileSerializer, ClubSerializer, MembershipSerializer
@ -17,7 +18,7 @@ class ProfileViewSet(ReadProtectedModelViewSet):
    """
    queryset = Profile.objects.order_by('id')
    serializer_class = ProfileSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['user', 'user__first_name', 'user__last_name', 'user__username', 'user__email',
                        'user__note__alias__name', 'user__note__alias__normalized_name', 'phone_number', "section",
                        'department', 'promotion', 'address', 'paid', 'ml_events_registration', 'ml_sport_registration',
@ -34,7 +35,7 @@ class ClubViewSet(ReadProtectedModelViewSet):
    """
    queryset = Club.objects.order_by('id')
    serializer_class = ClubSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'email', 'note__alias__name', 'note__alias__normalized_name', 'parent_club',
                        'parent_club__name', 'require_memberships', 'membership_fee_paid', 'membership_fee_unpaid',
                        'membership_duration', 'membership_start', 'membership_end', ]
@ -49,7 +50,7 @@ class MembershipViewSet(ReadProtectedModelViewSet):
    """
    queryset = Membership.objects.order_by('id')
    serializer_class = MembershipSerializer
-    filter_backends = [DjangoFilterBackend, OrderingFilter, SearchFilter]
+    filter_backends = [DjangoFilterBackend, OrderingFilter, RegexSafeSearchFilter]
    filterset_fields = ['club__name', 'club__email', 'club__note__alias__name', 'club__note__alias__normalized_name',
                        'user__username', 'user__last_name', 'user__first_name', 'user__email',
                        'user__note__alias__name', 'user__note__alias__normalized_name',
--- a/apps/member/forms.py
+++ b/apps/member/forms.py
@ -138,9 +138,6 @@ class ImageForm(forms.Form):

        return cleaned_data

-    def is_valid(self):
-        return super().is_valid() or super().clean().get('image') is None
-

 class ClubForm(forms.ModelForm):
    def clean(self):
@ -154,7 +151,7 @@ class ClubForm(forms.ModelForm):

    class Meta:
        model = Club
-        exclude = ("add_registration_form",)
+        fields = '__all__'
        widgets = {
            "membership_fee_paid": AmountInput(),
            "membership_fee_unpaid": AmountInput(),
--- a/apps/member/migrations/0012_club_add_registration_form.py
+++ b/apps/member/migrations/0012_club_add_registration_form.py
@ -1,18 +0,0 @@
-# Generated by Django 2.2.28 on 2024-07-15 09:24
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('member', '0011_profile_vss_charter_read'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='club',
-            name='add_registration_form',
-            field=models.BooleanField(default=False, verbose_name='add to registration form'),
-        ),
-    ]
--- a/apps/member/migrations/0013_auto_20240807_1409.py
+++ b/apps/member/migrations/0013_auto_20240807_1409.py
@ -1,18 +0,0 @@
-# Generated by Django 2.2.28 on 2024-08-07 12:09
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('member', '0012_club_add_registration_form'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='profile',
-            name='promotion',
-            field=models.PositiveSmallIntegerField(default=2024, help_text='Year of entry to the school (None if not ENS student)', null=True, verbose_name='promotion'),
-        ),
-    ]
--- a/apps/member/models.py
+++ b/apps/member/models.py
@ -259,11 +259,6 @@ class Club(models.Model):
        help_text=_('Maximal date of a membership, after which members must renew it.'),
    )

-    add_registration_form = models.BooleanField(
-        verbose_name=_("add to registration form"),
-        default=False,
-    )
-
    class Meta:
        verbose_name = _("club")
        verbose_name_plural = _("clubs")
--- a/apps/member/templates/member/picture_update.html
+++ b/apps/member/templates/member/picture_update.html
@ -14,9 +14,6 @@ SPDX-License-Identifier: GPL-3.0-or-later
      <form method="post" enctype="multipart/form-data" id="formUpload">
        {% csrf_token %}
        {{ form |crispy }}
-        {% if user.note.display_image != "pic/default.png" %}
-          <input type="submit" class="btn btn-primary" value="{% trans "Remove" %}">
-        {% endif %}
      </form>
    </div>
    <!-- MODAL TO CROP THE IMAGE -->
--- a/apps/member/views.py
+++ b/apps/member/views.py
@ -18,6 +18,7 @@ from django.views.generic import DetailView, UpdateView, TemplateView
 from django.views.generic.edit import FormMixin
 from django_tables2.views import SingleTableView
 from rest_framework.authtoken.models import Token
+from api.viewsets import is_regex
 from note.models import Alias, NoteClub, NoteUser, Trust
 from note.models.transactions import Transaction, SpecialTransaction
 from note.tables import HistoryTable, AliasTable, TrustTable, TrustedTable
@ -219,16 +220,20 @@ class UserListView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTableView):
        if "search" in self.request.GET and self.request.GET["search"]:
            pattern = self.request.GET["search"]

+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            prefix = "^" if valid_regex else ""
            qs = qs.filter(
-                username__iregex="^" + pattern
+                Q(**{f"username{suffix}": prefix + pattern})
            ).union(
                qs.filter(
-                    (Q(alias__iregex="^" + pattern)
-                     | Q(normalized_alias__iregex="^" + Alias.normalize(pattern))
-                     | Q(last_name__iregex="^" + pattern)
-                     | Q(first_name__iregex="^" + pattern)
+                    (Q(**{f"alias{suffix}": prefix + pattern})
+                     | Q(**{f"normalized_alias{suffix}": prefix + Alias.normalize(pattern)})
+                     | Q(**{f"last_name{suffix}": prefix + pattern})
+                     | Q(**{f"first_name{suffix}": prefix + pattern})
                     | Q(email__istartswith=pattern))
-                    & ~Q(username__iregex="^" + pattern)
+                    & ~Q(**{f"username{suffix}": prefix + pattern})
                ), all=True)
        else:
            qs = qs.none()
@ -326,15 +331,12 @@ class PictureUpdateView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin, Det
        """Save image to note"""
        image = form.cleaned_data['image']

-        if image is None:
-            image = "pic/default.png"
+        # Rename as a PNG or GIF
+        extension = image.name.split(".")[-1]
+        if extension == "gif":
+            image.name = "{}_pic.gif".format(self.object.note.pk)
        else:
-            # Rename as a PNG or GIF
-            extension = image.name.split(".")[-1]
-            if extension == "gif":
-                image.name = "{}_pic.gif".format(self.object.note.pk)
-            else:
-                image.name = "{}_pic.png".format(self.object.note.pk)
+            image.name = "{}_pic.png".format(self.object.note.pk)

        # Save
        self.object.note.display_image = image
@ -410,10 +412,15 @@ class ClubListView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTableView):
        if "search" in self.request.GET:
            pattern = self.request.GET["search"]

+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            prefix = "^" if valid_regex else ""
+
            qs = qs.filter(
-                Q(name__iregex=pattern)
-                | Q(note__alias__name__iregex=pattern)
-                | Q(note__alias__normalized_name__iregex=Alias.normalize(pattern))
+                Q(**{f"name{suffix}": prefix + pattern})
+                | Q(**{f"note__alias__name{suffix}": prefix + pattern})
+                | Q(**{f"note__alias__normalized_name{suffix}": prefix + Alias.normalize(pattern)})
            )

        return qs
@ -912,10 +919,15 @@ class ClubMembersListView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTableV

        if 'search' in self.request.GET:
            pattern = self.request.GET['search']
+
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            prefix = "^" if valid_regex else ""
            qs = qs.filter(
-                Q(user__first_name__iregex='^' + pattern)
-                | Q(user__last_name__iregex='^' + pattern)
-                | Q(user__note__alias__normalized_name__iregex='^' + Alias.normalize(pattern))
+                Q(**{f"user__first_name{suffix}": prefix + pattern})
+                | Q(**{f"user__last_name{suffix}": prefix + pattern})
+                | Q(**{f"user__note__alias__normalized_name{suffix}": prefix + Alias.normalize(pattern)})
            )

        only_active = "only_active" not in self.request.GET or self.request.GET["only_active"] != '0'
--- a/apps/note/api/views.py
+++ b/apps/note/api/views.py
@ -1,16 +1,16 @@
 # Copyright (C) 2018-2024 by BDE ENS Paris-Saclay
 # SPDX-License-Identifier: GPL-3.0-or-later
-import re

 from django.conf import settings
 from django.db.models import Q
 from django.core.exceptions import ValidationError
 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import OrderingFilter, SearchFilter
-from rest_framework import viewsets
+from rest_framework.filters import OrderingFilter
+from rest_framework import status, viewsets
 from rest_framework.response import Response
-from rest_framework import status
-from api.viewsets import ReadProtectedModelViewSet, ReadOnlyProtectedModelViewSet
+from api.filters import RegexSafeSearchFilter
+from api.viewsets import ReadProtectedModelViewSet, ReadOnlyProtectedModelViewSet, \
+    is_regex
 from permission.backends import PermissionBackend

 from .serializers import NotePolymorphicSerializer, AliasSerializer, ConsumerSerializer, \
@ -29,7 +29,7 @@ class NotePolymorphicViewSet(ReadProtectedModelViewSet):
    """
    queryset = Note.objects.order_by('id')
    serializer_class = NotePolymorphicSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter, OrderingFilter]
    filterset_fields = ['alias__name', 'polymorphic_ctype', 'is_active', 'balance', 'last_negative', 'created_at', ]
    search_fields = ['$alias__normalized_name', '$alias__name', '$polymorphic_ctype__model',
                     '$noteuser__user__last_name', '$noteuser__user__first_name', '$noteuser__user__email',
@ -48,10 +48,14 @@ class NotePolymorphicViewSet(ReadProtectedModelViewSet):
            .distinct()

        alias = self.request.query_params.get("alias", ".*")
+        # Check if this is a valid regex. If not, we won't check regex
+        valid_regex = is_regex(alias)
+        suffix = '__iregex' if valid_regex else '__istartswith'
+        alias_prefix = '^' if valid_regex else ''
        queryset = queryset.filter(
-            Q(alias__name__iregex="^" + alias)
-            | Q(alias__normalized_name__iregex="^" + Alias.normalize(alias))
-            | Q(alias__normalized_name__iregex="^" + alias.lower())
+            Q(**{f"alias__name{suffix}": alias_prefix + alias})
+            | Q(**{f"alias__normalized_name{suffix}": alias_prefix + Alias.normalize(alias)})
+            | Q(**{f"alias__normalized_name{suffix}": alias_prefix + alias.lower()})
        )

        return queryset.order_by("id")
@ -65,7 +69,7 @@ class TrustViewSet(ReadProtectedModelViewSet):
    """
    queryset = Trust.objects
    serializer_class = TrustSerializer
-    filter_backends = [SearchFilter, DjangoFilterBackend, OrderingFilter]
+    filter_backends = [RegexSafeSearchFilter, DjangoFilterBackend, OrderingFilter]
    search_fields = ['$trusting__alias__name', '$trusting__alias__normalized_name',
                     '$trusted__alias__name', '$trusted__alias__normalized_name']
    filterset_fields = ['trusting', 'trusting__noteuser__user', 'trusted', 'trusted__noteuser__user']
@ -91,11 +95,11 @@ class AliasViewSet(ReadProtectedModelViewSet):
    """
    REST API View set.
    The djangorestframework plugin will get all `Alias` objects, serialize it to JSON with the given serializer,
-    then render it on /api/note/aliases/
+    then render it on /api/note/alias/
    """
    queryset = Alias.objects
    serializer_class = AliasSerializer
-    filter_backends = [SearchFilter, DjangoFilterBackend, OrderingFilter]
+    filter_backends = [RegexSafeSearchFilter, DjangoFilterBackend, OrderingFilter]
    search_fields = ['$normalized_name', '$name', '$note__polymorphic_ctype__model', ]
    filterset_fields = ['name', 'normalized_name', 'note', 'note__noteuser__user',
                        'note__noteclub__club', 'note__polymorphic_ctype__model', ]
@ -126,18 +130,22 @@ class AliasViewSet(ReadProtectedModelViewSet):

        alias = self.request.query_params.get("alias", None)
        if alias:
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(alias)
+            suffix = '__iregex' if valid_regex else '__istartswith'
+            alias_prefix = '^' if valid_regex else ''
            queryset = queryset.filter(
-                name__iregex="^" + alias
+                **{f"name{suffix}": alias_prefix + alias}
            ).union(
                queryset.filter(
-                    Q(normalized_name__iregex="^" + Alias.normalize(alias))
-                    & ~Q(name__iregex="^" + alias)
+                    Q(**{f"normalized_name{suffix}": alias_prefix + Alias.normalize(alias)})
+                    & ~Q(**{f"name{suffix}": alias_prefix + alias})
                ),
                all=True).union(
                queryset.filter(
-                    Q(normalized_name__iregex="^" + alias.lower())
-                    & ~Q(normalized_name__iregex="^" + Alias.normalize(alias))
-                    & ~Q(name__iregex="^" + alias)
+                    Q(**{f"normalized_name{suffix}": "^" + alias.lower()})
+                    & ~Q(**{f"normalized_name{suffix}": "^" + Alias.normalize(alias)})
+                    & ~Q(**{f"name{suffix}": "^" + alias})
                ),
                all=True)

@ -147,7 +155,7 @@ class AliasViewSet(ReadProtectedModelViewSet):
 class ConsumerViewSet(ReadOnlyProtectedModelViewSet):
    queryset = Alias.objects
    serializer_class = ConsumerSerializer
-    filter_backends = [SearchFilter, OrderingFilter, DjangoFilterBackend]
+    filter_backends = [RegexSafeSearchFilter, OrderingFilter, DjangoFilterBackend]
    search_fields = ['$normalized_name', '$name', '$note__polymorphic_ctype__model', ]
    filterset_fields = ['name', 'normalized_name', 'note', 'note__noteuser__user',
                        'note__noteclub__club', 'note__polymorphic_ctype__model', ]
@ -166,11 +174,7 @@ class ConsumerViewSet(ReadOnlyProtectedModelViewSet):

        alias = self.request.query_params.get("alias", None)
        # Check if this is a valid regex. If not, we won't check regex
-        try:
-            re.compile(alias)
-            valid_regex = True
-        except (re.error, TypeError):
-            valid_regex = False
+        valid_regex = is_regex(alias)
        suffix = '__iregex' if valid_regex else '__istartswith'
        alias_prefix = '^' if valid_regex else ''
        queryset = queryset.prefetch_related('note')
@ -207,7 +211,7 @@ class TemplateCategoryViewSet(ReadProtectedModelViewSet):
    """
    queryset = TemplateCategory.objects.order_by('name')
    serializer_class = TemplateCategorySerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'templates', 'templates__name']
    search_fields = ['$name', '$templates__name', ]

@ -220,7 +224,7 @@ class TransactionTemplateViewSet(viewsets.ModelViewSet):
    """
    queryset = TransactionTemplate.objects.order_by('name')
    serializer_class = TransactionTemplateSerializer
-    filter_backends = [SearchFilter, DjangoFilterBackend, OrderingFilter]
+    filter_backends = [RegexSafeSearchFilter, DjangoFilterBackend, OrderingFilter]
    filterset_fields = ['name', 'amount', 'display', 'category', 'category__name', ]
    search_fields = ['$name', '$category__name', ]
    ordering_fields = ['amount', ]
@ -234,7 +238,7 @@ class TransactionViewSet(ReadProtectedModelViewSet):
    """
    queryset = Transaction.objects.order_by('-created_at')
    serializer_class = TransactionPolymorphicSerializer
-    filter_backends = [SearchFilter, DjangoFilterBackend, OrderingFilter]
+    filter_backends = [RegexSafeSearchFilter, DjangoFilterBackend, OrderingFilter]
    filterset_fields = ['source', 'source_alias', 'source__alias__name', 'source__alias__normalized_name',
                        'destination', 'destination_alias', 'destination__alias__name',
                        'destination__alias__normalized_name', 'quantity', 'polymorphic_ctype', 'amount',
--- a/apps/note/templates/note/mails/negative_balance.html
+++ b/apps/note/templates/note/mails/negative_balance.html
@ -23,7 +23,7 @@

 <p>
    Par ailleurs, le BDE ne sert pas d'alcool aux adhérents dont le solde
-    est inférieur à 0 €.
+    est inférieur à 0 € depuis plus de 24h.
 </p>

 <p>
@ -43,4 +43,4 @@
    {% trans "Mail generated by the Note Kfet on the" %} {% now "j F Y à H:i:s" %}
 </p>
 </body>
-</html>
+</html>
--- a/apps/note/templates/note/mails/summary_notes_report.html
+++ b/apps/note/templates/note/mails/summary_notes_report.html
@ -1,65 +0,0 @@
-{% load pretty_money %}
-{% load i18n %}
-
-<!DOCTYPE html>
-<html lang="fr">
-<head>
-    <meta charset="UTF-8">
-    <title>[Note Kfet] Récapitulatif de trésorerie</title>
-</head>
-<body>
-<h1>
-  Récapitulatif de trésorerie au {{ summary.date|date:"d/m/Y" }} à {{ summary.date|date:"H:i:s" }} :
-</h1>
-
-<h2>
-  Tous les utilisateur⋅rices :
-</h2>
-<ul>
-  <li>Positifs : {{ summary.total_positive_user }} soit {{ summary.balance_positive_user / 100 }} €</li>
-  <li>Neutres : {{ summary.total_zero_user }}</li>
-  <li>Négatifs : {{ summary.total_negative_user }} soit {{ summary.balance_negative_user / 100 }} €</li>
-</ul>
-
-<h2>
-  Les {{ summary.total_positive_user_bde + summary.total_zero_user_bde + summary.total_negative_user_bde }} adhérent⋅es BDE :
-</h2>
-<ul>
-  <li>Positifs : {{ summary.total_positive_user_bde }} soit {{ summary.balance_positive_user_bde / 100 }} €</li>
-  <li>Neutres : {{ summary.total_zero_user_bde }}</li>
-  <li>Négatifs : {{ summary.total_negative_user_bde }} soit {{ summary.balance_negative_user_bde / 100 }} €</li>
-</ul>
-
-<h2>
-  Clubs :
-</h2>
-<ul>
-  <li>Positifs : {{ summary.total_positive_club }} soit {{ summary.balance_positive_club / 100 }} €</li>
-  <li>Neutres : {{ summary.total_zero_club }}</li>
-  <li>Négatifs : {{ summary.total_negative_club }} soit {{ summary.balance_negative_club / 100 }} €</li>
-</ul>
-
-<h2>
-  Clubs hors BDE / Kfet et club dont le nom fini par "- BDE" :
-</h2>
-<ul>
-  <li>Positifs : {{ summary.total_positive_club_nbde }} soit {{ summary.balance_positive_club_nbde / 100 }} €</li>
-  <li>Neutres : {{ summary.total_zero_club_nbde }}</li>
-  <li>Négatifs : {{ summary.total_negative_club_nbde }} soit {{ summary.balance_negative_club_nbde / 100 }} €</li>
-</ul>
-
-<h2>
-  Progression :
-</h2>
-<ul>
-  <li>Ceci correspond à une différence de {{ balance_difference_user / 100 }} € pour les utilisateur⋅rices</li>
-  <li>Ceci correspond à une différence de {{ balance_difference_club / 100 }} € pour les clubs</li>
-</ul>
-
--
-<p>
-    Le BDE<br>
-    {% trans "Mail generated by the Note Kfet on the" %} {% now "j F Y à H:i:s" %}
-</p>
-</body>
-</html>
--- a/apps/note/templates/note/mails/summary_notes_report.txt
+++ b/apps/note/templates/note/mails/summary_notes_report.txt
@ -1,33 +0,0 @@
-{% load pretty_money %}
-{% load i18n %}
-
-Récapitulatif de trésorerie au {{ summary.date|date:"d/m/Y" }} à {{ summary.date|date:"H:i:s" }} :
-
-Tous les utilisateur⋅rices :
-  - Positifs : {{ summary.total_positive_user }} soit {{ summary.balance_positive_user / 100 }} €
-  - Neutres : {{ summary.total_zero_user }}
-  - Négatifs : {{ summary.total_negative_user }} soit {{ summary.balance_negative_user / 100 }} €
-
-Les {{ summary.total_positive_user_bde + summary.total_zero_user_bde + summary.total_negative_user_bde }} adhérent⋅es BDE :
-  - Positifs : {{ summary.total_positive_user_bde }} soit {{ summary.balance_positive_user_bde / 100 }} €
-  - Neutres : {{ summary.total_zero_user_bde }}
-  - Négatifs : {{ summary.total_negative_user_bde }} soit {{ summary.balance_negative_user_bde /100 }} €
-
-Clubs :
-  - Positifs : {{ summary.total_positive_club }} soit {{ summary.balance_positive_club / 100 }} €
-  - Neutres : {{ summary.total_zero_club }}
-  - Négatifs : {{ summary.total_negative_club }} soit {{ summary.balance_negative_club / 100 }} €
-
-Clubs hors BDE / Kfet et club dont le nom fini par "- BDE" :
-  - Positifs : {{ summary.total_positive_club_nbde }} soit {{ summary.balance_positive_club_nbde / 100 }} €
-  - Neutres : {{ summary.total_zero_club_nbde }}
-  - Négatifs : {{ summary.total_negative_club_nbde }} soit {{ summary.balance_negative_club_nbde / 100 }} €
-
-Progression :
-  - Ceci correspond à une différence de {{ balance_difference_user / 100 }} € pour les utilisateur⋅rices
-  - Ceci correspond à une différence de {{ balance_difference_club / 100 }} € pour les clubs
-
--
-Le BDE
-
-{% trans "Mail generated by the Note Kfet on the" %} {% now "j F Y à H:i:s" %}
--- a/apps/note/views.py
+++ b/apps/note/views.py
@ -13,6 +13,7 @@ from django.views.generic import CreateView, UpdateView, DetailView
 from django.urls import reverse_lazy
 from django_tables2 import SingleTableView
 from activity.models import Entry
+from api.viewsets import is_regex
 from permission.backends import PermissionBackend
 from permission.views import ProtectQuerysetMixin
 from note_kfet.inputs import AmountInput
@ -89,11 +90,15 @@ class TransactionTemplateListView(ProtectQuerysetMixin, LoginRequiredMixin, Sing
        qs = super().get_queryset().distinct()
        if "search" in self.request.GET:
            pattern = self.request.GET["search"]
+
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix = "__iregex" if valid_regex else "__icontains"
            qs = qs.filter(
-                Q(name__iregex=pattern)
-                | Q(destination__club__name__iregex=pattern)
-                | Q(category__name__iregex=pattern)
-                | Q(description__iregex=pattern)
+                Q(**{f"name{suffix}": pattern})
+                | Q(**{f"destination__club__name{suffix}": pattern})
+                | Q(**{f"category__name{suffix}": pattern})
+                | Q(**{f"description{suffix}": pattern})
            )

        qs = qs.order_by('-display', 'category__name', 'destination__club__name', 'name')
@ -223,7 +228,10 @@ class TransactionSearchView(ProtectQuerysetMixin, LoginRequiredMixin, DetailView
        if "type" in data and data["type"]:
            transactions = transactions.filter(polymorphic_ctype__in=data["type"])
        if "reason" in data and data["reason"]:
-            transactions = transactions.filter(reason__iregex=data["reason"])
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(data["reason"])
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            transactions = transactions.filter(Q(**{f"reason{suffix}": data["reason"]}))
        if "valid" in data and data["valid"]:
            transactions = transactions.filter(valid=data["valid"])
        if "amount_gte" in data and data["amount_gte"]:
--- a/apps/permission/api/views.py
+++ b/apps/permission/api/views.py
@ -1,9 +1,9 @@
 # Copyright (C) 2018-2024 by BDE ENS Paris-Saclay
 # SPDX-License-Identifier: GPL-3.0-or-later

-from api.viewsets import ReadOnlyProtectedModelViewSet
 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import SearchFilter
+from api.filters import RegexSafeSearchFilter
+from api.viewsets import ReadOnlyProtectedModelViewSet

 from .serializers import PermissionSerializer, RoleSerializer
 from ..models import Permission, Role
@ -17,9 +17,9 @@ class PermissionViewSet(ReadOnlyProtectedModelViewSet):
    """
    queryset = Permission.objects.order_by('id')
    serializer_class = PermissionSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['model', 'type', 'query', 'mask', 'field', 'permanent', ]
-    search_fields = ['$model__name', '$query', '$description', ]
+    search_fields = ['$model__model', '$query', '$description', ]


 class RoleViewSet(ReadOnlyProtectedModelViewSet):
@ -30,6 +30,6 @@ class RoleViewSet(ReadOnlyProtectedModelViewSet):
    """
    queryset = Role.objects.order_by('id')
    serializer_class = RoleSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'permissions', 'for_club', 'memberships__user', ]
    search_fields = ['$name', '$for_club__name', ]
--- a/apps/permission/fixtures/initial.json
+++ b/apps/permission/fixtures/initial.json
@ -2591,12 +2591,12 @@
 				"note",
 				"transaction"
 			],
-			"query": "[\"OR\", {\"source__balance__gte\": 0}, [\"AND\", [\"NOT\", {\"recurrenttransaction__template__category__name\": \"Alcool\"}], {\"source__balance__gte\": {\"F\": [\"SUB\", [\"MUL\", [\"F\", \"amount\"], [\"F\", \"quantity\"]], 2000]}}], {\"valid\": false}]",
+			"query": "[\"OR\", {\"source__balance__gte\": {\"F\": [\"SUB\", [\"MUL\", [\"F\", \"amount\"], [\"F\", \"quantity\"]], 2000]}}, {\"valid\": false}]",
 			"type": "add",
 			"mask": 2,
 			"field": "",
 			"permanent": false,
-			"description": "Créer une transaction quelconque tant que la source reste positive s'il s'agit d'alcool, sinon au-dessus de -20€"
+			"description": "Créer une transaction quelconque tant que la source reste au-dessus de -20 €"
 		}
 	},
 	{
--- a/apps/registration/forms.py
+++ b/apps/registration/forms.py
@ -5,6 +5,7 @@ from django import forms
 from django.contrib.auth.forms import UserCreationForm
 from django.contrib.auth.models import User
 from django.utils.translation import gettext_lazy as _
+# from member.models import Club
 from note.models import NoteSpecial, Alias
 from note_kfet.inputs import AmountInput

@ -114,3 +115,12 @@ class ValidationForm(forms.Form):
        required=False,
        initial=True,
    )
+
+#     If the bda exists
+#     if Club.objects.filter(name__iexact="bda").exists():
+#         The user can join the bda club at the inscription
+#         join_bda = forms.BooleanField(
+#             label=_("Join BDA Club"),
+#             required=False,
+#             initial=True,
+#         )
--- a/apps/registration/views.py
+++ b/apps/registration/views.py
@ -1,7 +1,6 @@
 # Copyright (C) 2018-2024 by BDE ENS Paris-Saclay
 # SPDX-License-Identifier: GPL-3.0-or-later

-from django import forms
 from django.conf import settings
 from django.contrib.auth.mixins import LoginRequiredMixin
 from django.contrib.auth.models import User
@ -16,6 +15,7 @@ from django.views import View
 from django.views.generic import CreateView, TemplateView, DetailView
 from django.views.generic.edit import FormMixin
 from django_tables2 import SingleTableView
+from api.viewsets import is_regex
 from member.forms import ProfileForm
 from member.models import Membership, Club
 from note.models import SpecialTransaction, Alias
@ -192,11 +192,16 @@ class FutureUserListView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTableVi
        if "search" in self.request.GET and self.request.GET["search"]:
            pattern = self.request.GET["search"]

+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix_username = "__iregex" if valid_regex else "__icontains"
+            suffix = "__iregex" if valid_regex else "__istartswith"
+            prefix = "^" if valid_regex else ""
            qs = qs.filter(
-                Q(first_name__iregex=pattern)
-                | Q(last_name__iregex=pattern)
-                | Q(profile__section__iregex=pattern)
-                | Q(username__iregex="^" + pattern)
+                Q(**{f"first_name{suffix}": pattern})
+                | Q(**{f"last_name{suffix}": pattern})
+                | Q(**{f"profile__section{suffix}": pattern})
+                | Q(**{f"username{suffix_username}": prefix + pattern})
            )

        return qs
@ -239,8 +244,9 @@ class FutureUserDetailView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin,
        fee += bde.membership_fee_paid if user.profile.paid else bde.membership_fee_unpaid
        kfet = Club.objects.get(name="Kfet")
        fee += kfet.membership_fee_paid if user.profile.paid else kfet.membership_fee_unpaid
-        for club in Club.objects.filter(add_registration_form=True):
-            fee += club.membership_fee_paid if user.profile.paid else club.membership_fee_unpaid
+        if Club.objects.filter(name__iexact="BDA").exists():
+            bda = Club.objects.get(name__iexact="BDA")
+            fee += bda.membership_fee_paid if user.profile.paid else bda.membership_fee_unpaid
        ctx["total_fee"] = "{:.02f}".format(fee / 100, )

 #        ctx["declare_soge_account"] = SogeCredit.objects.filter(user=user).exists()
@ -249,16 +255,6 @@ class FutureUserDetailView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin,

    def get_form(self, form_class=None):
        form = super().get_form(form_class)
-
-        # add clubs that are in registration form
-        for club in Club.objects.filter(add_registration_form=True).order_by("name"):
-            form_join_club = forms.BooleanField(
-                label=_("Join %(club)s Club") % {'club': club.name},
-                required=False,
-                initial=False,
-            )
-            form.fields.update({f"join_{club.id}": form_join_club})
-
        user = self.get_object()
        form.fields["last_name"].initial = user.last_name
        form.fields["first_name"].initial = user.first_name
@ -276,6 +272,11 @@ class FutureUserDetailView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin,
            form.add_error(None, _("An alias with a similar name already exists."))
            return self.form_invalid(form)

+        # Check if BDA exist to propose membership at regisration
+        bda_exists = False
+        if Club.objects.filter(name__iexact="BDA").exists():
+            bda_exists = True
+
        # Get form data
 #        soge = form.cleaned_data["soge"]
        credit_type = form.cleaned_data["credit_type"]
@ -285,9 +286,8 @@ class FutureUserDetailView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin,
        bank = form.cleaned_data["bank"]
        join_bde = form.cleaned_data["join_bde"]
        join_kfet = form.cleaned_data["join_kfet"]
-
-        clubs_registration = Club.objects.filter(add_registration_form=True).order_by("name")
-        join_clubs = [(club, form.cleaned_data[f"join_{club.id}"]) for club in clubs_registration]
+        if bda_exists:
+            join_bda = form.cleaned_data["join_bda"]

 #        if soge:
 #            # If Société Générale pays the inscription, the user automatically joins the two clubs.
@ -309,12 +309,11 @@ class FutureUserDetailView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin,
        kfet_fee = kfet.membership_fee_paid if user.profile.paid else kfet.membership_fee_unpaid
        # Add extra fee for the full membership
        fee += kfet_fee if join_kfet else 0
-        clubs_fee = dict()
-        for club, join_club in join_clubs:
-            club_fee = club.membership_fee_paid if user.profile.paid else club.membership_fee_unpaid
-            # Add extra fee for the club membership
-            clubs_fee[club] = club_fee
-            fee += club_fee if join_club else 0
+        if bda_exists:
+            bda = Club.objects.get(name__iexact="BDA")
+            bda_fee = bda.membership_fee_paid if user.profile.paid else bda.membership_fee_unpaid
+            # Add extra fee for the bda membership
+            fee += bda_fee if join_bda else 0

 #        # If the bank pays, then we don't credit now. Treasurers will validate the transaction
 #        # and credit the note later.
@ -394,18 +393,17 @@ class FutureUserDetailView(ProtectQuerysetMixin, LoginRequiredMixin, FormMixin,
            membership.roles.add(Role.objects.get(name="Adhérent Kfet"))
            membership.save()

-        for club, join_club in join_clubs:
-            if join_club:
-                # Create membership for the user to the BDA starting today
-                membership = Membership(
-                    club=club,
-                    user=user,
-                    fee=clubs_fee[club],
-                )
-                membership.save()
-                membership.refresh_from_db()
-                membership.roles.add(Role.objects.get(name="Membre de club"))
-                membership.save()
+        if bda_exists and join_bda:
+            # Create membership for the user to the BDA starting today
+            membership = Membership(
+                club=bda,
+                user=user,
+                fee=bda_fee,
+            )
+            membership.save()
+            membership.refresh_from_db()
+            membership.roles.add(Role.objects.get(name="Membre de club"))
+            membership.save()

 #        if soge:
 #            soge_credit = SogeCredit.objects.get(user=user)
--- a/apps/scripts
+++ b/apps/scripts
--- a/apps/treasury/admin.py
+++ b/apps/treasury/admin.py
@ -5,13 +5,13 @@ from django.contrib import admin
 from note_kfet.admin import admin_site

 from .forms import ProductForm
-from .models import Invoice, NoteSummary, Product, RemittanceType, Remittance, SogeCredit
+from .models import RemittanceType, Remittance, SogeCredit, Invoice, Product


@admin.register(RemittanceType, site=admin_site)
 class RemittanceTypeAdmin(admin.ModelAdmin):
    """
-    Admin customisation for RemittanceType
+    Admin customisation for RemiitanceType
    """
    list_display = ('note', )

@ -55,19 +55,3 @@ class InvoiceAdmin(admin.ModelAdmin):
    """
    list_display = ('object', 'id', 'bde', 'name', 'date', 'acquitted',)
    inlines = (ProductInline,)
-
-
-@admin.register(NoteSummary, site=admin_site)
-class NoteSummaryAdmin(admin.ModelAdmin):
-    """
-    Admin customisation for NoteSummary
-    """
-    list_display = (
-        'date', 'total_positive_user', 'balance_positive_user', 'total_positive_user_bde',
-        'balance_positive_user_bde', 'total_zero_user', 'total_zero_user_bde', 'total_negative_user',
-        'balance_negative_user', 'total_negative_user_bde', 'balance_negative_user_bde',
-        'total_vnegative_user', 'balance_vnegative_user', 'total_vnegative_user_bde',
-        'balance_vnegative_user_bde', 'total_positive_club', 'balance_positive_club',
-        'total_positive_club_nbde', 'balance_positive_club_nbde', 'total_zero_club', 'total_zero_club_nbde',
-        'total_negative_club', 'balance_negative_club', 'total_negative_club_nbde', 'balance_negative_club_nbde',
-    )
--- a/apps/treasury/api/views.py
+++ b/apps/treasury/api/views.py
@ -2,7 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import SearchFilter
+from api.filters import RegexSafeSearchFilter
 from api.viewsets import ReadProtectedModelViewSet

 from .serializers import InvoiceSerializer, ProductSerializer, RemittanceTypeSerializer, RemittanceSerializer, \
@ -18,7 +18,7 @@ class InvoiceViewSet(ReadProtectedModelViewSet):
    """
    queryset = Invoice.objects.order_by('id')
    serializer_class = InvoiceSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['bde', 'object', 'description', 'name', 'address', 'date', 'acquitted', 'locked', ]
    search_fields = ['$object', '$description', '$name', '$address', ]

@ -31,7 +31,7 @@ class ProductViewSet(ReadProtectedModelViewSet):
    """
    queryset = Product.objects.order_by('invoice_id', 'id')
    serializer_class = ProductSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['invoice', 'designation', 'quantity', 'amount', ]
    search_fields = ['$designation', '$invoice__object', ]

@ -44,7 +44,7 @@ class RemittanceTypeViewSet(ReadProtectedModelViewSet):
    """
    queryset = RemittanceType.objects.order_by('id')
    serializer_class = RemittanceTypeSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['note', ]
    search_fields = ['$note__special_type', ]

@ -57,7 +57,7 @@ class RemittanceViewSet(ReadProtectedModelViewSet):
    """
    queryset = Remittance.objects.order_by('id')
    serializer_class = RemittanceSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['date', 'remittance_type', 'comment', 'closed', 'transaction_proxies__transaction', ]
    search_fields = ['$remittance_type__note__special_type', '$comment', ]

@ -70,7 +70,7 @@ class SogeCreditViewSet(ReadProtectedModelViewSet):
    """
    queryset = SogeCredit.objects.order_by('id')
    serializer_class = SogeCreditSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['user', 'user__last_name', 'user__first_name', 'user__email', 'user__note__alias__name',
                        'user__note__alias__normalized_name', 'transactions', 'credit_transaction', ]
    search_fields = ['$user__last_name', '$user__first_name', '$user__email', '$user__note__alias__name',
--- a/apps/treasury/migrations/0009_notesummary.py
+++ b/apps/treasury/migrations/0009_notesummary.py
@ -1,49 +0,0 @@
-# Generated by Django 2.2.28 on 2024-08-07 12:09
-
-import datetime
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('treasury', '0008_auto_20240322_0045'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='NoteSummary',
-            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('date', models.DateField(default=datetime.date.today, verbose_name='Date')),
-                ('total_positive_user', models.PositiveIntegerField(verbose_name='Total positive user')),
-                ('balance_positive_user', models.PositiveIntegerField(verbose_name='Balance positive user')),
-                ('total_positive_user_bde', models.PositiveIntegerField(verbose_name='Total positive user BDE')),
-                ('balance_positive_user_bde', models.PositiveIntegerField(verbose_name='Balance positive user BDE')),
-                ('total_zero_user', models.PositiveIntegerField(verbose_name='Total zero user')),
-                ('total_zero_user_bde', models.PositiveIntegerField(verbose_name='Total zero user BDE')),
-                ('total_negative_user', models.PositiveIntegerField(verbose_name='Total negative user')),
-                ('balance_negative_user', models.PositiveIntegerField(verbose_name='Balance negative user')),
-                ('total_negative_user_bde', models.PositiveIntegerField(verbose_name='Total negative user BDE')),
-                ('balance_negative_user_bde', models.PositiveIntegerField(verbose_name='Balance negative user BDE')),
-                ('total_vnegative_user', models.PositiveIntegerField(verbose_name='Total very negative user')),
-                ('balance_vnegative_user', models.PositiveIntegerField(verbose_name='Balance very negative user')),
-                ('total_vnegative_user_bde', models.PositiveIntegerField(verbose_name='Total very negative user BDE')),
-                ('balance_vnegative_user_bde', models.PositiveIntegerField(verbose_name='Balance very negative user BDE')),
-                ('total_positive_club', models.PositiveIntegerField(verbose_name='Total positive club')),
-                ('balance_positive_club', models.PositiveIntegerField(verbose_name='Balance positive club')),
-                ('total_positive_club_nbde', models.PositiveIntegerField(verbose_name='Total positive club nbde')),
-                ('balance_positive_club_nbde', models.PositiveIntegerField(verbose_name='Balance positive club nbde')),
-                ('total_zero_club', models.PositiveIntegerField(verbose_name='Total zero club')),
-                ('total_zero_club_nbde', models.PositiveIntegerField(verbose_name='Total zero club nbde')),
-                ('total_negative_club', models.PositiveIntegerField(verbose_name='Total negative club')),
-                ('balance_negative_club', models.PositiveIntegerField(verbose_name='Balance negative club')),
-                ('total_negative_club_nbde', models.PositiveIntegerField(verbose_name='Total negative club nbde')),
-                ('balance_negative_club_nbde', models.PositiveIntegerField(verbose_name='Balance negative club nbde')),
-            ],
-            options={
-                'verbose_name': 'Summary',
-                'verbose_name_plural': 'Summaries',
-            },
-        ),
-    ]
--- a/apps/treasury/models.py
+++ b/apps/treasury/models.py
@ -460,117 +460,3 @@ class SogeCredit(models.Model):
            self.credit_transaction._force_save = True
            self.credit_transaction.save()
        super().delete(**kwargs)
-
-
-class NoteSummary(models.Model):
-    """
-    Summary of every notes
-    """
-
-    date = models.DateField(
-        default=date.today,
-        verbose_name=_("Date"),
-    )
-
-    total_positive_user = models.PositiveIntegerField(
-        verbose_name=_("Total positive user"),
-    )
-
-    balance_positive_user = models.PositiveIntegerField(
-        verbose_name=_("Balance positive user"),
-    )
-
-    total_positive_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Total positive user BDE"),
-    )
-
-    balance_positive_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Balance positive user BDE"),
-    )
-
-    total_zero_user = models.PositiveIntegerField(
-        verbose_name=_("Total zero user"),
-    )
-
-    total_zero_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Total zero user BDE"),
-    )
-
-    total_negative_user = models.PositiveIntegerField(
-        verbose_name=_("Total negative user"),
-    )
-
-    balance_negative_user = models.PositiveIntegerField(
-        verbose_name=_("Balance negative user"),
-    )
-
-    total_negative_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Total negative user BDE"),
-    )
-
-    balance_negative_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Balance negative user BDE"),
-    )
-
-    total_vnegative_user = models.PositiveIntegerField(
-        verbose_name=_("Total very negative user"),
-    )
-
-    balance_vnegative_user = models.PositiveIntegerField(
-        verbose_name=_("Balance very negative user"),
-    )
-
-    total_vnegative_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Total very negative user BDE"),
-    )
-
-    balance_vnegative_user_bde = models.PositiveIntegerField(
-        verbose_name=_("Balance very negative user BDE"),
-    )
-
-    total_positive_club = models.PositiveIntegerField(
-        verbose_name=_("Total positive club"),
-    )
-
-    balance_positive_club = models.PositiveIntegerField(
-        verbose_name=_("Balance positive club"),
-    )
-
-    total_positive_club_nbde = models.PositiveIntegerField(
-        verbose_name=_("Total positive club nbde"),
-    )
-
-    balance_positive_club_nbde = models.PositiveIntegerField(
-        verbose_name=_("Balance positive club nbde"),
-    )
-
-    total_zero_club = models.PositiveIntegerField(
-        verbose_name=_("Total zero club"),
-    )
-
-    total_zero_club_nbde = models.PositiveIntegerField(
-        verbose_name=_("Total zero club nbde"),
-    )
-
-    total_negative_club = models.PositiveIntegerField(
-        verbose_name=_("Total negative club"),
-    )
-
-    balance_negative_club = models.PositiveIntegerField(
-        verbose_name=_("Balance negative club"),
-    )
-
-    total_negative_club_nbde = models.PositiveIntegerField(
-        verbose_name=_("Total negative club nbde"),
-    )
-
-    balance_negative_club_nbde = models.PositiveIntegerField(
-        verbose_name=_("Balance negative club nbde"),
-    )
-
-    class Meta:
-        verbose_name = _("Summary")
-        verbose_name_plural = _("Summaries")
-
-    def __str__(self):
-        return "Note summary of {date}".format(date=self.date)
--- a/apps/treasury/views.py
+++ b/apps/treasury/views.py
@ -20,6 +20,7 @@ from django.views.generic import UpdateView, DetailView
 from django.views.generic.base import View, TemplateView
 from django.views.generic.edit import BaseFormView, DeleteView
 from django_tables2 import SingleTableView
+from api.viewsets import is_regex
 from note.models import SpecialTransaction, NoteSpecial, Alias
 from note_kfet.settings.base import BASE_DIR
 from permission.backends import PermissionBackend
@ -411,11 +412,16 @@ class SogeCreditListView(LoginRequiredMixin, ProtectQuerysetMixin, SingleTableVi
        if "search" in self.request.GET:
            pattern = self.request.GET["search"]
            if pattern:
+                # Check if this is a valid regex. If not, we won't check regex
+                valid_regex = is_regex(pattern)
+                suffix_alias = "__iregex" if valid_regex else "__icontains"
+                suffix = "__iregex" if valid_regex else "__istartswith"
+                prefix = "^" if valid_regex else ""
                qs = qs.filter(
-                    Q(user__first_name__iregex=pattern)
-                    | Q(user__last_name__iregex=pattern)
-                    | Q(user__note__alias__name__iregex="^" + pattern)
-                    | Q(user__note__alias__normalized_name__iregex="^" + Alias.normalize(pattern))
+                    Q(**{f"user__first_name{suffix}": pattern})
+                    | Q(**{f"user__last_name{suffix}": pattern})
+                    | Q(**{f"user__note__alias__name{suffix_alias}": prefix + pattern})
+                    | Q(**{f"user__note__alias__normalized_name{suffix_alias}": prefix + Alias.normalize(pattern)})
                )

        if "valid" not in self.request.GET or not self.request.GET["valid"]:
--- a/apps/wei/api/views.py
+++ b/apps/wei/api/views.py
@ -2,7 +2,8 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import OrderingFilter, SearchFilter
+from rest_framework.filters import OrderingFilter
+from api.filters import RegexSafeSearchFilter
 from api.viewsets import ReadProtectedModelViewSet

 from .serializers import WEIClubSerializer, BusSerializer, BusTeamSerializer, WEIRoleSerializer, \
@ -18,7 +19,7 @@ class WEIClubViewSet(ReadProtectedModelViewSet):
    """
    queryset = WEIClub.objects.order_by('id')
    serializer_class = WEIClubSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'year', 'date_start', 'date_end', 'email', 'note__alias__name',
                        'note__alias__normalized_name', 'parent_club', 'parent_club__name', 'require_memberships',
                        'membership_fee_paid', 'membership_fee_unpaid', 'membership_duration', 'membership_start',
@ -34,7 +35,7 @@ class BusViewSet(ReadProtectedModelViewSet):
    """
    queryset = Bus.objects.order_by('id')
    serializer_class = BusSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'wei', 'description', ]
    search_fields = ['$name', '$wei__name', '$description', ]

@ -47,7 +48,7 @@ class BusTeamViewSet(ReadProtectedModelViewSet):
    """
    queryset = BusTeam.objects.order_by('id')
    serializer_class = BusTeamSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'bus', 'color', 'description', 'bus__wei', ]
    search_fields = ['$name', '$bus__name', '$bus__wei__name', '$description', ]

@ -60,7 +61,7 @@ class WEIRoleViewSet(ReadProtectedModelViewSet):
    """
    queryset = WEIRole.objects.order_by('id')
    serializer_class = WEIRoleSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['name', 'permissions', 'memberships', ]
    search_fields = ['$name', ]

@ -73,7 +74,7 @@ class WEIRegistrationViewSet(ReadProtectedModelViewSet):
    """
    queryset = WEIRegistration.objects.order_by('id')
    serializer_class = WEIRegistrationSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter]
+    filter_backends = [DjangoFilterBackend, RegexSafeSearchFilter]
    filterset_fields = ['user', 'user__username', 'user__first_name', 'user__last_name', 'user__email',
                        'user__note__alias__name', 'user__note__alias__normalized_name', 'wei', 'wei__name',
                        'wei__email', 'wei__year', 'soge_credit', 'caution_check', 'birth_date', 'gender',
@ -92,7 +93,7 @@ class WEIMembershipViewSet(ReadProtectedModelViewSet):
    """
    queryset = WEIMembership.objects.order_by('id')
    serializer_class = WEIMembershipSerializer
-    filter_backends = [DjangoFilterBackend, OrderingFilter, SearchFilter]
+    filter_backends = [DjangoFilterBackend, OrderingFilter, RegexSafeSearchFilter]
    filterset_fields = ['club__name', 'club__email', 'club__note__alias__name',
                        'club__note__alias__normalized_name', 'user__username', 'user__last_name',
                        'user__first_name', 'user__email', 'user__note__alias__name',
--- a/apps/wei/views.py
+++ b/apps/wei/views.py
@ -23,6 +23,7 @@ from django.views.generic import DetailView, UpdateView, RedirectView, TemplateV
 from django.utils.translation import gettext_lazy as _
 from django.views.generic.edit import BaseFormView, DeleteView
 from django_tables2 import SingleTableView
+from api.viewsets import is_regex
 from member.models import Membership, Club
 from note.models import Transaction, NoteClub, Alias, SpecialTransaction, NoteSpecial
 from note.tables import HistoryTable
@ -219,13 +220,18 @@ class WEIMembershipsView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTableVi
        if not pattern:
            return qs.none()

+        # Check if this is a valid regex. If not, we won't check regex
+        valid_regex = is_regex(pattern)
+        suffix_alias = "__iregex" if valid_regex else "__istartswith"
+        suffix = "__iregex" if valid_regex else "__icontains"
+        prefix = "^" if valid_regex else ""
        qs = qs.filter(
-            Q(user__first_name__iregex=pattern)
-            | Q(user__last_name__iregex=pattern)
-            | Q(user__note__alias__name__iregex="^" + pattern)
-            | Q(user__note__alias__normalized_name__iregex="^" + Alias.normalize(pattern))
-            | Q(bus__name__iregex=pattern)
-            | Q(team__name__iregex=pattern)
+            Q(**{f"user__first_name{suffix}": pattern})
+            | Q(**{f"user__last_name{suffix}": pattern})
+            | Q(**{f"user__note__alias__name{suffix_alias}": prefix + pattern})
+            | Q(**{f"user__note__alias__normalized_name{suffix_alias}": prefix + Alias.normalize(pattern)})
+            | Q(**{f"bus__name{suffix}": pattern})
+            | Q(**{f"team__name{suffix}": pattern})
        )

        return qs
@ -255,11 +261,16 @@ class WEIRegistrationsView(ProtectQuerysetMixin, LoginRequiredMixin, SingleTable
        pattern = self.request.GET.get("search", "")

        if pattern:
+            # Check if this is a valid regex. If not, we won't check regex
+            valid_regex = is_regex(pattern)
+            suffix_alias = "__iregex" if valid_regex else "__istartswith"
+            suffix = "__iregex" if valid_regex else "__icontains"
+            prefix = "^" if valid_regex else ""
            qs = qs.filter(
-                Q(user__first_name__iregex=pattern)
-                | Q(user__last_name__iregex=pattern)
-                | Q(user__note__alias__name__iregex="^" + pattern)
-                | Q(user__note__alias__normalized_name__iregex="^" + Alias.normalize(pattern))
+                Q(**{f"user__first_name{suffix}": pattern})
+                | Q(**{f"user__last_name{suffix}": pattern})
+                | Q(**{f"user__note__alias__name{suffix_alias}": prefix + pattern})
+                | Q(**{f"user__note__alias__normalized_name{suffix_alias}": prefix + Alias.normalize(pattern)})
            )

        return qs
--- a/locale/fr/LC_MESSAGES/django.po
+++ b/locale/fr/LC_MESSAGES/django.po
@ -114,7 +114,7 @@ msgstr "Lieu où l'activité est organisée, par exemple la Kfet."
 msgid "type"
 msgstr "type"

-#: apps/activity/models.py:89 apps/logs/models.py:22 apps/member/models.py:318
+#: apps/activity/models.py:89 apps/logs/models.py:22 apps/member/models.py:313
 #: apps/note/models/notes.py:148 apps/treasury/models.py:293
 #: apps/wei/models.py:171 apps/wei/templates/wei/attribute_bus_1A.html:13
 #: apps/wei/templates/wei/survey.html:15
@ -247,7 +247,6 @@ msgid "The validation of the activity is pending."
 msgstr "La validation de cette activité est en attente."

 #: apps/activity/tables.py:43 apps/treasury/tables.py:107
-#: apps/member/templates/member/picture_update.html:18
 msgid "Remove"
 msgstr "Supprimer"

@ -263,13 +262,13 @@ msgstr "supprimer"
 msgid "Type"
 msgstr "Type"

-#: apps/activity/tables.py:84 apps/member/forms.py:196
+#: apps/activity/tables.py:84 apps/member/forms.py:193
 #: apps/registration/forms.py:92 apps/treasury/forms.py:131
 #: apps/wei/forms/registration.py:104
 msgid "Last name"
 msgstr "Nom de famille"

-#: apps/activity/tables.py:86 apps/member/forms.py:201
+#: apps/activity/tables.py:86 apps/member/forms.py:198
 #: apps/note/templates/note/transaction_form.html:138
 #: apps/registration/forms.py:97 apps/treasury/forms.py:133
 #: apps/wei/forms/registration.py:109
@ -401,37 +400,37 @@ msgstr "Inviter"
 msgid "Create new activity"
 msgstr "Créer une nouvelle activité"

-#: apps/activity/views.py:68 note_kfet/templates/base.html:90
+#: apps/activity/views.py:67 note_kfet/templates/base.html:90
 msgid "Activities"
 msgstr "Activités"

-#: apps/activity/views.py:108
+#: apps/activity/views.py:93
 msgid "Activity detail"
 msgstr "Détails de l'activité"

-#: apps/activity/views.py:128
+#: apps/activity/views.py:113
 msgid "Update activity"
 msgstr "Modifier l'activité"

-#: apps/activity/views.py:155
+#: apps/activity/views.py:140
 msgid "Invite guest to the activity \"{}\""
 msgstr "Invitation pour l'activité « {} »"

-#: apps/activity/views.py:193
+#: apps/activity/views.py:178
 msgid "You are not allowed to display the entry interface for this activity."
 msgstr ""
 "Vous n'êtes pas autorisé·e à afficher l'interface des entrées pour cette "
 "activité."

-#: apps/activity/views.py:196
+#: apps/activity/views.py:181
 msgid "This activity does not support activity entries."
 msgstr "Cette activité ne requiert pas d'entrées."

-#: apps/activity/views.py:199
+#: apps/activity/views.py:184
 msgid "This activity is closed."
 msgstr "Cette activité est fermée."

-#: apps/activity/views.py:295
+#: apps/activity/views.py:280
 msgid "Entry for activity \"{}\""
 msgstr "Entrées pour l'activité « {} »"

@ -508,11 +507,11 @@ msgstr "cotisation pour adhérer (normalien·ne élève)"
 msgid "membership fee (unpaid students)"
 msgstr "cotisation pour adhérer (normalien·ne étudiant·e)"

-#: apps/member/admin.py:65 apps/member/models.py:330
+#: apps/member/admin.py:65 apps/member/models.py:325
 msgid "roles"
 msgstr "rôles"

-#: apps/member/admin.py:66 apps/member/models.py:344
+#: apps/member/admin.py:66 apps/member/models.py:339
 msgid "fee"
 msgstr "cotisation"

@ -564,29 +563,29 @@ msgid "This image cannot be loaded."
 msgstr "Cette image ne peut pas être chargée."

 #: apps/member/forms.py:148 apps/member/views.py:102
-#: apps/registration/forms.py:34 apps/registration/views.py:276
+#: apps/registration/forms.py:34 apps/registration/views.py:266
 msgid "An alias with a similar name already exists."
 msgstr "Un alias avec un nom similaire existe déjà."

-#: apps/member/forms.py:175
+#: apps/member/forms.py:172
 msgid "Inscription paid by Société Générale"
 msgstr "Inscription payée par la Société générale"

-#: apps/member/forms.py:177
+#: apps/member/forms.py:174
 msgid "Check this case if the Société Générale paid the inscription."
 msgstr "Cochez cette case si la Société Générale a payé l'inscription."

-#: apps/member/forms.py:182 apps/registration/forms.py:79
+#: apps/member/forms.py:179 apps/registration/forms.py:79
 #: apps/wei/forms/registration.py:91
 msgid "Credit type"
 msgstr "Type de rechargement"

-#: apps/member/forms.py:183 apps/registration/forms.py:80
+#: apps/member/forms.py:180 apps/registration/forms.py:80
 #: apps/wei/forms/registration.py:92
 msgid "No credit"
 msgstr "Pas de rechargement"

-#: apps/member/forms.py:185
+#: apps/member/forms.py:182
 msgid "You can credit the note of the user."
 msgstr "Vous pouvez créditer la note de l'utilisateur·ice avant l'adhésion."

@ -595,17 +594,17 @@ msgstr "Vous pouvez créditer la note de l'utilisateur·ice avant l'adhésion."
 msgid "Credit amount"
 msgstr "Montant à créditer"

-#: apps/member/forms.py:206 apps/note/templates/note/transaction_form.html:144
+#: apps/member/forms.py:203 apps/note/templates/note/transaction_form.html:144
 #: apps/registration/forms.py:102 apps/treasury/forms.py:135
 #: apps/wei/forms/registration.py:114
 msgid "Bank"
 msgstr "Banque"

-#: apps/member/forms.py:233
+#: apps/member/forms.py:230
 msgid "User"
 msgstr "Utilisateur·ice"

-#: apps/member/forms.py:247
+#: apps/member/forms.py:244
 msgid "Roles"
 msgstr "Rôles"

@ -853,50 +852,46 @@ msgstr ""
 "Date maximale d'une fin d'adhésion, après laquelle les adhérent·e·s doivent la "
 "renouveler."

-#: apps/member/models.py:263
-msgid "add to registration form"
-msgstr "ajouter au formulaire d'inscription"
-
-#: apps/member/models.py:268 apps/member/models.py:324
+#: apps/member/models.py:263 apps/member/models.py:319
 #: apps/note/models/notes.py:176
 msgid "club"
 msgstr "club"

-#: apps/member/models.py:269
+#: apps/member/models.py:264
 msgid "clubs"
 msgstr "clubs"

-#: apps/member/models.py:335
+#: apps/member/models.py:330
 msgid "membership starts on"
 msgstr "l'adhésion commence le"

-#: apps/member/models.py:339
+#: apps/member/models.py:334
 msgid "membership ends on"
 msgstr "l'adhésion finit le"

-#: apps/member/models.py:348 apps/note/models/transactions.py:385
+#: apps/member/models.py:343 apps/note/models/transactions.py:385
 msgid "membership"
 msgstr "adhésion"

-#: apps/member/models.py:349
+#: apps/member/models.py:344
 msgid "memberships"
 msgstr "adhésions"

-#: apps/member/models.py:353
+#: apps/member/models.py:348
 #, python-brace-format
 msgid "Membership of {user} for the club {club}"
 msgstr "Adhésion de {user} pour le club {club}"

-#: apps/member/models.py:372
+#: apps/member/models.py:367
 #, python-brace-format
 msgid "The role {role} does not apply to the club {club}."
 msgstr "Le rôle {role} ne s'applique pas au club {club}."

-#: apps/member/models.py:381 apps/member/views.py:712
+#: apps/member/models.py:376 apps/member/views.py:712
 msgid "User is already a member of the club"
 msgstr "L'utilisateur·ice est déjà membre du club"

-#: apps/member/models.py:393 apps/member/views.py:721
+#: apps/member/models.py:388 apps/member/views.py:721
 msgid "User is not a member of the parent club"
 msgstr "L'utilisateur·ice n'est pas membre du club parent"

@ -1158,11 +1153,11 @@ msgstr "Introspection :"
 msgid "Show my applications"
 msgstr "Voir mes applications"

-#: apps/member/templates/member/picture_update.html:38
+#: apps/member/templates/member/picture_update.html:35
 msgid "Nevermind"
 msgstr "Annuler"

-#: apps/member/templates/member/picture_update.html:39
+#: apps/member/templates/member/picture_update.html:36
 msgid "Crop and upload"
 msgstr "Recadrer et envoyer"

@ -1701,8 +1696,6 @@ msgstr "Historique des transactions récentes"
 #: apps/note/templates/note/mails/negative_balance.txt:25
 #: apps/note/templates/note/mails/negative_notes_report.html:46
 #: apps/note/templates/note/mails/negative_notes_report.txt:13
-#: apps/note/templates/note/mails/summary_notes_report.html:62
-#: apps/note/templates/note/mails/summary_ntoes_report.txt:33
 #: apps/note/templates/note/mails/weekly_report.html:51
 #: apps/note/templates/note/mails/weekly_report.txt:32
 #: apps/registration/templates/registration/mails/email_validation_email.html:40
@ -2190,23 +2183,18 @@ msgstr "Utilisateur·ice·s en attente d'inscription"
 msgid "Registration detail"
 msgstr "Détails de l'inscription"

-#: apps/registration/views.py:256
-#, python-format
-msgid "Join %(club)s Club"
-msgstr "Adhérer au club %(club)s"
-
-#: apps/registration/views.py:299
+#: apps/registration/views.py:293
 msgid "You must join the BDE."
 msgstr "Vous devez adhérer au BDE."

-#: apps/registration/views.py:330
+#: apps/registration/views.py:323
 msgid ""
 "The entered amount is not enough for the memberships, should be at least {}"
 msgstr ""
 "Le montant crédité est trop faible pour adhérer, il doit être au minimum de "
 "{}"

-#: apps/registration/views.py:425
+#: apps/registration/views.py:417
 msgid "Invalidate pre-registration"
 msgstr "Invalider l'inscription"

@ -2264,7 +2252,6 @@ msgid "Address"
 msgstr "Adresse"

 #: apps/treasury/models.py:69 apps/treasury/models.py:202
-#: apps/treasury/models.py:472
 msgid "Date"
 msgstr "Date"

@ -2383,102 +2370,6 @@ msgstr ""
 "Cet·te utilisateur·ice n'a pas assez d'argent pour payer les adhésions avec sa "
 "note. Merci de lui demander de recharger sa note avant d'invalider ce crédit."

-#: apps/treasury/models.py:476
-msgid "Total positive user"
-msgstr "Nombre d'utilisateur⋅rices en positif"
-
-#: apps/treasury/models.py:480
-msgid "Balance positive user"
-msgstr "Solde des utilisateur⋅rices en positif"
-
-#: apps/treasury/models.py:484
-msgid "Total positive user BDE"
-msgstr "Nombre d'adhérent⋅es au BDE en positif"
-
-#: apps/treasury/models.py:488
-msgid "Balance positive user BDE"
-msgstr "Solde des adhérent⋅es au BDE en positif"
-
-#: apps/treasury/models.py:492
-msgid "Total zero user"
-msgstr "Nombre d'utilisateur⋅rices à zéro"
-
-#: apps/treasury/models.py:496
-msgid "Total zero user BDE"
-msgstr "Nombre d'adhérent⋅es au BDE à zéro"
-
-#: apps/treasury/models.py:500
-msgid "Total negative user"
-msgstr "Nombre d'utilisateur⋅rices en négatif"
-
-#: apps/treasury/models.py:504
-msgid "Balance negative user"
-msgstr "Solde des utilisateur⋅rices en négatif"
-
-#: apps/treasury/models.py:508
-msgid "Total negative user BDE"
-msgstr "Nombre d'adhérent⋅es au BDE en négatif"
-
-#: apps/treasury/models.py:512
-msgid "Balance negative user BDE"
-msgstr "Solde des adhérent⋅es au BDE en négatif"
-
-#: apps/treasury/models.py:516
-msgid "Total very negative user"
-msgstr "Nombre d'utilisateur⋅rices en négatif sévère"
-
-#: apps/treasury/models.py:520
-msgid "Balance very negative user"
-msgstr "Solde des utilisateur⋅rices en négatif sévère"
-
-#: apps/treasury/models.py:524
-msgid "Total very negative user BDE"
-msgstr "Nombre d'adhérent⋅es au BDE en négatif sévère"
-
-#: apps/treasury/models.py:528
-msgid "Balance very negative user BDE"
-msgstr "Solde des adhérent⋅es au BDE en négatif sévère"
-
-#: apps/treasury/models.py:532
-msgid "Total positive club"
-msgstr "Nombre de clubs en positif"
-
-#: apps/treasury/models.py:536
-msgid "Balance positive club"
-msgstr "Solde des clubs en positif"
-
-#: apps/treasury/models.py:540
-msgid "Total positive club nbde"
-msgstr "Nombre de clubs non-BDE en positif"
-
-#: apps/treasury/models.py:544
-msgid "Balance positive club nbde"
-msgstr "Solde des clubs non-BDE en positif"
-
-#: apps/treasury/models.py:548
-msgid "Total zero club"
-msgstr "Nombre de clubs à zéro"
-
-#: apps/treasury/models.py:552
-msgid "Total zero club nbde"
-msgstr "Nombre de clubs non-BDE à zéro"
-
-#: apps/treasury/models.py:556
-msgid "Total negative club"
-msgstr "Nombre de clubs en négatif"
-
-#: apps/treasury/models.py:560
-msgid "Balance negative club"
-msgstr "Solde des clubs en négatif"
-
-#: apps/treasury/models.py:564
-msgid "Total negative club nbde"
-msgstr "Nombre de clubs non-BDE en négatif"
-
-#: apps/treasury/models.py:568
-msgid "Balance negative club nbde"
-msgstr "Solde des clubs non-BDE en négatif"
-
 #: apps/treasury/tables.py:20
 msgid "Invoice #{:d}"
 msgstr "Facture n°{:d}"
@ -3729,6 +3620,9 @@ msgstr ""
 "d'adhésion. Vous devez également valider votre adresse email en suivant le "
 "lien que vous avez reçu."

+#~ msgid "Join BDA Club"
+#~ msgstr "Adhérer au club BDA"
+
 #, fuzzy
 #~| msgid "People having you as a friend"
 #~ msgid "You already have that person as a friend"
--- a/note.cron
+++ b/note.cron
@ -19,8 +19,6 @@ MAILTO=notekfet2020@lists.crans.org
 00  5     *   *   2     root   cd /var/www/note_kfet && env/bin/python manage.py send_mail_to_negative_balances --spam --negative-amount 1 -v 0
 # Envoyer le rapport mensuel aux trésoriers et respos info
 00  8     *   *   5     root   cd /var/www/note_kfet && env/bin/python manage.py send_mail_to_negative_balances --report --add-years 1 -v 0
-# Envoyer le recap de tresorerie
- 00  8     *   *   5     root   cd /var/www/note_kfet && env/bin/python manage.py send_summary_notes_report --negative-amount 2000
 # Envoyer les rapports aux gens
 55  6     *   *   *     root   cd /var/www/note_kfet && env/bin/python manage.py send_reports -v 0
 # Mettre à jour les boutons mis en avant
Author	SHA1	Message	Date
korenstin	74f0923feb	Merge branch 'no-api-error' into 'main' fix #113 See merge request bde/nk20!253	2024-07-18 16:28:30 +02:00
korenstin	de7b91db2a	Fix #113 . Fix regex in views.	2024-07-18 14:16:37 +02:00
Yohann D'ANELLO	799c43f688	Parse input of search filters to prevent errors based on invalid regex, fixes #113 Signed-off-by: Yohann D'ANELLO <ynerant@crans.org>	2024-07-18 14:16:07 +02:00