Properly split /api/filters endpoint handlers

Author: cdhorn

gramps_webapi/api/__init__.py

@@ -14,7 +14,7 @@
 from .resources.citation import CitationResource, CitationsResource
 from .resources.event import EventResource, EventsResource
 from .resources.family import FamiliesResource, FamilyResource
-from .resources.filters import FilterResource
+from .resources.filters import FilterResource, FiltersResource
 from .resources.media import MediaObjectResource, MediaObjectsResource
 from .resources.metadata import MetadataResource
 from .resources.name_groups import NameGroupsResource
@@ -81,7 +81,7 @@ def register_endpt(resource: Type[Resource], url: str, name: str):
 register_endpt(BookmarksResource, "/bookmarks/", "bookmarks")
 # Filter
 register_endpt(FilterResource, "/filters/<string:namespace>/<string:name>", "filter")
-register_endpt(FilterResource, "/filters/<string:namespace>", "filters")
+register_endpt(FiltersResource, "/filters/<string:namespace>", "filters")
 # Translate
 register_endpt(TranslationResource, "/translations/<string:isocode>", "translation")
 register_endpt(TranslationsResource, "/translations/", "translations")

gramps_webapi/api/resources/filters.py

@@ -1,7 +1,7 @@
 """Gramps filter interface."""
 
 import json
-from typing import Dict, List, Set
+from typing import Any, Dict, List, Set
 
 import gramps.gen.filters as filters
 from flask import Response, abort
@@ -29,7 +29,7 @@
 }
 
 
-def get_filter_rules(args: Dict[str, str], namespace: str) -> List[Dict]:
+def get_filter_rules(args: Dict[str, Any], namespace: str) -> List[Dict]:
     """Return a list of available filter rules for a namespace."""
     rule_list = []
     for rule_class in _RULES_LOOKUP[namespace]:
@@ -52,7 +52,7 @@ def get_filter_rules(args: Dict[str, str], namespace: str) -> List[Dict]:
     return rule_list
 
 
-def get_custom_filters(args: Dict[str, str], namespace: str) -> List[Dict]:
+def get_custom_filters(args: Dict[str, Any], namespace: str) -> List[Dict]:
     """Return a list of custom filters for a namespace."""
     filter_list = []
     filters.reload_custom_filters()
@@ -164,8 +164,8 @@ class CustomFilterSchema(FilterSchema):
     )
 
 
-class FilterResource(ProtectedResource, GrampsJSONEncoder):
-    """Filter resource."""
+class FiltersResource(ProtectedResource, GrampsJSONEncoder):
+    """Filters resource."""
 
     @use_args(
         {
@@ -228,6 +228,23 @@ def put(self, args: Dict, namespace: str) -> Response:
                 )
         return abort(404)
 
+
+class FilterResource(ProtectedResource, GrampsJSONEncoder):
+    """Filter resource."""
+
+    def get(self, namespace: str, name: str) -> Response:
+        """Get a custom filter."""
+        try:
+            namespace = GRAMPS_NAMESPACES[namespace]
+        except KeyError:
+            abort(404)
+
+        args = {"filters": [name]}
+        filter_list = get_custom_filters(args, namespace)
+        if len(filter_list) == 0:
+            abort(404)
+        return self.response(200, filter_list[0])
+
     @use_args(
         {
             "force": fields.Str(validate=validate.Length(equal=0)),

gramps_webapi/data/apispec.yaml

@@ -1909,10 +1909,38 @@ paths:
           description: "Forbidden: Bad credentials, authentication failed."
 
   /filters/{namespace}/{name}:    
+    get:
+      tags:
+      - filters
+      summary: "Get a custom filter for a given namespace or category."
+      operationId: getFilter
+      security:
+        - Bearer: []
+      parameters:
+      - name: namespace
+        in: path
+        required: true
+        type: string
+        description: "The namespace or category for the custom filter."
+      - name: name
+        in: path
+        required: true
+        type: string
+        description: "The name of a custom filter."
+      responses:
+        200:
+          description: "OK: Successful operation."
+          schema:
+            $ref: "#/definitions/CustomFilter"    
+        401:
+          description: "Unauthorized: Missing authorization header."
+        404:
+          description: "Not Found: Namespace or filter not found."
+
     delete:
       tags:
       - filters
-      summary: "Delete a custom filter."
+      summary: "Delete a custom filter in a given namespace or category."
       operationId: deleteFilter
       security:
         - Bearer: []

tests/test_endpoints/runners.py

@@ -248,16 +248,25 @@ def run_test_filters_endpoint_namespace(test, namespace: str, payload: Dict):
     # check response if filter already exists
     result = test.client.post("/api/filters/" + namespace, json=payload)
     test.assertEqual(result.status_code, 422)
-    # check can fetch the filter
+    # check can fetch the filter using query parm
     result = test.client.get("/api/filters/" + namespace + "?filters=" + filter_name)
     test.assertEqual(result.status_code, 200)
     test.assertTrue(len(result.json) == 1 and len(result.json["filters"]) == 1)
     test.assertEqual(result.json["filters"][0]["name"], filter_name)
-    # check response if fetching filter that does not exist
+    # check can fetch the filter using path
+    result = test.client.get("/api/filters/" + namespace + "/" + filter_name)
+    test.assertEqual(result.status_code, 200)
+    test.assertEqual(result.json["name"], filter_name)
+    # check response if fetching filter using query parm that does not exist
     result = test.client.get(
         "/api/filters/" + namespace + "?filters=" + filter_name + "Missing"
     )
     test.assertEqual(result.status_code, 404)
+    # check response if fetching filter using path that does not exist
+    result = test.client.get(
+        "/api/filters/" + namespace + "/" + filter_name + "Missing"
+    )
+    test.assertEqual(result.status_code, 404)
     # check response applying filter that does not exist
     result = test.client.get(
         "/api/" + namespace + "/?filter=" + filter_name + "Missing"