sapiopycommons 2024.7.25a299__py3-none-any.whl → 2024.8.2a301__py3-none-any.whl

sapiopycommons/general/audit_log.py

@@ -0,0 +1,200 @@
+from enum import Enum
+from typing import Any
+
+from sapiopylib.rest.DataRecordManagerService import DataRecordManager
+from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.CustomReport import ReportColumn, RawReportTerm, CustomReportCriteria, RawTermOperation, \
+    CompositeReportTerm, CompositeTermOperation
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+from sapiopycommons.src.sapiopycommons.general.aliases import RecordIdentifier, AliasUtil
+from sapiopycommons.src.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, Any]):
+        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: SapioWebhookContext | SapioUser):
+        self.user = context if isinstance(context, SapioUser) else context.user
+
+    @staticmethod
+    def create_data_record_audit_log_report(records: list[RecordIdentifier], fields: list[str] | 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.
+        """
+        # We need to compile the record ids from these record identifiers as "str" variables, so they can be
+        # concatenated.
+        record_ids = AliasUtil.to_record_ids(records)
+        id_strs = [str(id_int) for id_int in record_ids]
+
+        # Next we'll build the raw report term querying for any entry with a matching record id value to the record ID's
+        # passed in
+        root_term = RawReportTerm(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN,
+                                  RawTermOperation.EQUAL_TO_OPERATOR, "{" + ",".join(id_strs) + "}")
+
+        # If the user passed in any specific fields, then we should limit the query to those fields.
+        if fields:
+            field_term = RawReportTerm(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN,
+                                       RawTermOperation.EQUAL_TO_OPERATOR, "{" + ",".join(fields) + "}")
+            root_term = CompositeReportTerm(root_term, CompositeTermOperation.AND_OPERATOR, field_term)
+
+        return CustomReportCriteria(AuditLog.AUDIT_LOG_COLUMNS, root_term)
+
+    def run_data_record_audit_log_report(self, records: list[RecordIdentifier], fields: list[str] | 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.
+        """
+        # 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, Any]] = 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

@@ -0,0 +1,48 @@
+from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+from sapiopycommons.general.aliases import RecordIdentifier, ExperimentIdentifier, AliasUtil
+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: str | 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 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"

sapiopycommons/recordmodel/record_handler.py

@@ -7,6 +7,7 @@ from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, RawReportTer
 from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.DataRecordPaging import DataRecordPojoPageCriteria
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.autopaging import QueryDataRecordsAutoPager, QueryDataRecordByIdListAutoPager, \
     QueryAllRecordsOfTypeAutoPager
@@ -16,6 +17,7 @@ from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelMana
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType, WrappedRecordModel
 from sapiopylib.rest.utils.recordmodel.RelationshipPath import RelationshipPath, RelationshipNode, \
     RelationshipNodeType
+from sapiopylib.rest.utils.recordmodel.ancestry import RecordModelAncestorManager
 
 from sapiopycommons.general.aliases import RecordModel, SapioRecord, FieldMap
 from sapiopycommons.general.custom_report_util import CustomReportUtil
@@ -32,6 +34,7 @@ class RecordHandler:
     rec_man: RecordModelManager
     inst_man: RecordModelInstanceManager
     rel_man: RecordModelRelationshipManager
+    an_man: RecordModelAncestorManager
 
     def __init__(self, context: SapioWebhookContext | SapioUser):
         """
@@ -42,6 +45,7 @@ class RecordHandler:
         self.rec_man = RecordModelManager(self.user)
         self.inst_man = self.rec_man.instance_manager
         self.rel_man = self.rec_man.relationship_manager
+        self.an_man = RecordModelAncestorManager(self.rec_man)
 
     def wrap_model(self, record: DataRecord, wrapper_type: type[WrappedType]) -> WrappedType:
         """
@@ -51,6 +55,7 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :return: The record model for the input.
         """
+        self.__verify_data_type([record], wrapper_type)
         return self.inst_man.add_existing_record_of_type(record, wrapper_type)
 
     def wrap_models(self, records: Iterable[DataRecord], wrapper_type: type[WrappedType]) -> list[WrappedType]:
@@ -61,6 +66,7 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :return: The record models for the input.
         """
+        self.__verify_data_type(records, wrapper_type)
         return self.inst_man.add_existing_records_of_type(list(records), wrapper_type)
 
     def query_models(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
@@ -831,8 +837,6 @@ class RecordHandler:
         path, if any. The hierarchy must be linear (1:1 relationship between data types at every step) and the
         relationship path must already be loaded.
 
-        Currently, the relationship path may only contain parent/child nodes.
-
         :param models: A list of record models.
         :param path: The relationship path to follow.
         :param wrapper_type: The record model wrapper to use.
@@ -843,15 +847,44 @@ class RecordHandler:
         # PR-46832: Update path traversal to account for changes to RelationshipPath in Sapiopylib.
         path: list[RelationshipNode] = path.path
         for model in models:
-            current: PyRecordModel = model if isinstance(model, PyRecordModel) else model.backing_model
+            current: PyRecordModel | None = model if isinstance(model, PyRecordModel) else model.backing_model
             for node in path:
-                direction = node.direction
+                data_type: str = node.data_type_name
+                direction: RelationshipNodeType = node.direction
                 if current is None:
                     break
                 if direction == RelationshipNodeType.CHILD:
-                    current = current.get_child_of_type(node.data_type_name)
+                    current = current.get_child_of_type(data_type)
                 elif direction == RelationshipNodeType.PARENT:
-                    current = current.get_parent_of_type(node.data_type_name)
+                    current = current.get_parent_of_type(data_type)
+                elif direction == RelationshipNodeType.ANCESTOR:
+                    ancestors: list[PyRecordModel] = list(self.an_man.get_ancestors_of_type(current, data_type))
+                    if not ancestors:
+                        current = None
+                    elif len(ancestors) > 1:
+                        raise SapioException(f"Hierarchy contains multiple ancestors of type {data_type}.")
+                    else:
+                        current = ancestors[0]
+                elif direction == RelationshipNodeType.DESCENDANT:
+                    descendants: list[PyRecordModel] = list(self.an_man.get_descendant_of_type(current, data_type))
+                    if not descendants:
+                        current = None
+                    elif len(descendants) > 1:
+                        raise SapioException(f"Hierarchy contains multiple descendants of type {data_type}.")
+                    else:
+                        current = descendants[0]
+                elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
+                    current = current.get_forward_side_link(node.data_field_name)
+                elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
+                    field_name: str = node.data_field_name
+                    reverse_links: list[PyRecordModel] = current.get_reverse_side_link(field_name, data_type)
+                    if not reverse_links:
+                        current = None
+                    elif len(reverse_links) > 1:
+                        raise SapioException(f"Hierarchy contains multiple reverse links of type {data_type} on field "
+                                             f"{field_name}.")
+                    else:
+                        current = reverse_links[0]
                 else:
                     raise SapioException("Unsupported path direction.")
             ret_dict.update({model: self.inst_man.wrap(current, wrapper_type) if current else None})
@@ -864,8 +897,6 @@ class RecordHandler:
         path, if any. The hierarchy may be non-linear (1:Many relationships between data types are allowed) and the
         relationship path must already be loaded.
 
-        Currently, the relationship path may only contain parent/child nodes.
-
         :param models: A list of record models.
         :param path: The relationship path to follow.
         :param wrapper_type: The record model wrapper to use.
@@ -880,14 +911,23 @@ class RecordHandler:
             next_search: set[PyRecordModel] = set()
             # Exhaust the records at each step in the path, then use those records for the next step.
             for node in path:
-                direction = node.direction
+                data_type: str = node.data_type_name
+                direction: RelationshipNodeType = node.direction
                 if len(current_search) == 0:
                     break
                 for search in current_search:
                     if direction == RelationshipNodeType.CHILD:
-                        next_search.update(search.get_children_of_type(node.data_type_name))
+                        next_search.update(search.get_children_of_type(data_type))
                     elif direction == RelationshipNodeType.PARENT:
-                        next_search.update(search.get_parents_of_type(node.data_type_name))
+                        next_search.update(search.get_parents_of_type(data_type))
+                    elif direction == RelationshipNodeType.ANCESTOR:
+                        next_search.update(self.an_man.get_ancestors_of_type(search, data_type))
+                    elif direction == RelationshipNodeType.DESCENDANT:
+                        next_search.update(self.an_man.get_descendant_of_type(search, data_type))
+                    elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
+                        next_search.add(search.get_forward_side_link(node.data_field_name))
+                    elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
+                        next_search.update(search.get_reverse_side_link(node.data_field_name, data_type))
                     else:
                         raise SapioException("Unsupported path direction.")
                 current_search = next_search
@@ -908,8 +948,6 @@ class RecordHandler:
         relationships (e.g. a sample which is aliquoted to a number of samples, then those aliquots are pooled back
         together into a single sample).
 
-        Currently, the relationship path may only contain parent/child nodes.
-
         :param models: A list of record models.
         :param path: The relationship path to follow.
         :param wrapper_type: The record model wrapper to use.
@@ -922,13 +960,22 @@ class RecordHandler:
         for model in models:
             current: list[PyRecordModel] = [model if isinstance(model, PyRecordModel) else model.backing_model]
             for node in path:
-                direction = node.direction
+                data_type: str = node.data_type_name
+                direction: RelationshipNodeType = node.direction
                 if len(current) == 0:
                     break
                 if direction == RelationshipNodeType.CHILD:
-                    current = current[0].get_children_of_type(node.data_type_name)
+                    current = current[0].get_children_of_type(data_type)
                 elif direction == RelationshipNodeType.PARENT:
-                    current = current[0].get_parents_of_type(node.data_type_name)
+                    current = current[0].get_parents_of_type(data_type)
+                elif direction == RelationshipNodeType.ANCESTOR:
+                    current = list(self.an_man.get_ancestors_of_type(current[0], data_type))
+                elif direction == RelationshipNodeType.DESCENDANT:
+                    current = list(self.an_man.get_descendant_of_type(current[0], data_type))
+                elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
+                    current = [current[0].get_forward_side_link(node.data_field_name)]
+                elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
+                    current = current[0].get_reverse_side_link(node.data_field_name, data_type)
                 else:
                     raise SapioException("Unsupported path direction.")
             ret_dict.update({model: self.inst_man.wrap(current[0], wrapper_type) if current else None})
@@ -959,3 +1006,18 @@ class RecordHandler:
                                          f"encountered in system that matches all provided identifiers.")
                 unique_record = result
         return unique_record
+
+    @staticmethod
+    def __verify_data_type(records: Iterable[DataRecord], wrapper_type: type[WrappedType]) -> None:
+        """
+        Throw an exception if the data type of the given records and wrapper don't match.
+        """
+        model_type: str = wrapper_type.get_wrapper_data_type_name()
+        for record in records:
+            record_type: str = record.data_type_name
+            # Account for ELN data type records.
+            if ElnBaseDataType.is_eln_type(record_type):
+                record_type = ElnBaseDataType.get_base_type(record_type).data_type_name
+            if record_type != model_type:
+                raise SapioException(f"Data record of type {record_type} cannot be wrapped by the record model wrapper "
+                                     f"of type {model_type}")

sapiopycommons/rules/eln_rule_handler.py

@@ -1,5 +1,5 @@
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.webhook.VeloxRules import VeloxRuleType, VeloxRuleParser
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
@@ -12,7 +12,6 @@ from sapiopycommons.general.exceptions import SapioException
 class ElnRuleHandler:
     """
     A class which helps with the parsing and navigation of the ELN rule result map of a webhook context.
-    TODO: Add functionality around the VeloxRuleType of the rule results.
     """
     __context: SapioWebhookContext
     """The context that this handler is working from."""
@@ -64,13 +63,8 @@ class ElnRuleHandler:
                         # Get the data type of this record. If this is an ELN type, ignore the digits.
                         data_type: str = record.data_type_name
                         # PR-46331: Ensure that all ELN types are converted to their base data type name.
-                        # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
-                        if data_type.startswith("ELNExperiment_"):
-                            data_type = "ELNExperiment"
-                        elif data_type.startswith("ELNExperimentDetail_"):
-                            data_type = "ELNExperimentDetail"
-                        elif data_type.startswith("ELNSampleDetail_"):
-                            data_type = "ELNSampleDetail"
+                        if ElnBaseDataType.is_eln_type(data_type):
+                            data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
                         # Update the list of records of this type that exist so far globally.
                         self.__records.setdefault(data_type, set()).add(record)
                         # Do the same for the list of records of this type for this specific entry.
@@ -85,19 +79,9 @@ class ElnRuleHandler:
             entry_dict: dict[str, dict[int, FieldMap]] = {}
             for record_result in entry_results:
                 for result in record_result.velox_type_rule_field_map_result_list:
-                    # TODO: sapiopylib currently has a bug where this velox_type_pojo variable is stored as a dict instead
-                    #  of as the intended VeloxRuleType object. Parse that dict as a VeloxRuleType before use.
-                    velox_type: VeloxRuleType | dict = result.velox_type_pojo
-                    if isinstance(velox_type, dict):
-                        velox_type: VeloxRuleType = VeloxRuleParser.parse_velox_rule_type(velox_type)
-                    data_type: str = velox_type.data_type_name
-                    # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
-                    if data_type.startswith("ELNExperiment_"):
-                        data_type = "ELNExperiment"
-                    elif data_type.startswith("ELNExperimentDetail_"):
-                        data_type = "ELNExperimentDetail"
-                    elif data_type.startswith("ELNSampleDetail_"):
-                        data_type = "ELNSampleDetail"
+                    data_type: str = result.velox_type_pojo.data_type_name
+                    if ElnBaseDataType.is_eln_type(data_type):
+                        data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
                     for field_map in result.field_map_list:
                         rec_id: int = field_map.get("RecordId")
                         self.__field_maps.setdefault(data_type, {}).update({rec_id: field_map})

sapiopycommons/rules/on_save_rule_handler.py

@@ -1,5 +1,5 @@
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.webhook.VeloxRules import VeloxRuleType, VeloxRuleParser
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
@@ -12,7 +12,6 @@ from sapiopycommons.general.exceptions import SapioException
 class OnSaveRuleHandler:
     """
     A class which helps with the parsing and navigation of the on save rule result map of a webhook context.
-    TODO: Add functionality around the VeloxRuleType of the rule results.
     """
     __context: SapioWebhookContext
     """The context that this handler is working from."""
@@ -51,9 +50,6 @@ class OnSaveRuleHandler:
         self.__base_id_to_records = {}
         # Each record ID in the context has a list of results for that record.
         for record_id, rule_results in self.__context.velox_on_save_result_map.items():
-            # TODO: Record IDs are currently being stored in the map as strings instead of ints. This can be removed
-            #  once sapiopylib is fixed.
-            record_id = int(record_id)
             # Keep track of the records for this specific record ID.
             id_dict: dict[str, set[DataRecord]] = {}
             # The list of results for a record consist of a list of data records and a VeloxType that specifies
@@ -64,13 +60,8 @@ class OnSaveRuleHandler:
                     # Get the data type of this record. If this is an ELN type, ignore the digits.
                     data_type: str = record.data_type_name
                     # PR-46331: Ensure that all ELN types are converted to their base data type name.
-                    # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
-                    if data_type.startswith("ELNExperiment_"):
-                        data_type = "ELNExperiment"
-                    elif data_type.startswith("ELNExperimentDetail_"):
-                        data_type = "ELNExperimentDetail"
-                    elif data_type.startswith("ELNSampleDetail_"):
-                        data_type = "ELNSampleDetail"
+                    if ElnBaseDataType.is_eln_type(data_type):
+                        data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
                     # Update the list of records of this type that exist so far globally.
                     self.__records.setdefault(data_type, set()).add(record)
                     # Do the same for the list of records of this type that relate to this record ID.
@@ -82,24 +73,11 @@ class OnSaveRuleHandler:
         self.__base_id_to_field_maps = {}
         # Repeat the same thing for the field map results.
         for record_id, rule_results in self.__context.velox_on_save_field_map_result_map.items():
-            # TODO: Record IDs are currently being stored in the map as strings instead of ints. This can be removed
-            #  once sapiopylib is fixed.
-            record_id = int(record_id)
             id_dict: dict[str, dict[int, FieldMap]] = {}
             for record_result in rule_results:
-                # TODO: sapiopylib currently has a bug where this velox_type_pojo variable is stored as a dict instead
-                #  of as the intended VeloxRuleType object. Parse that dict as a VeloxRuleType before use.
-                velox_type: VeloxRuleType | dict = record_result.velox_type_pojo
-                if isinstance(velox_type, dict):
-                    velox_type: VeloxRuleType = VeloxRuleParser.parse_velox_rule_type(velox_type)
-                data_type: str = velox_type.data_type_name
-                # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
-                if data_type.startswith("ELNExperiment_"):
-                    data_type = "ELNExperiment"
-                elif data_type.startswith("ELNExperimentDetail_"):
-                    data_type = "ELNExperimentDetail"
-                elif data_type.startswith("ELNSampleDetail_"):
-                    data_type = "ELNSampleDetail"
+                data_type: str = record_result.velox_type_pojo.data_type_name
+                if ElnBaseDataType.is_eln_type(data_type):
+                    data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
                 for field_map in record_result.field_map_list:
                     rec_id: int = field_map.get("RecordId")
                     self.__field_maps.setdefault(data_type, {}).update({rec_id: field_map})