sapiopycommons 2024.8.7a303__py3-none-any.whl → 2024.8.19a305__py3-none-any.whl

sapiopycommons/callbacks/callback_util.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import io
 from typing import Any
+from weakref import WeakValueDictionary
 
 from sapiopylib.rest.ClientCallbackService import ClientCallback
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
@@ -24,6 +25,7 @@ from sapiopylib.rest.utils.FormBuilder import FormBuilder
 from sapiopylib.rest.utils.recorddatasinks import InMemoryRecordDataSink
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
+from sapiopycommons.files.file_util import FileUtil
 from sapiopycommons.general.aliases import FieldMap, SapioRecord, AliasUtil, RecordIdentifier
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioUserCancelledException, SapioException, SapioUserErrorException
@@ -37,17 +39,36 @@ class CallbackUtil:
     width_pixels: int | None
     width_percent: float | None
 
+    __instances: WeakValueDictionary[SapioUser, CallbackUtil] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, context: SapioWebhookContext | SapioUser):
+        """
+        :param context: The current webhook context or a user object to send requests from.
+        """
+        user = context if isinstance(context, SapioUser) else context.user
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
+
     def __init__(self, context: SapioWebhookContext | SapioUser):
         """
         :param context: The current webhook context or a user object to send requests from.
         """
+        if self.__initialized:
+            return
+        self.__initialized = True
+
         self.user = context if isinstance(context, SapioUser) else context.user
         self.callback = DataMgmtServer.get_client_callback(self.user)
         self.dt_cache = DataTypeCacheManager(self.user)
         self.width_pixels = None
         self.width_percent = None
 
-    def set_dialog_width(self, width_pixels: int | None, width_percent: float | None):
+    def set_dialog_width(self, width_pixels: int | None = None, width_percent: float | None = None):
         """
         Set the width that dialogs will appear as for those dialogs that support specifying their width.
 
@@ -55,6 +76,8 @@ class CallbackUtil:
         :param width_percent: The percentage (as a value between 0 and 1) of the client's screen width that dialogs
             will appear as.
         """
+        if width_pixels is not None and width_percent is not None:
+            raise SapioException("Cannot set both width_pixels and width_percent at once.")
         self.width_pixels = width_pixels
         self.width_percent = width_percent
 
@@ -69,6 +92,33 @@ class CallbackUtil:
         """
         self.callback.display_popup(DisplayPopupRequest(title, message, popup_type))
 
+    def display_info(self, message: str) -> None:
+        """
+        Display an info message to the user in a dialog. Repeated calls to this function will append the new messages
+        to the same dialog if it is still opened by the user.
+
+        :param message: The message to display to the user.
+        """
+        self.callback.display_info(message)
+
+    def display_warning(self, message: str) -> None:
+        """
+        Display a warning message to the user in a dialog. Repeated calls to this function will append the new messages
+        to the same dialog if it is still opened by the user.
+
+        :param message: The message to display to the user.
+        """
+        self.callback.display_warning(message)
+
+    def display_error(self, message: str) -> None:
+        """
+        Display an error message to the user in a dialog. Repeated calls to this function will append the new messages
+        to the same dialog if it is still opened by the user.
+
+        :param message: The message to display to the user.
+        """
+        self.callback.display_error(message)
+
     def option_dialog(self, title: str, msg: str, options: list[str], default_option: int = 0,
                       user_can_cancel: bool = False) -> str:
         """
@@ -810,7 +860,7 @@ class CallbackUtil:
 
         # If CustomReportCriteria was provided, it must be wrapped as a CustomReport.
         if isinstance(custom_search, CustomReportCriteria):
-            custom_search: CustomReport = CustomReport(False, None, custom_search)
+            custom_search: CustomReport = CustomReport(False, [], custom_search)
         # If a string was provided, locate the report criteria for the predefined search in the system matching this
         # name.
         if isinstance(custom_search, str):
@@ -929,7 +979,7 @@ class CallbackUtil:
         if len(allowed_extensions) != 0:
             matches: bool = False
             for ext in allowed_extensions:
-                if file_path.endswith("." + ext):
+                if file_path.endswith("." + ext.lstrip(".")):
                     matches = True
                     break
             if matches is False:
@@ -946,6 +996,16 @@ class CallbackUtil:
         data = io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data)
         self.callback.send_file(file_name, False, data)
 
+    def write_zip_file(self, zip_name: str, files: dict[str, str | bytes]) -> None:
+        """
+        Send a collection of files to the user in a zip file.
+
+        :param zip_name: The name of the zip file.
+        :param files: A dictionary of the files to add to the zip file.
+        """
+        data = io.BytesIO(FileUtil.zip_files(files))
+        self.callback.send_file(zip_name, False, data)
+
 
 class FieldModifier:
     """

sapiopycommons/customreport/column_builder.py

@@ -0,0 +1,60 @@
+from sapiopylib.rest.pojo.CustomReport import ReportColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+
+from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, AliasUtil
+from sapiopycommons.general.exceptions import SapioException
+
+# The system fields that every record has and their field types. System fields aren't generated as record model fields
+# for all platform version, hence the need to create a dict for them in the off chance that they're not present on
+# the model wrapper.
+SYSTEM_FIELDS: dict[str, FieldType] = {
+    "DataRecordName": FieldType.IDENTIFIER,
+    "RecordId": FieldType.LONG,
+    "DateCreated": FieldType.DATE,
+    "CreatedBy": FieldType.STRING,
+    "VeloxLastModifiedDate": FieldType.DATE,
+    "VeloxLastModifiedBy": FieldType.STRING
+}
+
+
+class ColumnBuilder:
+    """
+    A class for building report columns for custom reports.
+    """
+    @staticmethod
+    def build_column(data_type: DataTypeIdentifier, field: FieldIdentifier, field_type: FieldType | None = None) \
+            -> ReportColumn:
+        """
+        Build a ReportColumn from a variety of possible inputs.
+
+        :param data_type: An object that can be used to identify a data type.
+        :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.
+        :return: A ReportColumn for the inputs.
+        """
+        # Get the data type and field names from the inputs.
+        data_type_name = AliasUtil.to_data_type_name(data_type)
+        field_name = AliasUtil.to_data_field_name(field)
+        if field_type is None:
+            field_type = ColumnBuilder.__field_type(data_type, field)
+        if field_type is None:
+            raise SapioException("The field_type parameter is required for the provided data_type and field inputs.")
+        return ReportColumn(data_type_name, field_name, field_type)
+
+    @staticmethod
+    def __field_type(data_type: DataTypeIdentifier, field: FieldIdentifier) -> FieldType | None:
+        """
+        Given a record model wrapper and a field name, return the field type for that field. Accounts for system fields.
+
+        :param data_type: The record model wrapper that the field is on.
+        :param field: The field name to return the type of.
+        :return: The field type of the given field name.
+        """
+        # Check if the field name is a system field. If it us, use the field type defined in this file.
+        field_name: str = AliasUtil.to_data_field_name(field)
+        if field_name in SYSTEM_FIELDS:
+            return SYSTEM_FIELDS.get(field_name)
+        # Otherwise, check if the field type can be found from the wrapper.
+        return AliasUtil.to_field_type(field_name, data_type)

sapiopycommons/customreport/custom_report_builder.py

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,296 @@
+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
+
+
+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 an iterable object, then the return value is the contents of that iterable
+            # in a comma separated list surrounded by curly braces.
+            if 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