sapiopycommons 2024.8.27a310__py3-none-any.whl → 2024.8.28a313__py3-none-any.whl

sapiopycommons/customreport/custom_report_builder.py

@@ -1,125 +0,0 @@
-from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria, AbstractReportTerm, \
-    ExplicitJoinDefinition, RelatedRecordCriteria, QueryRestriction, FieldCompareReportTerm
-from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
-
-from sapiopycommons.customreport.column_builder import ColumnBuilder
-from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, AliasUtil, SapioRecord
-from sapiopycommons.general.exceptions import SapioException
-
-
-class CustomReportBuilder:
-    """
-    A class used for building custom reports. Look into using the TermBuilder and ColumnBuilder classes for building
-    parts of a custom report.
-    """
-    root_data_type: DataTypeIdentifier
-    data_type_name: str
-    root_term: AbstractReportTerm | None
-    record_criteria: RelatedRecordCriteria
-    column_list: list[ReportColumn]
-    join_list: list[ExplicitJoinDefinition]
-
-    def __init__(self, root_data_type: DataTypeIdentifier):
-        """
-        :param root_data_type: An object that can be used to identify a data type name. Used as the root data type name
-            of this search.
-        """
-        self.root_data_type = root_data_type
-        self.data_type_name = AliasUtil.to_data_type_name(root_data_type)
-        self.root_term = None
-        self.record_criteria = RelatedRecordCriteria(QueryRestriction.QUERY_ALL)
-        self.column_list = []
-        self.join_list = []
-
-    def has_root_term(self) -> bool:
-        """
-        :return: Whether this report builder has had its root term set.
-        """
-        return self.root_term is not None
-
-    def set_root_term(self, term: AbstractReportTerm) -> None:
-        """
-        Set the root term of the report. Use the TermBuilder class to construct the report terms.
-
-        :param term: The term to set as the root term.
-        """
-        self.root_term = term
-
-    def has_columns(self) -> bool:
-        """
-        :return: Whether this report builder has any report columns.
-        """
-        return bool(self.column_list)
-
-    def add_column(self, field: FieldIdentifier, field_type: FieldType = None,
-                   *, data_type: DataTypeIdentifier | None = None) -> None:
-        """
-        Add a column to this report builder.
-
-        :param field: An object that can be used to identify a data field.
-        :param field_type: The field type of the provided field. This is only required if the field type cannot be
-            determined from the given data type and field, which occurs when the given field is a string and the
-            given data type is not a wrapped record model or record model wrapper.
-        :param data_type: An object that can be used to identify a data type. If not provided, uses the root data type
-            provided when this builder was initialized. You'll only want to specify this value when adding a column
-            that is from a different data type than the root data type.
-        """
-        if data_type is None:
-            data_type = self.root_data_type
-        self.column_list.append(ColumnBuilder.build_column(data_type, field, field_type))
-
-    def add_columns(self, fields: list[FieldIdentifier], *, data_type: DataTypeIdentifier | None = None) -> None:
-        """
-        Add columns to this report builder.
-
-        :param fields: A list of objects that can be used to identify data fields.
-        :param data_type: An object that can be used to identify a data type. If not provided, uses the root data type
-            provided when this builder was initialized. You'll only want to specify this value when adding a column
-            that is from a different data type than the root data type.
-        """
-        for field in fields:
-            self.add_column(field, data_type=data_type)
-
-    def set_query_restriction(self, base_record: SapioRecord, search_related: QueryRestriction) -> None:
-        """
-        Set a restriction on the report for this report builder such that the returned results must be related in
-        some way to the provided base record. Without this, the report searches all records in the system that match the
-        root term.
-
-        :param base_record: The base record to run the search from.
-        :param search_related: Determine the relationship of the related records that can appear in the search, be those
-            children, parents, descendants, or ancestors.
-        """
-        if search_related == QueryRestriction.QUERY_ALL:
-            raise SapioException("The search_related must be something other than QUERY_ALL when setting a query restriction.")
-        self.record_criteria = RelatedRecordCriteria(search_related,
-                                                     AliasUtil.to_record_id(base_record),
-                                                     AliasUtil.to_data_type_name(base_record))
-
-    def add_join(self, comparison_term: FieldCompareReportTerm) -> None:
-        """
-        Add a join statement to this report builder.
-
-        :param comparison_term: The field comparison term to join with. The left side data type name of this term will
-            be the data type that is joined against.
-        """
-        self.join_list.append(ExplicitJoinDefinition(comparison_term.left_data_type_name, comparison_term))
-
-    def build_report_criteria(self, page_size: int = 0, page_number: int = -1, case_sensitive: bool = False,
-                              owner_restriction_set: list[str] = None) -> CustomReportCriteria:
-        """
-        Generate a CustomReportCriteria using the column list, root term, and root data type from this report builder.
-        You can use the CustomReportManager or CustomReportUtil to run the constructed report.
-
-        :param page_size: The page size of the custom report.
-        :param page_number: The page number of the current report.
-        :param case_sensitive: When searching texts, should the search be case-sensitive?
-        :param owner_restriction_set: Specifies to only return records if the record is owned by this list of usernames.
-        :return: A CustomReportCriteria from this report builder.
-        """
-        if not self.has_root_term():
-            raise SapioException("Cannot build a report with no root term.")
-        if not self.has_columns():
-            raise SapioException("Cannot build a report with no columns.")
-        return CustomReportCriteria(self.column_list, self.root_term, self.record_criteria, self.data_type_name,
-                                    case_sensitive, page_size, page_number, owner_restriction_set, self.join_list)

sapiopycommons/customreport/term_builder.py

@@ -1,299 +0,0 @@
-from typing import Iterable
-
-from sapiopylib.rest.pojo.CustomReport import RawTermOperation, CompositeTermOperation, RawReportTerm, \
-    CompositeReportTerm, AbstractReportTerm, FieldCompareReportTerm
-
-from sapiopycommons.general.aliases import DataTypeIdentifier, AliasUtil, FieldIdentifier
-
-# Raw term operations, for comparing field values.
-EQ = RawTermOperation.EQUAL_TO_OPERATOR
-NEQ = RawTermOperation.NOT_EQUAL_TO_OPERATOR
-LT = RawTermOperation.LESS_THAN_OPERATOR
-LTE = RawTermOperation.LESS_THAN_OR_EQUAL_OPERATOR
-GT = RawTermOperation.GREATER_THAN_OPERATOR
-GTE = RawTermOperation.GREATER_THAN_OR_EQUAL_OPERATOR
-
-# Composite term operations, for comparing two terms.
-AND = CompositeTermOperation.AND_OPERATOR
-OR = CompositeTermOperation.OR_OPERATOR
-
-# Forms that field term values can take.
-TermValue = str | int | float | bool | Iterable | None
-
-
-class TermBuilder:
-    """
-    A class that allows for the easier constructions of custom report terms.
-    """
-    @staticmethod
-    def all_records_term(data_type: DataTypeIdentifier) -> RawReportTerm:
-        """
-        Create a raw report term that captures all records of the given data type.
-
-        :param data_type: The data type of this term.
-        :return: A raw report term for "data_type.RecordId >= 0".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), "RecordId", GTE, TermBuilder.to_term_val(0))
-
-    @staticmethod
-    def is_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                *, trim: bool = False) -> RawReportTerm:
-        """
-        Create a raw report term for comparing a field value with an equals operation.
-
-        :param data_type: The data type of this term.
-        :param field: The data field of this term.
-        :param value: The value to compare for this term.
-        :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
-        :return: A raw report term for "data_type.field = value".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), EQ,
-                             TermBuilder.to_term_val(value), trim)
-
-    @staticmethod
-    def not_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                 *, trim: bool = False) -> RawReportTerm:
-        """
-        Create a raw report term for comparing a field value with a not equals operation.
-
-        :param data_type: The data type of this term.
-        :param field: The data field of this term.
-        :param value: The value to compare for this term.
-        :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
-        :return: A raw report term for "data_type.field != value".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), NEQ,
-                             TermBuilder.to_term_val(value), trim)
-
-    @staticmethod
-    def lt_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                *, trim: bool = False) -> RawReportTerm:
-        """
-        Create a raw report term for comparing a field value with a less than operation.
-
-        :param data_type: The data type of this term.
-        :param field: The data field of this term.
-        :param value: The value to compare for this term.
-        :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
-        :return: A raw report term for "data_type.field < value".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), LT,
-                             TermBuilder.to_term_val(value), trim)
-
-    @staticmethod
-    def lte_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                 *, trim: bool = False) -> RawReportTerm:
-        """
-        Create a raw report term for comparing a field value with a less than or equal to operation.
-
-        :param data_type: The data type of this term.
-        :param field: The data field of this term.
-        :param value: The value to compare for this term.
-        :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
-        :return: A raw report term for "data_type.field <= value".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), LTE,
-                             TermBuilder.to_term_val(value), trim)
-
-    @staticmethod
-    def gt_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                *, trim: bool = False) -> RawReportTerm:
-        """
-        Create a raw report term for comparing a field value with a greater than operation.
-
-        :param data_type: The data type of this term.
-        :param field: The data field of this term.
-        :param value: The value to compare for this term.
-        :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
-        :return: A raw report term for "data_type.field > value".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), GT,
-                             TermBuilder.to_term_val(value), trim)
-
-    @staticmethod
-    def gte_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                 *, trim: bool = False) -> RawReportTerm:
-        """
-        Create a raw report term for comparing a field value with a greater than or equal to operation.
-
-        :param data_type: The data type of this term.
-        :param field: The data field of this term.
-        :param value: The value to compare for this term.
-        :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
-        :return: A raw report term for "data_type.field >= value".
-        """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), GTE,
-                             TermBuilder.to_term_val(value), trim)
-
-    @staticmethod
-    def compare_is_term(data_type_A: DataTypeIdentifier, field_A: FieldIdentifier,
-                        data_type_B: DataTypeIdentifier, field_B: FieldIdentifier,
-                        *, trim: bool = False) -> FieldCompareReportTerm:
-        """
-        Create a field comparison report term for comparing field values between data types with an equals operation.
-
-        :param data_type_A: The data type for the left side of this term.
-        :param field_A: The data field for the left side of this term.
-        :param data_type_B: The data type for the right side of this term.
-        :param field_B: The data field for the right side of this term.
-        :param trim: Whether the field values should be trimmed of trailing and leading whitespace for comparing.
-        :return: A field comparison report term for "data_type_A.field_A = data_type_B.field_B".
-        """
-        return FieldCompareReportTerm(AliasUtil.to_data_type_name(data_type_A), AliasUtil.to_data_field_name(field_A), EQ,
-                                      AliasUtil.to_data_type_name(data_type_B), AliasUtil.to_data_field_name(field_B), trim)
-
-    @staticmethod
-    def compare_not_term(data_type_A: DataTypeIdentifier, field_A: FieldIdentifier,
-                         data_type_B: DataTypeIdentifier, field_B: FieldIdentifier,
-                         *, trim: bool = False) -> FieldCompareReportTerm:
-        """
-        Create a field comparison report term for comparing field values between data types with a not equals operation.
-
-        :param data_type_A: The data type for the left side of this term.
-        :param field_A: The data field for the left side of this term.
-        :param data_type_B: The data type for the right side of this term.
-        :param field_B: The data field for the right side of this term.
-        :param trim: Whether the field values should be trimmed of trailing and leading whitespace for comparing.
-        :return: A field comparison report term for "data_type_A.field_A != data_type_B.field_B".
-        """
-        return FieldCompareReportTerm(AliasUtil.to_data_type_name(data_type_A), AliasUtil.to_data_field_name(field_A), NEQ,
-                                      AliasUtil.to_data_type_name(data_type_B), AliasUtil.to_data_field_name(field_B), trim)
-
-    @staticmethod
-    def compare_lt_term(data_type_A: DataTypeIdentifier, field_A: FieldIdentifier,
-                        data_type_B: DataTypeIdentifier, field_B: FieldIdentifier,
-                        *, trim: bool = False) -> FieldCompareReportTerm:
-        """
-        Create a field comparison report term for comparing field values between data types with a less than operation.
-
-        :param data_type_A: The data type for the left side of this term.
-        :param field_A: The data field for the left side of this term.
-        :param data_type_B: The data type for the right side of this term.
-        :param field_B: The data field for the right side of this term.
-        :param trim: Whether the field values should be trimmed of trailing and leading whitespace for comparing.
-        :return: A field comparison report term for "data_type_A.field_A < data_type_B.field_B".
-        """
-        return FieldCompareReportTerm(AliasUtil.to_data_type_name(data_type_A), AliasUtil.to_data_field_name(field_A), LT,
-                                      AliasUtil.to_data_type_name(data_type_B), AliasUtil.to_data_field_name(field_B), trim)
-
-    @staticmethod
-    def compare_lte_term(data_type_A: DataTypeIdentifier, field_A: FieldIdentifier,
-                         data_type_B: DataTypeIdentifier, field_B: FieldIdentifier,
-                         *, trim: bool = False) -> FieldCompareReportTerm:
-        """
-        Create a field comparison report term for comparing field values between data types with a less than or equal
-        to operation.
-
-        :param data_type_A: The data type for the left side of this term.
-        :param field_A: The data field for the left side of this term.
-        :param data_type_B: The data type for the right side of this term.
-        :param field_B: The data field for the right side of this term.
-        :param trim: Whether the field values should be trimmed of trailing and leading whitespace for comparing.
-        :return: A field comparison report term for "data_type_A.field_A <= data_type_B.field_B".
-        """
-        return FieldCompareReportTerm(AliasUtil.to_data_type_name(data_type_A), AliasUtil.to_data_field_name(field_A), LTE,
-                                      AliasUtil.to_data_type_name(data_type_B), AliasUtil.to_data_field_name(field_B), trim)
-
-    @staticmethod
-    def compare_gt_term(data_type_A: DataTypeIdentifier, field_A: FieldIdentifier,
-                        data_type_B: DataTypeIdentifier, field_B: FieldIdentifier,
-                        *, trim: bool = False) -> FieldCompareReportTerm:
-        """
-        Create a field comparison report term for comparing field values between data types with a greater than
-        operation.
-
-        :param data_type_A: The data type for the left side of this term.
-        :param field_A: The data field for the left side of this term.
-        :param data_type_B: The data type for the right side of this term.
-        :param field_B: The data field for the right side of this term.
-        :param trim: Whether the field values should be trimmed of trailing and leading whitespace for comparing.
-        :return: A field comparison report term for "data_type_A.field_A > data_type_B.field_B".
-        """
-        return FieldCompareReportTerm(AliasUtil.to_data_type_name(data_type_A), AliasUtil.to_data_field_name(field_A), GT,
-                                      AliasUtil.to_data_type_name(data_type_B), AliasUtil.to_data_field_name(field_B), trim)
-
-    @staticmethod
-    def compare_gte_term(data_type_A: DataTypeIdentifier, field_A: FieldIdentifier,
-                         data_type_B: DataTypeIdentifier, field_B: FieldIdentifier,
-                         *, trim: bool = False) -> FieldCompareReportTerm:
-        """
-        Create a field comparison report term for comparing field values between data types with a greater than or
-        equal to operation.
-
-        :param data_type_A: The data type for the left side of this term.
-        :param field_A: The data field for the left side of this term.
-        :param data_type_B: The data type for the right side of this term.
-        :param field_B: The data field for the right side of this term.
-        :param trim: Whether the field values should be trimmed of trailing and leading whitespace for comparing.
-        :return: A field comparison report term for "data_type_A.field_A >= data_type_B.field_B".
-        """
-        return FieldCompareReportTerm(AliasUtil.to_data_type_name(data_type_A), AliasUtil.to_data_field_name(field_A), GTE,
-                                      AliasUtil.to_data_type_name(data_type_B), AliasUtil.to_data_field_name(field_B), trim)
-
-    @staticmethod
-    def or_terms(a: AbstractReportTerm, b: AbstractReportTerm, *, is_negated: bool = False) -> CompositeReportTerm:
-        """
-        Combine two report terms with an OR operation.
-
-        :param a: The first term in the operation.
-        :param b: The second term in the operation.
-        :param is_negated: Whether the returned term should be negated (i.e. turn this into a nor operation).
-        :return: A composite report term for "A or B".
-        """
-        return CompositeReportTerm(a, OR, b, is_negated)
-
-    @staticmethod
-    def and_terms(a: AbstractReportTerm, b: AbstractReportTerm, *, is_negated: bool = False) -> CompositeReportTerm:
-        """
-        Combine two report terms with an AND operation.
-
-        :param a: The first term in the operation.
-        :param b: The second term in the operation.
-        :param is_negated: Whether the returned term should be negated (i.e. turn this into a nand operation).
-        :return: A composite report term for "A and B".
-        """
-        return CompositeReportTerm(a, AND, b, is_negated)
-
-    @staticmethod
-    def xor_terms(a: AbstractReportTerm, b: AbstractReportTerm, *, is_negated: bool = False) -> CompositeReportTerm:
-        """
-        Combine two report terms with a XOR operation. Note that a XOR operation doesn't actually exist for custom
-        reports. This instead constructs a term that is "(A or B) and !(A and B)", which is equivalent to a XOR
-        operation.
-
-        :param a: The first term in the operation.
-        :param b: The second term in the operation.
-        :param is_negated: Whether the returned term should be negated (i.e. turn this into an xnor operation).
-        :return: A composite report term for "A xor B".
-        """
-        return TermBuilder.and_terms(TermBuilder.or_terms(a, b),
-                                     TermBuilder.and_terms(a, b, is_negated=True),
-                                     is_negated=is_negated)
-
-    @staticmethod
-    def to_term_val(value: TermValue) -> str:
-        """
-        Convert the given value to be used in a custom report term to a string. Term values may be strings, integers,
-        floats, booleans, or lists of values.
-
-        :param value: A value to be used in a custom report term.
-        :return: The provided value formatted as a string that can be used
-        """
-        # If the given value is already a string, then nothing needs to be done with it.
-        if not isinstance(value, str):
-            # If the given value is None, then use an empty string for the search instead.
-            if value is None:
-                value = ""
-            # If the given value is an iterable object, then the return value is the contents of that iterable
-            # in a comma separated list surrounded by curly braces.
-            elif isinstance(value, Iterable):
-                # When converting a list of values to a string, values in the list which are already strings should be
-                # put in quotation marks so that strings that contain commas do not get split up. All other value
-                # types can be simply converted to a string, though.
-                def convert_list_value(val: TermValue) -> str:
-                    return f"'{val}'" if isinstance(val, str) else str(val)
-                value = "{" + ",".join([convert_list_value(x) for x in value]) + "}"
-            else:
-                # Otherwise, the value is simply cast to a string.
-                value = str(value)
-        return value

sapiopycommons/eln/experiment_report_util.py

@@ -1,118 +0,0 @@
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
-
-from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
-from sapiopycommons.customreport.term_builder import TermBuilder
-from sapiopycommons.general.aliases import SapioRecord, UserIdentifier, AliasUtil
-from sapiopycommons.general.custom_report_util import CustomReportUtil
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-
-_NOTEBOOK_ID = "EXPERIMENTID"
-_RECORD_ID = "RECORDID"
-
-
-# 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:
-    @staticmethod
-    def map_records_to_experiment_ids(context: UserIdentifier, records: list[SapioRecord]) \
-            -> dict[SapioRecord, list[int]]:
-        """
-        Return a dictionary mapping each record to a list of ids of experiments that they were used in.
-        If a record wasn't used in any experiments then it will be mapped to an empty list.
-
-        :param context: The current webhook context or a user object to send requests from.
-        :param records: a list of records of the same data type.
-        :return: a dictionary mapping each record to a list of ids of each experiment it was used in.
-        """
-        if not records:
-            return {}
-
-        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]
-        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)
-        record_to_exps: dict[SapioRecord, set[int]] = {record: set() for record in records}
-        for row in rows:
-            record_id: int = row[_RECORD_ID]
-            exp_id: int = row[_NOTEBOOK_ID]
-            record = id_to_record[record_id]
-            record_to_exps[record].add(exp_id)
-
-        return {record: list(exps) for record, exps in record_to_exps.items()}
-
-    @staticmethod
-    def map_experiments_to_records_of_type(context: UserIdentifier, exp_ids: list[int],
-                                           wrapper_type: type[WrappedType]) -> dict[int, list[WrappedType]]:
-        """
-        Return a dictionary mapping each experiment id to a list of records of the given type that were used in each experiment.
-        If an experiment didn't use any records of the given type then it will be mapped to an empty list.
-
-        :param context: The current webhook context or a user object to send requests from.
-        :param exp_ids: a list of experiment ids. These are specifically the Notebook Experiment ids which can be found in the title of the experiment.
-        :param wrapper_type: The record model wrapper to use, corresponds to which data type we will query for.
-        :return: a dictionary mapping each experiment id to a list of records of the given type that were used in that experiment.
-        """
-        if not exp_ids:
-            return {}
-
-        user = AliasUtil.to_sapio_user(context)
-        record_handler = RecordHandler(user)
-        data_type_name: str = wrapper_type.get_wrapper_data_type_name()
-
-        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(user, data_type_name, exp_ids=exp_ids)
-        record_ids: set[int] = {row[_RECORD_ID] for row in rows}
-        records = record_handler.query_models_by_id(wrapper_type, record_ids)
-
-        id_to_record: dict[int, WrappedType] = RecordHandler.map_by_id(records)
-        exp_to_records: dict[int, set[SapioRecord]] = {exp: set() for exp in exp_ids}
-        for row in rows:
-            record_id: int = row[_RECORD_ID]
-            exp_id: int = row[_NOTEBOOK_ID]
-            record = id_to_record[record_id]
-            exp_to_records[exp_id].add(record)
-
-        return {exp: list(records) for exp, records in exp_to_records.items()}
-
-    @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]]:
-        """
-        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.
-        """
-        assert (record_ids or exp_ids)
-
-        if record_ids:
-            records_term = TermBuilder.is_term(data_type_name, "RECORDID", record_ids)
-        else:
-            # Get all records of the given type
-            records_term = TermBuilder.all_records_term(data_type_name)
-
-        if exp_ids:
-            exp_term = TermBuilder.is_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", exp_ids)
-        else:
-            # Get all experiments
-            exp_term = TermBuilder.gte_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", "0")
-
-        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("EXPERIMENTENTRYRECORD", "RECORDID", data_type_name, "RECORDID")
-        # Join entry records on the experiment entries they are in.
-        experiment_entry_enb_entry_join = TermBuilder.compare_is_term("ENBENTRY", "ENTRYID", "EXPERIMENTENTRYRECORD", "ENTRYID")
-        # Join entries on the experiments they are in.
-        enb_entry_experiment_join = TermBuilder.compare_is_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", "ENBENTRY", "EXPERIMENTID")
-
-        report_builder = CustomReportBuilder(data_type_name)
-        report_builder.set_root_term(root_term)
-        report_builder.add_column("RECORDID", FieldType.LONG, data_type=data_type_name)
-        report_builder.add_column("EXPERIMENTID", FieldType.LONG, data_type="NOTEBOOKEXPERIMENT")
-        report_builder.add_join(records_entry_join)
-        report_builder.add_join(experiment_entry_enb_entry_join)
-        report_builder.add_join(enb_entry_experiment_join)
-        return CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria())