sapiopycommons 2024.8.15a304__py3-none-any.whl → 2024.8.20a306__py3-none-any.whl

sapiopycommons/general/aliases.py

@@ -1,24 +1,47 @@
 from collections.abc import Iterable
 from typing import Any
 
+from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType, WrapperField
 
+from sapiopycommons.general.exceptions import SapioException
+
+FieldValue = int | float | str | bool | None
+"""Allowable values for fields in the system."""
 RecordModel = PyRecordModel | WrappedRecordModel | WrappedType
 """Different forms that a record model could take."""
 SapioRecord = DataRecord | RecordModel
 """A record could be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel (WrappedType)."""
 RecordIdentifier = SapioRecord | int
 """A RecordIdentifier is either a record type or an integer for the record's record ID."""
+DataTypeIdentifier = SapioRecord | type[WrappedType] | str
+"""A DataTypeIdentifier is either a SapioRecord, a record model wrapper type, or a string."""
+FieldIdentifier = WrapperField | str | tuple[str, FieldType]
+"""A FieldIdentifier is either wrapper field from a record model wrapper, a string, or a tuple of string
+and field type."""
+FieldIdentifierKey = WrapperField | str
+"""A FieldIdentifierKey is a FieldIdentifier, except it can't be a tuple, s tuples can't be used as keys in
+dictionaries.."""
+HasFieldWrappers = type[WrappedType] | WrappedRecordModel
+"""An identifier for classes that have wrapper fields."""
 ExperimentIdentifier = ElnExperimentProtocol | ElnExperiment | int
 """An ExperimentIdentifier is either an experiment protocol, experiment, or an integer for te experiment's notebook
 ID."""
-FieldMap = dict[str, Any]
+FieldMap = dict[str, FieldValue]
 """A field map is simply a dict of data field names to values. The purpose of aliasing this is to help distinguish
 any random dict in a webhook from one which is explicitly used for record fields."""
+FieldIdentifierMap = dict[FieldIdentifierKey, FieldValue]
+"""A field identifier map is the same thing as a field map, except the keys can be field identifiers instead
+of just strings. Note that although one of the allowed field identifiers is a tuple, you can't use tuples as
+keys in a dictionary."""
+UserIdentifier = SapioWebhookContext | SapioUser
+"""An identifier for classes from which a user object can be used for sending requests."""
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -50,7 +73,123 @@ class AliasUtil:
 
         :return: A list of record IDs for the input records.
         """
-        return [(x if isinstance(x, int) else x.record_id) for x in records]
+        return [(AliasUtil.to_record_id(x)) for x in records]
+
+    @staticmethod
+    def to_record_id(record: RecordIdentifier):
+        """
+        Convert a single variable that could be either an integer, DataRecord, PyRecordModel,
+        or WrappedRecordModel to just an integer (taking the record ID from the record).
+
+        :return: A record ID for the input record.
+        """
+        return record if isinstance(record, int) else record.record_id
+
+    @staticmethod
+    def to_data_type_name(value: DataTypeIdentifier) -> str:
+        """
+        Convert a given value to a data type name.
+
+        :param value: A value which is a string, record, or record model type.
+        :return: A string of the data type name of the input value.
+        """
+        if isinstance(value, str):
+            return value
+        if isinstance(value, SapioRecord):
+            return value.data_type_name
+        return value.get_wrapper_data_type_name()
+
+    @staticmethod
+    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False) -> list[str] | set[str]:
+        """
+        Convert a given iterable of values to a list or set of data type names.
+
+        :param values: An iterable of values which are strings, records, or record model types.
+        :param return_set: If true, return a set instead of a list.
+        :return: A list or set of strings of the data type name of the input value.
+        """
+        values = [AliasUtil.to_data_type_name(x) for x in values]
+        return set(values) if return_set else values
+
+    @staticmethod
+    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier]) -> str:
+        """
+        Convert a given iterable of values to a singular data type name that they share. Throws an exception if more
+        than one data type name exists in the provided list of identifiers.
+
+        :param values: An iterable of values which are strings, records, or record model types.
+        :return: The single data type name that the input vales share.
+        """
+        data_types: set[str] = AliasUtil.to_data_type_names(values, True)
+        if len(data_types) > 1:
+            raise SapioException(f"Provided values contain multiple data types: {data_types}. "
+                                 f"Only expecting a single data type.")
+        return data_types.pop()
+
+    @staticmethod
+    def to_data_field_name(value: FieldIdentifier) -> str:
+        """
+        Convert a string or WrapperField to a data field name string.
+
+        :param value: A string or WrapperField.
+        :return: A string of the data field name of the input value.
+        """
+        if isinstance(value, tuple):
+            return value[0]
+        if isinstance(value, WrapperField):
+            return value.field_name
+        return value
+
+    @staticmethod
+    def to_data_field_names(values: Iterable[FieldIdentifier]) -> list[str]:
+        """
+        Convert an iterable of strings or WrapperFields to a list of data field name strings.
+
+        :param values: An iterable of strings or WrapperFields.
+        :return: A list of strings of the data field names of the input values.
+        """
+        return [AliasUtil.to_data_field_name(x) for x in values]
+
+    @staticmethod
+    def to_data_field_names_dict(values: dict[FieldIdentifierKey, Any]) -> dict[str, Any]:
+        """
+        Take a dictionary whose keys are field identifiers and convert them all to strings for the data field name.
+
+        :param values: A dictionary of field identifiers to field values.
+        :return: A dictionary of strings of the data field names to field values for the input values.
+        """
+        ret_dict: dict[str, FieldValue] = {}
+        for field, value in values.items():
+            ret_dict[AliasUtil.to_data_field_name(field)] = value
+        return ret_dict
+
+    @staticmethod
+    def to_data_field_names_list_dict(values: list[dict[FieldIdentifierKey, Any]]) -> list[dict[str, Any]]:
+        ret_list: list[dict[str, Any]] = []
+        for field_map in values:
+            ret_list.append(AliasUtil.to_data_field_names_dict(field_map))
+        return ret_list
+
+    @staticmethod
+    def to_field_type(field: FieldIdentifier, data_type: HasFieldWrappers | None = None) -> FieldType:
+        """
+        Convert a given field identifier to the field type for that field.
+
+        :param field: A string or WrapperField.
+        :param data_type: If the field is provided as a string, then a record model wrapper or wrapped record model
+            must be provided to determine the field type.
+        :return: The field type of the given field.
+        """
+        if isinstance(field, tuple):
+            return field[1]
+        if isinstance(field, WrapperField):
+            return field.field_type
+        for var in dir(data_type):
+            attr = getattr(data_type, var)
+            if isinstance(attr, WrapperField) and attr.field_name == field:
+                return attr.field_type
+        raise SapioException(f"The wrapper of data type \"{data_type.get_wrapper_data_type_name()}\" doesn't have a "
+                             f"field with the name \"{field}\",")
 
     @staticmethod
     def to_field_map_lists(records: Iterable[SapioRecord]) -> list[FieldMap]:
@@ -63,6 +202,7 @@ class AliasUtil:
         field_map_list: list[FieldMap] = []
         for record in records:
             if isinstance(record, DataRecord):
+                # noinspection PyTypeChecker
                 field_map_list.append(record.get_fields())
             else:
                 field_map_list.append(record.fields.copy_to_dict())
@@ -80,3 +220,7 @@ class AliasUtil:
         if isinstance(experiment, ElnExperiment):
             return experiment.notebook_experiment_id
         return experiment.get_id()
+    
+    @staticmethod
+    def to_sapio_user(context: UserIdentifier) -> SapioUser:
+        return context if isinstance(context, SapioUser) else context.user

sapiopycommons/general/audit_log.py

@@ -0,0 +1,196 @@
+from enum import Enum
+
+from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+
+from sapiopycommons.customreport.term_builder import TermBuilder
+from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, UserIdentifier, FieldIdentifier, FieldValue
+from sapiopycommons.general.custom_report_util import CustomReportUtil
+
+EVENTTYPE_COLUMN = "EVENTTYPE"
+TIMESTAMP_COLUMN = "TIMESTAMP"
+DATATYPENAME_COLUMN = "DATATYPENAME"
+RECORDID_COLUMN = "RECORDID"
+DESCRIPTION_COLUMN = "DESCRIPTION"
+USERNAME_COLUMN = "USERNAME"
+USERCOMMENT_COLUMN = "USERCOMMENT"
+RECORDNAME_COLUMN = "RECORDNAME"
+DATAFIELDNAME_COLUMN = "DATAFIELDNAME"
+ORIGINALVALUE_COLUMN = "ORIGINALVALUE"
+NEWVALUE_COLUMN = "NEWVALUE"
+
+
+class EventType(Enum):
+    """An enum to represent the possible event type values with the event type column in the audit log table."""
+    ADD = 0
+    DELETE = 1
+    MODIFY = 2
+    INFO = 3
+    ERROR = 4
+    WARNING = 5
+    IMPORT = 6
+    GENERATE = 7
+    EXPORT = 8
+    ADDREF = 9
+    REMOVEREF = 10
+    ESIGNATURE = 11
+    ROLEASSIGNMENT = 12
+
+
+class AuditLogEntry:
+
+    __event_type: EventType
+    __date: int
+    __data_type_name: str
+    __record_id: int
+    __description: str
+    __users_login_name: str
+    __comment: str
+    __data_record_name: str
+    __data_field_name: str
+    __original_value: str
+    __new_value: str
+
+    @property
+    def event_type(self) -> EventType:
+        return self.__event_type
+
+    @property
+    def date(self) -> int:
+        return self.__date
+
+    @property
+    def data_type_name(self) -> str:
+        return self.__data_type_name
+
+    @property
+    def record_id(self) -> int:
+        return self.__record_id
+
+    @property
+    def description(self) -> str:
+        return self.__description
+
+    @property
+    def users_login_name(self) -> str:
+        return self.__users_login_name
+
+    @property
+    def comment(self) -> str:
+        return self.__comment
+
+    @property
+    def data_record_name(self) -> str:
+        return self.__data_record_name
+
+    @property
+    def data_field_name(self) -> str:
+        return self.__data_field_name
+
+    @property
+    def original_value(self) -> str:
+        return self.__original_value
+
+    @property
+    def new_value(self) -> str:
+        return self.__new_value
+
+    def __init__(self, report_row: dict[str, FieldValue]):
+        self.__event_type = EventType((report_row[EVENTTYPE_COLUMN]))
+        self.__date = report_row[TIMESTAMP_COLUMN]
+        self.__data_type_name = report_row[DATATYPENAME_COLUMN]
+        self.__record_id = report_row[RECORDID_COLUMN]
+        self.__description = report_row[DESCRIPTION_COLUMN]
+        self.__users_login_name = report_row[USERNAME_COLUMN]
+        self.__comment = report_row[USERCOMMENT_COLUMN]
+        self.__data_record_name = report_row[RECORDNAME_COLUMN]
+        self.__data_field_name = report_row[DATAFIELDNAME_COLUMN]
+        self.__original_value = report_row[ORIGINALVALUE_COLUMN]
+        self.__new_value = report_row[NEWVALUE_COLUMN]
+
+
+class AuditLog:
+    AUDIT_LOG_PSEUDO_DATATYPE: str = "AUDITLOG"
+    EVENT_TYPE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, EVENTTYPE_COLUMN, FieldType.ENUM)
+    DATE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, TIMESTAMP_COLUMN, FieldType.DATE)
+    DATA_TYPE_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, DATATYPENAME_COLUMN, FieldType.STRING)
+    RECORD_ID: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN, FieldType.LONG)
+    DESCRIPTION: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, DESCRIPTION_COLUMN, FieldType.STRING)
+    USERS_LOGIN_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, USERNAME_COLUMN, FieldType.STRING)
+    COMMENT: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, USERCOMMENT_COLUMN, FieldType.STRING)
+    DATA_RECORD_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, RECORDNAME_COLUMN, FieldType.STRING)
+    DATA_FIELD_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN, FieldType.STRING)
+    ORIGINAL_VALUE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, ORIGINALVALUE_COLUMN, FieldType.STRING)
+    NEW_VALUE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, NEWVALUE_COLUMN, FieldType.STRING)
+
+    AUDIT_LOG_COLUMNS = [EVENT_TYPE, DATE, DATA_TYPE_NAME, RECORD_ID, DESCRIPTION, USERS_LOGIN_NAME, COMMENT,
+                         DATA_RECORD_NAME, DATA_FIELD_NAME, ORIGINAL_VALUE, NEW_VALUE]
+    user: SapioUser
+
+    def __init__(self, context: UserIdentifier):
+        self.user = AliasUtil.to_sapio_user(context)
+
+    @staticmethod
+    def create_data_record_audit_log_report(records: list[RecordIdentifier],
+                                            fields: list[FieldIdentifier] | None = None) -> CustomReportCriteria:
+        """
+        This method creates a CustomReportCriteria object for running an audit log query based on data records.
+
+        Creates a CustomReportCriteria object with a query term based on the record ids/records passed into the method.
+        Optionally, the fields parameter can be populated to limit the search to particular fields. If the fields
+        parameter is not populated, the search will include results for all field changes.
+
+        :param records: The DataRecords, RecordModels, or record ids to base the search on.
+        :param fields: The data field names to include changes for.
+        :return: The constructed CustomReportCriteria object, which can be used to run a report on the audit log.
+        """
+        # Build the raw report term querying for any entry with a matching record ID value to the record ID's
+        # passed in.
+        record_ids = AliasUtil.to_record_ids(records)
+        root_term = TermBuilder.is_term(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN, record_ids)
+
+        # If the user passed in any specific fields, then we should limit the query to those fields.
+        if fields:
+            fields: list[str] = AliasUtil.to_data_field_names(fields)
+            field_term = TermBuilder.is_term(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN, fields)
+            root_term = TermBuilder.and_terms(root_term, field_term)
+
+        return CustomReportCriteria(AuditLog.AUDIT_LOG_COLUMNS, root_term)
+
+    def run_data_record_audit_log_report(self, records: list[RecordIdentifier],
+                                         fields: list[FieldIdentifier] | None = None) \
+            -> dict[RecordIdentifier, list[AuditLogEntry]]:
+        """
+        This method runs a custom report for changes made to the given data records using the audit log.
+        See "create_data_record_audit_log_report" for more details about the data record audit log report.
+
+        :param records: The DataRecords, RecordModels, or record ids to base the search on.
+        :param fields: The data field names to include changes for.
+        :return: A dictionary where the keys are the record identifiers passed in, and the values are a list of
+            AuditLogEntry objects which match the record id value of those records.
+        """
+        fields: list[str] = AliasUtil.to_data_field_names(fields)
+        # First, we must build our report criteria for running the Custom Report.
+        criteria = AuditLog.create_data_record_audit_log_report(records, fields)
+
+        # Then we must run the custom report using that criteria.
+        raw_report_data: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(self.user, criteria)
+
+        # This section will prepare a map matching the original RecordIdentifier by record id.
+        # This is because the audit log entries will have record ids, but we want the keys in our result map
+        # to match the record identifiers that the user passed in, for convenience.
+        record_identifier_mapping: dict[int, RecordIdentifier] = dict()
+        for record in records:
+            record_id = AliasUtil.to_record_id(record)
+            record_identifier_mapping[record_id] = record
+
+        # Finally, we compile our audit data into a map where the keys are the record identifiers passed in,
+        # and the value is a list of applicable audit log entries.
+        final_audit_data: dict[RecordIdentifier, list[AuditLogEntry]] = dict()
+        for audit_entry_data in raw_report_data:
+            audit_entry: AuditLogEntry = AuditLogEntry(audit_entry_data)
+            identifier: RecordIdentifier = record_identifier_mapping.get(audit_entry.record_id)
+            final_audit_data.setdefault(identifier, []).append(audit_entry)
+
+        return final_audit_data

sapiopycommons/general/custom_report_util.py

@@ -1,21 +1,21 @@
 from collections.abc import Iterable
-from typing import Any
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport, CustomReportCriteria, RawReportTerm
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+from sapiopycommons.general.aliases import UserIdentifier, FieldValue, AliasUtil, FieldIdentifierKey
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class CustomReportUtil:
     @staticmethod
-    def run_system_report(context: SapioWebhookContext | SapioUser,
+    def run_system_report(context: UserIdentifier,
                           report_name: str,
-                          filters: dict[str, Iterable[Any]] | None = None,
+                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                           page_limit: int | None = None,
                           page_size: int | None = None,
-                          page_number: int | None = None) -> list[dict[str, Any]]:
+                          page_number: int | None = None) -> list[dict[str, FieldValue]]:
         """
         Run a system report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -41,16 +41,16 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit,
                                                                   page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[Any]] = results[1]
+        rows: list[list[FieldValue]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def run_custom_report(context: SapioWebhookContext | SapioUser,
+    def run_custom_report(context: UserIdentifier,
                           report_criteria: CustomReportCriteria,
-                          filters: dict[str, Iterable[Any]] | None = None,
+                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                           page_limit: int | None = None,
                           page_size: int | None = None,
-                          page_number: int | None = None) -> list[dict[str, Any]]:
+                          page_number: int | None = None) -> list[dict[str, FieldValue]]:
         """
         Run a custom report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -82,16 +82,16 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_custom_report(context, report_criteria, page_limit,
                                                                   page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[Any]] = results[1]
+        rows: list[list[FieldValue]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def run_quick_report(context: SapioWebhookContext | SapioUser,
+    def run_quick_report(context: UserIdentifier,
                          report_term: RawReportTerm,
-                         filters: dict[str, Iterable[Any]] | None = None,
+                         filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                          page_limit: int | None = None,
                          page_size: int | None = None,
-                         page_number: int | None = None) -> list[dict[str, Any]]:
+                         page_number: int | None = None) -> list[dict[str, FieldValue]]:
         """
         Run a quick report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -115,11 +115,11 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_quick_report(context, report_term, page_limit,
                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[Any]] = results[1]
+        rows: list[list[FieldValue]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def get_system_report_criteria(context: SapioWebhookContext | SapioUser, report_name: str) -> CustomReport:
+    def get_system_report_criteria(context: UserIdentifier, report_name: str) -> CustomReport:
         """
         Retrieve a custom report from the system given the name of the report. This works by querying the system report
         with a page number and size of 1 to minimize the amount of data transfer needed to retrieve the report's config.
@@ -134,27 +134,27 @@ class CustomReportUtil:
         :param report_name: The name of the system report to run.
         :return: The CustomReport object for the given system report name.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
         return report_man.run_system_report_by_name(report_name, 1, 1)
 
     @staticmethod
-    def __exhaust_system_report(context: SapioWebhookContext | SapioUser,
+    def __exhaust_system_report(context: UserIdentifier,
                                 report_name: str,
                                 page_limit: int | None,
                                 page_size: int | None,
                                 page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[Any]]]:
+            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
         """
         Given a system report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
         has_next_page: bool = True
-        rows: list[list[Any]] = []
+        rows: list[list[FieldValue]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_system_report_by_name(report_name, page_size, page_number)
@@ -166,17 +166,17 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_custom_report(context: SapioWebhookContext | SapioUser,
+    def __exhaust_custom_report(context: UserIdentifier,
                                 report: CustomReportCriteria,
                                 page_limit: int | None,
                                 page_size: int | None,
                                 page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[Any]]]:
+            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
         """
         Given a custom report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
@@ -185,7 +185,7 @@ class CustomReportUtil:
         if page_number is not None:
             report.page_number = page_number
         has_next_page: bool = True
-        rows: list[list[Any]] = []
+        rows: list[list[FieldValue]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_custom_report(report)
@@ -197,22 +197,22 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_quick_report(context: SapioWebhookContext | SapioUser,
+    def __exhaust_quick_report(context: UserIdentifier,
                                report_term: RawReportTerm,
                                page_limit: int | None,
                                page_size: int | None,
                                page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[Any]]]:
+            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
         """
         Given a quick report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
         has_next_page: bool = True
-        rows: list[list[Any]] = []
+        rows: list[list[FieldValue]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_quick_report(report_term, page_size, page_number)
@@ -224,8 +224,8 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __process_results(rows: list[list[Any]], columns: list[ReportColumn],
-                          filters: dict[str, Iterable[Any]] | None) -> list[dict[str, Any]]:
+    def __process_results(rows: list[list[FieldValue]], columns: list[ReportColumn],
+                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None) -> list[dict[str, FieldValue]]:
         """
         Given the results of a report as a list of row values and the report's columns, combine these lists to
         result in a singular list of dictionaries for each row in the results.
@@ -243,9 +243,11 @@ class CustomReportUtil:
             else:
                 encountered_names.append(field_name)
 
-        ret: list[dict[str, Any]] = []
+        filters: dict[str, Iterable[FieldValue]] = AliasUtil.to_data_field_names_dict(filters)
+
+        ret: list[dict[str, FieldValue]] = []
         for row in rows:
-            row_data: dict[str, Any] = {}
+            row_data: dict[str, FieldValue] = {}
             filter_row: bool = False
             for value, column in zip(row, columns):
                 header: str = column.data_field_name