bookmark model and router (#560)

Author: Taniya-Das

src/database/model/bookmark/__init__.py

@@ -0,0 +1,21 @@
+from sqlmodel import SQLModel, Field
+from typing import Optional
+from datetime import datetime
+from sqlalchemy import Column, String
+
+
+class Bookmark(SQLModel, table=True):  # type: ignore [call-arg]
+    __tablename__ = "bookmark"
+    user_identifier: str = Field(
+        foreign_key="user.subject_identifier",
+        nullable=False,
+        ondelete="CASCADE",
+        primary_key=True,
+        description="The sub-identifier of the user who created the bookmark.",
+    )
+    resource_identifier: str = Field(
+        primary_key=True, description="The identifier of the resource being bookmarked."
+    )
+    created_at: datetime = Field(
+        default_factory=datetime.utcnow, description="The time when the bookmark was created."
+    )

src/database/model/bookmark/bookmark.py

@@ -40,6 +40,7 @@
     search_routers,
     review_router,
     user_router,
+    bookmark_router,
 )
 from setup_logger import setup_logger
 
@@ -85,7 +86,7 @@ def counts() -> dict:
         + parent_routers.router_list
         + enum_routers.router_list
         + search_routers.router_list
-        + [review_router, user_router]
+        + [review_router, user_router, bookmark_router]
     ):
         app.include_router(router.create(url_prefix))
 

src/main.py

@@ -0,0 +1,106 @@
+import sqlalchemy.exc
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List, cast
+from sqlmodel import Session, select, Field, SQLModel
+
+from authentication import KeycloakUser, get_user_or_raise
+from database.session import get_session
+from database.model.bookmark.bookmark import Bookmark
+from http import HTTPStatus
+from datetime import datetime
+from routers.helper_functions import get_asset_type_by_abbreviation
+
+
+class BookmarkRead(SQLModel):
+    resource_identifier: str = Field(description="The identifier of the resource being bookmarked.")
+    created_at: datetime = Field(
+        description="The time when the bookmark was created in ISO 8601 format."
+    )
+
+    class Config:
+        json_encoders = {datetime: lambda dt: dt.isoformat()}
+
+
+def create(url_prefix: str = "") -> APIRouter:
+    router = APIRouter()
+
+    for path in [
+        f"{url_prefix}/v2/bookmarks",
+        f"{url_prefix}/bookmarks",
+    ]:
+
+        @router.get(
+            path,
+            tags=["User"],
+            description="Return all your bookmarks.",
+            response_model=List[BookmarkRead],
+        )
+        def list_bookmarks(
+            user: KeycloakUser = Depends(get_user_or_raise), session: Session = Depends(get_session)
+        ) -> List[BookmarkRead]:
+            return session.exec(
+                select(Bookmark).where(Bookmark.user_identifier == user._subject_identifier)
+            ).all()
+
+        @router.post(
+            path,
+            tags=["User"],
+            response_model=BookmarkRead,
+            description="Add the asset to the logged-in user's bookmarks."
+            "If it was already bookmarked, return the existing bookmark.",
+            status_code=HTTPStatus.OK,
+        )
+        def create_bookmark(
+            resource_identifier: str,
+            user: KeycloakUser = Depends(get_user_or_raise),
+            session: Session = Depends(get_session),
+        ) -> BookmarkRead:
+            if not resource_identifier_exists_in_database(resource_identifier, session):
+                raise HTTPException(
+                    status_code=HTTPStatus.NOT_FOUND,
+                    detail=f"Resource {resource_identifier} does not exist.",
+                )
+
+            try:
+                bookmark = Bookmark(
+                    user_identifier=user._subject_identifier,
+                    resource_identifier=resource_identifier,
+                )
+                session.add(bookmark)
+                session.commit()
+            except sqlalchemy.exc.IntegrityError:  # The entry already exists
+                session.rollback()
+                bookmark = session.get(Bookmark, (user._subject_identifier, resource_identifier))
+            return cast(BookmarkRead, bookmark)
+
+        @router.delete(
+            path,
+            tags=["User"],
+            description="Delete a bookmark for the logged-in user by resource identifier."
+            "Also returns HTTP status code OK (200) if no such bookmark existed.",
+            status_code=HTTPStatus.OK,
+        )
+        def delete_bookmark(
+            resource_identifier: str,
+            user: KeycloakUser = Depends(get_user_or_raise),
+            session: Session = Depends(get_session),
+        ):
+            bookmark = session.get(Bookmark, (user._subject_identifier, resource_identifier))
+            if bookmark:
+                session.delete(bookmark)
+                session.commit()
+            return None
+
+    return router
+
+
+def resource_identifier_exists_in_database(resource_identifier: str, session: Session) -> bool:
+    """
+    Returns True if the given identifier exists in any of the tables.
+    """
+    asset_type = get_asset_type_by_abbreviation().get(resource_identifier.split("_")[0], None)
+    if asset_type:
+        query = select(asset_type).where(asset_type.identifier == resource_identifier)
+        return session.exec(query).first() is not None
+
+    return False

src/routers/bookmark_router.py

@@ -1,6 +1,7 @@
 import routers
 from database.model.concept.concept import AIoDConcept
 from database.model.helper_functions import non_abstract_subclasses
+from functools import cache
 
 
 def get_all_read_classes() -> dict[str, AIoDConcept]:
@@ -22,3 +23,12 @@ def get_all_asset_schemas():
     return [
         {"$ref": f"#/components/schemas/{clz.__name__}"} for clz in get_all_read_classes().values()
     ]
+
+
+@cache
+def get_asset_type_by_abbreviation() -> dict[str, type[AIoDConcept]]:
+    return {
+        cls.__abbreviation__: cls
+        for cls in non_abstract_subclasses(AIoDConcept)
+        if hasattr(cls, "__abbreviation__")
+    }

src/routers/helper_functions.py

@@ -17,6 +17,7 @@
 from .resource_bundle_router import ResourceBundleRouter
 from .. import ResourceRouter
 
+
 router_list: list[ResourceRouter | PlatformRouter] = [
     PlatformRouter(),
     CaseStudyRouter(),

src/routers/resource_routers/__init__.py

@@ -9,7 +9,7 @@
 from database.session import DbSession
 from tests.testutils.test_resource import factory_test_resource
 from tests.testutils.users import register_asset
-
+from database.model.concept.aiod_entry import EntryStatus, AIoDEntryORM
 
 def test_get_count_happy_path(client_test_resource: TestClient):
     with DbSession() as session:
@@ -60,7 +60,6 @@ def test_get_count_detailed_happy_path(client_test_resource: TestClient):
     assert response_json == {"aiod": 1, "example": 2, "openml": 1}
     assert "deprecated" not in response.headers
 
-from database.model.concept.aiod_entry import EntryStatus, AIoDEntryORM
 # default platfrom is "aiod"
 def test_get_count_total(
     client: TestClient,

src/tests/routers/generic/test_router_get_count.py

@@ -0,0 +1,142 @@
+from http import HTTPStatus
+
+from starlette.testclient import TestClient
+from database.session import DbSession
+
+from tests.testutils.users import logged_in_user, ALICE
+from database.model.bookmark.bookmark import Bookmark
+from database.session import DbSession
+from tests.testutils.users import register_asset, register_user
+from datetime import datetime
+from database.model.agent.person import Person
+from database.model.agent.contact import Contact
+
+
+def test_create_bookmark(
+    client: TestClient,
+    person: Person) -> None:
+
+    identifier = register_asset(person)
+
+    with logged_in_user():
+        response = client.post(
+            f"/bookmarks?resource_identifier={identifier}",
+            headers={"Authorization": "fake token"},
+        )
+    assert response.status_code == HTTPStatus.OK
+    bookmark = response.json()
+    assert bookmark["resource_identifier"] == identifier
+    now = datetime.utcnow()
+    assert (now - datetime.fromisoformat(bookmark["created_at"])).total_seconds() < 2
+
+
+def test_create_bookmark_for_non_existing_resource(client: TestClient) -> None:
+    # Create bookmark for non existing resource.
+
+    with logged_in_user():
+        response = client.post(
+            f"/bookmarks?resource_identifier=wrong_indetifier",
+            headers={"Authorization": "fake token"},
+        )
+
+    assert response.status_code == HTTPStatus.NOT_FOUND
+    assert response.json()["detail"] == f"Resource wrong_indetifier does not exist."
+
+
+def test_create_duplicate(
+    client: TestClient,
+    person: Person
+) -> None:
+
+    with DbSession() as session:
+        identifier = register_asset(person)
+        user = register_user(ALICE, session)
+        now = datetime.utcnow()
+        bookmark = Bookmark(
+            user_identifier=user.subject_identifier,
+            resource_identifier=identifier,
+            created_at=now
+        )
+        session.add(bookmark)
+        session.commit()
+
+    # Attempt to create a duplicate bookmark
+    with logged_in_user(ALICE):
+        response = client.post(
+            f"/bookmarks?resource_identifier={identifier}",
+            headers={"Authorization": "fake token"},
+        )
+
+    assert response.status_code == HTTPStatus.OK
+    bookmark = response.json()
+    assert bookmark["resource_identifier"] == identifier
+    assert bookmark["created_at"] == now.isoformat()
+
+
+def test_get_bookmarks(client: TestClient, person: Person, contact: Contact) -> None:
+    with DbSession() as session:
+        prsn_id = register_asset(person)
+        contact_id = register_asset(contact)
+        user = register_user(ALICE, session)
+        session.commit()
+
+    # Add a bookmark
+    with logged_in_user(ALICE):
+        response = client.post(
+            f"/bookmarks?resource_identifier={prsn_id}",
+            headers={"Authorization": "fake token"},
+        )
+        assert response.status_code == HTTPStatus.OK
+
+        response = client.post(
+            f"/bookmarks?resource_identifier={contact_id}",
+            headers={"Authorization": "fake token"},
+        )
+        assert response.status_code == HTTPStatus.OK
+
+        # Fetch bookmarks
+        response = client.get(
+            "/bookmarks",
+            headers={"Authorization": "fake token"},
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        bookmarks = response.json()
+        assert len(bookmarks) == 2
+
+
+def test_delete_bookmark(
+    client: TestClient,
+    person: Person
+) -> None:
+
+
+    with DbSession() as session:
+        identifier = register_asset(person)
+        register_user(ALICE, session)
+        session.commit()
+
+    with logged_in_user(ALICE):
+        response = client.post(
+            f"/bookmarks?resource_identifier={identifier}",
+            headers={"Authorization": "fake token"},
+        )
+    assert response.status_code == HTTPStatus.OK
+
+
+    with logged_in_user(ALICE):
+        response = client.delete(
+            f"/bookmarks?resource_identifier={identifier}",
+            headers={"Authorization": "fake token"},
+            )
+    assert response.status_code == HTTPStatus.OK
+    assert response.json() == None
+
+    # Confirm it's deleted
+    with logged_in_user(ALICE):
+        response = client.get(
+            "/bookmarks",
+            headers={"Authorization": "fake token"},
+        )
+    assert response.status_code == HTTPStatus.OK
+    assert all(b["resource_identifier"] != identifier for b in response.json())

src/tests/test_bookmark_endpoints.py

@@ -125,7 +125,11 @@ def clear_db(request, engine: Engine):
     with engine.connect() as connection:
         transaction = connection.begin()
         for table in reversed(SQLModel.metadata.sorted_tables):
-            connection.execute(table.delete())
+            try:
+                connection.execute(table.delete())
+            except Exception as e:
+                print(f"Error while clearing table {table.name}: {e}")
+                raise
         transaction.commit()