#440 - Review case template endpoints and add page template endpoints

Kamforka · Kamforka · commit 29924da19b68 · 2025-06-20T18:20:22.000+02:00
diff --git a/pyproject.toml b/pyproject.toml
@@ -7,7 +7,7 @@ name = "thehive4py"
 description = "Python client for TheHive5"
 version = "2.0.0b11"
 requires-python = ">=3.9"
-dependencies = ["requests~=2.27"]
+dependencies = ["requests~=2.27", "typing_extensions==4.*"]
 readme = "README.md"
 keywords = ["thehive5", "api", "client"]
 license = { text = "MIT" }
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -13,6 +13,7 @@
 from thehive4py.types.observable import InputObservable, OutputObservable
 from thehive4py.types.observable_type import OutputObservableType
 from thehive4py.types.page import OutputCasePage
+from thehive4py.types.page_template import InputPageTemplate, OutputPageTemplate
 from thehive4py.types.procedure import OutputProcedure
 from thehive4py.types.profile import OutputProfile
 from thehive4py.types.task import InputTask, OutputTask
@@ -146,6 +147,37 @@ def test_case_templates(thehive: TheHiveApi) -> List[OutputCaseTemplate]:
     ]
 
 
+@pytest.fixture
+def test_page_template(thehive: TheHiveApi) -> OutputPageTemplate:
+    return thehive.page_template.create(
+        page_template={
+            "title": "my first page template",
+            "category": "testing",
+            "content": "...",
+        }
+    )
+
+
+@pytest.fixture
+def test_page_templates(thehive: TheHiveApi) -> List[OutputPageTemplate]:
+    page_templates: List[InputPageTemplate] = [
+        {
+            "title": "my first page template",
+            "category": "testing",
+            "content": "...",
+        },
+        {
+            "title": "my second case template",
+            "category": "testing",
+            "content": "...",
+        },
+    ]
+    return [
+        thehive.page_template.create(page_template=page_template)
+        for page_template in page_templates
+    ]
+
+
 @pytest.fixture
 def test_observable(thehive: TheHiveApi, test_case: OutputCase) -> OutputObservable:
     return thehive.observable.create_in_case(
diff --git a/tests/test_case_template_endpoint.py b/tests/test_case_template_endpoint.py
@@ -1,6 +1,7 @@
 from typing import List
 
 import pytest
+
 from thehive4py.client import TheHiveApi
 from thehive4py.errors import TheHiveError
 from thehive4py.types.case_template import InputCaseTemplate, OutputCaseTemplate
@@ -39,6 +40,31 @@ def test_delete(self, thehive: TheHiveApi, test_case_template: OutputCaseTemplat
         with pytest.raises(TheHiveError):
             thehive.case_template.get(case_template_id=case_template_id)
 
+    def test_link_and_find_page_templates(
+        self,
+        thehive: TheHiveApi,
+        test_case_template: OutputCaseTemplate,
+        test_page_templates: List[dict],
+    ):
+        case_template_id = test_case_template["_id"]
+        page_template_ids = [
+            page_template["_id"] for page_template in test_page_templates
+        ]
+
+        thehive.case_template.link_page_templates(
+            case_template_id=case_template_id,
+            page_template_ids=page_template_ids,
+        )
+
+        linked_page_templates = thehive.case_template.find_page_templates(
+            case_template_id=case_template_id
+        )
+
+        linked_page_template_ids = [
+            page_template["_id"] for page_template in linked_page_templates
+        ]
+        assert sorted(linked_page_template_ids) == sorted(page_template_ids)
+
     def test_find(
         self,
         thehive: TheHiveApi,
diff --git a/tests/test_page_template_endpoint.py b/tests/test_page_template_endpoint.py
@@ -0,0 +1,52 @@
+from typing import List
+
+import pytest
+
+from thehive4py.client import TheHiveApi
+from thehive4py.errors import TheHiveError
+from thehive4py.types.page_template import InputUpdatePageTemplate, OutputPageTemplate
+
+
+class TestPageTemplateEndpoint:
+    def test_create_and_get(self, thehive: TheHiveApi):
+        created_page_template = thehive.page_template.create(
+            page_template={
+                "title": "my page template",
+                "category": "testing",
+                "content": "...",
+            }
+        )
+        fetched_page_template = thehive.page_template.get(created_page_template["_id"])
+        assert created_page_template == fetched_page_template
+
+    def test_update(self, thehive: TheHiveApi, test_page_template: OutputPageTemplate):
+        page_template_id = test_page_template["_id"]
+        update_fields: InputUpdatePageTemplate = {
+            "title": "updated page template name",
+            "content": "updated page template description",
+        }
+        thehive.page_template.update(
+            page_template_id=page_template_id, fields=update_fields
+        )
+        updated_page_template = thehive.page_template.get(
+            page_template_id=page_template_id
+        )
+
+        for key, value in update_fields.items():
+            assert updated_page_template.get(key) == value
+
+    def test_delete(self, thehive: TheHiveApi, test_page_template: OutputPageTemplate):
+        page_template_id = test_page_template["_id"]
+        thehive.page_template.delete(page_template_id=page_template_id)
+        with pytest.raises(TheHiveError):
+            thehive.page_template.get(page_template_id=page_template_id)
+
+    def test_find(
+        self,
+        thehive: TheHiveApi,
+        test_page_templates: List[OutputPageTemplate],
+    ):
+        found_templates = thehive.page_template.find()
+        original_ids = [template["_id"] for template in test_page_templates]
+        found_ids = [template["_id"] for template in found_templates]
+        assert sorted(found_ids) == sorted(original_ids)
diff --git a/tests/utils.py b/tests/utils.py
@@ -98,6 +98,7 @@ def _reset_hive_org(hive_url: str, test_config: TestConfig, organisation: str) -
     attachments = client.organisation.find_attachments(org_id=organisation)
     cases = client.case.find()
     case_templates = client.case_template.find()
+    page_templates = client.page_template.find()
 
     with ThreadPoolExecutor() as executor:
         executor.map(client.alert.delete, [alert["_id"] for alert in alerts])
@@ -110,6 +111,10 @@ def _reset_hive_org(hive_url: str, test_config: TestConfig, organisation: str) -
             client.case_template.delete,
             [case_template["_id"] for case_template in case_templates],
         )
+        executor.map(
+            client.page_template.delete,
+            [page_template["_id"] for page_template in page_templates],
+        )
 
 
 def _reset_hive_admin_org(hive_url: str, test_config: TestConfig) -> None:
diff --git a/thehive4py/client.py b/thehive4py/client.py
@@ -17,6 +17,7 @@
 from thehive4py.endpoints.cortex import CortexEndpoint
 from thehive4py.endpoints.custom_field import CustomFieldEndpoint
 from thehive4py.endpoints.observable_type import ObservableTypeEndpoint
+from thehive4py.endpoints.page_template import PageTemplateEndpoint
 from thehive4py.endpoints.query import QueryEndpoint
 from thehive4py.session import DEFAULT_RETRY, RetryValue, TheHiveSession, VerifyValue
 
@@ -66,6 +67,7 @@ def __init__(
         self.case_template = CaseTemplateEndpoint(self.session)
         self.comment = CommentEndpoint(self.session)
         self.observable = ObservableEndpoint(self.session)
+        self.page_template = PageTemplateEndpoint(self.session)
         self.procedure = ProcedureEndpoint(self.session)
         self.task = TaskEndpoint(self.session)
         self.task_log = TaskLogEndpoint(self.session)
diff --git a/thehive4py/endpoints/case_template.py b/thehive4py/endpoints/case_template.py
@@ -1,19 +1,102 @@
+from typing import List, Optional
+
 from thehive4py.endpoints._base import EndpointBase
 from thehive4py.query import QueryExpr
 from thehive4py.query.filters import FilterExpr
 from thehive4py.query.page import Paginate
 from thehive4py.query.sort import SortExpr
-from thehive4py.types.case_template import OutputCaseTemplate, InputCaseTemplate
-from typing import List, Optional
+from thehive4py.types.case_template import InputCaseTemplate, OutputCaseTemplate
+from thehive4py.types.page_template import OutputPageTemplate
 
 
 class CaseTemplateEndpoint(EndpointBase):
+    def create(self, case_template: InputCaseTemplate) -> OutputCaseTemplate:
+        """Create a case template.
+
+        Args:
+            case_template: The body of the case template.
+
+        Returns:
+            The created case template.
+        """
+        return self._session.make_request(
+            "POST", path="/api/v1/caseTemplate", json=case_template
+        )
+
+    def get(self, case_template_id: str) -> OutputCaseTemplate:
+        """Get a case template by id.
+
+        Args:
+            case_template_id: The id of the case template.
+
+        Returns:
+            The case template specified by the id.
+        """
+        return self._session.make_request(
+            "GET", path=f"/api/v1/caseTemplate/{case_template_id}"
+        )
+
+    def delete(self, case_template_id: str) -> None:
+        """Delete a case template.
+
+        Args:
+            case_template_id: The id of the case template.
+
+        Returns:
+            N/A
+        """
+        return self._session.make_request(
+            "DELETE", path=f"/api/v1/caseTemplate/{case_template_id}"
+        )
+
+    def update(self, case_template_id: str, fields: InputCaseTemplate) -> None:
+        """Update a case template.
+
+        Args:
+            case_template_id: The id of the case template.
+            fields: The fields of the case template to update.
+
+        Returns:
+            N/A
+        """
+        return self._session.make_request(
+            "PATCH", path=f"/api/v1/caseTemplate/{case_template_id}", json=fields
+        )
+
+    def link_page_templates(
+        self, case_template_id: str, page_template_ids: List[str]
+    ) -> None:
+        """Link page templates to a case template.
+
+        Args:
+            case_template_id: The id or name of the case template.
+            page_template_ids: The list of page template ids to link.
+
+        Returns:
+            N/A
+        """
+        return self._session.make_request(
+            "PUT",
+            path=f"/api/v1/caseTemplate/{case_template_id}/pageTemplate/link",
+            json={"pageTemplateIds": page_template_ids},
+        )
+
     def find(
         self,
         filters: Optional[FilterExpr] = None,
         sortby: Optional[SortExpr] = None,
         paginate: Optional[Paginate] = None,
     ) -> List[OutputCaseTemplate]:
+        """Find multiple case templates.
+
+        Args:
+            filters: The filter expressions to apply in the query.
+            sortby: The sort expressions to apply in the query.
+            paginate: The pagination expression to apply in the query.
+
+        Returns:
+            The list of case templates matched by the query or an empty list.
+        """
         query: QueryExpr = [
             {"_name": "listCaseTemplate"},
             *self._build_subquery(filters=filters, sortby=sortby, paginate=paginate),
@@ -26,22 +109,33 @@ def find(
             params={"name": "caseTemplate"},
         )
 
-    def get(self, case_template_id: str) -> OutputCaseTemplate:
-        return self._session.make_request(
-            "GET", path=f"/api/v1/caseTemplate/{case_template_id}"
-        )
+    def find_page_templates(
+        self,
+        case_template_id: str,
+        filters: Optional[FilterExpr] = None,
+        sortby: Optional[SortExpr] = None,
+        paginate: Optional[Paginate] = None,
+    ) -> List[OutputPageTemplate]:
+        """Find page templates related to a case template.
 
-    def create(self, case_template: InputCaseTemplate) -> OutputCaseTemplate:
-        return self._session.make_request(
-            "POST", path="/api/v1/caseTemplate", json=case_template
-        )
+        Args:
+            case_template_id: The case template id.
+            filters: The filter expressions to apply in the query.
+            sortby: The sort expressions to apply in the query.
+            paginate: The pagination expression to apply in the query.
 
-    def delete(self, case_template_id: str) -> None:
-        return self._session.make_request(
-            "DELETE", path=f"/api/v1/caseTemplate/{case_template_id}"
-        )
+        Returns:
+            The list of page templates matched by the query or an empty list.
+        """
+        query: QueryExpr = [
+            {"_name": "getCaseTemplate", "idOrName": case_template_id},
+            *self._build_subquery(filters=filters, sortby=sortby, paginate=paginate),
+            {"_name": "pageTemplates"},
+        ]
 
-    def update(self, case_template_id: str, fields: InputCaseTemplate) -> None:
         return self._session.make_request(
-            "PATCH", path=f"/api/v1/caseTemplate/{case_template_id}", json=fields
+            "POST",
+            path="/api/v1/query",
+            json={"query": query},
+            params={"name": "pageTemplate"},
         )
diff --git a/thehive4py/endpoints/page_template.py b/thehive4py/endpoints/page_template.py
diff --git a/thehive4py/types/case_template.py b/thehive4py/types/case_template.py
diff --git a/thehive4py/types/page_template.py b/thehive4py/types/page_template.py
