sapiopycommons 2024.8.28a315__py3-none-any.whl → 2024.8.29a317__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/general/audit_log.py

@@ -1,196 +0,0 @@
-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/sapio_links.py

@@ -1,50 +0,0 @@
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-
-from sapiopycommons.general.aliases import RecordIdentifier, ExperimentIdentifier, AliasUtil, DataTypeIdentifier
-from sapiopycommons.general.exceptions import SapioException
-
-
-class SapioNavigationLinker:
-    """
-    Given a URL to a system's webservice API (example: https://company.exemplareln.com/webservice/api), construct
-    URLs for navigation links to various locations in the system.
-    """
-    base_url: str
-
-    def __init__(self, url: str | SapioUser | SapioWebhookContext):
-        """
-        :param url: A user or context object that is being used to send requests to a Sapio system, or a URL to a
-            system's webservice API.
-        """
-        if isinstance(url, SapioWebhookContext):
-            url = url.user.url
-        elif isinstance(url, SapioUser):
-            url = url.url
-        self.base_url = url.rstrip("/").replace('webservice/api', 'veloxClient')
-
-    def data_record(self, record_identifier: RecordIdentifier, data_type_name: DataTypeIdentifier | None = None) -> str:
-        """
-        :param record_identifier: An object that can be used to identify a record in the system, be that a record ID,
-            a data record, or a record model.
-        :param data_type_name: If the provided record identifier is a record ID, then the data type name of the record
-            must be provided in this parameter. Otherwise, this parameter is ignored.
-        :return: A URL for navigating to the input record.
-        """
-        record_id: int = AliasUtil.to_record_id(record_identifier)
-        if data_type_name:
-            data_type_name = AliasUtil.to_data_type_name(data_type_name)
-        if not isinstance(record_identifier, int):
-            data_type_name = AliasUtil.to_data_type_name(record_identifier)
-        if not data_type_name:
-            raise SapioException("Unable to create a data record link without a data type name. "
-                                 "Only a record ID was provided.")
-        return self.base_url + f"/#dataType={data_type_name};recordId={record_id};view=dataRecord"
-
-    def experiment(self, experiment: ExperimentIdentifier) -> str:
-        """
-        :param experiment: An object that can be used to identify an experiment in the system, be that an experiment
-            object, experiment protocol, or a notebook ID.
-        :return: A URL for navigating to the input experiment.
-        """
-        return self.base_url + f"/#notebookExperimentId={AliasUtil.to_notebook_id(experiment)};view=eln"