change birthdate only if user didn't have it previously

core/api.py

@@ -25,6 +25,7 @@ from core.schemas import (
     UserFamilySchema,
     UserFilterSchema,
     UserProfileSchema,
+    UserSchema,
 )
 from core.templatetags.renderer import markdown
 
@@ -69,16 +70,22 @@ class MailingListController(ControllerBase):
         return data
 
 
-@api_controller("/user", permissions=[CanAccessLookup])
+@api_controller("/user")
 class UserController(ControllerBase):
-    @route.get("", response=list[UserProfileSchema])
+    @route.get("", response=list[UserProfileSchema], permissions=[CanAccessLookup])
     def fetch_profiles(self, pks: Query[set[int]]):
         return User.objects.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)
+
     @route.get(
         "/search",
         response=PaginatedResponseSchema[UserProfileSchema],
         url_name="search_users",
+        permissions=[CanAccessLookup],
     )
     @paginate(PageNumberPaginationExtra, page_size=20)
     def search_users(self, filters: Query[UserFilterSchema]):

core/management/commands/populate_more.py

@@ -94,7 +94,11 @@ class Command(BaseCommand):
                 username=self.faker.user_name(),
                 first_name=self.faker.first_name(),
                 last_name=self.faker.last_name(),
-                date_of_birth=self.faker.date_of_birth(minimum_age=15, maximum_age=25),
+                date_of_birth=(
+                    None
+                    if random.random() < 0.2
+                    else self.faker.date_of_birth(minimum_age=15, maximum_age=25)
+                ),
                 email=self.faker.email(),
                 phone=self.faker.phone_number(),
                 address=self.faker.address(),

core/models.py

@@ -560,7 +560,7 @@ class User(AbstractUser):
         """Determine if the object is owned by the user."""
         if hasattr(obj, "is_owned_by") and obj.is_owned_by(self):
             return True
-        if hasattr(obj, "owner_group") and self.is_in_group(pk=obj.owner_group_id):
+        if hasattr(obj, "owner_group") and self.is_in_group(pk=obj.owner_group.id):
             return True
         return self.is_root
 
@@ -569,15 +569,9 @@ class User(AbstractUser):
         if hasattr(obj, "can_be_edited_by") and obj.can_be_edited_by(self):
             return True
         if hasattr(obj, "edit_groups"):
-            if (
+            for pk in obj.edit_groups.values_list("pk", flat=True):
-                hasattr(obj, "_prefetched_objects_cache")
+                if self.is_in_group(pk=pk):
-                and "edit_groups" in obj._prefetched_objects_cache
+                    return True
-            ):
-                pks = [g.id for g in obj.edit_groups.all()]
-            else:
-                pks = list(obj.edit_groups.values_list("id", flat=True))
-            if any(self.is_in_group(pk=pk) for pk in pks):
-                return True
         if isinstance(obj, User) and obj == self:
             return True
         return self.is_owner(obj)
@@ -587,18 +581,9 @@ class User(AbstractUser):
         if hasattr(obj, "can_be_viewed_by") and obj.can_be_viewed_by(self):
             return True
         if hasattr(obj, "view_groups"):
-            # if "view_groups" has already been prefetched, use
+            for pk in obj.view_groups.values_list("pk", flat=True):
-            # the prefetch cache, else fetch only the ids, to make
+                if self.is_in_group(pk=pk):
-            # the query lighter.
+                    return True
-            if (
-                hasattr(obj, "_prefetched_objects_cache")
-                and "view_groups" in obj._prefetched_objects_cache
-            ):
-                pks = [g.id for g in obj.view_groups.all()]
-            else:
-                pks = list(obj.view_groups.values_list("id", flat=True))
-            if any(self.is_in_group(pk=pk) for pk in pks):
-                return True
         return self.can_edit(obj)
 
     def can_be_edited_by(self, user):
@@ -1399,9 +1384,9 @@ class Page(models.Model):
 
     @cached_property
     def is_club_page(self):
-        return (
+        club_root_page = Page.objects.filter(name=settings.SITH_CLUB_ROOT_PAGE).first()
-            self.name == settings.SITH_CLUB_ROOT_PAGE
+        return club_root_page is not None and (
-            or settings.SITH_CLUB_ROOT_PAGE in [p.name for p in self.get_parent_list()]
+            self == club_root_page or club_root_page in self.get_parent_list()
         )
 
     @cached_property

core/schemas.py

@@ -34,6 +34,22 @@ class SimpleUserSchema(ModelSchema):
         fields = ["id", "nick_name", "first_name", "last_name"]
 
 
+class UserSchema(ModelSchema):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "nick_name",
+            "first_name",
+            "last_name",
+            "date_of_birth",
+            "email",
+            "role",
+            "quote",
+            "promo",
+        ]
+
+
 class UserProfileSchema(ModelSchema):
     """The necessary information to show a user profile"""
 

core/templates/core/page_list.jinja

@@ -5,12 +5,16 @@
 {% endblock %}
 
 {% block content %}
-  <h3>{% trans %}Page list{% endtrans %}</h3>
+  {% if page_list %}
-  <ul>
+    <h3>{% trans %}Page list{% endtrans %}</h3>
-    {% for p in page_list %}
+    <ul>
-      <li><a href="{{ p.get_absolute_url() }}">{{ p.display_name }}</a></li>
+      {% for p in page_list %}
-    {% endfor %}
+        <li><a href="{{ p.get_absolute_url() }}">{{ p.get_display_name() }}</a></li>
-  </ul>
+      {% endfor %}
+    </ul>
+  {% else %}
+    {% trans %}There is no page in this website.{% endtrans %}
+  {% endif %}
 {% endblock %}
 
 

core/views/page.py

@@ -12,10 +12,7 @@
 # OR WITHIN THE LOCAL FILE "LICENSE"
 #
 #
-
 from django.contrib.auth.mixins import PermissionRequiredMixin
-from django.db.models import F, OuterRef, Subquery
-from django.db.models.functions import Coalesce
 
 # This file contains all the views that concern the page model
 from django.forms.models import modelform_factory
@@ -46,20 +43,6 @@ class CanEditPagePropMixin(CanEditPropMixin):
 class PageListView(CanViewMixin, ListView):
     model = Page
     template_name = "core/page_list.jinja"
-    queryset = (
-        Page.objects.annotate(
-            display_name=Coalesce(
-                Subquery(
-                    PageRev.objects.filter(page=OuterRef("id"))
-                    .order_by("-date")
-                    .values("title")[:1]
-                ),
-                F("name"),
-            )
-        )
-        .prefetch_related("view_groups")
-        .select_related("parent")
-    )
 
 
 class PageView(CanViewMixin, DetailView):

galaxy/management/commands/rule_galaxy.py

@@ -45,9 +45,8 @@ class Command(BaseCommand):
                 "verbosity level should be between 0 and 2 included", stacklevel=2
             )
 
-        if options["verbosity"] >= 2:
+        if options["verbosity"] == 2:
             logger.setLevel(logging.DEBUG)
-            logging.getLogger("django.db.backends").setLevel(logging.DEBUG)
         elif options["verbosity"] == 1:
             logger.setLevel(logging.INFO)
         else:
@@ -60,3 +59,6 @@ class Command(BaseCommand):
         Galaxy.objects.filter(state__isnull=True).delete()
 
         logger.info("Ruled the galaxy in {} queries.".format(len(connection.queries)))
+        if options["verbosity"] > 2:
+            for q in connection.queries:
+                logger.debug(q)

galaxy/models.py

@@ -31,14 +31,13 @@ from collections import defaultdict
 from typing import NamedTuple, TypedDict
 
 from django.db import models
-from django.db.models import Count, Exists, F, OuterRef, Q, QuerySet
+from django.db.models import Count, F, Q, QuerySet
-from django.utils.timezone import localdate, now
+from django.utils.timezone import localdate
 from django.utils.translation import gettext_lazy as _
 
 from club.models import Membership
 from core.models import User
 from sas.models import PeoplePictureRelation, Picture
-from subscription.models import Subscription
 
 
 class GalaxyStar(models.Model):
@@ -199,16 +198,8 @@ class Galaxy(models.Model):
         cls, picture_count_threshold: int = DEFAULT_PICTURE_COUNT_THRESHOLD
     ) -> QuerySet[User]:
         return (
-            User.objects.filter(is_subscriber_viewable=True)
+            User.objects.exclude(subscriptions=None)
-            .exclude(subscriptions=None)
+            .annotate(pictures_count=Count("pictures"))
-            .annotate(
-                pictures_count=Count("pictures"),
-                is_active_in_galaxy=Exists(
-                    Subscription.objects.filter(
-                        member=OuterRef("id"), subscription_end__gt=now()
-                    )
-                ),
-            )
             .filter(pictures_count__gt=picture_count_threshold)
             .distinct()
         )
@@ -299,9 +290,9 @@ class Galaxy(models.Model):
         31/12/2022 (also two years, but with an offset of one year), then their
         club score is 365.
         """
-        memberships = user.memberships.values("start_date", "end_date", "club_id")
+        memberships = user.memberships.only("start_date", "end_date", "club_id")
         result = defaultdict(int)
-        today = localdate()
+        now = localdate()
         for membership in memberships:
             # This is a N+1 query, but 92% of galaxy users have less than 10 memberships.
             # Only 5 users have more than 30 memberships.
@@ -309,23 +300,23 @@ class Galaxy(models.Model):
                 Membership.objects.exclude(user=user)
                 .filter(
                     Q(  # start2 <= start1 <= end2
-                        start_date__lte=membership["start_date"],
+                        start_date__lte=membership.start_date,
-                        end_date__gte=membership["start_date"],
+                        end_date__gte=membership.start_date,
                     )
-                    | Q(  # start2 <= start1 <= today
+                    | Q(  # start2 <= start1 <= now
-                        start_date__lte=membership["start_date"], end_date=None
+                        start_date__lte=membership.start_date, end_date=None
                     )
                     | Q(  # start1 <= start2 <= end2
-                        start_date__gte=membership["start_date"],
+                        start_date__gte=membership.start_date,
-                        start_date__lte=membership["end_date"] or today,
+                        start_date__lte=membership.end_date or now,
                     ),
-                    club_id=membership["club_id"],
+                    club_id=membership.club_id,
                 )
                 .only("start_date", "end_date", "user_id")
             )
             for other in common_memberships:
-                start = max(membership["start_date"], other.start_date)
+                start = max(membership.start_date, other.start_date)
-                end = min(membership["end_date"] or today, other.end_date or today)
+                end = min(membership.end_date or now, other.end_date or now)
                 result[other.user_id] += (end - start).days * cls.CLUBS_POINTS
         return result
 
@@ -391,22 +382,18 @@ class Galaxy(models.Model):
         # this is memory expensive but prevents a lot of db hits, therefore
         # is far more time efficient
 
-        rulable_users_qs = self.get_rulable_users(picture_count_threshold)
+        rulable_users = list(self.get_rulable_users(picture_count_threshold))
-        active_users_count = rulable_users_qs.filter(is_active_in_galaxy=True).count()
+        rulable_users_count = len(rulable_users)
-        rulable_users = list(rulable_users_qs)
         user1_count = 0
         self.logger.info(
-            f" {len(rulable_users)} citizens (with {active_users_count} active ones) "
+            f"{rulable_users_count} citizen have been listed. Starting to rule."
-            f"have been listed. Starting to rule."
         )
 
         self.logger.info("Creating stars for all citizen")
         individual_scores = self.compute_individual_scores()
         GalaxyStar.objects.bulk_create(
             [
-                GalaxyStar(
+                GalaxyStar(owner=user, galaxy=self, mass=individual_scores[user.id])
-                    owner_id=user.id, galaxy=self, mass=individual_scores[user.id]
-                )
                 for user in rulable_users
             ]
         )
@@ -418,9 +405,9 @@ class Galaxy(models.Model):
         t_global_start = time.time()
         while len(rulable_users) > 0:
             user1 = rulable_users.pop()
-            if not user1.is_active_in_galaxy:
-                continue
             user1_count += 1
+            rulable_users_count2 = len(rulable_users)
+
             star1 = stars[user1.id]
 
             lanes = []
@@ -461,20 +448,17 @@ class Galaxy(models.Model):
                 self.logger.info("")
                 self.logger.info(f" Ruling of {self} ".center(60, "#"))
                 self.logger.info(
-                    f"Progression: {user1_count}/{active_users_count} "
+                    f"Progression: {user1_count}/{rulable_users_count} "
-                    f"citizen -- {active_users_count - user1_count} remaining"
+                    f"citizen -- {rulable_users_count - user1_count} remaining"
                 )
                 self.logger.info(f"Speed: {global_avg_speed:.2f} citizen per second")
-                eta = len(rulable_users) // global_avg_speed
+                eta = rulable_users_count2 // global_avg_speed
                 self.logger.info(
                     f"ETA: {int(eta // 60 % 60)} minutes {int(eta % 60)} seconds"
                 )
                 self.logger.info("#" * 60)
             t_global_start = time.time()
 
-        count, _ = self.stars.filter(Q(lanes1=None) & Q(lanes2=None)).delete()
-        self.logger.info(f"{count} orphan stars have been trimmed.")
-
         # Here, we get the IDs of the old galaxies that we'll need to delete. In normal operation, only one galaxy
         # should be returned, and we can't delete it yet, as it's the one still displayed by the Sith.
         old_galaxies_pks = list(

galaxy/tests.py

@@ -122,7 +122,7 @@ class TestGalaxyModel(TestCase):
             self.com,
         ]
 
-        with self.assertNumQueries(38):
+        with self.assertNumQueries(44):
             while len(users) > 0:
                 user1 = users.pop(0)
                 family_scores = Galaxy.compute_user_family_score(user1)
@@ -150,7 +150,7 @@ class TestGalaxyModel(TestCase):
         that the number of queries to rule the galaxy is stable.
         """
         galaxy = Galaxy.objects.create()
-        with self.assertNumQueries(36):
+        with self.assertNumQueries(39):
             galaxy.rule(0)  # We want everybody here
 
 

locale/fr/LC_MESSAGES/django.po

@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-09-01 18:18+0200\n"
+"POT-Creation-Date: 2025-09-02 15:56+0200\n"
 "PO-Revision-Date: 2016-07-18\n"
 "Last-Translator: Maréchal <thomas.girod@utbm.fr\n"
 "Language-Team: AE info <ae.info@utbm.fr>\n"
@@ -5135,6 +5135,10 @@ msgstr "Tee-shirt AE"
 msgid "A user with that email address already exists"
 msgstr "Un utilisateur avec cette adresse email existe déjà"
 
+#: subscription/forms.py
+msgid "This user didn't fill its birthdate yet."
+msgstr "Cet utilisateur n'a pas encore renseigné sa date de naissance"
+
 #: subscription/models.py
 msgid "Bad subscription type"
 msgstr "Mauvais type de cotisation"
@@ -5174,7 +5178,7 @@ msgid ""
 "%(user)s received its new %(type)s subscription. It will be active until "
 "%(end)s included."
 msgstr ""
-"%(user)s a reçu sa nouvelle cotisaton %(type)s. Elle sert active jusqu'au "
+"%(user)s a reçu sa nouvelle cotisaton %(type)s. Elle sera active jusqu'au "
 "%(end)s inclu."
 
 #: subscription/templates/subscription/fragments/creation_success.jinja

subscription/forms.py

@@ -23,8 +23,8 @@ class SelectionDateForm(forms.Form):
 
 
 class SubscriptionForm(forms.ModelForm):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, initial=None, **kwargs):
-        initial = kwargs.pop("initial", {})
+        initial = initial or {}
         if "subscription_type" not in initial:
             initial["subscription_type"] = "deux-semestres"
         if "payment_method" not in initial:
@@ -131,8 +131,57 @@ class SubscriptionExistingUserForm(SubscriptionForm):
     """Form to add a subscription to an existing user."""
 
     template_name = "subscription/forms/create_existing_user.html"
+    required_css_class = "required"
+
+    birthdate = forms.fields_for_model(
+        User,
+        ["date_of_birth"],
+        widgets={"date_of_birth": SelectDate(attrs={"hidden": True})},
+        help_texts={"date_of_birth": _("This user didn't fill its birthdate yet.")},
+    )["date_of_birth"]
 
     class Meta:
         model = Subscription
         fields = ["member", "subscription_type", "payment_method", "location"]
         widgets = {"member": AutoCompleteSelectUser}
+
+    field_order = [
+        "member",
+        "birthdate",
+        "subscription_type",
+        "payment_method",
+        "location",
+    ]
+
+    def __init__(self, *args, initial=None, **kwargs):
+        super().__init__(*args, initial=initial, **kwargs)
+        self.fields["birthdate"].required = True
+        if not initial:
+            return
+        member: str | None = initial.get("member")
+        if member and member.isdigit():
+            member: User | None = User.objects.filter(id=int(member)).first()
+        else:
+            member = None
+        if member and member.date_of_birth:
+            # if there is an initial member with a birthdate,
+            # there is no need to ask this to the user
+            self.fields["birthdate"].initial = member.date_of_birth
+        elif member:
+            # if there is an initial member without a birthdate,
+            # then the field must be displayed
+            self.fields["birthdate"].widget.attrs.update({"hidden": False})
+        # if there is no initial member, it means that it will be
+        # dynamically selected using the AutoCompleteSelectUser widget.
+        # JS will take care of un-hiding the field if necessary
+
+    def save(self, *args, **kwargs):
+        if self.errors:
+            return super().save(*args, **kwargs)
+        if (
+            self.cleaned_data["birthdate"] is not None
+            and self.instance.member.date_of_birth is None
+        ):
+            self.instance.member.date_of_birth = self.cleaned_data["birthdate"]
+            self.instance.member.save()
+        return super().save(*args, **kwargs)

subscription/static/bundled/subscription/creation-form-existing-user-index.ts

@@ -1,3 +1,5 @@
+import { userFetchUser } from "#openapi";
+
 document.addEventListener("alpine:init", () => {
   Alpine.data("existing_user_subscription_form", () => ({
     loading: false,
@@ -12,13 +14,24 @@ document.addEventListener("alpine:init", () => {
     },
 
     async loadProfile(userId: number) {
+      const birthdayInput = document.getElementById("id_birthdate") as HTMLInputElement;
       if (!Number.isInteger(userId)) {
         this.profileFragment = "";
+        birthdayInput.hidden = true;
         return;
       }
       this.loading = true;
-      const response = await fetch(`/user/${userId}/mini/`);
+      const [miniProfile, userInfos] = await Promise.all([
-      this.profileFragment = await response.text();
+        fetch(`/user/${userId}/mini/`),
+        // biome-ignore lint/style/useNamingConvention: api is snake_case
+        userFetchUser({ path: { user_id: userId } }),
+      ]);
+      this.profileFragment = await miniProfile.text();
+      // If the user has no birthdate yet, show the form input
+      // to fill this info.
+      // Else keep the input hidden and change its value to the user birthdate
+      birthdayInput.value = userInfos.data.date_of_birth;
+      birthdayInput.hidden = userInfos.data.date_of_birth !== null;
       this.loading = false;
     },
   }));

subscription/static/subscription/css/subscription.scss

@@ -1,4 +1,14 @@
 #subscription-form form {
+  margin-top: 0;
+
+  .form-content {
+    margin-top: 0;
+  }
+
+  fieldset p:first-of-type, & > p:first-of-type {
+    margin-top: 0;
+  }
+
   .form-content.existing-user {
     max-height: 100%;
     display: flex;
@@ -13,6 +23,11 @@
      * then display the user profile right in the middle of the remaining space. */
     fieldset {
       flex: 0 1 auto;
+
+      p:has(input[hidden]) {
+        // when the input is hidden, hide the whole label+input+help text group
+        display: none;
+      }
     }
 
     #subscription-form-user-mini-profile {

subscription/tests/test_new_subscription.py

@@ -1,6 +1,6 @@
 """Tests focused on testing subscription creation"""
 
-from datetime import timedelta
+from datetime import date, timedelta
 from typing import Callable
 
 import pytest
@@ -31,6 +31,26 @@ def test_form_existing_user_valid(
 ):
     """Test `SubscriptionExistingUserForm`"""
     user = user_factory()
+    user.date_of_birth = date(year=1967, month=3, day=14)
+    user.save()
+    data = {
+        "member": user,
+        "birthdate": user.date_of_birth,
+        "subscription_type": "deux-semestres",
+        "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
+        "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
+    }
+    form = SubscriptionExistingUserForm(data)
+    assert form.is_valid()
+    form.save()
+    user.refresh_from_db()
+    assert user.is_subscribed
+
+
+@pytest.mark.django_db
+def test_form_existing_user_with_birthdate(settings: SettingsWrapper):
+    """Test `SubscriptionExistingUserForm`"""
+    user = baker.make(User, date_of_birth=None)
     data = {
         "member": user,
         "subscription_type": "deux-semestres",
@@ -38,11 +58,15 @@ def test_form_existing_user_valid(
         "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
     }
     form = SubscriptionExistingUserForm(data)
+    assert not form.is_valid()
 
+    data |= {"birthdate": date(year=1967, month=3, day=14)}
+    form = SubscriptionExistingUserForm(data)
     assert form.is_valid()
     form.save()
     user.refresh_from_db()
     assert user.is_subscribed
+    assert user.date_of_birth == date(year=1967, month=3, day=14)
 
 
 @pytest.mark.django_db
@@ -132,6 +156,14 @@ def test_page_access(
     assert res.status_code == status_code
 
 
+@pytest.mark.django_db
+def test_page_access_with_get_data(client: Client):
+    user = old_subscriber_user.make()
+    client.force_login(baker.make(User, is_superuser=True))
+    res = client.get(reverse("subscription:subscription", query={"member": user.id}))
+    assert res.status_code == 200
+
+
 @pytest.mark.django_db
 def test_submit_form_existing_user(client: Client, settings: SettingsWrapper):
     client.force_login(
@@ -140,11 +172,12 @@ def test_submit_form_existing_user(client: Client, settings: SettingsWrapper):
             user_permissions=Permission.objects.filter(codename="add_subscription"),
         )
     )
-    user = old_subscriber_user.make()
+    user = old_subscriber_user.make(date_of_birth=date(year=1967, month=3, day=14))
     response = client.post(
         reverse("subscription:fragment-existing-user"),
         {
             "member": user.id,
+            "birthdate": user.date_of_birth,
             "subscription_type": "deux-semestres",
             "location": settings.SITH_SUBSCRIPTION_LOCATIONS[0][0],
             "payment_method": settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],