WIP

Author: imperosol

core/management/commands/populate.py

@@ -693,9 +693,7 @@ def handle(self, *args, **options):
         # SAS
         for f in self.SAS_FIXTURE_PATH.glob("*"):
             if f.is_dir():
-                album = Album(name=f.name)
-                album.clean()
-                album.save()
+                album = Album.objects.create(name=f.name, is_moderated=True)
                 for p in f.iterdir():
                     file = resize_image(Image.open(p), 1000, "WEBP")
                     pict = Picture(
@@ -709,6 +707,7 @@ def handle(self, *args, **options):
                     pict.generate_thumbnails()
                     pict.full_clean()
                     pict.save()
+                album.generate_thumbnail()
 
         img_skia = Picture.objects.get(name="skia.jpg")
         img_sli = Picture.objects.get(name="sli.jpg")

core/models.py

@@ -883,8 +883,6 @@ def clean(self):
         super().clean()
         if "/" in self.name:
             raise ValidationError(_("Character '/' not authorized in name"))
-        if self == self.parent:
-            raise ValidationError(_("Loop in folder tree"), code="loop")
         if self == self.parent or (
             self.parent is not None and self in self.get_parent_list()
         ):

core/tests/test_files.py

@@ -5,6 +5,7 @@
 from uuid import uuid4
 
 import pytest
+from django.conf import settings
 from django.core.cache import cache
 from django.core.files.uploadedfile import SimpleUploadedFile, UploadedFile
 from django.test import Client, TestCase
@@ -17,8 +18,8 @@
 from core.baker_recipes import board_user, old_subscriber_user, subscriber_user
 from core.models import Group, QuickUploadImage, SithFile, User
 from core.utils import RED_PIXEL_PNG
+from sas.baker_recipes import picture_recipe
 from sas.models import Picture
-from sith import settings
 
 
 @pytest.mark.django_db
@@ -30,24 +31,19 @@ class TestImageAccess:
             lambda: baker.make(
                 User, groups=[Group.objects.get(pk=settings.SITH_GROUP_SAS_ADMIN_ID)]
             ),
-            lambda: baker.make(
-                User, groups=[Group.objects.get(pk=settings.SITH_GROUP_COM_ADMIN_ID)]
-            ),
         ],
     )
     def test_sas_image_access(self, user_factory: Callable[[], User]):
         """Test that only authorized users can access the sas image."""
         user = user_factory()
-        picture: SithFile = baker.make(
-            Picture, parent=SithFile.objects.get(pk=settings.SITH_SAS_ROOT_DIR_ID)
-        )
-        assert picture.is_owned_by(user)
+        picture = picture_recipe.make()
+        assert user.can_edit(picture)
 
     def test_sas_image_access_owner(self):
         """Test that the owner of the image can access it."""
         user = baker.make(User)
-        picture: Picture = baker.make(Picture, owner=user)
-        assert picture.is_owned_by(user)
+        picture = picture_recipe.make(owner=user)
+        assert user.can_edit(picture)
 
     @pytest.mark.parametrize(
         "user_factory",
@@ -63,7 +59,7 @@ def test_sas_image_access_forbidden(self, user_factory: Callable[[], User]):
         user = user_factory()
         owner = baker.make(User)
         picture: Picture = baker.make(Picture, owner=owner)
-        assert not picture.is_owned_by(user)
+        assert not user.can_edit(picture)
 
 
 @pytest.mark.django_db

core/utils.py

@@ -12,20 +12,23 @@
 # OR WITHIN THE LOCAL FILE "LICENSE"
 #
 #
-
+from dataclasses import dataclass
 from datetime import date, timedelta
 
 # Image utils
 from io import BytesIO
-from typing import Final, Unpack
+from typing import Any, Final, Unpack
 
 import PIL
 from django.conf import settings
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import UploadedFile
 from django.db import models
+from django.forms import BaseForm
 from django.http import Http404, HttpRequest
 from django.shortcuts import get_list_or_404
+from django.template.loader import render_to_string
+from django.utils.safestring import SafeString
 from django.utils.timezone import localdate
 from PIL import ExifTags
 from PIL.Image import Image, Resampling
@@ -44,6 +47,21 @@
 """
 
 
+@dataclass
+class FormFragmentTemplateData[T: BaseForm]:
+    """Dataclass used to pre-render form fragments"""
+
+    form: T
+    template: str
+    context: dict[str, Any]
+
+    def render(self, request: HttpRequest) -> SafeString:
+        # Request is needed for csrf_tokens
+        return render_to_string(
+            self.template, context={"form": self.form, **self.context}, request=request
+        )
+
+
 def get_start_of_semester(today: date | None = None) -> date:
     """Return the date of the start of the semester of the given date.
     If no date is given, return the start date of the current semester.

docs/tutorial/groups.md

@@ -263,3 +263,35 @@ avec un unique champ permettant de sélectionner des groupes.
 Par défaut, seuls les utilisateurs avec la permission
 `auth.change_permission` auront accès à ce formulaire
 (donc, normalement, uniquement les utilisateurs Root).
+
+```mermaid
+sequenceDiagram
+    participant A as Utilisateur
+    participant B as ReverseProxy
+    participant C as MarkdownImage
+    participant D as Model
+
+    A->>B: GET /page/foo
+    B->>C: GET /page/foo
+    C-->>B: La page, avec les urls
+    B-->>A: La page, avec les urls
+    alt image publique 
+        A->>B: GET markdown/public/2025/img.webp
+        B-->>A: img.webp
+    end
+    alt image privée 
+        A->>B: GET markdown_image/{id}
+        B->>C: GET markdown_image/{id}
+        C->>D: user.can_view(image)
+        alt l'utilisateur a le droit de voir l'image
+            D-->>C: True
+            C-->>B: 200 (avec le X-Accel-Redirect)
+            B-->>A: img.webp
+        end
+        alt l'utilisateur n'a pas le droit de l'image
+            D-->>C: False
+            C-->>B: 403
+            B-->>A: 403
+        end
+    end
+```

galaxy/management/commands/generate_galaxy_test_data.py

@@ -35,14 +35,6 @@
 from sas.models import Album, PeoplePictureRelation, Picture
 from subscription.models import Subscription
 
-RED_PIXEL_PNG: Final[bytes] = (
-    b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
-    b"\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90\x77\x53"
-    b"\xde\x00\x00\x00\x0c\x49\x44\x41\x54\x08\xd7\x63\xf8\xcf\xc0\x00"
-    b"\x00\x03\x01\x01\x00\x18\xdd\x8d\xb0\x00\x00\x00\x00\x49\x45\x4e"
-    b"\x44\xae\x42\x60\x82"
-)
-
 USER_PACK_SIZE: Final[int] = 1000
 
 

sas/api.py

@@ -2,8 +2,10 @@
 
 from django.conf import settings
 from django.core.exceptions import ValidationError
+from django.shortcuts import get_list_or_404
 from django.urls import reverse
-from ninja import Body, File, Query
+from ninja import Body, Query, UploadedFile
+from ninja.errors import HttpError
 from ninja.security import SessionAuth
 from ninja_extra import ControllerBase, api_controller, paginate, route
 from ninja_extra.exceptions import NotFound, PermissionDenied
@@ -16,18 +18,20 @@
     CanAccessLookup,
     CanEdit,
     CanView,
+    HasPerm,
     IsInGroup,
     IsRoot,
 )
 from core.models import Notification, User
-from core.schemas import UploadedImage
+from core.utils import get_list_exact_or_404
 from sas.models import Album, PeoplePictureRelation, Picture
 from sas.schemas import (
     AlbumAutocompleteSchema,
     AlbumFilterSchema,
     AlbumSchema,
     IdentifiedUserSchema,
     ModerationRequestSchema,
+    MoveAlbumSchema,
     PictureFilterSchema,
     PictureSchema,
 )
@@ -69,6 +73,48 @@ def autocomplete_album(self, filters: Query[AlbumFilterSchema]):
             Album.objects.viewable_by(self.context.request.user).order_by("-date")
         )
 
+    @route.patch("/parent", permissions=[IsAuthenticated])
+    def change_album_parent(self, payload: list[MoveAlbumSchema]):
+        """Change parents of albums
+
+        Note:
+            For this operation to work, the user must be authorized
+            to edit both the moved albums and their new parent.
+        """
+        user: User = self.context.request.user
+        albums: list[Album] = get_list_exact_or_404(
+            Album, pk__in={a.id for a in payload}
+        )
+        if not user.has_perm("sas.change_album"):
+            unauthorized = [a.id for a in albums if not user.can_edit(a)]
+            raise PermissionDenied(
+                f"You can't move the following albums : {unauthorized}"
+            )
+        parents: list[Album] = get_list_exact_or_404(
+            Album, pk__in={a.new_parent_id for a in payload}
+        )
+        if not user.has_perm("sas.change_album"):
+            unauthorized = [a.id for a in parents if not user.can_edit(a)]
+            raise PermissionDenied(
+                f"You can't move to the following albums : {unauthorized}"
+            )
+        id_to_new_parent = {i.id: i.new_parent_id for i in payload}
+        for album in albums:
+            album.parent_id = id_to_new_parent[album.id]
+        # known caveat : moving an album won't move it's thumbnail.
+        # E.g. if the album foo/bar is moved to foo/baz,
+        # the thumbnail will still be foo/bar/thumb.webp
+        # This has no impact for the end user
+        # and doing otherwise would be hard for us to implement,
+        # because we would then have to manage rollbacks on fail.
+        Album.objects.bulk_update(albums, fields=["parent_id"])
+
+    @route.delete("", permissions=[HasPerm("sas.delete_album")])
+    def delete_album(self, album_ids: list[int]):
+        # known caveat : deleting an album doesn't delete the pictures on the disk.
+        # It's a db only operation.
+        albums: list[Album] = get_list_or_404(Album, pk__in=album_ids)
+
 
 @api_controller("/sas/picture")
 class PicturesController(ControllerBase):
@@ -110,27 +156,25 @@ def fetch_pictures(self, filters: Query[PictureFilterSchema]):
         },
         url_name="upload_picture",
     )
-    def upload_picture(self, album_id: Body[int], picture: File[UploadedImage]):
+    def upload_picture(self, album_id: Body[int], picture: UploadedFile):
         album = self.get_object_or_exception(Album, pk=album_id)
         user = self.context.request.user
         self_moderate = user.has_perm("sas.moderate_sasfile")
         new = Picture(
             parent=album,
             name=picture.name,
-            file=picture,
+            original=picture,
             owner=user,
             is_moderated=self_moderate,
-            is_folder=False,
-            mime_type=picture.content_type,
         )
         if self_moderate:
             new.moderator = user
+        new.generate_thumbnails()
         try:
-            new.generate_thumbnails()
             new.full_clean()
-            new.save()
         except ValidationError as e:
-            return self.create_response({"detail": dict(e)}, status_code=409)
+            raise HttpError(status_code=409, message=str(e)) from e
+        new.save()
 
     @route.get(
         "/{picture_id}/identified",

sas/baker_recipes.py

@@ -1,12 +1,35 @@
+from django.core.files.uploadedfile import SimpleUploadedFile
 from model_bakery import seq
 from model_bakery.recipe import Recipe
 
-from sas.models import Picture
+from core.utils import RED_PIXEL_PNG
+from sas.models import Album, Picture
 
-picture_recipe = Recipe(Picture, is_moderated=True, name=seq("Picture "))
-"""A SAS Picture fixture.
+album_recipe = Recipe(
+    Album,
+    name=seq("Album "),
+    thumbnail=SimpleUploadedFile(
+        name="thumb.webp", content=b"", content_type="image/webp"
+    ),
+)
 
-Warnings:
-    If you don't `bulk_create` this, you need
-    to explicitly set the parent album, or it won't work
-"""
+
+picture_recipe = Recipe(
+    Picture,
+    is_moderated=True,
+    name=seq("Picture "),
+    original=SimpleUploadedFile(
+        # compressed and thumbnail are generated on save (except if bulk creating).
+        # For this step no to fail, original must be a valid image.
+        name="img.png",
+        content=RED_PIXEL_PNG,
+        content_type="image/png",
+    ),
+    compressed=SimpleUploadedFile(
+        name="img.webp", content=b"", content_type="image/webp"
+    ),
+    thumbnail=SimpleUploadedFile(
+        name="img.webp", content=b"", content_type="image/webp"
+    ),
+)
+"""A SAS Picture fixture."""