howler-api 4.0.0.dev973__tar.gz → 4.0.0.dev982__tar.gz

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/PKG-INFO

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

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/actions/demote.py

@@ -76,6 +76,7 @@ def execute(
                     *hit_helper.demote_hit(escalation=escalation),
                     odm_helper.update("howler.assessment", None),
                     odm_helper.update("howler.rationale", None),
+                    odm_helper.update("howler.assignment", None),
                 ],
             )
         else:
@@ -93,7 +94,7 @@ def execute(
             ds.hit.update_by_query(
                 query,
                 [
-                    *hit_helper.assess_hit(assessment, rationale),
+                    *hit_helper.assess_hit(assessment, rationale, user=(user if user else "automation")),
                     odm_helper.update(
                         "howler.assignment",
                         user.get("uname", "automation") if user else "automation",

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/actions/promote.py

@@ -10,6 +10,7 @@ from howler.odm.models.howler_data import (
     AssessmentEscalationMap,
     Escalation,
 )
+from howler.odm.models.user import User
 from howler.utils.str_utils import sanitize_lucene_query
 
 OPERATION_ID = "promote"
@@ -26,6 +27,7 @@ def execute(
     escalation: Escalation = Escalation.ALERT,
     assessment: Optional[str] = None,
     rationale: Optional[str] = None,
+    user: Optional[User] = None,
     **kwargs,
 ):
     """Promote a hit.
@@ -73,6 +75,7 @@ def execute(
                     *hit_helper.promote_hit(escalation=escalation),
                     odm_helper.update("howler.assessment", None),
                     odm_helper.update("howler.rationale", None),
+                    odm_helper.update("howler.assignment", None),
                 ],
             )
         else:
@@ -87,7 +90,9 @@ def execute(
                 )
                 return report
 
-            ds.hit.update_by_query(query, hit_helper.assess_hit(assessment, rationale))
+            ds.hit.update_by_query(
+                query, hit_helper.assess_hit(assessment, rationale, user=(user if user else "automation"))
+            )
 
         report.append(
             {

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/datastore/collection.py

@@ -480,8 +480,8 @@ class ESCollection(Generic[ModelType]):
                 else:
                     raise
 
-    def _safe_index_copy(self, copy_function, src, target, settings=None, min_status="yellow"):
-        options_client = self.datastore.client.options(request_timeout=60)
+    def _safe_index_copy(self, copy_function, src, target, settings=None, min_status="yellow", request_timeout=60):
+        options_client = self.datastore.client.options(request_timeout=request_timeout)
         timed_function = getattr(options_client.indices, copy_function.__name__)
         ret = timed_function(index=src, target=target, settings=settings)
         if not ret["acknowledged"]:
@@ -703,22 +703,80 @@ class ESCollection(Generic[ModelType]):
             settings=clone_finish_settings,
         )
 
-    def reindex(self):
-        """This function should be overloaded to perform a reindex of all the data of the different hosts
-        specified in self.datastore.hosts.
+    def _index_doc_count(self, index: str) -> int:
+        """Return the number of documents in a physical index.
 
-        :return: Should return True of the commit was successful on all hosts
+        :param index: the name of the physical index to count documents in
+        :return: the number of documents currently stored in the index
+        """
+        self.with_retries(self.datastore.client.indices.refresh, index=index)
+        return self.with_retries(self.datastore.client.count, index=index)["count"]
+
+    def reindex(self, allow_failures: bool = False, request_timeout: int = 60):
+        """Reindex all the data of the collection into a freshly mapped index.
+
+        For every index in ``self.index_list`` the data is copied into a temporary
+        ``__reindex`` index that uses the current mappings/settings. Writes to the source
+        index are blocked while the copy runs so the reindex result and document counts can
+        be validated before the original index is deleted. The temporary index is only
+        collapsed back onto the original name once those checks pass.
+
+        :param allow_failures: when ``True``, proceed even if the reindex reported document
+            failures or version conflicts, or if the document counts do not match. This is
+            DESTRUCTIVE: documents that could not be converted to the new mappings will be
+            permanently dropped. Only use this for intentional lossy migrations.
+        :param request_timeout: transport timeout in seconds for synchronous index-copy
+            operations. Defaults to 60 seconds.
+        :return: ``True`` when the reindex (and validation) completed successfully on all
+            indexes.
+        :raises DataStoreException: if a reindex reported failures/conflicts, or if the
+            document count of the reindexed data does not match the source, and
+            ``allow_failures`` is ``False``. The ``__reindex`` index is left in place so the
+            operation can be recovered with :meth:`reindex_cleanup`.
         """
         logger.warning("Beginning Reindex")
         for index in self.index_list:
             new_name = f"{index}__reindex"
             index_data = None
-            if self.with_retries(self.datastore.client.indices.exists, index=index) and not self.with_retries(
-                self.datastore.client.indices.exists, index=new_name
-            ):
+            source_count = None
+            source_writes_blocked = False
+
+            source_exists = self.with_retries(self.datastore.client.indices.exists, index=index)
+            target_exists = self.with_retries(self.datastore.client.indices.exists, index=new_name)
+
+            # Never reindex while a '__reindex' index already exists. Its presence means a previous
+            # reindex was interrupted, and the leftover may be stale or incomplete. Committing it
+            # could silently replace live data, so force the operator to reconcile the state with
+            # --cleanup before any new reindex is attempted.
+            if target_exists:
+                raise DataStoreException(
+                    f"A leftover reindex index '{new_name}' already exists. This usually means a previous "
+                    f"reindex was interrupted. Refusing to reindex because '{new_name}' may contain stale "
+                    f"or incomplete data. Run the reindex script with --cleanup to reconcile the state "
+                    f"if '{index}' still exists, or manually recover '{new_name}' if the source index is "
+                    f"missing, then retry the reindex."
+                )
+
+            if not source_exists:
+                logger.warning("Neither %s nor %s exist, nothing to reindex.", index, new_name)
+                continue
+
+            try:
                 # Get information about the index to reindex
                 index_data = self.with_retries(self.datastore.client.indices.get, index=index)[index]
 
+                logger.warning("Block writes to source index %s", index)
+                self.with_retries(
+                    self.datastore.client.indices.put_settings,
+                    index=index,
+                    settings=write_block_settings,
+                )
+                source_writes_blocked = True
+
+                # Record the number of documents we expect to migrate after writes are blocked.
+                source_count = self._index_doc_count(index)
+                logger.warning("Source index %s contains %s document(s)", index, source_count)
+
                 # Create reindex target
                 logger.warning("Creating new index with name %s", new_name)
                 self.with_retries(
@@ -728,32 +786,6 @@ class ESCollection(Generic[ModelType]):
                     settings=self._get_index_settings(),
                 )
 
-                # For all aliases related to the index, add a new alias to the reindex index
-                for alias, alias_data in index_data["aliases"].items():
-                    # Make the reindex index the new write index if the original index was
-                    if alias_data.get("is_write_index", True):
-                        alias_actions = [
-                            {
-                                "add": {
-                                    "index": new_name,
-                                    "alias": alias,
-                                    "is_write_index": True,
-                                }
-                            },
-                            {
-                                "add": {
-                                    "index": index,
-                                    "alias": alias,
-                                    "is_write_index": False,
-                                }
-                            },
-                        ]
-                    else:
-                        alias_actions = [{"add": {"index": new_name, "alias": alias}}]
-
-                    logger.warning("Updating alias %s", alias)
-                    self.with_retries(self.datastore.client.indices.update_aliases, actions=alias_actions)
-
                 # Reindex data into target
                 logger.warning("Beginning reindex from %s to %s", index, new_name)
                 r_task = self.with_retries(
@@ -763,23 +795,29 @@ class ESCollection(Generic[ModelType]):
                     wait_for_completion=False,
                 )
                 logger.warning("Reindex taskId: %s", r_task["task"])
-                self._get_task_results(r_task)
+                reindex_result = self._get_task_results(r_task)
 
-            if self.with_retries(self.datastore.client.indices.exists, index=new_name):
-                if index_data is None:
-                    index_data = self.with_retries(self.datastore.client.indices.get, index=index)[index]
+                # Validate the reindex did not silently drop or conflict on documents before
+                # we commit to deleting the source index further down.
+                self._validate_reindex_result(index, new_name, reindex_result, allow_failures)
 
                 logger.warning("Committing reindexed data in index %s", new_name)
                 self.with_retries(self.datastore.client.indices.refresh, index=new_name)
                 self.with_retries(self.datastore.client.indices.clear_cache, index=new_name)
 
+                # Compare the document counts of the source and reindexed indexes before deleting
+                # the source so a silent document drop is caught.
+                target_count = self._index_doc_count(new_name)
+                self._validate_reindex_counts(index, new_name, source_count, target_count, allow_failures)
+
                 logger.warning("Deleting old index %s", index)
-                if self.with_retries(self.datastore.client.indices.exists, index=index):
-                    self.with_retries(self.datastore.client.indices.delete, index=index)
+                self.with_retries(self.datastore.client.indices.delete, index=index)
+                source_writes_blocked = False
 
-                logger.warning("Block write to index")
+                logger.warning("Block writes to reindex target %s", new_name)
                 self.with_retries(
                     self.datastore.client.indices.put_settings,
+                    index=new_name,
                     settings=write_block_settings,
                 )
 
@@ -790,36 +828,181 @@ class ESCollection(Generic[ModelType]):
                         new_name,
                         index,
                         settings=self._get_index_settings(),
+                        request_timeout=request_timeout,
                     )
 
-                    # Restore original aliases for the index
-                    for alias, alias_data in index_data["aliases"].items():
-                        # Make the reindex index the new write index if the original index was
-                        if alias_data.get("is_write_index", True):
-                            alias_actions = [
-                                {
-                                    "add": {
-                                        "index": index,
-                                        "alias": alias,
-                                        "is_write_index": True,
-                                    }
-                                },
-                                {"remove_index": {"index": new_name}},
-                            ]
-                            self.with_retries(
-                                self.datastore.client.indices.update_aliases,
-                                actions=alias_actions,
-                            )
+                    alias_actions = []
+                    aliases = index_data.get("aliases", {}) or {self.name: {"is_write_index": True}}
+                    for alias, alias_data in aliases.items():
+                        alias_action = {"index": index, "alias": alias}
+                        alias_action.update(alias_data)
+                        if alias == self.name or alias_data.get("is_write_index", False):
+                            alias_action["is_write_index"] = True
+                        alias_actions.append({"add": alias_action})
+                    alias_actions.append({"remove_index": {"index": new_name}})
+                    self.with_retries(self.datastore.client.indices.update_aliases, actions=alias_actions)
 
                     if self.with_retries(self.datastore.client.indices.exists, index=new_name):
                         logger.warning("Deleting reindex target %s", new_name)
                         self.with_retries(self.datastore.client.indices.delete, index=new_name)
                 finally:
-                    logger.warning("Unblock write to the index")
+                    if self.with_retries(self.datastore.client.indices.exists, index=index):
+                        logger.warning("Unblock writes to the index")
+                        self.with_retries(
+                            self.datastore.client.indices.put_settings,
+                            index=index,
+                            settings=write_unblock_settings,
+                        )
+            except Exception:
+                if source_writes_blocked and self.with_retries(self.datastore.client.indices.exists, index=index):
+                    logger.warning("Unblock writes to source index %s after failed reindex", index)
                     self.with_retries(
                         self.datastore.client.indices.put_settings,
+                        index=index,
                         settings=write_unblock_settings,
                     )
+                raise
+
+        return True
+
+    def _validate_reindex_result(self, index, new_name, reindex_result, allow_failures):
+        """Validate the result of an Elasticsearch reindex task.
+
+        :param index: the source index being reindexed
+        :param new_name: the temporary ``__reindex`` index being written to
+        :param reindex_result: the ``response``/``status`` payload returned by the reindex task
+        :param allow_failures: when ``True``, log the problems but do not abort
+        :raises DataStoreException: if the reindex reported failures or version conflicts and
+            ``allow_failures`` is ``False``
+        """
+        failures = reindex_result.get("failures", []) if reindex_result else []
+        version_conflicts = reindex_result.get("version_conflicts", 0) if reindex_result else 0
+
+        if not failures and not version_conflicts:
+            return
+
+        # Summarize the failures so the operator understands what went wrong
+        summary = (
+            f"Reindex of {index} into {new_name} reported {len(failures)} document failure(s) "
+            f"and {version_conflicts} version conflict(s)."
+        )
+        for failure in failures[:10]:
+            cause = failure.get("cause", failure)
+            logger.error(
+                "Reindex failure on document %s: %s - %s",
+                failure.get("id", "<unknown>"),
+                cause.get("type", "<unknown>"),
+                cause.get("reason", cause),
+            )
+        if len(failures) > 10:
+            logger.error("... and %s additional failure(s) not shown.", len(failures) - 10)
+
+        if allow_failures:
+            logger.warning("%s Proceeding anyway because allow_failures is set (DESTRUCTIVE).", summary)
+            return
+
+        raise DataStoreException(
+            f"{summary} Aborting before deleting the source index to prevent data loss. The '{new_name}' "
+            f"index has been left in place; run the reindex script with --cleanup to remove it and restore "
+            f"'{index}', then retry. Re-run with --allow-failures only if you intend to drop the "
+            f"un-convertible documents."
+        )
+
+    def _validate_reindex_counts(self, index, new_name, source_count, target_count, allow_failures):
+        """Validate that the reindexed index contains the same number of documents as the source.
+
+        :param index: the source index being reindexed
+        :param new_name: the temporary ``__reindex`` index being written to
+        :param source_count: the number of documents in the source index
+        :param target_count: the number of documents in the reindexed index
+        :param allow_failures: when ``True``, log the mismatch but do not abort
+        :raises DataStoreException: if the counts differ and ``allow_failures`` is ``False``
+        """
+        if source_count == target_count:
+            logger.warning("Document count validated: %s document(s) in both %s and %s", source_count, index, new_name)
+            return
+
+        summary = (
+            f"Document count mismatch reindexing {index} into {new_name}: "
+            f"source has {source_count} document(s) but reindex target has {target_count}."
+        )
+
+        if allow_failures:
+            logger.warning("%s Proceeding anyway because allow_failures is set (DESTRUCTIVE).", summary)
+            return
+
+        raise DataStoreException(
+            f"{summary} Aborting before deleting the source index to prevent data loss. The '{new_name}' "
+            f"index has been left in place; run the reindex script with --cleanup to remove it and restore "
+            f"'{index}', then retry. Re-run with --allow-failures only if you intend to accept the count "
+            f"mismatch."
+        )
+
+    def reindex_cleanup(self):
+        """Recover from a failed or interrupted :meth:`reindex` run.
+
+        For every index that still has a leftover ``__reindex`` index, restore the source
+        index as the writable target and delete the orphaned ``__reindex`` index. If the
+        source index is missing, raise an error instead of deleting ``__reindex`` because
+        it may be the only remaining copy of the data.
+
+        Write blocks set during reindexing are cleared so the collection is usable again.
+
+        :return: ``True`` when cleanup completed on all indexes
+        """
+        logger.warning("Beginning reindex cleanup")
+        for index in self.index_list:
+            new_name = f"{index}__reindex"
+
+            if not self.with_retries(self.datastore.client.indices.exists, index=new_name):
+                logger.info("No leftover reindex index found for %s, nothing to clean up.", index)
+                continue
+
+            if not self.with_retries(self.datastore.client.indices.exists, index=index):
+                raise DataStoreException(
+                    f"Source index '{index}' is missing but leftover reindex index '{new_name}' exists. "
+                    f"Cannot safely clean up because '{new_name}' may be the only remaining copy of the data. "
+                    f"Manually recover '{new_name}' or delete it if the data is no longer needed."
+                )
+
+            logger.warning("Restoring aliases for %s and removing leftover index %s", index, new_name)
+            index_data = self.with_retries(self.datastore.client.indices.get, index=index)[index]
+            new_index_data = self.with_retries(self.datastore.client.indices.get, index=new_name)[new_name]
+            source_aliases = index_data.get("aliases", {})
+            reindex_aliases = new_index_data.get("aliases", {})
+
+            alias_actions = []
+            for alias in sorted(set(source_aliases) | set(reindex_aliases) | {self.name}):
+                source_alias_data = source_aliases.get(alias, {})
+                reindex_alias_data = reindex_aliases.get(alias, {})
+
+                add_alias_data = {"index": index, "alias": alias}
+                add_alias_data.update(source_alias_data)
+                if (
+                    alias == self.name
+                    or source_alias_data.get("is_write_index", False)
+                    or reindex_alias_data.get("is_write_index", False)
+                ):
+                    add_alias_data["is_write_index"] = True
+
+                alias_actions.append({"add": add_alias_data})
+
+            for alias in reindex_aliases:
+                alias_actions.append({"remove": {"index": new_name, "alias": alias}})
+
+            if alias_actions:
+                logger.warning("Restoring aliases to %s", index)
+                self.with_retries(self.datastore.client.indices.update_aliases, actions=alias_actions)
+
+            logger.warning("Deleting leftover reindex index %s", new_name)
+            self.with_retries(self.datastore.client.indices.delete, index=new_name)
+
+            logger.warning("Unblock write to the index")
+            self.with_retries(
+                self.datastore.client.indices.put_settings,
+                index=index,
+                settings=write_unblock_settings,
+            )
 
         return True
 

howler_api-4.0.0.dev982/howler/external/reindex_data.py

@@ -0,0 +1,134 @@
+import argparse
+import json
+import os
+import sys
+import time
+
+DELAY = 5
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Reindex elasticsearch indexes.",
+        epilog="Valid index names are derived from the datastore configuration.",
+    )
+    parser.add_argument("indexes", nargs="*", help="Indexes to reindex.")
+    parser.add_argument("--all", action="store_true", help="Reindex all indexes.")
+    parser.add_argument("--force", action="store_true", help="Skip confirmation prompts and countdown.")
+    parser.add_argument("--verbose", action="store_true", help="Print index schema before reindexing.")
+    parser.add_argument(
+        "--cleanup",
+        action="store_true",
+        help="Recover from a failed or interrupted reindex by restoring the source index and "
+        "deleting leftover '__reindex' indexes. If the source index is missing, cleanup fails "
+        "to avoid deleting the only remaining copy of the data.",
+    )
+    parser.add_argument(
+        "--allow-failures",
+        action="store_true",
+        help="DESTRUCTIVE: proceed even if the reindex reports document failures, version conflicts, "
+        "or a document count mismatch. Documents that cannot be converted to the new mappings will be "
+        "permanently dropped. Only use this for intentional lossy migrations.",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=3600,
+        help="Elasticsearch transport timeout in seconds for synchronous operations. Increase this if "
+        "large indexes time out during the clone/settings steps. Default: 3600.",
+    )
+    args = parser.parse_args()
+
+    if args.all and args.indexes:
+        parser.error("--all cannot be combined with positional index arguments.")
+
+    if not args.indexes and not args.all:
+        parser.error("Provide index names as arguments, or use --all.")
+
+    if args.timeout <= 0:
+        parser.error("--timeout must be a positive number of seconds.")
+
+    # Raise the Elasticsearch transport timeout before the datastore is imported so the value is
+    # baked into every connection (including connections rebuilt after a reset). This lets long
+    # running synchronous operations complete without timing out the client.
+    os.environ["HWL_DATASTORE_TRANSPORT_TIMEOUT"] = str(args.timeout)
+
+    from howler.datastore.collection import ESCollection
+    from howler.datastore.exceptions import DataStoreException
+
+    ESCollection.IGNORE_ENSURE_COLLECTION = True
+
+    if args.force:
+        ESCollection.ENSURE_COLLECTION_WARNED = True
+
+    from howler.common import loader
+
+    ds = loader.datastore(archive_access=False)
+
+    # Derive the set of reindexable indexes from the datastore configuration. Collections without
+    # an ODM model (e.g. user_avatar) cannot be reindexed and are excluded.
+    index_names = sorted(name for name, model in ds.ds.get_models().items() if model is not None)
+
+    invalid = [name for name in args.indexes if name not in index_names]
+    if invalid:
+        parser.error(f"Invalid index(es): {', '.join(invalid)}. Valid options: {', '.join(index_names)}")
+
+    selected = list(dict.fromkeys(index_names if args.all else args.indexes))
+
+    if args.cleanup:
+        for index_name in selected:
+            collection: ESCollection = getattr(ds, index_name)
+            print(f"Cleaning up leftover reindex state for '{index_name}'.")
+            try:
+                collection.reindex_cleanup()
+            except DataStoreException as e:
+                print(f"ERROR: Cleanup of '{index_name}' failed: {e}", file=sys.stderr)
+                sys.exit(1)
+            print(f"Cleanup of '{index_name}' complete.")
+        sys.exit(0)
+
+    if args.allow_failures and not args.force:
+        print(
+            "WARNING: --allow-failures is DESTRUCTIVE. Documents that cannot be converted to the new "
+            "mappings will be permanently dropped, and count mismatches will be ignored."
+        )
+        answer = input("Are you sure you want to proceed with --allow-failures? [yes/NO] ")
+        if not answer.startswith("y"):
+            print("Confirmation not provided, aborting.")
+            sys.exit(1)
+
+    for index_name in selected:
+        collection: ESCollection = getattr(ds, index_name)
+
+        if args.verbose:
+            print(f"Index schema for '{index_name}':")
+            print(json.dumps(collection._get_index_mappings(), indent=2))
+
+        print(f"Reindexing: {', '.join(collection.index_list_full)}")
+
+        if not args.force:
+            answer = input(f"Are you sure you want to reindex '{index_name}'? [yes/NO] ")
+            if not answer.startswith("y"):
+                print("Confirmation not provided, skipping.")
+                continue
+
+            for i in range(2 * DELAY):
+                print(f"Reindexing in {2 * DELAY - i}...", end="\r")
+                time.sleep(1)
+            print()
+
+        try:
+            result = collection.reindex(allow_failures=args.allow_failures, request_timeout=args.timeout)
+        except Exception as e:  # noqa: BLE001
+            print(f"ERROR: Reindex of '{index_name}' failed: {e}", file=sys.stderr)
+            print(
+                "Run this script with --cleanup to recover before retrying: if the source index is "
+                "still present it will be restored and any leftover '__reindex' index removed. If the "
+                "source was already deleted but '__reindex' exists, cleanup will fail to avoid deleting "
+                "the only remaining copy of the data; recover or delete that index manually. Investigate "
+                "the failure before retrying.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        print(f"Reindex of '{index_name}' complete. Success: {result}.")

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/helper/hit.py

@@ -24,13 +24,16 @@ def assess_hit(
     assessment: Optional[str] = None,
     rationale: Optional[str] = None,
     hit: Optional[Union[dict[str, Any], Hit]] = None,
+    *,
+    user: User | str,
     **kwargs,
 ) -> list[OdmUpdateOperation]:
     """Update the assessment and esclation of a hit
 
     Args:
+        user (User | str): The user making the assessment
         assessment (Optional[str], optional): The assessment to set the hit to. Defaults to None.
-        hit (Optional[dict[str, Any]], optional): The hit to update. Defaults to None.
+        hit (Optional[Union[dict[str, Any], Hit]], optional): The hit to update. Defaults to None.
 
     Raises:
         InvalidDataException: An invalid assessment was provided
@@ -63,10 +66,16 @@ def assess_hit(
         escalation,
     )
 
+    if assessment is None:
+        assessor_id = None
+    else:
+        assessor_id = user.get("uname", user.get("username", None)) if isinstance(user, User) else user
+
     return [
         odm_helper.update("howler.assessment", assessment),
         odm_helper.update("howler.escalation", escalation),
         odm_helper.update("howler.rationale", rationale, silent=True),
+        odm_helper.update("howler.assessor", assessor_id, silent=True),
     ]
 
 

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/odm/helper.py

@@ -168,6 +168,7 @@ def generate_useful_hit(lookups: dict[str, dict[str, Any]], users: list[str], pr
     hit.howler.status = "open"
     hit.howler.assignment = "unassigned"
     hit.howler.escalation = choice([Escalation.HIT, Escalation.ALERT])
+    hit.howler.assessor = None
 
     if randint(1, 10) > 9:
         hit.howler.expiry = datetime.now() + timedelta(days=randint(1, 60))

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/odm/models/howler_data.py

@@ -210,6 +210,12 @@ class HowlerData(odm.Model):
         description="Unique identifier of the assigned user.",
         default=DEFAULT_ASSIGNMENT,
     )
+    assessor: Optional[str] = odm.Optional(
+        odm.Keyword(
+            description="The most recent person to assess a hit",
+            default=None,
+        )
+    )
     bundles: list[str] = odm.List(
         odm.Keyword(
             description="A list of bundle IDs this hit is a part of. Corresponds to the howler.id of the bundle."

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/odm/random_data.py

@@ -577,6 +577,7 @@ def create_hits(ds: HowlerDatastore, hit_count: int = 200):
                 hit.howler.id,
                 [
                     *assess_hit(
+                        user=user,
                         assessment=choice(Assessment.list()),
                         rationale=get_random_string(),
                         hit=hit,

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/howler/services/hit_service.py

@@ -111,7 +111,7 @@ def get_hit_workflow() -> Workflow:
                     "source": [HitStatus.OPEN, HitStatus.IN_PROGRESS],
                     "transition": HitStatusTransition.ASSESS,
                     "dest": HitStatus.RESOLVED,
-                    "actions": [assess_hit, assign_hit],
+                    "actions": [assess_hit],
                 }
             ),
             Transition(

{howler_api-4.0.0.dev973 → howler_api-4.0.0.dev982}/pyproject.toml

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