howler-api 4.0.0.dev652__tar.gz → 4.0.0.dev664__tar.gz

{howler_api-4.0.0.dev652 → howler_api-4.0.0.dev664}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: howler-api
-Version: 4.0.0.dev652
+Version: 4.0.0.dev664
 Summary: Howler - API server
 License: MIT
 Keywords: howler,alerting,gc,canada,cse-cst,cse,cst,cyber,cccs

{howler_api-4.0.0.dev652 → howler_api-4.0.0.dev664}/howler/api/v2/case.py

@@ -7,6 +7,7 @@ from howler.common.loader import datastore
 from howler.common.logging import get_logger
 from howler.common.swagger import generate_swagger_docs
 from howler.datastore.exceptions import DataStoreException
+from howler.odm.models.case import CaseItem
 from howler.odm.models.user import User
 from howler.security import api_login
 from howler.services import case_service
@@ -217,7 +218,8 @@ def append_item(id: str, user: User, **kwargs):  # noqa: C901
     Data Block:
     {
         "type": "hit",            # Type of item to append: "hit", "observable", "case", "table", "lead", or "reference"
-        "value": "item-id-123"    # The ID or reference value for the item
+        "value": "item-id-123"    # The ID or reference value for the item,
+        "path": "example/path/Title"
     }
 
     Result Example:
@@ -230,56 +232,58 @@ def append_item(id: str, user: User, **kwargs):  # noqa: C901
     except UnsupportedMediaType:
         return bad_request(err="Invalid JSON body")
 
-    if "value" not in body:
-        return bad_request(err="Case 'value' is required")
-
-    if "type" not in body:
-        return bad_request(err="Case 'type' missing")
+    for field in ["value", "type", "path"]:
+        if field not in body:
+            return bad_request(err=f"CaseItem '{field}' is required")
 
     try:
-        case_service.append_case_item(
-            id, item_type=body["type"], item_value=body["value"], item_path=body.get("path", None)
-        )
+        return ok(case_service.append_case_item(id, item=CaseItem(body)))
     except DataStoreException as e:
         logger.exception("Save Error")
         return internal_error(err=str(e))
     except InvalidDataException as e:
         return bad_request(err=str(e))
 
-    return ok()
-
 
 @generate_swagger_docs()
-@case_api.route("/<id>/items/<value>", methods=["DELETE"])
+@case_api.route("/<case_id>/items", methods=["DELETE"])
 @api_login(required_priv=["R", "W"])
-def delete_item(id: str, value: str, **kwargs):
-    """Delete an item from a case
+def delete_item(case_id: str, **kwargs):
+    """Delete one or more items from a case
 
-    This endpoint removes an item from a case's items list. If the item is a hit or
+    This endpoint removes items from a case's items list. If an item is a hit or
     observable, the bidirectional relationship is cleaned up - the case reference will
     be removed from the backing object's related.cases list.
 
     Variables:
-    id       => The id of the case to modify
-    value    => The value of the item to delete (must match the item's value field)
+    case_id       => The id of the case to modify
 
     Arguments:
     None
 
     Data Block:
-    None
+    {
+        "values": ["item-id-123", "item-id-456"]   # The values of the items to delete
+    }
 
     Result Example:
     {
-        "success": true     # Did the deletion succeed?
+        ...case     # The updated case data
     }
     """
+    body = request.json
+
+    if not body or not isinstance(body, dict) or "values" not in body:
+        return bad_request(err="Request body must be a JSON object with a 'values' field.")
+
+    values = body["values"]
+    if not isinstance(values, list) or not values:
+        return bad_request(err="'values' must be a non-empty list.")
+
     try:
-        case_service.remove_case_item(id, item_value=value)
+        return ok(case_service.remove_case_items(case_id, values))
     except DataStoreException as e:
         logger.exception("Save Error")
         return internal_error(err=str(e))
-    except InvalidDataException as e:
+    except (InvalidDataException, NotFoundException) as e:
         return bad_request(err=str(e))
-
-    return ok()

{howler_api-4.0.0.dev652 → howler_api-4.0.0.dev664}/howler/odm/models/view.py

@@ -11,9 +11,17 @@ class Settings(odm.Model):
     )
 
 
+DEFAULT_INDEXES = ["hit"]
+
+
 @odm.model(index=True, store=True, description="Model of views")
 class View(odm.Model):
     view_id: str = odm.UUID(description="A UUID for this view")
+    indexes: list[str] = odm.List(
+        odm.Keyword(),
+        default=DEFAULT_INDEXES,
+        description="What indexes this view applies to.",
+    )
     title: str = odm.CaseInsensitiveKeyword(description="The name of this view.")
     query: str = odm.Keyword(description="The query to run in this view.")
     sort: str = odm.Keyword(description="The sorting to use with this view.", optional=True)

{howler_api-4.0.0.dev652 → howler_api-4.0.0.dev664}/howler/services/case_service.py

@@ -222,13 +222,13 @@ def update_case(case_id: str, case_data: dict[str, Any], user: User) -> Case:
 
 
 @overload
-def append_case_item(case_id: str, item: CaseItem): ...
+def append_case_item(case_id: str, item: CaseItem) -> Case: ...
 
 
 @overload
 def append_case_item(
     case_id: str, item: None = None, item_type: str = ..., item_value: str = ..., item_path: str = ...
-): ...
+) -> Case: ...
 
 
 def append_case_item(  # noqa: C901
@@ -236,8 +236,8 @@ def append_case_item(  # noqa: C901
     item: CaseItem | None = None,
     item_type: str | None = None,
     item_value: str | None = None,
-    item_path: str = "related/",
-):
+    item_path: str = "related",
+) -> Case:
     """Append an item to a case, dispatching to the appropriate handler based on item type.
 
     Can be called either with a pre-built CaseItem object or with individual
@@ -251,12 +251,13 @@ def append_case_item(  # noqa: C901
             "table", "lead", "reference"). Required if item is not provided.
         item_value: The value/identifier of the item to append. Required if item
             is not provided.
-        item_path: Optional path prefix for organizing the item within the case.
-            A trailing "/" is appended automatically if not present.
+        item_path: Path for organizing the item within the case. Must not end
+            with a trailing "/".
 
     Raises:
         InvalidDataException: If item is not provided and item_type or item_value
-            are missing, or if item_type is not a valid CaseItemTypes value.
+            are missing, or if item_type is not a valid CaseItemTypes value, or
+            if the resolved item path ends with a trailing "/".
     """
     if item is None:
         if not all([item_type, item_value]):
@@ -266,28 +267,31 @@ def append_case_item(  # noqa: C901
             raise InvalidDataException(f"Invalid item type: {item_type}, valid types are: {', '.join(CaseItemTypes)}")
 
         if not item_path:
-            item_path = "related/"
+            item_path = "related"
 
         item = CaseItem({"type": item_type, "value": item_value, "path": item_path})
 
+    if item.path.endswith("/"):
+        raise InvalidDataException("item path must not end with a trailing '/'")
+
     match item.type:
         case CaseItemTypes.HIT:
-            append_hit(case_id, item)
+            return append_hit(case_id, item)
         case CaseItemTypes.OBSERVABLE:
-            append_observable(case_id, item)
+            return append_observable(case_id, item)
         case CaseItemTypes.CASE:
-            append_case(case_id, item)
+            return append_case(case_id, item)
         case CaseItemTypes.TABLE:
-            append_table(case_id, item)
+            return append_table(case_id, item)
         case CaseItemTypes.LEAD:
-            append_lead(case_id, item)
+            return append_lead(case_id, item)
         case CaseItemTypes.REFERENCE:
-            append_reference(case_id, item)
+            return append_reference(case_id, item)
         case _:
             raise InvalidDataException(f"Unsupported item type: {item_type}")
 
 
-def append_hit(case_id: str, item: CaseItem):
+def append_hit(case_id: str, item: CaseItem) -> Case:
     """Append a hit item to a case and create a back-reference on the hit.
 
     Validates that the case and hit both exist and that the hit is not already
@@ -306,37 +310,36 @@ def append_hit(case_id: str, item: CaseItem):
     """
     ds = datastore()
 
-    case = ds.case.get(key=case_id)
+    _case = ds.case.get(case_id)
 
-    if case is None:
+    if _case is None:
         raise NotFoundException(f"Case {case_id} does not exist")
 
-    if any(item.value == case_item["value"] for case_item in case.items):
+    if any(item.value == case_item["value"] for case_item in _case.items):
         raise InvalidDataException(f"Hit {item.value} already exists in case {case_id}")
 
-    hit = ds.hit.get(key=item.value)
+    hit = ds.hit.get(item.value)
 
     if hit is None:
         raise NotFoundException(f"Hit {item.value} not found, cannot be added to case")
 
-    if item.path == "related/":
-        item.path = f"alerts/{hit.howler.analytic} ({hit.howler.id})"
+    _case.items.append(item)
 
-    case.items.append(item)
+    if not ds.case.save(_case.case_id, _case):
+        raise DataStoreException(f"Failed to save {_case.case_id} with new item {item.value}")
 
-    if not datastore().case.save(case.case_id, case):
-        raise DataStoreException(f"Failed to save {case.case_id} with new item {item.value}")
+    _add_backreference(hit, _case.case_id)
 
-    _add_backreference(hit, case.case_id)
-    _sync_case_metadata(case_id)
+    _sync_case_metadata(_case.case_id)
 
+    return _case
 
-def append_observable(case_id: str, item: CaseItem):
+
+def append_observable(case_id: str, item: CaseItem) -> Case:
     """Append an observable item to a case and create a back-reference on the observable.
 
     Validates that the case and observable both exist and that the observable is
-    not already present in the case. Sets the item's path to include the
-    observable's ID, then persists the updated case and adds a back-reference
+    not already present in the case. It then persists the updated case and adds a back-reference
     from the observable to the case.
 
     Args:
@@ -363,24 +366,22 @@ def append_observable(case_id: str, item: CaseItem):
     if observable is None:
         raise NotFoundException(f"Observable {item.value} not found, cannot be added to case")
 
-    if item.path == "related/":
-        item.path = f"observables/{observable.howler.id}"
-
     _case.items.append(item)
 
-    if not datastore().case.save(_case.case_id, _case):
+    if not ds.case.save(_case.case_id, _case):
         raise DataStoreException(f"Failed to save {_case.case_id} with new item {item.value}")
 
     _add_backreference(observable, _case.case_id)
     _sync_case_metadata(case_id)
 
+    return _case
+
 
-def append_case(case_id: str, item: CaseItem):
+def append_case(case_id: str, item: CaseItem) -> Case:
     """Append a case reference item to a case.
 
     Validates that both the parent case and the referenced case exist, and that
-    the referenced case is not already present in the parent case. Sets the
-    item's path to include the referenced case's ID, then persists the updated
+    the referenced case is not already present in the parent case. It then persists the updated
     parent case.
 
     Args:
@@ -394,7 +395,7 @@ def append_case(case_id: str, item: CaseItem):
     """
     ds = datastore()
 
-    _case = ds.case.get(key=case_id)
+    _case = ds.case.get(case_id)
 
     if _case is None:
         raise NotFoundException(f"Case {case_id} does not exist")
@@ -407,18 +408,15 @@ def append_case(case_id: str, item: CaseItem):
     if referenced_case is None:
         raise NotFoundException(f"Referenced case {item.value} not found, cannot be added to case")
 
-    if item.path == "related/":
-        item.path = "cases/"
-
-    item.path += f"{referenced_case.case_id}"
-
     _case.items.append(item)
 
     if not datastore().case.save(_case.case_id, _case):
         raise DataStoreException(f"Failed to save {_case.case_id} with new item {item.value}")
 
+    return _case
+
 
-def append_table(case_id: str, item: CaseItem):
+def append_table(case_id: str, item: CaseItem) -> Case:
     """Append a table item to a case.
 
     Not yet implemented.
@@ -433,7 +431,7 @@ def append_table(case_id: str, item: CaseItem):
     raise NotImplementedError
 
 
-def append_lead(case_id: str, item: CaseItem):
+def append_lead(case_id: str, item: CaseItem) -> Case:
     """Append a lead item to a case.
 
     Not yet implemented.
@@ -448,19 +446,37 @@ def append_lead(case_id: str, item: CaseItem):
     raise NotImplementedError
 
 
-def append_reference(case_id: str, item: CaseItem):
-    """Append a reference item to a case.
+def append_reference(case_id: str, item: CaseItem) -> Case:
+    """Append an external reference item to a case.
 
-    Not yet implemented.
+    Validates that the case exists and that the reference URL is not already
+    present in the case. It then persists the updated case.
 
     Args:
         case_id: Unique identifier of the case to append the reference to.
-        item: A CaseItem representing the external reference to append.
+        item: A CaseItem whose ``value`` is the external URL to reference.
 
     Raises:
-        NotImplementedError: Always raised; this feature is not yet implemented.
+        NotFoundException: If the case does not exist.
+        InvalidDataException: If the reference URL is already present in the case.
+        DataStoreException: If saving the updated case fails.
     """
-    raise NotImplementedError
+    ds = datastore()
+
+    _case = ds.case.get_if_exists(key=case_id, as_obj=True)
+
+    if _case is None:
+        raise NotFoundException(f"Case {case_id} does not exist")
+
+    if any(item.value == case_item["value"] for case_item in _case.items):
+        raise InvalidDataException(f"Reference {item.value} already exists in case {case_id}")
+
+    _case.items.append(item)
+
+    if not datastore().case.save(_case.case_id, _case):
+        raise DataStoreException(f"Failed to save {_case.case_id} with new item {item.value}")
+
+    return _case
 
 
 def _collect_indicators_from_related(related: Related | None) -> set[str]:
@@ -575,20 +591,26 @@ def remove_backreference(backing_obj: Hit | Observable | None, case_id: str):
         datastore()[backing_obj.__class__.__name__.lower()].save(backing_obj.howler.id, backing_obj)
 
 
-def remove_case_item(case_id: str, item_value: str):
-    """Remove an item from a case and clean up any associated back-references.
+def remove_case_items(case_id: str, values: list[str]):
+    """Remove one or more items from a case in a single atomic operation.
 
-    Locates the item within the case by its value, removes it from the case's
-    items list, persists the updated case, and removes the back-reference from
-    the backing hit or observable if applicable.
+    Validates that every requested value exists within the case before making
+    any modifications.  If any value is missing the call raises NotFoundException
+    without altering the case.  When all values are confirmed, all matching
+    items are removed in memory, the case is persisted once, and back-references
+    are cleaned up from any associated hits or observables.
 
     Args:
-        case_id: Unique identifier of the case to remove the item from.
-        item_value: The value/identifier of the item to remove.
+        case_id: Unique identifier of the case to remove items from.
+        item_values: List of item values (IDs / URLs) to remove.
+
+    Returns:
+        The updated Case object.
 
     Raises:
-        NotFoundException: If the case does not exist.
-        DataStoreException: If saving the updated case fails.
+        NotFoundException: If the case does not exist, or if any requested value
+            is not present in the case's items list.
+        DataStoreException: If persisting the updated case fails.
     """
     ds = datastore()
 
@@ -597,20 +619,34 @@ def remove_case_item(case_id: str, item_value: str):
     if not _case:
         raise NotFoundException(f"Case {case_id} does not exist")
 
-    case_item = next((item for item in _case.items if item["value"] == item_value), None)
-    if not case_item:
-        raise NotFoundException(f"Case item {item_value} does not exist")
+    # Build a lookup of value → item for all items currently in the case.
+    items_by_value = {_item["value"]: _item for _item in _case.items}
 
-    backing_obj: Hit | Observable | None = None
-    if case_item.type in [CaseItemTypes.HIT, CaseItemTypes.OBSERVABLE]:
-        backing_obj = ds[case_item.type].get(case_item.value)
+    # Pre-validate all requested values before touching anything.
+    missing = [v for v in values if v not in items_by_value]
+    if missing:
+        raise NotFoundException(f"Case item(s) not found in case: {', '.join(missing)}")
 
-    _case.items.remove(case_item)
+    # Resolve items and collect backing objects that need back-reference cleanup.
+    items_to_remove = [items_by_value[v] for v in values]
+    backing_objs: list[Hit | Observable] = []
+    for item in items_to_remove:
+        if item.type in [CaseItemTypes.HIT, CaseItemTypes.OBSERVABLE]:
+            obj = ds[item.type].get(item.value)
+            if obj:
+                backing_objs.append(obj)
+
+    # Remove all items in memory, then persist the case once.
+    for item in items_to_remove:
+        _case.items.remove(item)
 
     if not ds.case.save(_case.case_id, _case):
         raise DataStoreException("Failed to save case after item removal")
 
-    if backing_obj:
+    # Clean up back-references after the case is safely persisted.
+    for backing_obj in backing_objs:
         remove_backreference(backing_obj, _case.case_id)
 
     _sync_case_metadata(case_id)
+
+    return _case

{howler_api-4.0.0.dev652 → howler_api-4.0.0.dev664}/pyproject.toml

@@ -152,7 +152,7 @@ suppress-none-returning = true
 [tool.poetry]
 package-mode = true
 name = "howler-api"
-version = "4.0.0.dev652"
+version = "4.0.0.dev664"
 description = "Howler - API server"
 authors = [
     "Canadian Centre for Cyber Security <howler@cyber.gc.ca>",