feat(bookmarks): adds CRUD for bookmarks (#53)

* feat(bookmarks): adds CRUD for bookmarks

* adds tests

* refactor search document by id

Author: sandragjacinto

src/app/api/api_v1/endpoints/search.py

@@ -1,9 +1,19 @@
+import uuid
+from collections import Counter
+
 from fastapi import APIRouter, Depends, Response
 from qdrant_client.models import ScoredPoint
 from sqlalchemy.sql import select
 
-from src.app.models.db_models import CorpusEmbedding, QtyDocumentInQdrant
-from src.app.models.documents import Collection_schema
+from src.app.models.db_models import (
+    Corpus,
+    CorpusEmbedding,
+    DocumentSlice,
+    QtyDocumentInQdrant,
+    Sdg,
+    WeLearnDocument,
+)
+from src.app.models.documents import Collection_schema, DocumentPayloadModel
 from src.app.models.search import (
     EnhancedSearchQuery,
     SDGFilter,
@@ -201,3 +211,85 @@ async def search_all(
     response.status_code = 200
 
     return res
+
+
+@router.post(
+    "/documents/by_ids",
+    summary="get documents payload by ids",
+    description="Get documents payload by list of document ids",
+)
+def get_documents_payload_by_ids(
+    documents_ids: list[uuid.UUID],
+) -> list[DocumentPayloadModel]:
+    with session_maker() as s:
+        documents = s.execute(
+            select(
+                WeLearnDocument.title,
+                WeLearnDocument.url,
+                WeLearnDocument.corpus_id,
+                WeLearnDocument.id,
+                WeLearnDocument.description,
+                WeLearnDocument.details,
+            ).where(WeLearnDocument.id.in_(documents_ids))
+        ).all()
+
+        # Batch fetch corpora
+        corpus_ids = list({doc.corpus_id for doc in documents})
+
+        corpora = s.execute(
+            select(Corpus.id, Corpus.source_name).where(Corpus.id.in_(corpus_ids))
+        ).all()
+
+        corpus_map = {corpus.id: corpus.source_name for corpus in corpora}
+
+        # Batch fetch slices
+        slices = s.execute(
+            select(DocumentSlice.id, DocumentSlice.document_id).where(
+                DocumentSlice.document_id.in_(documents_ids)
+            )
+        ).all()
+
+        # Map document_id -> list of slices
+        slices_ids_map = {}
+        slice_ids = []
+        for slice_ in slices:
+            slices_ids_map.setdefault(slice_.document_id, []).append(slice_.id)
+            slice_ids.append(slice_.id)
+
+        # Batch fetch SDGs
+        sdgs = s.execute(
+            select(Sdg.sdg_number, Sdg.slice_id).where(Sdg.slice_id.in_(slice_ids))
+        ).all()
+
+        # Map slice_id -> list of sdgs
+        sdg_map = {}
+        for sdg in sdgs:
+            sdg_map.setdefault(sdg.slice_id, []).append(sdg)
+
+        docs = []
+        for doc in documents:
+            corpus = corpus_map.get(doc.corpus_id)
+            slices_id_for_doc = slices_ids_map.get(doc.id, [])
+            sdgs_for_doc = []
+            for slice_id in slices_id_for_doc:
+                sdgs_for_doc.extend(sdg_map.get(slice_id, []))
+            short_sdg_list = Counter(
+                [sdg.sdg_number for sdg in sdgs_for_doc]
+            ).most_common(2)
+
+            docs.append(
+                DocumentPayloadModel(
+                    document_id=doc.id,
+                    document_title=doc.title,
+                    document_url=doc.url,
+                    document_desc=doc.description,
+                    document_sdg=[sdg[0] for sdg in short_sdg_list],
+                    document_details=doc.details,
+                    slice_content="",
+                    document_lang="",
+                    document_corpus=corpus if corpus else "",
+                    slice_sdg=None,
+                )
+            )
+
+        return docs

src/app/api/api_v1/endpoints/user.py

@@ -4,7 +4,7 @@
 from fastapi import APIRouter, HTTPException, Request
 from sqlalchemy.sql import select
 
-from src.app.models.db_models import InferredUser, Session
+from src.app.models.db_models import Bookmark, InferredUser, Session
 from src.app.services.sql_db import session_maker
 from src.app.utils.logger import logger as logger_utils
 
@@ -109,3 +109,118 @@ def handle_session(
     except Exception as e:
         logger.error(f"Error creating session: {e}")
         raise HTTPException(status_code=500, detail=f"Error creating session: {e}")
+
+
+@router.get(
+    "/:user_id/bookmarks",
+    summary="get user bookmarks",
+    description="Get all bookmarks for a user",
+)
+def get_user_bookmarks(user_id: uuid.UUID):
+    with session_maker() as s:
+        user = s.execute(
+            select(InferredUser.id).where(InferredUser.id == user_id)
+        ).first()
+        if not user:
+            logger.error(f"User={user_id} does not exist")
+            raise HTTPException(
+                status_code=404, detail=f"User={user_id} does not exist"
+            )
+        bookmarks = s.execute(
+            select(Bookmark).where(Bookmark.inferred_user_id == user_id)
+        ).all()
+        return {"bookmarks": [bookmark for (bookmark,) in bookmarks]}
+
+
+@router.delete(
+    "/:user_id/bookmarks",
+    summary="delete user bookmarks",
+    description="Delete all bookmarks for a user",
+)
+def delete_user_bookmarks(user_id: uuid.UUID):
+    with session_maker() as s:
+        user = s.execute(
+            select(InferredUser.id).where(InferredUser.id == user_id)
+        ).first()
+        if not user:
+            logger.error(f"User={user_id} does not exist")
+            raise HTTPException(
+                status_code=404, detail=f"User={user_id} does not exist"
+            )
+        deleted = (
+            s.query(Bookmark).filter(Bookmark.inferred_user_id == user_id).delete()
+        )
+        s.commit()
+        logger.info(f"Deleted {deleted} bookmarks for user={user_id}")
+        return {"deleted": deleted}
+
+
+@router.delete(
+    "/:user_id/bookmarks/:document_id",
+    summary="delete user bookmark",
+    description="Delete a bookmark for a user",
+)
+def delete_user_bookmark(user_id: uuid.UUID, document_id: uuid.UUID):
+    with session_maker() as s:
+        user = s.execute(
+            select(InferredUser.id).where(InferredUser.id == user_id)
+        ).first()
+
+        if not user:
+            logger.error(f"User={user_id} does not exist")
+            raise HTTPException(
+                status_code=404, detail=f"User={user_id} does not exist"
+            )
+        bookmark = s.execute(
+            select(Bookmark).where(
+                (Bookmark.inferred_user_id == user_id)
+                & (Bookmark.document_id == document_id)
+            )
+        ).first()
+        if not bookmark:
+            logger.error(f"Bookmark={document_id} for user={user_id} does not exist")
+            raise HTTPException(
+                status_code=404,
+                detail=f"Bookmark={document_id} for user={user_id} does not exist",
+            )
+        s.delete(bookmark[0])
+        s.commit()
+        logger.info(f"Deleted bookmark={document_id} for user={user_id}")
+        return {"deleted": document_id}
+
+
+@router.post(
+    "/:user_id/bookmarks/:document_id",
+    summary="add user bookmark",
+    description="Add a bookmark for a user",
+)
+def add_user_bookmark(user_id: uuid.UUID, document_id: uuid.UUID):
+    with session_maker() as s:
+        user = s.execute(
+            select(InferredUser.id).where(InferredUser.id == user_id)
+        ).first()
+        if not user:
+            logger.error(f"User={user_id} does not exist")
+            raise HTTPException(
+                status_code=404, detail=f"User={user_id} does not exist"
+            )
+        bookmark = s.execute(
+            select(Bookmark).where(
+                (Bookmark.inferred_user_id == user_id)
+                & (Bookmark.document_id == document_id)
+            )
+        ).first()
+        if bookmark:
+            logger.error(f"Bookmark={document_id} for user={user_id} already exists")
+            raise HTTPException(
+                status_code=400,
+                detail=f"Bookmark={document_id} for user={user_id} already exists",
+            )
+        new_bookmark = Bookmark(
+            document_id=document_id,
+            inferred_user_id=user_id,
+        )
+        s.add(new_bookmark)
+        s.commit()
+        logger.info(f"Added bookmark={document_id} for user={user_id}")
+        return {"added": document_id}

src/app/models/db_models.py

@@ -167,25 +167,40 @@ class UserProfile(Base):
 
 class Bookmark(Base):
     __tablename__ = "bookmark"
+    __table_args__ = {"schema": "user_related"}
 
     id = Column(
         Uuid(as_uuid=True),
         primary_key=True,
         server_default="gen_random_uuid()",
         nullable=False,
     )
-    document_id = Column(
-        Uuid(as_uuid=True),
+    document_id: Mapped[UUID] = mapped_column(
+        types.Uuid,
         ForeignKey("document_related.welearn_document.id"),
         nullable=False,
     )
-    user_id = Column(
-        Uuid(as_uuid=True),
-        ForeignKey("user_related.user_profile.id"),
+    inferred_user_id: Mapped[UUID] = mapped_column(
+        types.Uuid,
+        ForeignKey("user_related.inferred_user.id"),
         nullable=False,
     )
 
-    __table_args__ = {"schema": "user_related"}
+    created_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP(timezone=False),
+        nullable=False,
+        default=func.localtimestamp(),
+        server_default="NOW()",
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP(timezone=False),
+        nullable=False,
+        default=func.localtimestamp(),
+        server_default="NOW()",
+        onupdate=func.localtimestamp(),
+    )
+
+    user = relationship("InferredUser", foreign_keys=[inferred_user_id])
 
 
 class APIKeyManagement(Base):

src/app/models/documents.py

@@ -1,3 +1,5 @@
+import uuid
+
 from pydantic import BaseModel
 
 
@@ -12,7 +14,7 @@ class DocumentPayloadModel(BaseModel):
     document_corpus: str
     document_desc: str
     document_details: dict[str, list[dict] | list[str] | str | int | float | None]
-    document_id: str
+    document_id: uuid.UUID
     document_lang: str
     document_sdg: list[int]
     document_title: str

src/app/tests/api/api_v1/test_chat.py

@@ -27,7 +27,7 @@
                 "readability": 42.61,
                 "source": "au",
             },
-            "document_id": "testDocId",
+            "document_id": "12345678-1234-5678-1234-567812345678",
             "document_lang": "en",
             "document_scrape_date": "testDate",
             "document_sdg": [11, 12, 13, 15, 2, 8],
@@ -108,7 +108,7 @@ async def test_chat_empty_history(self, chat_mock, *mocks):
                             "readability": 42.61,
                             "source": "au",
                         },
-                        document_id="testDocId",
+                        document_id="12345678-1234-5678-1234-567812345678",
                         document_lang="en",
                         document_sdg=[11, 12, 13, 15, 2, 8],
                         document_title="testTitle",
@@ -159,7 +159,7 @@ async def test_chat_rephrase(self, *mocks):
                                 "readability": 42.61,
                                 "source": "au",
                             },
-                            document_id="testDocId",
+                            document_id="12345678-1234-5678-1234-567812345678",
                             document_lang="en",
                             document_sdg=[11, 12, 13, 15, 2, 8],
                             document_title="testTitle",
@@ -287,7 +287,7 @@ async def test_stream(self, *mocks):
                                 "readability": 42.61,
                                 "source": "au",
                             },
-                            document_id="testDocId",
+                            document_id="12345678-1234-5678-1234-567812345678",
                             document_lang="en",
                             document_sdg=[11, 12, 13, 15, 2, 8],
                             document_title="testTitle",