fixup! adapt back with blocknote interface

Author: lunika

src/backend/core/api/serializers.py

@@ -879,134 +879,127 @@ class MoveDocumentSerializer(serializers.Serializer):
     )
 
 
-class ThreadSerializer(serializers.ModelSerializer):
-    """Serialize threads in a backward compatible shape for current frontend.
+class ReactionSerializer(serializers.ModelSerializer):
+    """Serialize reactions."""
+
+    users = UserLightSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = models.Reaction
+        fields = [
+            "id",
+            "emoji",
+            "created_at",
+            "updated_at",
+            "users",
+        ]
+        read_only_fields = ["id", "created_at", "updated_at"]
 
-    We expose a flatten representation where ``content`` maps to the first
-    comment's body. Creating a thread requires a ``content`` field which is
-    stored as the first comment.
-    """
+
+class CommentSerializer(serializers.ModelSerializer):
+    """Serialize comments (nested under a thread) with reactions and abilities."""
 
     user = UserLightSerializer(read_only=True)
-    abilities = serializers.SerializerMethodField(read_only=True)
-    content = serializers.JSONField(write_only=True, required=True)
-    document = serializers.PrimaryKeyRelatedField(read_only=True)
+    abilities = serializers.SerializerMethodField()
+    reactions = ReactionSerializer(many=True, read_only=True)
 
     class Meta:
-        model = models.Thread
+        model = models.Comment
         fields = [
             "id",
-            "content",  # write: body of initial comment; read: not returned (we override to_representation)
+            "user",
+            "body",
             "created_at",
             "updated_at",
-            "user",
-            "document",
+            "reactions",
             "abilities",
         ]
         read_only_fields = [
             "id",
+            "user",
             "created_at",
             "updated_at",
-            "user",
-            "document",
+            "reactions",
             "abilities",
         ]
 
-    def to_representation(self, instance):
-        rep = super().to_representation(instance)
-        # Provide first comment body as ``content`` to match previous API.
-        first_comment = instance.first_comment
-        rep["content"] = first_comment.body if first_comment else None
-        return rep
+    def validate(self, attrs):
+        """Validate comment data."""
+
+        request = self.context.get("request")
+        user = getattr(request, "user", None)
 
-    def get_abilities(self, thread) -> dict:  # type: ignore[override]
+        attrs["thread_id"] = self.context["thread_id"]
+        attrs["user_id"] = user.id if user else None
+        return attrs
+
+    def get_abilities(self, obj):
+        """Return comment's abilities."""
         request = self.context.get("request")
         if request:
-            return thread.get_abilities(request.user)
+            return obj.get_abilities(request.user)
         return {}
 
-    def create(self, validated_data):
-        request = self.context.get("request")
-        document_id = self.context.get("resource_id")
-        content = validated_data.pop("content")
-        document = models.Document.objects.get(pk=document_id)
-        user = request.user if request else None
-        thread = models.Thread.objects.create(document=document, user=user)
-        models.Comment.objects.create(thread=thread, user=user, body=content)
-        return thread
-
-    def update(self, instance, validated_data):  # pragma: no cover - not used yet
-        # Allow updating first comment body for backward compatibility.
-        content = validated_data.get("content")
-        if content is not None:
-            first = instance.first_comment
-            if first:
-                first.body = content
-                first.save(update_fields=["body", "updated_at"])
-        return instance
-
-
-class CommentInThreadSerializer(serializers.ModelSerializer):
-    """Serialize comments (nested under a thread) with reactions and abilities."""
 
-    user = UserLightSerializer(read_only=True)
-    reactions = serializers.SerializerMethodField()
-    abilities = serializers.SerializerMethodField()
+class ThreadSerializer(serializers.ModelSerializer):
+    """Serialize threads in a backward compatible shape for current frontend.
+
+    We expose a flatten representation where ``content`` maps to the first
+    comment's body. Creating a thread requires a ``content`` field which is
+    stored as the first comment.
+    """
+
+    creator = UserLightSerializer(read_only=True)
+    abilities = serializers.SerializerMethodField(read_only=True)
+    body = serializers.JSONField(write_only=True, required=True)
+    document = serializers.PrimaryKeyRelatedField(read_only=True)
+    comments = CommentSerializer(many=True, read_only=True)
 
     class Meta:
-        model = models.Comment
+        model = models.Thread
         fields = [
             "id",
-            "user",
             "body",
             "created_at",
             "updated_at",
-            "reactions",
+            "creator",
+            "document",
             "abilities",
+            "comments",
         ]
-        read_only_fields = fields
-
-    def get_reactions(self, obj):
-        # Collect all users for reactions in a single query
-        from django.contrib.auth import get_user_model
-        User = get_user_model()
-        reactions = list(obj.reactions.all())
-        user_ids = set()
-        for r in reactions:
-            user_ids.update(r.user_ids or [])
-        users_by_id = {
-            u.id: u
-            for u in User.objects.filter(id__in=user_ids).only(
-                "id", "email", "full_name", "short_name", "language"
-            )
-        }
-        # Serialize users with UserLightSerializer semantics (full_name/short_name logic)
-        user_serializer = UserLightSerializer
-        return [
-            {
-                "emoji": r.emoji,
-                "created_at": r.created_at,
-                "users": [
-                    user_serializer(users_by_id[uid]).data
-                    for uid in r.user_ids
-                    if uid in users_by_id
-                ],
-            }
-            for r in reactions
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "creator",
+            "document",
+            "abilities",
+            "comments",
         ]
 
-    def get_abilities(self, obj):
+    def validate(self, attrs):
+        """Validate thread data."""
+        request = self.context.get("request")
+        user = getattr(request, "user", None)
+
+        attrs["document_id"] = self.context["resource_id"]
+        attrs["creator_id"] = user.id if user else None
+
+        return attrs
+
+    def get_abilities(self, thread):
+        """Return thread's abilities."""
         request = self.context.get("request")
         if request:
-            return obj.get_abilities(request.user)
+            return thread.get_abilities(request.user)
         return {}
 
 
 class ThreadFullSerializer(serializers.ModelSerializer):
     """Full thread representation with nested comments."""
 
-    user = UserLightSerializer(read_only=True)
-    comments = serializers.SerializerMethodField()
+    creator = UserLightSerializer(read_only=True)
+    comments = CommentSerializer(many=True, read_only=True)
     abilities = serializers.SerializerMethodField()
 
     class Meta:
@@ -1015,79 +1008,19 @@ class Meta:
             "id",
             "created_at",
             "updated_at",
-            "user",
+            "creator",
             "resolved",
-            "resolved_updated_at",
+            "resolved_at",
             "resolved_by",
             "metadata",
             "comments",
             "abilities",
         ]
         read_only_fields = fields
 
-    def get_comments(self, instance):
-        qs = instance.comments.select_related("user").prefetch_related("reactions")
-        return CommentInThreadSerializer(qs, many=True, context=self.context).data
-
     def get_abilities(self, instance):
+        """Return thread's abilities."""
         request = self.context.get("request")
         if request:
             return instance.get_abilities(request.user)
         return {}
-
-
-class CreateThreadSerializer(serializers.Serializer):
-    body = serializers.JSONField(required=True)
-    metadata = serializers.JSONField(required=False)
-
-    def create(self, validated_data):
-        request = self.context.get("request")
-        document = self.context.get("document")
-        thread = models.Thread.objects.create(
-            document=document,
-            user=request.user if request else None,
-            metadata=validated_data.get("metadata", {}),
-        )
-        models.Comment.objects.create(
-            thread=thread,
-            user=request.user if request else None,
-            body=validated_data["body"],
-            metadata=validated_data.get("metadata", {}),
-        )
-        return thread
-
-
-class CreateCommentSerializer(serializers.Serializer):
-    body = serializers.JSONField(required=True)
-    metadata = serializers.JSONField(required=False)
-
-    def create(self, validated_data):
-        request = self.context.get("request")
-        thread = self.context.get("thread")
-        return models.Comment.objects.create(
-            thread=thread,
-            user=request.user if request else None,
-            body=validated_data["body"],
-            metadata=validated_data.get("metadata", {}),
-        )
-
-
-class UpdateCommentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = models.Comment
-        fields = ["body"]
-
-
-class ReactionCreateSerializer(serializers.Serializer):
-    emoji = serializers.CharField(max_length=32)
-
-    def save(self, **kwargs):  # pylint: disable=unused-argument
-        request = self.context.get("request")
-        comment = self.context.get("comment")
-        emoji = self.validated_data["emoji"]
-        reaction, _created = models.Reaction.objects.get_or_create(
-            comment=comment, emoji=emoji
-        )
-        if request and request.user:
-            reaction.add_user(request.user)
-        return reaction