Whiteboard fetch improvements (#556)

* prefetch whiteboard data to reduce number of requests

* added memo ids to several dats objects

* updated api

* fixed missing memo_ids

* added new test and fixed deletion cascade

Author: bigabig

backend/src/api/endpoints/bbox_annotation.py

@@ -119,8 +119,11 @@ def delete_by_id(
 ) -> BBoxAnnotationRead:
     authz_user.assert_in_same_project_as(Crud.BBOX_ANNOTATION, bbox_id)
 
-    db_obj = crud_bbox_anno.remove(db=db, id=bbox_id)
-    return BBoxAnnotationRead.model_validate(db_obj)
+    db_obj = crud_bbox_anno.read(db=db, id=bbox_id)
+    bbox_read = BBoxAnnotationRead.model_validate(db_obj)
+
+    crud_bbox_anno.remove(db=db, id=bbox_id)
+    return bbox_read
 
 
 @router.delete(

backend/src/api/endpoints/code.py

@@ -78,5 +78,8 @@ def delete_by_id(
 ) -> CodeRead:
     authz_user.assert_in_same_project_as(Crud.CODE, code_id)
 
-    db_obj = crud_code.remove(db=db, id=code_id)
-    return CodeRead.model_validate(db_obj)
+    db_obj = crud_code.read(db=db, id=code_id)
+    code_read = CodeRead.model_validate(db_obj)
+
+    crud_code.remove(db=db, id=code_id)
+    return code_read

backend/src/api/endpoints/document_tag.py

@@ -220,8 +220,11 @@ def delete_by_id(
 ) -> DocumentTagRead:
     authz_user.assert_in_same_project_as(Crud.DOCUMENT_TAG, tag_id)
 
-    db_obj = crud_document_tag.remove(db=db, id=tag_id)
-    return DocumentTagRead.model_validate(db_obj)
+    db_obj = crud_document_tag.read(db=db, id=tag_id)
+    tag_read = DocumentTagRead.model_validate(db_obj)
+
+    crud_document_tag.remove(db=db, id=tag_id)
+    return tag_read
 
 
 @router.get(

backend/src/api/endpoints/sentence_annotation.py

@@ -155,8 +155,11 @@ def delete_by_id(
 ) -> SentenceAnnotationRead:
     authz_user.assert_in_same_project_as(Crud.SENTENCE_ANNOTATION, sentence_anno_id)
 
-    db_obj = crud_sentence_anno.remove(db=db, id=sentence_anno_id)
-    return SentenceAnnotationRead.model_validate(db_obj)
+    db_obj = crud_sentence_anno.read(db=db, id=sentence_anno_id)
+    sentence_anno_read = SentenceAnnotationRead.model_validate(db_obj)
+
+    crud_sentence_anno.remove(db=db, id=sentence_anno_id)
+    return sentence_anno_read
 
 
 @router.delete(

backend/src/api/endpoints/span_annotation.py

@@ -157,8 +157,11 @@ def delete_by_id(
 ) -> SpanAnnotationDeleted:
     authz_user.assert_in_same_project_as(Crud.SPAN_ANNOTATION, span_id)
 
-    db_obj = crud_span_anno.remove(db=db, id=span_id)
-    return SpanAnnotationDeleted.model_validate(db_obj)
+    db_obj = crud_span_anno.read(db=db, id=span_id)
+    anno_read = SpanAnnotationDeleted.model_validate(db_obj)
+
+    crud_span_anno.remove(db=db, id=span_id)
+    return anno_read
 
 
 @router.delete(

backend/src/api/endpoints/whiteboard.py

@@ -6,6 +6,7 @@
 from app.core.data.dto.whiteboard import (
     WhiteboardCreate,
     WhiteboardCreateIntern,
+    WhiteboardData,
     WhiteboardRead,
     WhiteboardUpdate,
     WhiteboardUpdateIntern,
@@ -60,6 +61,22 @@ def get_by_id(
     return WhiteboardRead.model_validate(db_obj)
 
 
+@router.get(
+    "/data/{whiteboard_id}",
+    response_model=WhiteboardData,
+    summary="Returns the Whiteboard with the given ID if it exists",
+)
+def get_data_by_id(
+    *,
+    db: Session = Depends(get_db_session),
+    whiteboard_id: int,
+    authz_user: AuthzUser = Depends(),
+) -> WhiteboardData:
+    authz_user.assert_in_same_project_as(Crud.WHITEBOARD, whiteboard_id)
+
+    return crud_whiteboard.read_data(db=db, id=whiteboard_id)
+
+
 @router.get(
     "/project/{project_id}",
     response_model=List[WhiteboardRead],

backend/src/app/core/data/crud/whiteboard.py

@@ -1,10 +1,32 @@
-from typing import List
+from typing import Dict, List
 
 from sqlalchemy.orm import Session
 
+from app.core.data.crud.bbox_annotation import crud_bbox_anno
 from app.core.data.crud.crud_base import CRUDBase
+from app.core.data.crud.memo import crud_memo
+from app.core.data.crud.project import crud_project
+from app.core.data.crud.sentence_annotation import crud_sentence_anno
+from app.core.data.crud.source_document import crud_sdoc
+from app.core.data.crud.span_annotation import crud_span_anno
+from app.core.data.dto.bbox_annotation import BBoxAnnotationRead
+from app.core.data.dto.code import CodeRead
+from app.core.data.dto.document_tag import DocumentTagRead
+from app.core.data.dto.memo import MemoRead
+from app.core.data.dto.sentence_annotation import SentenceAnnotationRead
+from app.core.data.dto.source_document import SourceDocumentRead
+from app.core.data.dto.span_annotation import SpanAnnotationRead
 from app.core.data.dto.whiteboard import (
+    BBoxAnnotationNodeData,
+    MemoNodeData,
+    SdocNodeData,
+    SentenceAnnotationNodeData,
+    SpanAnnotationNodeData,
     WhiteboardCreateIntern,
+    WhiteboardData,
+    WhiteboardNode,
+    WhiteboardNodeType,
+    WhiteboardRead,
     WhiteboardUpdateIntern,
 )
 from app.core.data.orm.whiteboard import WhiteboardORM
@@ -36,6 +58,98 @@ def read_by_project(self, db: Session, *, project_id: int) -> List[WhiteboardORM
         )
         return db_obj
 
+    def read_data(self, db: Session, *, id: int) -> WhiteboardData:
+        db_obj = self.read(db, id=id)
+        whiteboard = WhiteboardRead.model_validate(db_obj)
+
+        # group nodes by their type
+        whiteboard_nodes: Dict[str, List[WhiteboardNode]] = {
+            node_type.value: [] for node_type in WhiteboardNodeType
+        }
+        for node in whiteboard.content.nodes:
+            if node.type in whiteboard_nodes:
+                whiteboard_nodes[node.type].append(node)
+
+        # fetch all data by type
+        result = WhiteboardData(
+            sdocs=[],
+            codes=[],
+            tags=[],
+            span_annotations=[],
+            sent_annotations=[],
+            bbox_annotations=[],
+            memos=[],
+        )
+        for node_type, nodes in whiteboard_nodes.items():
+            match node_type:
+                case WhiteboardNodeType.SPAN_ANNOTATION:
+                    span_ids = [
+                        SpanAnnotationNodeData.model_validate(
+                            node.data
+                        ).spanAnnotationId
+                        for node in nodes
+                    ]
+                    result.span_annotations = [
+                        SpanAnnotationRead.model_validate(sa)
+                        for sa in crud_span_anno.read_by_ids(db=db, ids=span_ids)
+                    ]
+                case WhiteboardNodeType.SENTENCE_ANNOTATION:
+                    sent_ids = [
+                        SentenceAnnotationNodeData.model_validate(
+                            node.data
+                        ).sentenceAnnotationId
+                        for node in nodes
+                    ]
+                    result.sent_annotations = [
+                        SentenceAnnotationRead.model_validate(sa)
+                        for sa in crud_sentence_anno.read_by_ids(db=db, ids=sent_ids)
+                    ]
+                case WhiteboardNodeType.BBOX_ANNOTATION:
+                    bbox_ids = [
+                        BBoxAnnotationNodeData.model_validate(
+                            node.data
+                        ).bboxAnnotationId
+                        for node in nodes
+                    ]
+                    result.bbox_annotations = [
+                        BBoxAnnotationRead.model_validate(b)
+                        for b in crud_bbox_anno.read_by_ids(db=db, ids=bbox_ids)
+                    ]
+                case WhiteboardNodeType.MEMO:
+                    memo_ids = [
+                        MemoNodeData.model_validate(node.data).memoId for node in nodes
+                    ]
+                    result.memos = [
+                        MemoRead.model_validate(m)
+                        for m in crud_memo.read_by_ids(db=db, ids=memo_ids)
+                    ]
+                case WhiteboardNodeType.SDOC:
+                    sdoc_ids = [
+                        SdocNodeData.model_validate(node.data).sdocId for node in nodes
+                    ]
+                    result.sdocs = [
+                        SourceDocumentRead.model_validate(s)
+                        for s in crud_sdoc.read_by_ids(db=db, ids=sdoc_ids)
+                    ]
+                case WhiteboardNodeType.CODE:
+                    if len(nodes) > 0:
+                        result.codes = [
+                            CodeRead.model_validate(c)
+                            for c in crud_project.read(
+                                db=db, id=whiteboard.project_id
+                            ).codes
+                        ]
+                case WhiteboardNodeType.TAG:
+                    if len(nodes) > 0:
+                        result.tags = [
+                            DocumentTagRead.model_validate(c)
+                            for c in crud_project.read(
+                                db=db, id=whiteboard.project_id
+                            ).document_tags
+                        ]
+
+        return result
+
     def duplicate_by_id(
         self, db: Session, *, whiteboard_id: int, user_id: int
     ) -> WhiteboardORM:

backend/src/app/core/data/dto/bbox_annotation.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import List
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -46,4 +47,5 @@ class BBoxAnnotationRead(BBoxAnnotationBaseDTO):
     sdoc_id: int = Field(description="SourceDocument the BBoxAnnotation refers to")
     created: datetime = Field(description="Created timestamp of the BBoxAnnotation")
     updated: datetime = Field(description="Updated timestamp of the BBoxAnnotation")
+    memo_ids: List[int] = Field(description="Memo IDs attached to the BBoxAnnotation")
     model_config = ConfigDict(from_attributes=True)

backend/src/app/core/data/dto/code.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Optional
+from typing import List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -48,4 +48,5 @@ class CodeRead(CodeBaseDTO):
     created: datetime = Field(description="Created timestamp of the Code")
     updated: datetime = Field(description="Updated timestamp of the Code")
     is_system: bool = Field(description="Is the Code a system code")
+    memo_ids: List[int] = Field(description="Memo IDs attached to the Code")
     model_config = ConfigDict(from_attributes=True)

backend/src/app/core/data/dto/document_tag.py

@@ -43,6 +43,7 @@ class DocumentTagRead(DocumentTagBaseDTO):
     project_id: int = Field(description="Project the DocumentTag belongs to")
     created: datetime = Field(description="Created timestamp of the DocumentTag")
     updated: datetime = Field(description="Updated timestamp of the DocumentTag")
+    memo_ids: List[int] = Field(description="Memo IDs attached to the DocumentTag")
     model_config = ConfigDict(from_attributes=True)