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

sapiopycommons/callbacks/callback_util.py

@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 import io
-from weakref import WeakValueDictionary
+from typing import Any
 
 from sapiopylib.rest.ClientCallbackService import ClientCallback
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
@@ -11,21 +9,20 @@ from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.datatype.DataType import DataTypeDefinition
 from sapiopylib.rest.pojo.datatype.DataTypeLayout import DataTypeLayout
 from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition, VeloxStringFieldDefinition, \
-    VeloxIntegerFieldDefinition, VeloxDoubleFieldDefinition, FieldDefinitionParser
+    VeloxIntegerFieldDefinition, VeloxDoubleFieldDefinition
 from sapiopylib.rest.pojo.webhook.ClientCallbackRequest import OptionDialogRequest, ListDialogRequest, \
     FormEntryDialogRequest, InputDialogCriteria, TableEntryDialogRequest, ESigningRequestPojo, \
-    DataRecordDialogRequest, InputSelectionRequest, FilePromptRequest, MultiFilePromptRequest, \
-    TempTableSelectionRequest, DisplayPopupRequest, PopupType
+    DataRecordSelectionRequest, DataRecordDialogRequest, InputSelectionRequest, FilePromptRequest, \
+    MultiFilePromptRequest
 from sapiopylib.rest.pojo.webhook.ClientCallbackResult import ESigningResponsePojo
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.pojo.webhook.WebhookEnums import FormAccessLevel, ScanToSelectCriteria, SearchType
 from sapiopylib.rest.utils.DataTypeCacheManager import DataTypeCacheManager
 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, FieldValue, \
-    UserIdentifier
+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
 from sapiopycommons.recordmodel.record_handler import RecordHandler
@@ -38,86 +35,26 @@ class CallbackUtil:
     width_pixels: int | None
     width_percent: float | None
 
-    __instances: WeakValueDictionary[SapioUser, CallbackUtil] = WeakValueDictionary()
-    __initialized: bool
-
-    def __new__(cls, context: UserIdentifier):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        """
-        user = AliasUtil.to_sapio_user(context)
-        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: UserIdentifier):
+    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 = AliasUtil.to_sapio_user(context)
+        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 = None, width_percent: float | None = None):
+    def set_dialog_width(self, width_pixels: int | None, width_percent: float | None):
         """
         Set the width that dialogs will appear as for those dialogs that support specifying their width.
 
         :param width_pixels: The number of pixels wide that dialogs will appear as.
-        :param width_percent: The percentage (as a value between 0 and 1) of the client's screen width that dialogs
-            will appear as.
+        :param width_percent: The percentage 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
-
-    def toaster_popup(self, message: str, title: str = "", popup_type: PopupType = PopupType.Info) -> None:
-        """
-        Display a toaster popup in the bottom right corner of the user's screen.
-
-        :param message: The message to display in the toaster.
-        :param title: The title to display at the top of the toaster.
-        :param popup_type: The popup type to use for the toaster. This controls the color that the toaster appears with.
-            Info is blue, Success is green, Warning is yellow, and Error is red
-        """
-        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:
         """
@@ -132,8 +69,7 @@ class CallbackUtil:
             SapioUserCancelledException is thrown.
         :return: The name of the button that the user selected.
         """
-        request = OptionDialogRequest(title, msg, options, default_option, user_can_cancel,
-                                      width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = OptionDialogRequest(title, msg, options, default_option, user_can_cancel)
         response: int | None = self.callback.show_option_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
@@ -173,20 +109,16 @@ class CallbackUtil:
         """
         return self.option_dialog(title, msg, ["Yes", "No"], 0 if default_yes else 1, False) == "Yes"
 
-    def list_dialog(self, title: str, options: list[str], multi_select: bool = False,
-                    preselected_values: list[str] | None = None) -> list[str]:
+    def list_dialog(self, title: str, options: list[str], multi_select: bool = False) -> list[str]:
         """
         Create a list dialog with the given options for the user to choose from.
 
         :param title: The title of the dialog.
         :param options: The list options that the user has to choose from.
         :param multi_select: Whether the user is able to select multiple options from the list.
-        :param preselected_values: A list of values that will already be selected when the list dialog is created. The
-            user can unselect these values if they want to.
         :return: The list of options that the user selected.
         """
-        request = ListDialogRequest(title, multi_select, options, preselected_values,
-                                    width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = ListDialogRequest(title, multi_select, options)
         response: list[str] | None = self.callback.show_list_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
@@ -229,6 +161,8 @@ class CallbackUtil:
         builder = FormBuilder(data_type, display_name, plural_display_name)
         for field_def in fields:
             field_name = field_def.data_field_name
+            if values and hasattr(field_def, "default_value"):
+                field_def.default_value = values.get(field_name)
             column: int = 0
             span: int = 4
             if column_positions and field_name in column_positions:
@@ -237,8 +171,7 @@ class CallbackUtil:
                 span = position[1]
             builder.add_field(field_def, column, span)
 
-        request = FormEntryDialogRequest(title, msg, builder.get_temporary_data_type(), values,
-                                         width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = FormEntryDialogRequest(title, msg, builder.get_temporary_data_type())
         response: FieldMap | None = self.callback.show_form_entry_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
@@ -276,33 +209,32 @@ class CallbackUtil:
         type_def: DataTypeDefinition = self.dt_cache.get_data_type(data_type)
         field_defs: dict[str, AbstractVeloxFieldDefinition] = self.dt_cache.get_fields_for_type(data_type)
 
-        # Make everything visible, because presumably the caller gave a field name because they want it to be seen.
-        modifier = FieldModifier(visible=True, editable=editable)
-
         # Build the form using only those fields that are desired.
-        values: dict[str, FieldValue] = {}
         builder = FormBuilder(data_type, type_def.display_name, type_def.plural_display_name)
         for field_name in fields:
             field_def = field_defs.get(field_name)
             if field_def is None:
                 raise SapioException(f"No field of name \"{field_name}\" in field definitions of type \"{data_type}\"")
-            values[field_name] = record.get_field_value(field_name)
+            if editable is not None:
+                field_def.editable = editable
+            field_def.visible = True
+            if hasattr(field_def, "default_value"):
+                field_def.default_value = record.get_field_value(field_name)
             column: int = 0
             span: int = 4
             if column_positions and field_name in column_positions:
                 position = column_positions.get(field_name)
                 column = position[0]
                 span = position[1]
-            builder.add_field(modifier.modify_field(field_def), column, span)
+            builder.add_field(field_def, column, span)
 
-        request = FormEntryDialogRequest(title, msg, builder.get_temporary_data_type(), values,
-                                         width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = FormEntryDialogRequest(title, msg, builder.get_temporary_data_type())
         response: FieldMap | None = self.callback.show_form_entry_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
         return response
 
-    def input_dialog(self, title: str, msg: str, field: AbstractVeloxFieldDefinition) -> FieldValue:
+    def input_dialog(self, title: str, msg: str, field: AbstractVeloxFieldDefinition) -> Any:
         """
         Create an input dialog where the user must input data for a singular field.
 
@@ -311,9 +243,8 @@ class CallbackUtil:
         :param field: The definition for a field that the user must provide input to.
         :return: The response value from the user for the given field.
         """
-        request = InputDialogCriteria(title, msg, field,
-                                      width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: FieldValue | None = self.callback.show_input_dialog(request)
+        request = InputDialogCriteria(title, msg, field, self.width_pixels, self.width_percent)
+        response: Any | None = self.callback.show_input_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
         return response
@@ -328,7 +259,7 @@ class CallbackUtil:
         :param field_name: The name and display name of the string field.
         :param default_value: The default value to place into the string field, if any.
         :param max_length: The max length of the string value. If not provided, uses the length of the default value.
-            If neither this nor a default value are provided, defaults to 100 characters.
+            If neither this or a default value are not provided, defaults to 100 characters.
         :param editable: Whether the field is editable by the user.
         :param kwargs: Any additional keyword arguments to pass to the field definition.
         :return: The string that the user input into the dialog.
@@ -389,8 +320,6 @@ class CallbackUtil:
                      msg: str,
                      fields: list[AbstractVeloxFieldDefinition],
                      values: list[FieldMap],
-                     group_by: str | None = None,
-                     image_data: list[bytes] | None = None,
                      *,
                      data_type: str = "Default",
                      display_name: str | None = None,
@@ -404,10 +333,6 @@ class CallbackUtil:
         :param fields: The definitions of the fields to display as table columns. Fields will be displayed in the order
             they are provided in this list.
         :param values: The values to set for each row of the table.
-        :param group_by: If provided, the created table dialog will be grouped by the field with this name by default.
-            The user may remove this grouping if they want to.
-        :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
-            the image data list corresponds to the element at the same index in the values list.
         :param data_type: The data type name for the temporary data type that will be created for this table.
         :param display_name: The display name for the temporary data type. If not provided, defaults to the data type
             name.
@@ -421,17 +346,11 @@ class CallbackUtil:
         if plural_display_name is None:
             plural_display_name = display_name + "s"
 
-        # Key fields display their columns in order before all non-key fields.
-        # Unmark key fields so that the column order is respected exactly as the caller provides it.
-        modifier = FieldModifier(key_field=False)
-
         builder = FormBuilder(data_type, display_name, plural_display_name)
-        for field in fields:
-            builder.add_field(modifier.modify_field(field))
+        for column in fields:
+            builder.add_field(column)
 
-        request = TableEntryDialogRequest(title, msg, builder.get_temporary_data_type(), values,
-                                          record_image_data_list=image_data, group_by_field=group_by,
-                                          width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = TableEntryDialogRequest(title, msg, builder.get_temporary_data_type(), values)
         response: list[FieldMap] | None = self.callback.show_table_entry_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
@@ -442,14 +361,11 @@ class CallbackUtil:
                             msg: str,
                             fields: list[str],
                             records: list[SapioRecord],
-                            editable: bool | None = True,
-                            group_by: str | None = None,
-                            image_data: list[bytes] | None = None) -> list[FieldMap]:
+                            editable: bool | None = True) -> list[FieldMap]:
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
-        a given list of records of a singular type. Provided field names must match fields on the definition of the data
-        type of the given records. The fields that are displayed will have their default value be that of the fields on
-        the given records.
+        a given list of records. Provided field names must match fields on the definition of the data type of the given
+        records. The fields that are displayed will have their default value be that of the fields on the given records.
 
         Makes webservice calls to get the data type definition and fields of the given records if they weren't
         previously cached.
@@ -461,10 +377,6 @@ class CallbackUtil:
             they are provided in this list.
         :param editable: If true, all fields are displayed as editable. If false, all fields are displayed as
             uneditable. If none, only those fields that are defined as editable by the data designer will be editable.
-        :param group_by: If provided, the created table dialog will be grouped by the field with this name by default.
-            The user may remove this grouping if they want to.
-        :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
-            the image data list corresponds to the element at the same index in the records list.
         :return: A list of dictionaries mapping the data field names of the given field definitions to the response
             value from the user for that field for each row.
         """
@@ -478,180 +390,21 @@ class CallbackUtil:
         type_def: DataTypeDefinition = self.dt_cache.get_data_type(data_type)
         field_defs: dict[str, AbstractVeloxFieldDefinition] = self.dt_cache.get_fields_for_type(data_type)
 
-        # Key fields display their columns in order before all non-key fields.
-        # Unmark key fields so that the column order is respected exactly as the caller provides it.
-        # Also make everything visible, because presumably the caller gave a field name because they want it to be seen.
-        modifier = FieldModifier(visible=True, key_field=False, editable=editable)
-
         # Build the form using only those fields that are desired.
         builder = FormBuilder(data_type, type_def.display_name, type_def.plural_display_name)
         for field_name in fields:
             field_def = field_defs.get(field_name)
             if field_def is None:
                 raise SapioException(f"No field of name \"{field_name}\" in field definitions of type \"{data_type}\"")
-            builder.add_field(modifier.modify_field(field_def))
-
-        request = TableEntryDialogRequest(title, msg, builder.get_temporary_data_type(), field_map_list,
-                                          record_image_data_list=image_data, group_by_field=group_by,
-                                          width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: list[FieldMap] | None = self.callback.show_table_entry_dialog(request)
-        if response is None:
-            raise SapioUserCancelledException()
-        return response
-
-    def multi_type_table_dialog(self,
-                                title: str,
-                                msg: str,
-                                fields: list[(str, str) | AbstractVeloxFieldDefinition],
-                                row_contents: list[list[SapioRecord | FieldMap]],
-                                *,
-                                default_modifier: FieldModifier | None = None,
-                                field_modifiers: dict[str, FieldModifier] | None = None,
-                                data_type: str = "Default",
-                                display_name: str | None = None,
-                                plural_display_name: str | None = None) -> list[FieldMap]:
-        """
-        Create a table dialog where the user may input data into the fields of the table. The table is constructed from
-        a given list of records of multiple data types or field maps. Provided field names must match with field names
-        from the data type definition of the given records. The fields that are displayed will have their default value
-        be that of the fields on the given records or field maps.
-
-        Makes webservice calls to get the data type field definitions of the given records if they weren't
-        previously cached.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog.
-        :param fields: A list of objects representing the fields in the table. This could either be a two-element tuple
-            where the first element is a data type name and the second is a field name, or it could be a field
-            definition. If it is the former, a query will be made to find the field definition matching tht data type.
-            The data type names of the fields must match the data type names of the records in the row contents.
-            See the description of row_contents for what to do if you want to construct a field that pulls from a field
-            map.
-            If two fields share the same field name, an exception will be thrown. This is even true in the case where
-            the data type name of the fields is different. If you wish to display two fields from two data types with
-            the same name, then you must provide a FieldModifier for at least one of the fields where prepend_data_type
-            is True in order to make that field's name unique again. Note that if you do this for a field, the mapping
-            of record to field name will use the unedited field name, but the return results of this function will
-            use the edited field name in the results dictionary for a row.
-        :param row_contents: A list where each element is another list representing the records or a field map that will
-            be used to populate the columns of the table. If the data type of a given record doesn't match any of the
-            data type names of the given fields, then it will not be used.
-            This list can contain up to one field map, which are fields not tied to a record. This is so that you can
-            create abstract field definition not tied to a specific record in the system. If you want to define an
-            abstract field that pulls from the field map in the row contents, then you must set the data type name to
-            Default.
-            If a record of a given data type appears more than once in one of the inner-lists of the row contents, or
-            there is more than one field map, then an exception will be thrown, as there is no way of distinguishing
-            which record should be used for a field, and not all fields could have their values combined across multiple
-            records.
-            The row contents may have an inner-list which is missing a record of a data type that matches one of the
-            fields. In this case, the field value for that row under that column will be null.
-            The inner-list does not need to be sorted in any way, as this function will map the inner-list contents to
-            fields as necessary.
-            The inner-list may contain null elements; these will simply be discarded by this function.
-        :param default_modifier: A default field modifier that will be applied to the given fields. This can be used to
-            make field definitions from the system behave differently than their system values. If this value is None,
-            then a default field modifier is created that causes all specified fields to be both visible and not key
-            fields. (Key fields get displayed first before any non-key fields in tables, so the key field setting is
-            disabled by default in order to have the columns in the table respect the order of the fields as they are
-            provided to this function.)
-        :param field_modifiers: A mapping of data field name to field modifier for changes that should be applied to
-            the matching field. If a data field name is not present in the provided dict, or the provided dictionary is
-            None, then the default modifier will be used.
-        :param data_type: The data type name for the temporary data type that will be created for this table.
-        :param display_name: The display name for the temporary data type. If not provided, defaults to the data type
-            name.
-        :param plural_display_name: The plural display name for the temporary data type. If not provided, defaults to
-            the display name + "s".
-        :return: A list of dictionaries mapping the data field names of the given field definitions to the response
-            value from the user for that field for each row.
-        """
-        # Set the default modifier to make all fields visible and not key if no default was provided.
-        if default_modifier is None:
-            default_modifier = FieldModifier(visible=True, key_field=False)
-        # To make things simpler, treat null field modifiers as an empty dict.
-        if field_modifiers is None:
-            field_modifiers = {}
-
-        # Construct the final fields list from the possible field objects.
-        final_fields: list[AbstractVeloxFieldDefinition] = []
-        # Keep track of whether any given field name appears more than once, as two fields could have the same
-        # field name but different data types. In this case, the user should provide a field modifier or field
-        # definition that changes one of the field names.
-        field_names: list[str] = []
-        for field in fields:
-            # Find the field definition for this field object.
-            if isinstance(field, tuple):
-                field_def: AbstractVeloxFieldDefinition = self.dt_cache.get_fields_for_type(field[0]).get(field[1])
-            elif isinstance(field, AbstractVeloxFieldDefinition):
-                field_def: AbstractVeloxFieldDefinition = field
-            else:
-                raise SapioException("Unrecognized field object.")
-
-            # Locate the modifier for this field and store the modified field.
-            name: str = field_def.data_field_name
-            modifier: FieldModifier = field_modifiers.get(name, default_modifier)
-            field_def: AbstractVeloxFieldDefinition = modifier.modify_field(field_def)
-            final_fields.append(field_def)
-
-            # Verify that this field name isn't a duplicate.
-            # The field name may have changed due to the modifier.
-            name: str = field_def.data_field_name
-            if name in field_names:
-                raise SapioException(f"The field name \"{name}\" appears more than once in the given fields. "
-                                     f"If you have provided two fields with the same name but different data types, "
-                                     f"consider providing a FieldModifier where prepend_data_type is true for one of "
-                                     f"the fields so that the field names will be different.")
-            field_names.append(name)
-
-        # Get the values for each row.
-        values: list[dict[str, FieldValue]] = []
-        for row in row_contents:
-            # The final values for this row:
-            row_values: dict[str, FieldValue] = {}
-
-            # Map the records for this row by their data type. If a field map is provided, its data type is Default.
-            row_records: dict[str, SapioRecord | FieldMap] = {}
-            for rec in row:
-                # Toss out null elements.
-                if rec is None:
-                    continue
-                # Map records to their data type name. Map field maps to Default.
-                dt: str = "Default" if isinstance(rec, dict) else rec.data_type_name
-                # Warn if the same data type name appears more than once.
-                if dt in row_records:
-                    raise SapioException(f"The data type \"{dt}\" appears more than once in the given row contents.")
-                row_records[dt] = rec
-
-            # Get the field values from the above records.
-            for field in final_fields:
-                # Find the object that corresponds to this field given its data type name.
-                record: SapioRecord | FieldMap | None = row_records.get(field.data_type_name)
-                # This could be either a record, a field map, or null. Convert any records to field maps.
-                if not isinstance(record, dict) and record is not None:
-                    record: FieldMap | None = AliasUtil.to_field_map_lists([record])[0]
-
-                # Find out if this field had its data type prepended to it. If this is the case, then we need to find
-                # the true data field name before retrieving the value from the field map.
-                name: str = field.data_field_name
-                if field_modifiers.get(name, default_modifier).prepend_data_type is True:
-                    name = name.split(".")[1]
-
-                # Set the value for this particular field.
-                row_values[field.data_field_name] = record.get(name) if record else None
-            values.append(row_values)
-
-        if display_name is None:
-            display_name = data_type
-        if plural_display_name is None:
-            plural_display_name = display_name + "s"
-
-        builder = FormBuilder(data_type, display_name, plural_display_name)
-        for field in final_fields:
-            builder.add_field(field)
-
-        request = TableEntryDialogRequest(title, msg, builder.get_temporary_data_type(), values,
-                                          width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+            if editable is not None:
+                field_def.editable = editable
+            field_def.visible = True
+            # Key fields display their columns in order before all non-key fields.
+            # Unmark key fields so that the column order is respected exactly as the caller provides it.
+            field_def.key_field = False
+            builder.add_field(field_def)
+
+        request = TableEntryDialogRequest(title, msg, builder.get_temporary_data_type(), field_map_list)
         response: list[FieldMap] | None = self.callback.show_table_entry_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
@@ -700,8 +453,7 @@ class CallbackUtil:
                 raise SapioException(f"The data type \"{data_type}\" does not have a layout by the name "
                                      f"\"{layout_name}\" in the system.")
 
-        request = DataRecordDialogRequest(title, record, layout, minimized, access_level, plugin_path_list,
-                                          width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = DataRecordDialogRequest(title, record, layout, minimized, access_level, plugin_path_list)
         response: bool = self.callback.data_record_form_view_dialog(request)
         if not response:
             raise SapioUserCancelledException()
@@ -712,8 +464,7 @@ class CallbackUtil:
                          values: list[FieldMap],
                          multi_select: bool = True,
                          *,
-                         data_type: str = "Default",
-                         display_name: str | None = None,
+                         display_name: str = "Default",
                          plural_display_name: str | None = None) -> list[FieldMap]:
         """
         Create a selection dialog for a list of field maps for the user to choose from. Requires that the caller
@@ -724,31 +475,24 @@ class CallbackUtil:
             they are provided in this list.
         :param values: The values to set for each row of the table.
         :param multi_select: Whether the user is able to select multiple rows from the list.
-        :param data_type: The data type name for the temporary data type that will be created for this table.
-        :param display_name: The display name for the temporary data type. If not provided, defaults to the data type
-            name.
+        :param display_name: The display name for the temporary data type that will be created.
         :param plural_display_name: The plural display name for the temporary data type. If not provided, defaults to
             the display name + "s".
         :return: A list of field maps corresponding to the chosen input field maps.
         """
-        if display_name is None:
-            display_name = data_type
         if plural_display_name is None:
             plural_display_name = display_name + "s"
 
-        builder = FormBuilder(data_type, display_name, plural_display_name)
-        for field in fields:
-            builder.add_field(field)
-
-        request = TempTableSelectionRequest(builder.get_temporary_data_type(), msg, values,
-                                            multi_select=multi_select)
-        response: list[FieldMap] | None = self.callback.show_temp_table_selection_dialog(request)
+        # Build the form using only those fields that are desired.
+        request = DataRecordSelectionRequest(display_name, plural_display_name,
+                                             fields, values, msg, multi_select)
+        response: list[FieldMap] | None = self.callback.show_data_record_selection_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
         return response
     
     def record_selection_dialog(self, msg: str, fields: list[str], records: list[SapioRecord],
-                                multi_select: bool = True) -> list[SapioRecord]:
+                                multi_select: bool = True) -> list[FieldMap]:
         """
         Create a record selection dialog for a list of records for the user to choose from. Provided field names must
         match fields on the definition of the data type of the given records.
@@ -761,7 +505,7 @@ class CallbackUtil:
             they are provided in this list.
         :param records: The records to display as rows in the table.
         :param multi_select: Whether the user is able to select multiple records from the list.
-        :return: A list of the selected records.
+        :return: A list of field maps corresponding to the chosen input records.
         """
         data_types: set[str] = {x.data_type_name for x in records}
         if len(data_types) > 1:
@@ -777,22 +521,21 @@ class CallbackUtil:
         type_def: DataTypeDefinition = self.dt_cache.get_data_type(data_type)
         field_defs: dict[str, AbstractVeloxFieldDefinition] = self.dt_cache.get_fields_for_type(data_type)
 
-        # Key fields display their columns in order before all non-key fields.
-        # Unmark key fields so that the column order is respected exactly as the caller provides it.
-        # Also make everything visible, because presumably the caller give a field name because they want it to be seen.
-        modifier = FieldModifier(visible=True, key_field=False)
-
         # Build the form using only those fields that are desired.
-        builder = FormBuilder(data_type, type_def.display_name, type_def.plural_display_name)
+        field_def_list: list = []
         for field_name in fields:
             field_def = field_defs.get(field_name)
             if field_def is None:
                 raise SapioException(f"No field of name \"{field_name}\" in field definitions of type \"{data_type}\"")
-            builder.add_field(modifier.modify_field(field_def))
-
-        request = TempTableSelectionRequest(builder.get_temporary_data_type(), msg, field_map_list,
-                                            multi_select=multi_select)
-        response: list[FieldMap] | None = self.callback.show_temp_table_selection_dialog(request)
+            field_def.visible = True
+            # Key fields display their columns in order before all non-key fields.
+            # Unmark key fields so that the column order is respected exactly as the caller provides it.
+            field_def.key_field = False
+            field_def_list.append(field_def)
+
+        request = DataRecordSelectionRequest(type_def.display_name, type_def.plural_display_name,
+                                             field_def_list, field_map_list, msg, multi_select)
+        response: list[FieldMap] | None = self.callback.show_data_record_selection_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
         # Map the field maps in the response back to the record they come from, returning the chosen record instead of
@@ -859,7 +602,7 @@ class CallbackUtil:
 
         # If CustomReportCriteria was provided, it must be wrapped as a CustomReport.
         if isinstance(custom_search, CustomReportCriteria):
-            custom_search: CustomReport = CustomReport(False, [], custom_search)
+            custom_search: CustomReport = CustomReport(False, None, 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):
@@ -892,15 +635,14 @@ class CallbackUtil:
             for field in additional_fields:
                 builder.add_field(field)
             temp_dt = builder.get_temporary_data_type()
-        request = ESigningRequestPojo(title, msg, show_comment, temp_dt,
-                                      width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        request = ESigningRequestPojo(title, msg, show_comment, temp_dt)
         response: ESigningResponsePojo | None = self.callback.show_esign_dialog(request)
         if response is None:
             raise SapioUserCancelledException()
         return response
 
     def request_file(self, title: str, exts: list[str] | None = None,
-                     show_image_editor: bool = False, show_camera_button: bool = False) -> tuple[str, bytes]:
+                     show_image_editor: bool = False, show_camera_button: bool = False) -> (str, bytes):
         """
         Request a single file from the user.
 
@@ -933,7 +675,7 @@ class CallbackUtil:
         return file_path, sink.data
 
     def request_files(self, title: str, exts: list[str] | None = None,
-                      show_image_editor: bool = False, show_camera_button: bool = False) -> dict[str, bytes]:
+                      show_image_editor: bool = False, show_camera_button: bool = False):
         """
         Request multiple files from the user.
 
@@ -964,7 +706,7 @@ class CallbackUtil:
         return ret_dict
 
     @staticmethod
-    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: list[str]) -> None:
+    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: list[str]):
         """
         Verify that the provided file was read (i.e. the file path and file bytes aren't None or empty) and that it
         has the correct file extension. Raises a user error exception if something about the file is incorrect.
@@ -978,7 +720,7 @@ class CallbackUtil:
         if len(allowed_extensions) != 0:
             matches: bool = False
             for ext in allowed_extensions:
-                if file_path.endswith("." + ext.lstrip(".")):
+                if file_path.endswith("." + ext):
                     matches = True
                     break
             if matches is False:
@@ -992,85 +734,5 @@ class CallbackUtil:
         :param file_name: The name of the file.
         :param file_data: The data of the file, provided as either a string or as a bytes array.
         """
-        data = io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data)
+        data = io.StringIO(file_data) if isinstance(file_data, str) else io.BytesIO(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:
-    """
-    A FieldModifier can be used to update the settings of a field definition from the system.
-    """
-    prepend_data_type: bool
-    display_name: str | None
-    required: bool | None
-    editable: bool | None
-    visible: bool | None
-    key_field: bool | None
-    column_width: int | None
-
-    def __init__(self, *, prepend_data_type: bool = False,
-                 display_name: str | None = None, required: bool | None = None, editable: bool | None = None,
-                 visible: bool | None = None, key_field: bool | None = None, column_width: int | None = None):
-        """
-        If any values are given as None then that value will not be changed on the given field.
-
-        :param prepend_data_type: If true, prepends the data type name of the field to the data field name. For example,
-            if a field has a data type name X and a data field name Y, then the field name would become "X.Y". This is
-            useful for cases where you have the same field name on two different data types and want to distinguish one
-            or both of them.
-        :param display_name: Change the display name.
-        :param required: Change the required status.
-        :param editable: Change the editable status.
-        :param visible: Change the visible status.
-        :param key_field: Change the key field status.
-        :param column_width: Change the column width.
-        """
-        self.prepend_data_type = prepend_data_type
-        self.display_name = display_name
-        self.required = required
-        self.editable = editable
-        self.visible = visible
-        self.key_field = key_field
-        self.column_width = column_width
-
-    def modify_field(self, field: AbstractVeloxFieldDefinition) -> AbstractVeloxFieldDefinition:
-        """
-        Apply modifications to a given field.
-
-        :param field: The field to modify.
-        :return: A copy of the input field with the modifications applied.
-        """
-        field = copy_field(field)
-        if self.prepend_data_type is True:
-            field._data_field_name = field.data_field_name + "." + field.data_field_name
-        if self.display_name is not None:
-            field.display_name = self.display_name
-        if self.required is not None:
-            field.required = self.required
-        if self.editable is not None:
-            field.editable = self.editable
-        if self.visible is not None:
-            field.visible = self.visible
-        if self.key_field is not None:
-            field.key_field = self.key_field
-        if self.column_width is not None:
-            field.default_table_column_width = self.column_width
-        return field
-
-
-def copy_field(field: AbstractVeloxFieldDefinition) -> AbstractVeloxFieldDefinition:
-    """
-    Create a copy of a given field definition. This is used to modify field definitions from the server for existing
-    data types without also modifying the field definition in the cache.
-    """
-    return FieldDefinitionParser.to_field_definition(field.to_json())