sapiopycommons 2024.10.25a345__py3-none-any.whl → 2024.10.30a348__py3-none-any.whl

sapiopycommons/eln/experiment_handler.py

@@ -57,9 +57,9 @@ class ExperimentHandler:
     # additional queries to obtain, but may also be repeatedly accessed. In such cases, cache the information after it
     # has been requested so that the user doesn't need to worry about caching it themselves.
     # CR-46341: Replace class variables with instance variables.
-    __exp_record: DataRecord
+    __exp_record: DataRecord | None
     """The data record for this experiment. Only cached when first accessed."""
-    __exp_template: ElnTemplate
+    __exp_template: ElnTemplate | None
     """The template for this experiment. Only cached when first accessed."""
     __exp_options: dict[str, str]
     """Experiment options for this experiment. Only cached when first accessed."""
@@ -277,6 +277,7 @@ class ExperimentHandler:
         """
         template_id: int | None = self.__eln_exp.template_id
         if template_id is None:
+            self.__exp_template = None
             if exception_on_none:
                 raise SapioException(f"Experiment with ID {self.__exp_id} has no template ID.")
             return None
@@ -635,6 +636,9 @@ class ExperimentHandler:
         if not records:
             return
         dt: str = AliasUtil.to_singular_data_type_name(records)
+        if ElnBaseDataType.is_base_data_type(dt):
+            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
+                                 f"Use add_eln_rows or add_sample_details instead.")
         if dt != step.get_data_type_names()[0]:
             raise SapioException(f"Cannot add {dt} records to entry {step.get_name()} of type "
                                  f"{step.get_data_type_names()[0]}.")
@@ -659,6 +663,9 @@ class ExperimentHandler:
         if not records:
             return
         dt: str = AliasUtil.to_singular_data_type_name(records)
+        if ElnBaseDataType.is_base_data_type(dt):
+            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
+                                 f"Use remove_eln_rows or remove_sample_details instead.")
         if dt != step.get_data_type_names()[0]:
             raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
                                  f"{step.get_data_type_names()[0]}.")
@@ -687,6 +694,9 @@ class ExperimentHandler:
         step = self.__to_eln_step(step)
         if records:
             dt: str = AliasUtil.to_singular_data_type_name(records)
+            if ElnBaseDataType.is_base_data_type(dt):
+                raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
+                                     f"Use add_eln_rows or add_sample_details instead.")
             if dt != step.get_data_type_names()[0]:
                 raise SapioException(f"Cannot set {dt} records for entry {step.get_name()} of type "
                                      f"{step.get_data_type_names()[0]}.")
@@ -779,7 +789,7 @@ class ExperimentHandler:
             raise SapioException("The provided step is not an ELN data type entry.")
         if not records:
             return
-        record_dt: str = AliasUtil.to_singular_data_type_name(records)
+        record_dt: str = AliasUtil.to_singular_data_type_name(records, False)
         if record_dt != dt:
             raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
                                  f"{step.get_data_type_names()[0]}.")

sapiopycommons/eln/experiment_report_util.py

@@ -1,7 +1,9 @@
 from sapiopylib.rest.ELNService import ElnManager
 from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, AbstractReportTerm, RawReportTerm
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, ElnExperimentQueryCriteria
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnExperimentStatus, ElnBaseDataType
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
 from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
@@ -11,9 +13,131 @@ from sapiopycommons.datatype.pseudo_data_types import EnbEntryOptionsPseudoDef,
 from sapiopycommons.general.aliases import SapioRecord, UserIdentifier, AliasUtil, FieldValue, \
     ExperimentEntryIdentifier, ExperimentIdentifier
 from sapiopycommons.general.custom_report_util import CustomReportUtil
+from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
 
+# FR-47234: Create an ExperimentReportCriteria class for finer experiment searching
+# and create/update ExperimentReportUtil functions to use it.
+class ExperimentReportCriteria:
+    """
+    Experiment report criteria is used to restrict the results of searches for experiments.
+    """
+    notebook_ids: list[int] | None
+    not_notebook_ids: list[int] | None
+    names: list[str] | None
+    not_names: list[str] | None
+    created_by: list[str] | None
+    not_created_by: list[str] | None
+    last_modified_by: list[str] | None
+    not_last_modified_by: list[str] | None
+    owners: list[str] | None
+    not_owners: list[str] | None
+    statuses: list[str] | None
+    not_statuses: list[str] | None
+    templates: str | None
+    not_templates: str | None
+    is_from_template: bool | None
+    is_from_protocol_template: bool | None
+    is_modifiable: bool | None
+    is_active: bool | None
+    created_before: int | None
+    created_after: int | None
+    due_before: int | None
+    due_after: int | None
+    last_modified_before: int | None
+    last_modified_after: int | None
+
+    def __init__(self, *,
+                 notebook_ids: list[ExperimentIdentifier] | None = None,
+                 not_notebook_ids: list[ExperimentIdentifier] | None = None,
+                 names: list[str] | None = None,
+                 not_names: list[str] | None = None,
+                 created_by: list[str] | None = None,
+                 not_created_by: list[str] | None = None,
+                 last_modified_by: list[str] | None = None,
+                 not_last_modified_by: list[str] | None = None,
+                 owners: list[str] | None = None,
+                 not_owners: list[str] | None = None,
+                 statuses: list[ElnExperimentStatus | str] | None = None,
+                 not_statuses: list[ElnExperimentStatus | str] | None = None,
+                 templates: list[str] | None = None,
+                 not_templates: list[str] | None = None,
+                 is_from_template: bool | None = None,
+                 is_from_protocol_template: bool | None = None,
+                 is_modifiable: bool | None = None,
+                 is_active: bool | None = None,
+                 created_after: int | None = None,
+                 created_before: int | None = None,
+                 due_after: int | None = None,
+                 due_before: int | None = None,
+                 last_modified_after: int | None = None,
+                 last_modified_before: int | None = None):
+        """
+        Restrict searches using the following criteria.
+
+        :param notebook_ids: The allowed notebook ID(s) of the experiment.
+        :param not_notebook_ids: The disallowed notebook ID(s) of the experiment.
+        :param names: The allowed name(s) of the experiment.
+        :param not_names: The disallowed name(s) of the experiment.
+        :param created_by: The allowed username(s) of the user who created the experiment.
+        :param not_created_by: The disallowed username(s) of the user who created the experiment.
+        :param last_modified_by: The allowed username(s) of the user who last modified the experiment.
+        :param not_last_modified_by: The disallowed username(s) of the user who last modified the experiment.
+        :param owners: The allowed username(s) of the user who owns the experiment.
+        :param not_owners: The disallowed username(s) of the user who owns the experiment.
+        :param statuses: The allowed status(es) of the experiment.
+        :param not_statuses: The disallowed status(es) of the experiment.
+        :param templates: The allowed template name(s) that the experiment was created from.
+        :param not_templates: The disallowed template name(s) that the experiment was created from.
+        :param is_from_template: Whether the experiment was created from a template.
+        :param is_from_protocol_template: Whether the experiment was created from a protocol template.
+        :param is_modifiable: Whether the experiment is modifiable.
+        :param is_active: Whether the experiment is from an active template.
+        :param created_after: A timestamp after which the experiment was created.
+        :param created_before: A timestamp before which the experiment was created.
+        :param due_after: A timestamp after which the experiment's approval is due.
+        :param due_before: A timestamp before which the experiment's approval is due.
+        :param last_modified_after: A timestamp after which the experiment last modified.
+        :param last_modified_before: A timestamp before which the experiment last modified.
+        """
+        self.notebook_ids = notebook_ids
+        self.not_notebook_ids = not_notebook_ids
+        self.names = names
+        self.not_names = not_names
+        self.created_by = created_by
+        self.not_created_by = not_created_by
+        self.last_modified_by = last_modified_by
+        self.not_last_modified_by = not_last_modified_by
+        self.owners = owners
+        self.not_owners = not_owners
+        self.statuses = statuses
+        self.not_statuses = not_statuses
+        self.templates = templates
+        self.not_templates = not_templates
+
+        self.is_from_template = is_from_template
+        self.is_from_protocol_template = is_from_protocol_template
+        self.is_modifiable = is_modifiable
+        self.is_active = is_active
+
+        self.created_before = created_before
+        self.created_after = created_after
+        self.due_before = due_before
+        self.due_after = due_after
+        self.last_modified_before = last_modified_before
+        self.last_modified_after = last_modified_after
+
+        if self.notebook_ids is not None:
+            self.notebook_ids = AliasUtil.to_notebook_ids(self.notebook_ids)
+        if self.not_notebook_ids is not None:
+            self.not_notebook_ids = AliasUtil.to_notebook_ids(self.not_notebook_ids)
+        if self.statuses is not None:
+            self.statuses = [x.description if isinstance(x, ElnExperimentStatus) else x for x in self.statuses]
+        if self.not_statuses is not None:
+            self.not_statuses = [x.description if isinstance(x, ElnExperimentStatus) else x for x in self.not_statuses]
+
+
 # FR-46908 - Provide a utility class that holds experiment related custom reports e.g. getting all the experiments
 # that given records were used in or getting all records of a datatype used in given experiments.
 class ExperimentReportUtil:
@@ -34,7 +158,7 @@ class ExperimentReportUtil:
         user: SapioUser = AliasUtil.to_sapio_user(context)
         data_type_name: str = AliasUtil.to_singular_data_type_name(records)
 
-        record_ids = [record.record_id for record in records]
+        record_ids: list[int] = AliasUtil.to_record_ids(records)
         rows = ExperimentReportUtil.__get_record_experiment_relation_rows(user, data_type_name, record_ids=record_ids)
 
         id_to_record: dict[int, SapioRecord] = RecordHandler.map_by_id(records)
@@ -47,6 +171,45 @@ class ExperimentReportUtil:
 
         return {record: list(exps) for record, exps in record_to_exps.items()}
 
+    @staticmethod
+    def map_eln_records_to_experiment_ids(context: UserIdentifier, records: list[SapioRecord]) \
+            -> dict[SapioRecord, int]:
+        """
+        Return a dictionary mapping each ELN record to the ID of the experiments that each were used in.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param records: A list of ELN data type records. They are permitted to be of mixed data type names.
+        :return: A dictionary mapping each record to the ID of the experiment it was used in.
+        """
+        if not records:
+            return {}
+
+        data_types: set[str] = AliasUtil.to_data_type_names(records, True, False)
+        for data_type in data_types:
+            if not ElnBaseDataType.is_eln_type(data_type):
+                raise SapioException(f"Data type {data_type} is not an ELN data type.")
+
+        dt_to_record: dict[str, list[SapioRecord]] = {}
+        for record in records:
+            dt_to_record.setdefault(AliasUtil.to_data_type_name(record, False), []).append(record)
+
+        report_builder = CustomReportBuilder(EnbEntryPseudoDef.DATA_TYPE_NAME)
+        report_builder.add_column(EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME)
+        report_builder.add_column(EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME)
+        report_builder.set_root_term(TermBuilder.is_term(EnbEntryPseudoDef.DATA_TYPE_NAME,
+                                                         EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME,
+                                                         data_types))
+        criteria = report_builder.build_report_criteria()
+
+        ret_val: dict[SapioRecord, int] = {}
+        rows: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, criteria)
+        for row in rows:
+            dt: str = row[EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME.field_name]
+            exp_id: int = row[EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
+            for record in dt_to_record[dt]:
+                ret_val[record] = exp_id
+        return ret_val
+
     @staticmethod
     def map_experiments_to_records_of_type(context: UserIdentifier, exp_ids: list[ExperimentIdentifier],
                                            wrapper_type: type[WrappedType]) -> dict[int, list[WrappedType]]:
@@ -148,52 +311,299 @@ class ExperimentReportUtil:
         return options
 
     @staticmethod
-    def get_experiments_by_name(context: UserIdentifier, name: str) -> list[ElnExperiment]:
+    def get_template_names_for_experiments(context: UserIdentifier, experiments: list[ExperimentIdentifier]) \
+            -> dict[int, str]:
+        """
+        Run a custom report to retrieve the template names for all the provided experiments.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param experiments: The experiment identifiers to retrieve the template names for.
+        :return: A dictionary mapping the notebook experiment ID to the template name that the experiment was created from.
+        """
+        exp_ids: list[int] = AliasUtil.to_notebook_ids(experiments)
+
+        report_builder = CustomReportBuilder(NotebookExperimentPseudoDef.DATA_TYPE_NAME)
+        root = TermBuilder.is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                   NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                   exp_ids)
+        report_builder.add_join(TermBuilder.compare_is_term("ELNExperiment",
+                                                            "RecordId",
+                                                            NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                                            NotebookExperimentPseudoDef.EXPERIMENT_RECORD_ID__FIELD_NAME))
+        report_builder.set_root_term(root)
+        report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME)
+        report_builder.add_column("TemplateExperimentName", FieldType.STRING, data_type="ELNExperiment")
+        report = report_builder.build_report_criteria()
+
+        ret_val: dict[int, str] = {}
+        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
+        for row in results:
+            exp_id: int = row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
+            name: str = row["TemplateExperimentName"]
+            ret_val[exp_id] = name
+        return ret_val
+
+    @staticmethod
+    def get_experiments_for_criteria(context: UserIdentifier, criteria: ExperimentReportCriteria) -> list[ElnExperiment]:
+        """
+        Run a custom report that retrieves every experiment in the system for the given search criteria.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param criteria: The search criteria to query for experiments with.
+        :return: A list of every experiment in the system that matches the search criteria.
+        """
+        report: CustomReportCriteria = ExperimentReportUtil.build_experiment_id_report(criteria)
+        return ExperimentReportUtil.get_experiments_for_report(context, report)
+
+    @staticmethod
+    def get_experiments_by_name(context: UserIdentifier, name: str,
+                                criteria: ExperimentReportCriteria = ExperimentReportCriteria()) -> list[ElnExperiment]:
         """
         Run a custom report that retrieves every experiment in the system with a given name.
 
         :param context: The current webhook context or a user object to send requests from.
         :param name: The name of the experiment to query for.
-        :return: A list of every experiment in the system with a name that matches the input.
+        :param criteria: Additional search criteria to filter the results.
+        :return: A list of every experiment in the system with a name that matches the input
+            that matches the given criteria.
         """
-        return ExperimentReportUtil.get_experiments_by_names(context, [name])[name]
+        return ExperimentReportUtil.get_experiments_by_names(context, [name], criteria)[name]
 
     @staticmethod
-    def get_experiments_by_names(context: UserIdentifier, names: list[str]) -> dict[str, list[ElnExperiment]]:
+    def get_experiments_by_names(context: UserIdentifier, names: list[str],
+                                 criteria: ExperimentReportCriteria = ExperimentReportCriteria()) -> dict[str, list[ElnExperiment]]:
         """
         Run a custom report that retrieves every experiment in the system with a name from a list of names.
 
         :param context: The current webhook context or a user object to send requests from.
         :param names: The names of the experiment to query for.
-        :return: A dictionary mapping the experiment name to a list of every experiment in the system with that name.
+        :param criteria: Additional search criteria to filter the results.
+        :return: A dictionary mapping the experiment name to a list of every experiment in the system with that name
+            that matches the given criteria.
         """
-        user = AliasUtil.to_sapio_user(context)
+        criteria.names = names
+        experiments: list[ElnExperiment] = ExperimentReportUtil.get_experiments_for_criteria(context, criteria)
 
-        report_builder = CustomReportBuilder(NotebookExperimentPseudoDef.DATA_TYPE_NAME)
+        # Ensure that each name appears in the dictionary, even if it has no experiments.
+        ret_val: dict[str, list[ElnExperiment]] = {x: [] for x in names}
+        for experiment in experiments:
+            ret_val.get(experiment.notebook_experiment_name).append(experiment)
+        return ret_val
+
+    @staticmethod
+    def get_experiments_by_owner(context: UserIdentifier, owner: str,
+                                 criteria: ExperimentReportCriteria = ExperimentReportCriteria()) -> list[ElnExperiment]:
+        """
+        Run a custom report that retrieves every experiment in the system with a given owner.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param owner: The username of the owner of the experiments to query for.
+        :param criteria: Additional search criteria to filter the results.
+        :return: A list of every experiment in the system with the owner that matches the input
+            that matches the given criteria.
+        """
+        return ExperimentReportUtil.get_experiments_by_owners(context, [owner], criteria)[owner]
+
+    @staticmethod
+    def get_experiments_by_owners(context: UserIdentifier, owners: list[str],
+                                  criteria: ExperimentReportCriteria = ExperimentReportCriteria) \
+            -> dict[str, list[ElnExperiment]]:
+        """
+        Run a custom report that retrieves every experiment in the system with a given list of owners.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param owners: The usernames of the owner of the experiments to query for.
+        :param criteria: Additional search criteria to filter the results.
+        :return: A dictionary mapping the owner username to a list of every experiment in the system from that owner
+            that matches the given criteria.
+        """
+        criteria.owners = owners
+        experiments: list[ElnExperiment] = ExperimentReportUtil.get_experiments_for_criteria(context, criteria)
+
+        # Ensure that each name appears in the dictionary, even if it has no experiments.
+        ret_val: dict[str, list[ElnExperiment]] = {x: [] for x in owners}
+        for experiment in experiments:
+            ret_val.get(experiment.owner).append(experiment)
+        return ret_val
+
+    @staticmethod
+    def get_experiments_by_creator(context: UserIdentifier, created_by: str,
+                                   criteria: ExperimentReportCriteria = ExperimentReportCriteria()) \
+            -> list[ElnExperiment]:
+        """
+        Run a custom report that retrieves every experiment in the system with a given creator.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param created_by: The username of the creator of the experiments to query for.
+        :param criteria: Additional search criteria to filter the results.
+        :return: A list of every experiment in the system with the creator that matches the input
+            that matches the given criteria.
+        """
+        return ExperimentReportUtil.get_experiments_by_creators(context, [created_by], criteria=criteria)[created_by]
+
+    @staticmethod
+    def get_experiments_by_creators(context: UserIdentifier, created_by: list[str],
+                                    criteria: ExperimentReportCriteria = ExperimentReportCriteria()) \
+            -> dict[str, list[ElnExperiment]]:
+        """
+        Run a custom report that retrieves every experiment in the system with a given list of creators.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param created_by: The usernames of the creator of the experiments to query for.
+        :param criteria: Additional search criteria to filter the results.
+        :return: A dictionary mapping the owner username to a list of every experiment in the system from that creator
+            that matches the given criteria.
+        """
+        criteria.created_by = created_by
+        experiments: list[ElnExperiment] = ExperimentReportUtil.get_experiments_for_criteria(context, criteria)
+
+        # Ensure that each name appears in the dictionary, even if it has no experiments.
+        ret_val: dict[str, list[ElnExperiment]] = {x: [] for x in created_by}
+        for experiment in experiments:
+            ret_val.get(experiment.created_by).append(experiment)
+        return ret_val
+
+    @staticmethod
+    def build_experiment_id_report(criteria: ExperimentReportCriteria = ExperimentReportCriteria()) \
+            -> CustomReportCriteria:
+        """
+        Construct a custom report using the provided ExperimentReportCriteria.
+
+        :param criteria: The criteria to construct a custom report from.
+        :return: A custom report that can be used to search for experiment IDs that match the given criteria.
+        """
+        dt: str = NotebookExperimentPseudoDef.DATA_TYPE_NAME
+        report_builder = CustomReportBuilder(dt)
         report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME)
-        root = TermBuilder.is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                   NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME,
-                                   names)
+
+        root: AbstractReportTerm | None = None
+        if criteria.notebook_ids is not None:
+            root = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, criteria.notebook_ids)
+        if criteria.not_notebook_ids is not None:
+            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, criteria.not_notebook_ids)
+            if root is not None:
+                root = TermBuilder.and_terms(root, term)
+        if root is None:
+            root = ExperimentReportUtil.all_notebook_experiments_term()
+
+        if criteria.names is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME, criteria.names)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.not_names is not None:
+            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME, criteria.not_names)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.created_by is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.CREATED_BY__FIELD_NAME, criteria.created_by)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.not_created_by is not None:
+            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.CREATED_BY__FIELD_NAME, criteria.not_created_by)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.last_modified_by is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_BY__FIELD_NAME, criteria.last_modified_by)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.not_last_modified_by is not None:
+            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_BY__FIELD_NAME, criteria.not_last_modified_by)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.owners is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_OWNER__FIELD_NAME, criteria.owners)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.not_owners is not None:
+            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_OWNER__FIELD_NAME, criteria.not_owners)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.statuses is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.STATUS__FIELD_NAME, criteria.statuses)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.not_statuses is not None:
+            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.STATUS__FIELD_NAME, criteria.not_statuses)
+            root = TermBuilder.and_terms(root, term)
+
+        # For the template name term, we need to join on the experiment record.
+        if criteria.templates is not None or criteria.not_templates is not None:
+            join = TermBuilder.compare_is_term("ELNExperiment",
+                                               "RecordId",
+                                               NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                               NotebookExperimentPseudoDef.EXPERIMENT_RECORD_ID__FIELD_NAME)
+            report_builder.add_join(join)
+        if criteria.templates is not None:
+            term = TermBuilder.is_term("ELNExperiment", "TemplateExperimentName", criteria.templates)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.not_templates is not None:
+            term = TermBuilder.not_term("ELNExperiment", "TemplateExperimentName", criteria.not_templates)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.is_from_template is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_TEMPLATE__FIELD_NAME, criteria.is_from_template)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.is_from_protocol_template is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_PROTOCOL_TEMPLATE__FIELD_NAME, criteria.is_from_protocol_template)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.is_modifiable is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_MODIFIABLE__FIELD_NAME, criteria.is_modifiable)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.is_active is not None:
+            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_ACTIVE__FIELD_NAME, criteria.is_active)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.created_after is not None:
+            term = TermBuilder.gte_term(dt, NotebookExperimentPseudoDef.DATE_CREATED__FIELD_NAME, criteria.created_after)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.created_before is not None:
+            term = TermBuilder.lte_term(dt, NotebookExperimentPseudoDef.DATE_CREATED__FIELD_NAME, criteria.created_before)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.last_modified_after is not None:
+            term = TermBuilder.gte_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_DATE__FIELD_NAME, criteria.last_modified_after)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.last_modified_before is not None:
+            term = TermBuilder.lte_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_DATE__FIELD_NAME, criteria.last_modified_before)
+            root = TermBuilder.and_terms(root, term)
+
+        if criteria.due_after is not None:
+            term = TermBuilder.gte_term(dt, NotebookExperimentPseudoDef.APPROVAL_DUE_DATE__FIELD_NAME, criteria.due_after)
+            root = TermBuilder.and_terms(root, term)
+        if criteria.due_before is not None:
+            term = TermBuilder.lte_term(dt, NotebookExperimentPseudoDef.APPROVAL_DUE_DATE__FIELD_NAME, criteria.due_before)
+            root = TermBuilder.and_terms(root, term)
+
         report_builder.set_root_term(root)
+        return report_builder.build_report_criteria()
 
-        # Ensure that each entry appears in the dictionary, even if it has no experiments.
-        ret_val: dict[str, list[ElnExperiment]] = {x: [] for x in names}
+    @staticmethod
+    def get_experiments_for_report(context: UserIdentifier, report: CustomReportCriteria) -> list[ElnExperiment]:
+        """
+        Retrieve the ELN experiment objects for experiments whose notebook IDs appear in a custom report.
 
+        :param context: The current webhook context or a user object to send requests from.
+        :param report: A custom report that searches for ELN experiments, containing an "Experiment ID" column to
+            query for the experiments of.
+        :return: The ELN experiments that match the provided report.
+        """
+        user = AliasUtil.to_sapio_user(context)
         exp_ids: list[int] = []
-        for row in CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria()):
+        for row in CustomReportUtil.run_custom_report(user, report):
             exp_ids.append(row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name])
         if not exp_ids:
-            return ret_val
+            return []
 
         criteria = ElnExperimentQueryCriteria(notebook_experiment_id_white_list=exp_ids)
-        experiments: list[ElnExperiment] = ElnManager(user).get_eln_experiment_by_criteria(criteria)
-        for experiment in experiments:
-            ret_val.get(experiment.notebook_experiment_name).append(experiment)
-        return ret_val
+        return ElnManager(user).get_eln_experiment_by_criteria(criteria)
+
+    @staticmethod
+    def all_notebook_experiments_term() -> RawReportTerm:
+        """
+        :return: A report term searching for all notebook experiments.
+        """
+        return TermBuilder.gte_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                    NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                    0)
 
     @staticmethod
     def __get_record_experiment_relation_rows(user: SapioUser, data_type_name: str, record_ids: list[int] | None = None,
-                                              exp_ids: list[int] | None = None) -> list[dict[str, int]]:
+                                              exp_ids: list[int] | None = None) -> list[dict[str, FieldValue]]:
         """
         Return a list of dicts mapping \"RECORDID\" to the record id and \"EXPERIMENTID\" to the experiment id.
         At least one of record_ids and exp_ids should be provided.
@@ -212,17 +622,15 @@ class ExperimentReportUtil:
                                            exp_ids)
         else:
             # Get all experiments
-            exp_term = TermBuilder.gte_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                            NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
-                                            0)
+            exp_term = ExperimentReportUtil.all_notebook_experiments_term()
 
         root_term = TermBuilder.and_terms(records_term, exp_term)
 
         # Join records on the experiment entry records that correspond to them.
-        records_entry_join = TermBuilder.compare_is_term(ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
-                                                         ExperimentEntryRecordPseudoDef.RECORD_ID__FIELD_NAME,
-                                                         data_type_name,
-                                                         "RecordId")
+        records_entry_join = TermBuilder.compare_is_term(data_type_name,
+                                                         "RecordId",
+                                                         ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
+                                                         ExperimentEntryRecordPseudoDef.RECORD_ID__FIELD_NAME)
         # Join entry records on the experiment entries they are in.
         experiment_entry_enb_entry_join = TermBuilder.compare_is_term(EnbEntryPseudoDef.DATA_TYPE_NAME,
                                                                       EnbEntryPseudoDef.ENTRY_ID__FIELD_NAME,
@@ -239,7 +647,7 @@ class ExperimentReportUtil:
         report_builder.add_column("RecordId", FieldType.LONG)
         report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
                                   data_type=NotebookExperimentPseudoDef.DATA_TYPE_NAME)
-        report_builder.add_join(records_entry_join)
-        report_builder.add_join(experiment_entry_enb_entry_join)
-        report_builder.add_join(enb_entry_experiment_join)
+        report_builder.add_join(records_entry_join, ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME)
+        report_builder.add_join(experiment_entry_enb_entry_join, EnbEntryPseudoDef.DATA_TYPE_NAME)
+        report_builder.add_join(enb_entry_experiment_join, NotebookExperimentPseudoDef.DATA_TYPE_NAME)
         return CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria())