Class UserInfoEngine

Overridable property to set the debounce time for entity events. Default is 1500 milliseconds (1.5 seconds). This debounce time is used when immediate array mutations cannot be applied (e.g., when Filter, OrderBy, or AdditionalLoading overrides are present) and a full view refresh is required.

Note: When immediate mutations ARE possible (no Filter, OrderBy, or AdditionalLoading override), updates happen synchronously without any debounce delay.

Subclasses can override this method to perform additional loading tasks

This method handles the debouncing process, by default using the EntityEventDebounceTime property to set the debounce time. Debouncing is done on a per-entity basis, meaning that if the debounce time passes for a specific entity name, the event will be processed. This is done to prevent multiple events from being processed in quick succession for a single entity which would cause a lot of wasted processing.

Override this method if you want to change how debouncing time such as having variable debounce times per-entity, etc.

This method handles the individual base entity event. For events that can use immediate array mutations (no Filter, OrderBy, or AdditionalLoading override), processing happens synchronously without debounce. For events that require full view refresh, debouncing is applied to batch rapid successive changes.

Override this method if you want to have a different handling for the filtering of events that are debounced or if you don't want to debounce at all you can do that in an override of this method.

Subclasses of BaseEngine can override this method to handle individual MJGlobal events. This is typically done to optimize the way refreshes are done when a BaseEntity is updated. If you are interested in only BaseEntity events, override the HandleIndividualBaseEntityEvent method instead as this method primarily serves to filter all the events we get from MJGlobal and only pass on BaseEntity events to HandleIndividualBaseEntityEvent.

Handles the result of a single view load.

This method should be called by sub-classes to load up their specific metadata requirements. For more complex metadata loading or for post-processing of metadata loading done here, overide the AdditionalLoading method to add your logic.

Loads the specified metadata configurations.

Handles the process of loading multiple entity configs in a single network call via RunViews()

Loads a single metadata configuration.

Handles the process of loading a single config of type 'dataset'.

Handles the process of loading a single config of type 'entity'.

Notify listeners that a data property has changed. Called automatically by HandleSingleViewResult after data refresh and by applyImmediateMutation for array operations. Subclasses can also call this manually when modifying data arrays directly.

This method does the actual work of processing the entity event. It is not directly called from the event handler because we want to first debounce the events which also introduces a delay which is usually desirable so that our processing is typically outside of the scope of any transaction processing that would have originated the event.

This is the best method to override if you want to change the actual processing of an entity event but do NOT want to modify the debouncing behavior.

Internal method to set the provider when an engine is loaded

This method is responsible for registering for MJGlobal events and listening for BaseEntity events where those BaseEntity are related to the engine's configuration metadata. The idea is to auto-refresh the releated configs when the BaseEntity is updated.

Helper method for sub-classes to have a single line of code that will make sure the data is loaded before proceeding and will throw an error if not loaded.

Utility method to upgrade an object to a BaseEnginePropertyConfig object.

Applies an immediate array mutation based on the entity event type. This is faster than running a full view refresh for simple add/update/delete operations.

Determines if an immediate array mutation can be used instead of running a full view refresh. Immediate mutations are only safe when:

1. The config has no Filter (no server-side filtering that might exclude the entity)
2. The config has no OrderBy (no server-side ordering that would need to be maintained)
3. The subclass has not overridden AdditionalLoading (no post-processing that depends on full data)

Finds an entity in the array by matching all primary key columns. Supports composite primary keys by comparing all PrimaryKey fields from EntityInfo.

Checks if the current instance has overridden the AdditionalLoading method. We do this by comparing the method to the base class's method.

Checks if the exact entity object reference is already in the config's data array. Used to skip unnecessary refreshes for UPDATE events where the object was mutated in place.

Checks if an entity is in the config's data array by object reference OR by primary key match. Used for DELETE events where we need to know if the entity still exists in the array. The object reference may still exist (entity.Delete() just marks it deleted), but if it was manually spliced out by engine code, we check by primary key as fallback.

Returns the singleton instance of the class. If the instance does not exist, it is created and stored in the Global Object Store. If className is provided it will be used as part of the key in the Global Object Store, otherwise the actual class name will be used. NOTE: the class name used by default is the lowest level of the object hierarchy, so if you have a class that extends another class, the lowest level class name will be used.