Allow editing bookmarks (#469)

Author: DavidMStraub

gramps_webapi/api/__init__.py

@@ -29,7 +29,11 @@
 from .cache import thumbnail_cache
 from .media import get_media_handler
 from .resources.base import Resource
-from .resources.bookmarks import BookmarkResource, BookmarksResource
+from .resources.bookmarks import (
+    BookmarkResource,
+    BookmarksResource,
+    BookmarkEditResource,
+)
 from .resources.citations import CitationResource, CitationsResource
 from .resources.config import ConfigResource, ConfigsResource
 from .resources.dna import PersonDnaMatchesResource
@@ -202,6 +206,11 @@ def register_endpt(resource: Type[Resource], url: str, name: str):
 # Bookmarks
 register_endpt(BookmarkResource, "/bookmarks/<string:namespace>", "bookmark")
 register_endpt(BookmarksResource, "/bookmarks/", "bookmarks")
+register_endpt(
+    BookmarkEditResource,
+    "/bookmarks/<string:namespace>/<string:handle>",
+    "bookmark_edit",
+)
 # Filters
 register_endpt(FilterResource, "/filters/<string:namespace>/<string:name>", "filter")
 register_endpt(FiltersResource, "/filters/<string:namespace>", "filters-namespace")

gramps_webapi/api/resources/bookmarks.py

@@ -19,12 +19,15 @@
 
 """Bookmark API resource."""
 
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 from flask import Response, abort
 from gramps.gen.db.base import DbReadBase
+from gramps.gen.db.bookmarks import DbBookmarks
 
-from ..util import get_db_handle, use_args
+from ...auth.const import PERM_EDIT_OBJ
+from ..auth import require_permissions
+from ..util import get_db_handle, use_args, abort_with_message
 from . import ProtectedResource
 from .emit import GrampsJSONEncoder
 
@@ -41,9 +44,8 @@
 ]
 
 
-def get_bookmarks(db_handle: DbReadBase, namespace: str) -> Optional[List]:
-    """Return bookmarks for a namespace."""
-    result = None
+def _get_bookmarks_object(db_handle: DbReadBase, namespace: str) -> DbBookmarks:
+    """Return bookmarks object for a namespace."""
     if namespace == "people":
         result = db_handle.get_bookmarks()
     elif namespace == "families":
@@ -62,9 +64,43 @@ def get_bookmarks(db_handle: DbReadBase, namespace: str) -> Optional[List]:
         result = db_handle.get_source_bookmarks()
     elif namespace == "repositories":
         result = db_handle.get_repo_bookmarks()
-    if result is None:
+    else:
         abort(404)
-    return result.get()
+    return result
+
+
+def get_bookmarks(db_handle: DbReadBase, namespace: str) -> Optional[List]:
+    """Return bookmarks for a namespace."""
+    bookmarks = _get_bookmarks_object(db_handle, namespace)
+    return bookmarks.get()
+
+
+def create_bookmark(db_handle: DbReadBase, namespace: str, handle: str) -> None:
+    """Create a bookmark if it doesn't exist yet."""
+    bookmarks = _get_bookmarks_object(db_handle, namespace)
+    if handle not in bookmarks.get():
+        has_handle_func = {
+            "people": db_handle.has_person_handle,
+            "families": db_handle.has_family_handle,
+            "events": db_handle.has_event_handle,
+            "places": db_handle.has_place_handle,
+            "sources": db_handle.has_source_handle,
+            "citations": db_handle.has_citation_handle,
+            "repositories": db_handle.has_repository_handle,
+            "media": db_handle.has_media_handle,
+            "notes": db_handle.has_note_handle,
+        }[namespace]
+        if not has_handle_func(handle):
+            abort_with_message(404, "Object does not exist")
+        bookmarks.append(handle)
+
+
+def delete_bookmark(db_handle: DbReadBase, namespace: str, handle: str) -> None:
+    """Delete a bookmark."""
+    bookmarks = _get_bookmarks_object(db_handle, namespace)
+    if handle not in bookmarks.get():
+        abort_with_message(404, "Bookmark does not exist")
+    bookmarks.remove(handle)
 
 
 class BookmarkResource(ProtectedResource, GrampsJSONEncoder):
@@ -96,3 +132,25 @@ def get(self, args: Dict) -> Response:
         for bookmark in _BOOKMARK_TYPES:
             result.update({bookmark: get_bookmarks(self.db_handle, bookmark)})
         return self.response(200, result)
+
+
+class BookmarkEditResource(ProtectedResource):
+    """Resource for editing and creating bookmarks."""
+
+    @property
+    def db_handle(self) -> DbReadBase:
+        """Get the database instance."""
+        return get_db_handle(readonly=False)
+
+    def put(self, namespace: str, handle: str) -> Response:
+        """Create a bookmark."""
+        require_permissions([PERM_EDIT_OBJ])
+        if handle not in get_bookmarks(self.db_handle, namespace):
+            create_bookmark(self.db_handle, namespace, handle)
+        return Response("", 200)
+
+    def delete(self, namespace: str, handle: str) -> Response:
+        require_permissions([PERM_EDIT_OBJ])
+        """Delete a bookmark."""
+        delete_bookmark(self.db_handle, namespace, handle)
+        return Response("", 200)

gramps_webapi/data/apispec.yaml

@@ -4964,6 +4964,67 @@ paths:
           description: "Not Found: Bookmark type not found."
 
 
+  /bookmarks/{namespace}/{handle}:
+    put:
+      tags:
+      - bookmarks
+      summary: "Add a bookmark to a given category."
+      operationId: addBookmark
+      security:
+        - Bearer: []
+      parameters:
+      - name: namespace
+        in: path
+        required: true
+        type: string
+        description: "The namespace or category for the bookmarks."
+      - name: handle
+        in: path
+        required: true
+        type: string
+        description: "The object's handle."
+      responses:
+        200:
+          description: "OK: Successful operation."
+          schema:
+            type: array
+            items:
+              type: string
+        401:
+          description: "Unauthorized: Missing authorization header."
+        404:
+          description: "Not Found: Bookmark type or handle not found."
+    delete:
+      tags:
+      - bookmarks
+      summary: "Delte a bookmark from a given category."
+      operationId: deleteBookmark
+      security:
+        - Bearer: []
+      parameters:
+      - name: namespace
+        in: path
+        required: true
+        type: string
+        description: "The namespace or category for the bookmarks."
+      - name: handle
+        in: path
+        required: true
+        type: string
+        description: "The object's handle."
+      responses:
+        200:
+          description: "OK: Successful operation."
+          schema:
+            type: array
+            items:
+              type: string
+        401:
+          description: "Unauthorized: Missing authorization header."
+        404:
+          description: "Not Found: Bookmark type not found or bookmark does not exist."
+
+
 ##############################################################################
 # Endpoint - Filters
 ##############################################################################

tests/test_endpoints/test_bookmarks.py

@@ -21,14 +21,15 @@
 
 import unittest
 
-from . import BASE_URL, get_test_client
+from . import BASE_URL, get_test_client, ROLE_MEMBER
 from .checks import (
     check_conforms_to_schema,
     check_invalid_semantics,
     check_requires_token,
     check_resource_missing,
     check_success,
 )
+from .util import fetch_header
 
 TEST_URL = BASE_URL + "/bookmarks/"
 
@@ -78,3 +79,62 @@ def test_get_bookmarks_namespace_missing_content(self):
     def test_get_bookmarks_namespace_validate_semantics(self):
         """Test invalid parameters and values."""
         check_invalid_semantics(self, TEST_URL + "families?query")
+
+    def test_add_and_remove_bookmarks(self):
+        for namespace in [
+            "citations",
+            "events",
+            "families",
+            "media",
+            "notes",
+            "people",
+            "places",
+            "repositories",
+            "sources",
+        ]:
+            # fetch bookmarks
+            rv = check_success(self, f"{TEST_URL}{namespace}")
+            original = rv
+
+            # find an object that is not bookmarked
+            rv = check_success(self, f"{BASE_URL}/{namespace}/")
+            for obj in rv:
+                if obj["handle"] not in original:
+                    new_handle = obj["handle"]
+                    break
+
+            # add bookmark
+            header = fetch_header(self.client)
+            header_member = fetch_header(self.client, role=ROLE_MEMBER)
+
+            # this shouldn't work
+            rv = self.client.put(
+                f"{TEST_URL}{namespace}/{new_handle}", headers=header_member
+            )
+            assert rv.status_code == 403
+            rv = check_success(self, f"{TEST_URL}{namespace}")
+            assert rv == original
+
+            # this should work
+            rv = self.client.put(f"{TEST_URL}{namespace}/{new_handle}", headers=header)
+            assert rv.status_code == 200
+            rv = check_success(self, f"{TEST_URL}{namespace}")
+            assert rv == original + [new_handle]
+
+            # delete again
+
+            # this shouldn't work
+            rv = self.client.delete(
+                f"{TEST_URL}{namespace}/{new_handle}", headers=header_member
+            )
+            assert rv.status_code == 403
+            rv = check_success(self, f"{TEST_URL}{namespace}")
+            assert rv == original + [new_handle]
+
+            # this should work
+            rv = self.client.delete(
+                f"{TEST_URL}{namespace}/{new_handle}", headers=header
+            )
+            assert rv.status_code == 200
+            rv = check_success(self, f"{TEST_URL}{namespace}")
+            assert rv == original