Replace manual serialization with ModelViewSet

Author: XanderVertegaal

backend/langpro_annotator/urls.py

@@ -21,11 +21,14 @@
 
 from rest_framework import routers
 
+from problem.views.problem import ProblemView
+
 from .index import index
 from .proxy_frontend import proxy_frontend
 from .i18n import i18n
 
 api_router = routers.DefaultRouter()  # register viewsets with this router
+api_router.register(r"problem", ProblemView, basename="problem")
 
 
 if settings.PROXY_FRONTEND:

backend/problem/models.py

@@ -57,33 +57,6 @@ def get_index(self, qs: QuerySet) -> int | None:
             logger.exception(f"Error getting index for problem {self.pk}: {e}")
             return None
 
-    def serialize(self) -> dict:
-        """
-        Serialize the Problem instance to a dictionary.
-        """
-
-        match self.dataset:
-            case self.Dataset.SICK:
-                serialized_extra_data = SickData.serialize(self.extra_data)
-            case self.Dataset.FRACAS:
-                serialized_extra_data = FracasData.serialize(self.extra_data)
-            case self.Dataset.SNLI:
-                serialized_extra_data = SNLIData.serialize(self.extra_data)
-            case _:
-                serialized_extra_data = {}
-
-        kb_items = self.knowledge_bases.all() # type: ignore
-
-        return {
-            "id": self.pk,
-            "dataset": self.dataset,
-            "premises": [premise.text for premise in self.premises.all()],
-            "hypothesis": self.hypothesis.text,
-            "entailmentLabel": self.entailment_label,
-            "extraData": serialized_extra_data,
-            "kbItems": [item.serialize() for item in kb_items],
-        }
-
 
 class KnowledgeBase(models.Model):
     class Relationship(models.TextChoices):

backend/problem/problem_details.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from dataclasses import dataclass
 
 from django.http import QueryDict

backend/problem/serializers.py

@@ -1,4 +1,5 @@
 from rest_framework import serializers
+from problem.services import FracasData, SNLIData, SickData
 from problem.models import Problem, KnowledgeBase
 
 
@@ -21,6 +22,56 @@ def validate_id(self, value):
         return value
 
 
+class ProblemSerializer(serializers.ModelSerializer):
+    """
+    Serializer for Problem model output.
+    Handles serialization of problems with all related data including labels.
+    """
+
+    premises = serializers.SerializerMethodField()
+    hypothesis = serializers.SerializerMethodField()
+    entailmentLabel = serializers.CharField(source="entailment_label")
+    extraData = serializers.SerializerMethodField()
+    kbItems = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Problem
+        fields = [
+            "id",
+            "dataset",
+            "premises",
+            "hypothesis",
+            "entailmentLabel",
+            "extraData",
+            "kbItems",
+        ]
+
+    def get_premises(self, problem):
+        """Get list of premise texts."""
+        return [premise.text for premise in problem.premises.all()]
+
+    def get_hypothesis(self, problem):
+        """Get hypothesis text."""
+        return problem.hypothesis.text
+
+    def get_extraData(self, problem):
+        """Get dataset-specific extra data."""
+        match problem.dataset:
+            case Problem.Dataset.SICK:
+                return SickData.serialize(problem.extra_data)
+            case Problem.Dataset.FRACAS:
+                return FracasData.serialize(problem.extra_data)
+            case Problem.Dataset.SNLI:
+                return SNLIData.serialize(problem.extra_data)
+            case _:
+                return {}
+
+    def get_kbItems(self, problem):
+        """Get knowledge base items."""
+        kb_items = problem.knowledge_bases.all()
+        return KnowledgeBaseSerializer(kb_items, many=True).data
+
+
 class ProblemInputSerializer(serializers.Serializer):
     """
     Serializer for validating problem input data.

backend/problem/urls.py

@@ -1,11 +1,7 @@
 from django.urls import path
 
 from problem.views.parse import ParseView
-from problem.views.problem import ProblemView
-
 
 urlpatterns = [
-    path("<int:problem_id>", ProblemView.as_view(), name="problem_detail_view"),
     path("parse", ParseView.as_view(), name="parse_view"),
-    path("", ProblemView.as_view(), name="problem_view"),
 ]

backend/problem/views/problem.py

@@ -2,42 +2,18 @@
 
 from django.db import DatabaseError
 from django.http import JsonResponse
-from rest_framework.views import APIView
+from rest_framework.decorators import action
 from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.viewsets import ModelViewSet
 
 from langpro_annotator.logger import logger
-from problem.problem_details import get_filters, get_related_problem_ids
+from problem.problem_details import (
+    get_filters,
+    get_related_problem_ids,
+)
 from problem.models import KnowledgeBase, Problem, Sentence
-from problem.serializers import ProblemInputSerializer
-
-
-@dataclass
-class ProblemResponse:
-    problem: Problem | None = None
-    index: int | None = None
-    error: str | None = None
-
-    first: int | None = None
-    previous: int | None = None
-    next: int | None = None
-    last: int | None = None
-    total: int | None = None
-
-    def json_response(self, status=200) -> JsonResponse:
-        return JsonResponse(
-            {
-                "index": self.index,
-                "problem": self.problem.serialize() if self.problem else None,
-                "error": self.error,
-                "firstProblemId": self.first,
-                "previousProblemId": self.previous,
-                "nextProblemId": self.next,
-                "lastProblemId": self.last,
-                "totalProblems": self.total if self.total is not None else 0,
-            },
-            status=status,
-        )
-
+from problem.serializers import ProblemSerializer
 
 @dataclass
 class SaveProblemResponse:
@@ -48,23 +24,54 @@ def json_response(self, status=200) -> JsonResponse:
         return JsonResponse(asdict(self), status=status)
 
 
-class ProblemView(APIView):
-    def get(self, request: Request, problem_id: int | None = None) -> JsonResponse:
+class ProblemView(ModelViewSet):
+    queryset = Problem.objects.all()
+    serializer_class = ProblemSerializer
+
+    def list(self, request: Request) -> Response:
+        """
+        Lists all Problems in the database, with optional filtering.
+        """
+        filters = get_filters(request.query_params)
+
+        qs = self.get_queryset()
+
+        if filters is not None:
+            qs = qs.filter(filters)
+
+        serializer = self.get_serializer(qs, many=True)
+        return Response(serializer.data, status=200)
+
+
+    @action(detail=False, methods=['get'], url_path='first')
+    def first(self, request: Request) -> Response:
+        """
+        Retrieves the first problem from the queryset.
+        """
+        return self._get_problem_response(request, pk=None)
+
+    def retrieve(self, request: Request, pk: int | None = None) -> Response:
+        """
+        Retrieves the requested Problem by ID.
+        """
+        return self._get_problem_response(request, pk=pk)
+
+    def _get_problem_response(self, request: Request, pk: int | None) -> Response:
         """
-        If a Problem ID is provided, retrieves the requested Problem.
-        Otherwise, simply returns the first problem of the QS.
+        Helper method to build the problem response.
+        If pk is provided, retrieves that problem; otherwise returns the first problem.
         """
         filters = get_filters(request.query_params)
 
-        qs = Problem.objects.all()
+        qs = self.get_queryset()
 
         if filters is not None:
             qs = qs.filter(filters)
 
         problem = None
-        if problem_id is not None:
+        if pk is not None:
             try:
-                problem = qs.get(id=problem_id)
+                problem = qs.get(id=pk)
             except Problem.DoesNotExist:
                 # The selected problem may not be part of the selected filters.
                 # In that case, we simply take the first problem from the queryset.
@@ -74,17 +81,19 @@ def get(self, request: Request, problem_id: int | None = None) -> JsonResponse:
             problem = qs.first()
 
         problem_index = problem.get_index(qs) if problem else None
-        related_problem_ids = get_related_problem_ids(qs, problem_id)
-
-        return ProblemResponse(
-            problem=problem,
-            index=problem_index,
-            first=related_problem_ids.first,
-            previous=related_problem_ids.previous,
-            next=related_problem_ids.next,
-            last=related_problem_ids.last,
-            total=related_problem_ids.total,
-        ).json_response(status=200)
+        related_problem_ids = get_related_problem_ids(qs, pk)
+
+        serializer = self.get_serializer(problem)
+
+        return Response({
+            "problem": serializer.data,
+            "index": problem_index,
+            "first": related_problem_ids.first,
+            "previous": related_problem_ids.previous,
+            "next": related_problem_ids.next,
+            "last": related_problem_ids.last,
+            "total": related_problem_ids.total,
+        }, status=200)
 
     def post(self, request: Request, problem_id: int | None = None) -> JsonResponse:
         """

frontend/src/app/annotate/navigator/navigator.component.html

@@ -6,8 +6,8 @@
             <button
                 class="btn btn-outline-primary btn-sm"
                 type="button"
-                (click)="navigateToProblem(problemResponse?.firstProblemId)"
-                [disabled]="problemResponse?.problem?.id === problemResponse?.firstProblemId"
+                (click)="navigateToProblem(problemResponse?.first)"
+                [disabled]="problemResponse?.problem?.id === problemResponse?.first"
                 aria-labelledby="label-first"
                 title="First problem"
                 title-i18n
@@ -24,8 +24,8 @@
             <button
                 class="btn btn-outline-primary btn-sm"
                 type="button"
-                (click)="navigateToProblem(problemResponse?.previousProblemId)"
-                [disabled]="problemResponse?.previousProblemId === null"
+                (click)="navigateToProblem(problemResponse?.previous)"
+                [disabled]="problemResponse?.previous === null"
                 aria-labelledby="label-previous"
                 title="Previous problem"
                 title-i18n
@@ -47,16 +47,16 @@
                 {{ problemResponse?.index ?? '-' }}
             </span>
             <hr class="my-1">
-            <span class="small" i18n>{{ problemResponse.totalProblems }}</span>
+            <span class="small" i18n>{{ problemResponse.total }}</span>
             }
         </div>
 
         <div class="responsive-button-grid">
             <button
                 class="btn btn-outline-primary btn-sm"
                 type="button"
-                (click)="navigateToProblem(problemResponse?.nextProblemId)"
-                [disabled]="problemResponse?.nextProblemId === null"
+                (click)="navigateToProblem(problemResponse?.next)"
+                [disabled]="problemResponse?.next === null"
                 title="Next problem"
                 title-i18n
             >
@@ -69,8 +69,8 @@
             </button>
             <button
                 class="btn btn-outline-primary btn-sm"
-                (click)="navigateToProblem(problemResponse?.lastProblemId)"
-                [disabled]="problemResponse?.problem?.id === problemResponse?.lastProblemId"
+                (click)="navigateToProblem(problemResponse?.last)"
+                [disabled]="problemResponse?.problem?.id === problemResponse?.last"
                 title="Last problem"
                 title-i18n
             >

frontend/src/app/services/problem.service.ts

@@ -76,11 +76,11 @@ export class ProblemService {
     private newProblem$(): Observable<ProblemResponse> {
         return of<ProblemResponse>({
             index: null,
-            firstProblemId: null,
-            lastProblemId: null,
-            nextProblemId: null,
-            previousProblemId: null,
-            totalProblems: 0,
+            first: null,
+            last: null,
+            next: null,
+            previous: null,
+            total: 0,
             error: null,
             problem: {
                 id: null,
@@ -98,7 +98,7 @@ export class ProblemService {
     private existingProblem$(problemId?: string, queryParams?: ParamMap): Observable<ProblemResponse | null> {
         const httpParams = queryParams ? this.extractSearchParams(queryParams) : undefined;
 
-        return this.http.get<ProblemResponse>(`/api/problem/${problemId ?? ""}`, { params: httpParams }).pipe(
+        return this.http.get<ProblemResponse>(`/api/problem/${problemId ?? "first"}/`, { params: httpParams }).pipe(
             catchError((error) => {
                 const message = `Error fetching ${problemId ? `problem ${problemId}` : "first problem"}`;
                 console.error(message, error);

frontend/src/app/types.ts

@@ -74,11 +74,11 @@ interface BaseResponse {
 export interface ProblemResponse extends BaseResponse {
     index: number | null;
     problem: Problem | null;
-    firstProblemId: number | null;
-    previousProblemId: number | null;
-    nextProblemId: number | null;
-    lastProblemId: number | null;
-    totalProblems: number;
+    first: number | null;
+    previous: number | null;
+    next: number | null;
+    last: number | null;
+    total: number;
 }
 
 export interface SaveProblemResponse extends BaseResponse {