sapiopycommons 2024.3.19a157__py3-none-any.whl → 2025.1.17a402__py3-none-any.whl

sapiopycommons/customreport/term_builder.py

@@ -0,0 +1,315 @@
+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.
+    """
+    data_type: str
+
+    def __init__(self, data_type: DataTypeIdentifier):
+        """
+        :param data_type: An object that can be used to identify a data type name. Used as the default data type name
+            of the terms created from this TermBuilder.
+        """
+        self.data_type = AliasUtil.to_data_type_name(data_type)
+
+    def all_records_term(self, *, data_type: DataTypeIdentifier | None = None) -> RawReportTerm:
+        """
+        Create a raw report term that captures all records of the given data type.
+
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :return: A raw report term for "data_type.RecordId >= 0".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(data_type, "RecordId", GTE, TermBuilder.to_term_val(0))
+
+    def is_term(self, field: FieldIdentifier, value: TermValue,
+                *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
+        """
+        Create a raw report term for comparing a field value with an equals operation.
+
+        :param field: The data field of this term.
+        :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :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".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), EQ,
+                             TermBuilder.to_term_val(value), trim)
+
+    def not_term(self, field: FieldIdentifier, value: TermValue,
+                 *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
+        """
+        Create a raw report term for comparing a field value with a not equals operation.
+
+        :param field: The data field of this term.
+        :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :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".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), NEQ,
+                             TermBuilder.to_term_val(value), trim)
+
+    def lt_term(self, field: FieldIdentifier, value: TermValue,
+                *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
+        """
+        Create a raw report term for comparing a field value with a less than operation.
+
+        :param field: The data field of this term.
+        :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :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".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), LT,
+                             TermBuilder.to_term_val(value), trim)
+
+    def lte_term(self, field: FieldIdentifier, value: TermValue,
+                 *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
+        """
+        Create a raw report term for comparing a field value with a less than or equal to operation.
+
+        :param field: The data field of this term.
+        :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :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".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), LTE,
+                             TermBuilder.to_term_val(value), trim)
+
+    def gt_term(self, field: FieldIdentifier, value: TermValue,
+                *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
+        """
+        Create a raw report term for comparing a field value with a greater than operation.
+
+        :param field: The data field of this term.
+        :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :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".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), GT,
+                             TermBuilder.to_term_val(value), trim)
+
+    def gte_term(self, field: FieldIdentifier, value: TermValue,
+                 *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
+        """
+        Create a raw report term for comparing a field value with a greater than or equal to operation.
+
+        :param field: The data field of this term.
+        :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
+        :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".
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        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/datatype/attachment_util.py

@@ -1,42 +1,42 @@
 import io
 
-from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager
+from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord
+from sapiopycommons.general.aliases import AliasUtil, SapioRecord, UserIdentifier
 from sapiopycommons.general.exceptions import SapioException
+from sapiopycommons.recordmodel.record_handler import RecordHandler
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class AttachmentUtil:
     @staticmethod
-    def get_attachment_bytes(context: SapioWebhookContext, attachment: SapioRecord) -> bytes:
+    def get_attachment_bytes(context: UserIdentifier, attachment: SapioRecord) -> bytes:
         """
         Get the data bytes for the given attachment record. Makes a webservice call to retrieve the data.
 
-        :param context: The current webhook context.
+        :param context: The current webhook context or a user object to send requests from.
         :param attachment: The attachment record.
         :return: The bytes for the attachment's file data.
         """
         attachment = AliasUtil.to_data_record(attachment)
+        dr_man = DataMgmtServer.get_data_record_manager(AliasUtil.to_sapio_user(context))
         with io.BytesIO() as data_sink:
             def consume_data(chunk: bytes):
                 data_sink.write(chunk)
-            context.data_record_manager.get_attachment_data(attachment, consume_data)
+            dr_man.get_attachment_data(attachment, consume_data)
             data_sink.flush()
             data_sink.seek(0)
             file_bytes = data_sink.read()
         return file_bytes
 
     @staticmethod
-    def set_attachment_bytes(context: SapioWebhookContext, attachment: SapioRecord,
+    def set_attachment_bytes(context: UserIdentifier, attachment: SapioRecord,
                              file_name: str, file_bytes: bytes) -> None:
         """
         Set the attachment data for a given attachment record. Makes a webservice call to set the data.
 
-        :param context: The current webhook context.
+        :param context: The current webhook context or a user object to send requests from.
         :param attachment: The attachment record. Must be an existing data record that is an attachment type.
         :param file_name: The name of the attachment.
         :param file_bytes: The bytes of the attachment data.
@@ -45,24 +45,23 @@ class AttachmentUtil:
             raise SapioException("Provided record cannot have its attachment data set, as it does not exist in the "
                                  "system yet.")
         attachment = AliasUtil.to_data_record(attachment)
+        dr_man = DataMgmtServer.get_data_record_manager(AliasUtil.to_sapio_user(context))
         with io.BytesIO(file_bytes) as stream:
-            context.data_record_manager.set_attachment_data(attachment, file_name, stream)
+            dr_man.set_attachment_data(attachment, file_name, stream)
 
     @staticmethod
-    def create_attachment(context: SapioWebhookContext, file_name: str, file_bytes: bytes,
+    def create_attachment(context: UserIdentifier, file_name: str, file_bytes: bytes,
                           wrapper_type: type[WrappedType]) -> WrappedType:
         """
         Create an attachment data type and initialize its attachment bytes at the same time.
         Makes a webservice call to create the attachment record and a second to set its bytes.
 
-        :param context: The current webhook context.
+        :param context: The current webhook context or a user object to send requests from.
         :param file_name: The name of the attachment.
         :param file_bytes: THe bytes of the attachment data.
         :param wrapper_type: The attachment type to create.
         :return: A record model for the newly created attachment.
         """
-        inst_man = RecordModelManager(context.user).instance_manager
-        attachment: DataRecord = context.data_record_manager.add_data_record(wrapper_type.DATA_TYPE_NAME)
-        attachment: WrappedType = inst_man.add_existing_record_of_type(attachment, wrapper_type)
+        attachment: WrappedType = RecordHandler(context).create_models(wrapper_type, 1)[0]
         AttachmentUtil.set_attachment_bytes(context, attachment, file_name, file_bytes)
         return attachment

sapiopycommons/datatype/data_fields.py

@@ -0,0 +1,61 @@
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrapperField
+
+
+class SystemFields:
+    RECORD_ID__FIELD = WrapperField("RecordId", FieldType.LONG)
+    DATA_RECORD_NAME__FIELD = WrapperField("DataRecordName", FieldType.IDENTIFIER)
+    CREATED_BY__FIELD = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD = WrapperField("DateCreated", FieldType.DATE)
+    LAST_MODIFIED_BY__FIELD = WrapperField("VeloxLastModifiedBy", FieldType.STRING)
+    LAST_MODIFIED_DATE__FIELD = WrapperField("VeloxLastModifiedDate", FieldType.DATE)
+
+
+class ProcessQueueItemFields:
+    DATA_TYPE_NAME: str = 'ProcessQueueItem'
+    ASSIGNED_TO__FIELD = WrapperField('AssignedTo', FieldType.SELECTION)
+    DATA_RECORD_ID__FIELD = WrapperField('DataRecordId', FieldType.LONG)
+    DATA_TYPE_NAME__FIELD = WrapperField('DataTypeName', FieldType.STRING)
+    DURATION_IN_QUEUE__FIELD = WrapperField('DurationInQueue', FieldType.LONG)
+    EXPERIMENT__FIELD = WrapperField('Experiment', FieldType.SIDE_LINK)
+    LAUNCHED_DATE__FIELD = WrapperField('LaunchedDate', FieldType.DATE)
+    PROCESS_HEADER_NAME__FIELD = WrapperField('ProcessHeaderName', FieldType.STRING)
+    SCHEDULED_DATE__FIELD = WrapperField('ScheduledDate', FieldType.DATE)
+    SHOW_IN_QUEUE__FIELD = WrapperField('ShowInQueue', FieldType.BOOLEAN)
+    WORKFLOW_HEADER_NAME__FIELD = WrapperField('WorkflowHeaderName', FieldType.STRING)
+
+
+class ProcessWorkflowTrackingFields:
+    DATA_TYPE_NAME: str = 'ProcessWorkflowTracking'
+    ACTIVE_WORKFLOW_ID__FIELD = WrapperField("ActiveWorkflowId", FieldType.LONG)
+    BRANCH_LONG_ID__FIELD = WrapperField("BranchLongId", FieldType.LONG)
+    END_DATE__FIELD = WrapperField("EndDate", FieldType.DATE)
+    END_HOUR__FIELD = WrapperField("EndHour", FieldType.LONG)
+    END_MINUTE_TIME__FIELD = WrapperField("EndMinuteTime", FieldType.LONG)
+    EXPECTED_QUEUE_TIME__FIELD = WrapperField("ExpectedQueueTime", FieldType.DOUBLE)
+    EXPECTED_TAT__FIELD = WrapperField("ExpectedTAT", FieldType.DOUBLE)
+    PROCESS_QUEUE_ITEM__FIELD = WrapperField("ProcessQueueItem", FieldType.SIDE_LINK)
+    PROCESS_STEP_NUMBER__FIELD = WrapperField("ProcessStepNumber", FieldType.LONG)
+    QUEUED_HOURS__FIELD = WrapperField("QueuedHours", FieldType.LONG)
+    QUEUED_MINUTES__FIELD = WrapperField("QueuedMinutes", FieldType.LONG)
+    QUEUED_TIME__FIELD = WrapperField("QueuedTime", FieldType.DOUBLE)
+    QUEUE_START_DATE__FIELD = WrapperField("QueueStartDate", FieldType.DATE)
+    QUEUE_START_HOUR__FIELD = WrapperField("QueueStartHour", FieldType.LONG)
+    QUEUE_START_MINUTE_TIME__FIELD = WrapperField("QueueStartMinuteTime", FieldType.LONG)
+    SAMPLE_RECORD_ID__FIELD = WrapperField("SampleRecordId", FieldType.LONG)
+    START_DATE__FIELD = WrapperField("StartDate", FieldType.DATE)
+    START_HOUR__FIELD = WrapperField("StartHour", FieldType.LONG)
+    START_MINUTE_TIME__FIELD = WrapperField("StartMinuteTime", FieldType.LONG)
+    STATUS__FIELD = WrapperField("Status", FieldType.PICKLIST)
+    TURN_AROUND_HOURS__FIELD = WrapperField("TurnAroundHours", FieldType.LONG)
+    TURN_AROUND_MINUTES__FIELD = WrapperField("TurnAroundMinutes", FieldType.LONG)
+    WORKFLOW_END_USER_ID__FIELD = WrapperField("WorkflowEndUserId", FieldType.STRING)
+    WORKFLOW_EXPECTED_QUEUE_TIME__FIELD = WrapperField("WorkflowExpectedQueueTime", FieldType.STRING)
+    WORKFLOW_EXPECTED_TAT__FIELD = WrapperField("WorkflowExpectedTAT", FieldType.STRING)
+    WORKFLOW_EXPECTED_TOTAL_TAT__FIELD = WrapperField("WorkflowExpectedTotalTAT", FieldType.DOUBLE)
+    WORKFLOW_ID_NUMBER__FIELD = WrapperField("WorkflowIdNumber", FieldType.LONG)
+    WORKFLOW_NAME__FIELD = WrapperField("WorkflowName", FieldType.STRING)
+    WORKFLOW_PROCESS_TAT__FIELD = WrapperField("WorkflowProcessTAT", FieldType.DOUBLE)
+    WORKFLOW_START_USER_ID__FIELD = WrapperField("WorkflowStartUserId", FieldType.STRING)
+    WORKFLOW_TAT__FIELD = WrapperField("WorkflowTAT", FieldType.DOUBLE)
+    WORKFLOW_VERSION__FIELD = WrapperField("WorkflowVersion", FieldType.LONG)