All Classes and Interfaces
Class
Description
AbstractActionBindingImpl<H extends com.vaadin.flow.component.Component,A extends Action,C extends com.vaadin.flow.component.Component>
AbstractAssignActionInitTask<C extends com.vaadin.flow.component.Component>
Base class for events that contain information about
BackgroundTask.AbstractComboBoxLoader<T extends com.vaadin.flow.component.combobox.ComboBox<?>>
AbstractComponentDelegate<C extends com.vaadin.flow.component.Component>
AbstractComponentLoader<T extends com.vaadin.flow.component.Component>
AbstractContainerLoader<T extends com.vaadin.flow.component.Component>
AbstractDatabaseUserRepository<T extends org.springframework.security.core.userdetails.UserDetails>
Base implementation of
UserRepository that loads users from the database.AbstractDataViewDelegate<C extends com.vaadin.flow.component.Component & com.vaadin.flow.data.provider.HasDataView<V,?,?> & com.vaadin.flow.data.provider.HasListDataView<V,?> & SupportsDataProvider<V>,V>
AbstractDateTimeFieldDelegate<C extends com.vaadin.flow.component.AbstractField<?,V>,T extends Comparable,V>
AbstractDescriptionEditFragment<C extends com.vaadin.flow.component.Component>
AbstractDetailsLoader<C extends com.vaadin.flow.component.details.Details>
Base class of application events sent on entity operations.
Class containing a basic functionality of standard JSON transformer.
AbstractFilterComponentConverter<C extends com.vaadin.flow.component.Component & FilterComponent,M extends FilterCondition>
AbstractGridDelegate<C extends com.vaadin.flow.component.grid.Grid<E> & ListDataComponent<E> & EnhancedDataGrid<E> & HasActions,E,ITEMS extends DataGridItems<E>>
Contains information about metaClass, data container, loader, fetch plan.
AbstractHtmlComponentLoader<T extends com.vaadin.flow.component.HtmlComponent>
AbstractHtmlContainerLoader<T extends com.vaadin.flow.component.HtmlContainer>
Simplifies join expression generation depending on mapping type.
AbstractLayoutLoader<T extends com.vaadin.flow.component.Component & com.vaadin.flow.component.orderedlayout.ThemableLayout & com.vaadin.flow.component.orderedlayout.FlexComponent>
AbstractLdapUserDetailsSynchronizationStrategy<T extends org.springframework.security.core.userdetails.UserDetails>
A basic implementation of
LdapUserDetailsSynchronizationStrategy, which provides
a general functionality for user synchronization with UserRepository.AbstractLoginFormLoader<C extends com.vaadin.flow.component.login.AbstractLogin>
AbstractMultiSelectComboBoxLoader<C extends com.vaadin.flow.component.combobox.MultiSelectComboBox<?>>
AbstractShortcutActionBindingImpl<H extends com.vaadin.flow.component.Component,A extends Action,C extends com.vaadin.flow.component.Component>
AbstractTabsLoader<C extends com.vaadin.flow.component.Component & com.vaadin.flow.component.HasStyle & com.vaadin.flow.component.HasTheme & com.vaadin.flow.component.HasSize>
Abstract class for generating client files.
Base class for exception handlers determining their ability to handle an exception by its class name and optional
implementation of
AbstractUiExceptionHandler.canHandle(String, String, Throwable) method.This event is used to notify listeners about user invalidation: when the user has been deleted or disabled.
Main class for validators.
AbstractValueComponentDelegate<C extends com.vaadin.flow.component.Component & com.vaadin.flow.component.HasValue<?,V>,T,V>
Provides a fluent interface to configure navigation parameters and navigate to a
View.Provides the ability to store authorities on a
UserDetailsShould be implemented by the User entity to provide tenant id for current authentication.
Base interface of classes that make authorization decisions.
Marker interface for classes defining authorization points.
Exception that is raised on attempt to violate a security constraint.
Helps to track access control restrictions of the current user.
ActionBinder<H extends com.vaadin.flow.component.Component>
Factory to create actions declared as
ActionType.ActionsHolderBinding<H extends com.vaadin.flow.component.Component,A extends Action,C extends com.vaadin.flow.component.Component>
ActionsHolderBindingImpl<H extends com.vaadin.flow.component.Component,A extends Action,C extends com.vaadin.flow.component.Component>
An event listener that publishes a Spring application event when an activity is completed.
An event listener that publishes a Spring application event when an activity is started.
A number format that is used when the entity attribute has the
NumberFormat annotation.Defines additional business day in annotated business calendar (see
BusinessCalendar).Gathers information about additional business days for annotated business calendar.
Provides the additional criteria for the query.
Implementations of the interface are responsible for constructing a global
AuthenticationManager.Interface to be implemented by actions which may adjust
their 'enabled' state according to the view read-only mode.
Interface for listeners notified after transaction completion.
Defines the contract for handling of entities after they have been deleted or marked as deleted in DB.
Defines the contract for handling entities after they have been inserted into DB.
Defines the contract for handling of entities after they have been updated in DB.
Helper class that used to build
BusinessCalendar from class annotated with BusinessCalendar.Provider that builds and returns business calendars from classes annotated with
BusinessCalendar.Role provider that gets roles from classes annotated with
ResourceRole.Role provider that gets row level roles from classes annotated with
RowLevelRole.The
AnnotationLockDescriptorProvider creates and collects
LockDescriptor objects for locks annotated by PessimisticLock
annotation from data model objects.Controls how
AccessConstraints are used by JmixDataRepository.A default value.
A boolean default value.
A double default value.
An int default value.
A long default value.
Base class for entities that present application settings.
Exception indicating a failure during extraction of an archive file.
Strategy interface to Resolves method parameters by delegating to a list of registered
MethodArgumentResolvers.Event fired after resource server (registered by Authorization Server add-on) API controller call.
Event fired before resource server (registered by Authorization Server add-on) API call.
The purpose of the filter is to throw before- and after- events for resource server API invocations.
AssignDropdownButtonActionInitTask<C extends com.vaadin.flow.component.Component & DropdownButtonComponent>
An object describing changes in entity attributes.
INTERNAL.
Provides information about changes in entity attributes.
Class is used to display the attributes list in the
EntityAttributeResourcePolicyModelCreateView screen.Used for current time conversion from
Date to CreatedDate, LastModifiedDate and DeletedDate field types.Default implementation to support common types.
Provides information about current user for audit purposes -
Creatable, Updatable, SoftDelete entities and for Entity Log.
Class contains authentication information.
Annotation for bean methods which require authentication, i.e.
A resolver that provides
Locale if current authentication does not contain it.Interface is responsible for providing an instance of global
AuthenticationManager.Strategy for accessing root authentication from wrapped authentication in the current security context.
Token introspector that queries the backing store of tokens (authorization service) and fills the authenticated
principal authorities with proper roles depending on authorization grant type:
For AUTHORIZATION_CODE grant type, roles of authenticated user are used
For CLIENT_CREDENTIALS grant type, roles specified for the client in the properties file are used
Provider used when configuring HTTP web security for API endpoints (like REST, MVC controllers).
Class stores Jmix-specific settings of Authorization Server client.
Background task for execute by
BackgroundWorker.Listener of the task life cycle events, complementary to the tasks own methods:
BackgroundTask.progress(List), BackgroundTask.done(Object),
BackgroundTask.canceled().Task handler for
BackgroundTask.Event is published if the task does not handle timeout in
BackgroundTask.handleTimeoutException().Event is published if the
BackgroundTask.done(Object) throws an exception and executor
cannot handle it.Implementation of
BackgroundTaskWatchDog for BackgroundWorker.Entry point to
BackgroundTask execution functionality.Implementation of
BackgroundWorker.ClaimsRolesMapper that can be used as super-class for your own ClaimsRolesMapper implementations.Root interface of collection loaders.
Base implementation of sorting collection containers.
Base role provider that gets resource roles/row level roles from the database.
Used by enhancing process.
Abstract class implements the
OidcUserMapper and may be used for creating your own mappers.Allows resolving the current
Locale as method argument.Validator that applies JSR 303 rules for
HasValue instance.Defines the contract for handling entities right before they are attached to an EntityManager on merge operation.
Interface for listeners notified before transaction commit.
Defines the contract for handling of entities before they have been deleted or
marked as deleted in DB.
Defines the contract for handling entities right before they are detached from an EntityManager
on transaction commit.
Defines the contract for handling entities before they have been inserted into DB.
Defines the contract for handling of entities before they have been updated in DB.
Data binding state.
Handle images with format string: ${bitmap:100x100}
ImportBeanDefinitionRegistrar for Jmix data repositories autoconfigurationA bootstrap connector which establishes a connection to an OOo server.
A Bootstrap Connector which uses a socket to connect to an OOo server.
Performs checking for all requests which match with: /rest/bpm/process/**, rest/bpm/dmn/** because they should be
available only for authenticated users with a special
BpmRestAccessContext.POLICY_NAME policy.Adapter between Flowable
BusinessCalendar and Jmix BusinessCalendar.A copy of
BpmAsResourceServerBeforeInvocationEventListener that works with OIDC add-on events.Helper class for calculating triggering date for
TimerEventDefinition
in case of using repeating intervals and non-default Flowable business calendar.This BPMN parse handler handles the case when a UserTask is located inside a lane.
Validator checks that UserTask due date duration is not defined in days, weeks, months or years when a business
calendar is also selected.
Class is responsible for the brute-force protection on user authentication.
Indicates that annotated interface is a "Business Calendar".
Defines API to operate with date and time in terms of "business hours".
Allows to detect all classes that have annotation
BusinessCalendar.Non-persistent entity used to display business calendars in UI
Interface must be implemented by classes that provide business calendars from a particular source type.
Allows registering inside default Flowable
BusinessCalendarManager
all business calendars from Business Calendar add-on.Defines convenient methods to fetch configured in the system business calendars.
Helper that provides information about registered business calendars into screen fragments.
Presents business day with configured working interval.
Resolves method parameters by delegating to a list of registered
MethodArgumentResolvers.Used for additional cache operation like iterations over cache entries.
Indicates that auto case conversion should be used for text input fields bound with marked entity field.
ChangePasswordAction<E extends org.springframework.security.core.userdetails.UserDetails>
Interface of views that can contain unsaved changes.
An optional interface of
CloseActions used in views that may have unsaved changes on closing.Since Spring Boot 2.6 circular references prohibited by default.
Mapper of claims received from the OpenID Provider into Jmix resource roles and row-level roles.
Loads classes taking into account hot-deploy feature.
Marker interface for objects that describe how a
View was closed.Type of a collection change event.
Container that holds a collection of entity instances.
Event sent on changes in the container items collection - adding, removing, replacing elements.
Standard implementation of sorting
CollectionContainers.Collection formatter to be used in view descriptors and controllers.
Enum describes the policy of processing collection members when importing the entity with the
EntityImportPlanLoader of entity collections.
Event sent after successful loading of entities, merging them into
DataContext and setting to
the container.Event sent before loading entities.
Container that holds a collection of entity instances which is a collection property of another entity.
Standard implementation of sorting
CollectionPropertyContainers.ComponentActionBinder<C extends com.vaadin.flow.component.Component>
ComponentActionsHolderBinder<C extends com.vaadin.flow.component.Component>
ComponentActionsHolderUnbinder<C extends com.vaadin.flow.component.Component>
ComponentActionUnbinder<C extends com.vaadin.flow.component.Component>
Contains information for
ComponentGenerationStrategy when creating
components using UiComponentsGenerator.A strategy for creating FlowUi components by
UiComponentsGenerator.ComponentLoader<T extends com.vaadin.flow.component.Component>
InitTasks are used to perform deferred initialization of visual components.
Registers new component loader or override a UI component in the framework.
Builds registration object that is used for adding new component loader or overriding UI components in the
framework.
ComponentRootLoader<T extends com.vaadin.flow.component.Component>
INTERNAL
ComponentShortcutActionBinder<C extends com.vaadin.flow.component.Component>
ComponentShortcutActionsHolderBinder<C extends com.vaadin.flow.component.Component>
An implementation of
UserRepository that compose all UserRepositorys
registered in an application and delegates operations to them.Marks a reference as composition.
The tree of
Conditions represents an optional part of a query that is added if the corresponding parameters
are present.Modifies parts of JPQL query
Modifies JPQL query according to the tree of conditions.
Utility class to build
Condition by Spring Data repositories PartTreeLoads the tree of
Conditions from XML.A configuration is a set of filter components.
Handles ConstraintViolationException that can be thrown by bean validation on persistence layer.
Handle tags in format strings
Resolves method parameters by delegating to a list of registered in Spring context
MethodArgumentResolvers.Implementations of the interface are used for wiring of fields/setters to the view controllers.
Class describes injection context that contains view controller and options.
Exception that can be thrown during value conversion methods of UI components.
Defines a case conversion type.
Interface to be implemented by entities having a state which is not reflected in metadata.
Configuration of the core module.
This security configuration can be used in test or simple projects, for example:
CORS settings used by default
CorsConfigurationSource provided by Jmix core
module auto-configuration.Creates HTML from a list of
CreditsItem objects.Carries information about third-party software.
Provides information about third-party software by loading
credits.xml files of Jmix modules.Crockford's Base32 encoding of UUID values.
Defines cron-based holiday in annotated business calendar (see
BusinessCalendar).Presents arbitrary holiday which can be expressed via quartz cron expression.
INTERNAL.
Class provides helper methods to work with
DataSet.Extraction controller for
BandOrientation.CROSS orientation.An access context to check permissions on entity operations.
Stores metadata for
JmixDataRepository methods.Provides
CrudMethodMetadata for current invoked methodRepositoryProxyPostProcessor to add interceptor designated for determining and storing CrudMethodMetadata
information for currently invoked JmixDataRepository method.Defines CurrencyField currency label position.
Indicates that a field which is marked by this annotation contains currency value
Provides information about the currently authenticated user.
Takes query parameter values from the currently authenticated (or substituted) user object.
Interface is used to get the information about current user substitution
Apply custom style to target cell
Contains UI component loaders from add-ons and project configurations.
Registers external UI components or component loaders that should be used by the framework.
Input parameter for a function to get a custom value of property.
Mapping for entity property that has a custom value calculated by specified function.
This interface may be implemented if you need custom formatting logic, not covered by and provided formatter
Example: you need to merge pdfs created by another reports
The event that is fired when a user inputs value manually.
Business calendar provider that fetches business calendars from database.
Role provider that gets resource roles from the database from the
ResourceRoleEntity.Role assignment provider that gets role assignments from the database.
Role provider that gets row level roles from the database from the
RowLevelRoleEntity.A
UserSubstitutionProvider that stores UserSubstitution in a database.Factory bean for data API components.
Interface for tracking changes in entities loaded to UI.
Event sent when the context detects changes in an entity, a new instance is merged or an entity is removed.
Event sent after saving changes.
Event sent before saving changes.
Gives direct access to collections of modified and removed instances in
DataContext.Standard implementation of
DataContext which saves data to DataManager.Marker interface of
DataContext implementations that can form hierarchies
using DataContext.setParent(DataContext).This class should load data using ReportQuery objects, convert data onto BandData object and build BandData object tree (link children and parent bands)
The default implementation is io.jmix.reports.yarg.reporting.DataExtractorImpl
!Attention! Please make sure if you really need to change this behaviour against default implementation cause it might crash report generation logic
An editor in a Grid.
An event that is fired when item set is changed.
An event that is fired when selected item is changed.
The DataGridItems that supports sorting.
An event that is fired when value of item property is changed.
API to import entities from the input data using specified import configuration.
Executes import for a given import configuration and
ImportedData.Base interface for load contexts used in
DataManager.Type of the LIKE clause.
Load trigger.
The root interface in the data loaders hierarchy.
Utility class working with data loaders.
Thrown when data loader catches internal exception during load
Same as
UnconstrainedDataManager but performs authorization of all operations by applying registered
access constraints.Class presents factory bean for create
DataSet instance with basic filled attributesDefines sorting options of a data store.
Interface defining methods for CRUD operations on entities.
INTERNAL.
Represents a data type of an entity property.
Convenience bean for locale-dependent conversion of some widely used data types to and from strings.
Registry for
DatatypesController that is used for getting datatypes information.
An event that is fired when DataUnit state is changed.
DataViewBinding<C extends com.vaadin.flow.component.Component & com.vaadin.flow.data.provider.HasDataView<V,?,?>,V>
DataViewBindingImpl<C extends com.vaadin.flow.component.Component & com.vaadin.flow.data.provider.HasDataView<V,?,?>,V>
DataViewDelegate<C extends com.vaadin.flow.component.Component & com.vaadin.flow.data.provider.HasDataView<V,?,?> & com.vaadin.flow.data.provider.HasListDataView<V,?> & SupportsDataProvider<V>,V>
DateDatatype works with java.sql.Date but is parameterized with
java.util.Date to avoid problems with casting.DateFormatter formatter to be used in view descriptors and controllers.Specifies a format pattern for an entity attribute of a date/time type.
Interface defining methods of getting some DBMS-specific values.
Factory for obtaining implementations of DBMS-specific objects, particularly
DbmsFeatures,
SequenceSupport and DbTypeConverter.INTERNAL.
Interface defining methods to convert data between Java objects and JDBC params and results depending on the current
DBMS type.
A collection of JDBC helper methods.
Indicates whether a JPA entity is a database view.
Defines a DDL code to be generated by tooling.
Container for
Ddl annotations.Settings used by development tools to generate DDL scripts for this entity.
Default implementation for file archive extraction.
Default
ClaimsRolesMapper implementation that takes OidcUser
role names and transforms roles names to resource and row-level roles using role name prefixes.Default extraction context implementation
Default data extraction logic implementation
Default controller factory implementation
Default file downloader implementation.
The default implementation of
JmixOidcUser that wraps the OidcUser provided by the OpenID Connect 1.0
Provider and delegates some method invocations to the wrapped OidcUser.A
OidcUserService that is enabled by auto-configuration.Marker interface which indicates that the actual view's route parent
must be the main view returned by
UiProperties.getMainViewId().The default implementation
OidcUserMapper implementation that converts OidcUser into DefaultJmixOidcUser.Default preprocessor factory implementation
Class is used for getting default policy group for the
ResourcePolicy instance.Class contains an info about classes of following types:
org.flowable.engine.delegate.JavaDelegate
org.flowable.engine.delegate.TaskListener
org.flowable.engine.delegate.ExecutionListener
org.flowable.common.engine.api.delegate.event.FlowableEventListener
The class is used for getting a list of class members with
org.flowable.common.engine.api.delegate.Expression type.Marked entity field will be used to store information about user deleted entity.
Makes entity soft-delete when placed on field.
This enum defines a behaviour to deal with linked objects in case of soft delete
DENY - throw
DENY - throw
DeletePolicyException when linked object exists
CASCADE - soft delete the linked object
UNLINK - remove link
Exception that is raised on attempt to soft delete an object,
which has linked objects marked with
OnDelete annotation
with DeletePolicy.DENY value.Defines properties that the annotated property depends on.
INTERNAL.
Updates desciptor properties according to requirements.
POJO to store all information needed to process entity descriptor.
Interface of views that display an entity instance and can save changes made by the user.
Defines a detail view purpose: to create a new entity instance or to edit an existing one.
Provides a fluent interface to configure navigation parameters and navigate to an entity detail
View.Provides a fluent interface to configure and open a details view
in a
DialogWindow.Provides a fluent interface to configure and open a details view with
the specific class in a
DialogWindow.Trigger for running dev mode initialization when running in a compatible
servlet environment.
Tracks the output of a dev server and scans for given success and/or failure
patterns while copying the dev server output to standard output.
Encapsulates the result of a find operation.
Default actions which should be used in
InputDialog.Specifies parameters of
DialogWindow.A possible outcome of the input dialog with the standard close actions.
Provides fluent interface for configuring and displaying dialogs.
Builder of background task dialog.
Represents Dialog Builders with close setting.
Base class for all Dialog Builders.
Represents Dialog Builders that can be dragged.
Represents Dialog Builders that have a text inside
Paragraph component.Represents Dialog Builders that have a header.
Represents Dialog Builders that have modal setting.
Represents Dialog Builders that have size setting.
Represents Dialog Builders that have style setting.
Represents Dialog Builders that have a text inside
Paragraph component as a content.Represents Dialog Builders that have theme setting.
Enum for describing the position of label components in a
InputDialog.Represents Dialog Builders that can be resized.
An interface to be implemented by builders which opens a view in a
DialogWindow.An interface to be implemented by builders which opens a
specific view in a
DialogWindow.Provides fluent interface for opening views in dialog windows.
Document formatter for '.doc' and '.odt' file types
* Document formatter for '.docx' file types
Helper class for XML parsing.
Helper bean for XML parsing with DOM4J.
This class is not thread-safe and should not be accessed concurrently from multiple threads without proper
synchronization.
INTERNAL.
INTERNAL.
Provides data for
Downloader.Generic interface to download data from the system.
Shows exported data in the web browser or downloads it.
Format of data exported by
Downloader.Executes import for a given import configuration and
ImportedData.Available policies to process a found duplicate:
Update: an extracted entity not imported, existing one is updated.
Defines an interface for EclipseLink cluster communication
Utility class to provide common functionality related to persistence.
Contains information for a function that returns the column editor component
used by
DataGridEditor.Annotation for detail view controllers which specifies a data container that contains the edited entity.
Interface to be implemented by beans that transform an entity after returning it from a detail view.
Should be used to delete old emails and attachments.
Interface provides methods to load, store and update email message and attachment entities
Provides application with emailing functionality.
Email sending error.
Contains failed addresses and corresponding error messages.
Contains failed addresses and corresponding error messages.
The EmailHeader class stores a name/value pair to represent headers.
Contains email details: list of recipients, from address, subject, body and attachments.
EmailInfo builder.
Adapter to javax.mail email sending API.
Used for
Embeddable entities by enhancing processUpdates database mapping to support embedded parameters.
Defines additional parameters for Embedded attributes.
Marker interface to indicate that the implementing class provides no data.
Annotation to enable data repositories.
Indicates whether to enable restoring of soft deleted entity instances.
A factory for creating Vaadin Endpoint generator tasks.
An event that is fired when the user selects another locale.
An event that is fired when "Remember Me" becomes checked and unchecked.
Controller that performs CRUD entity operations
Class that executes business logic required by the
EntitiesController.Controller that is used for getting entities metadata.
Class is used by the
EntitiesMetadataController.Interface to be implemented by domain model objects with identifiers.
This exception is raised on attempt to load a deleted object.
An access context to check permissions on entity attributes.
An extension point for the entity import mechanism.
Defines entity attribute resource policy in annotated resource role (see
ResourceRole).Action for
EntityAttributePolicyAn extension point for a mechanism to serialize and deserialize entity to JSON.
Visitor to be submitted to
MetadataTools.traverseAttributes(Object, EntityAttributeVisitor).A Spring application event that is sent right after an entity is changed in the data store.
Type of the event:
EntityChangedEvent.Type.CREATED, EntityChangedEvent.Type.UPDATED or EntityChangedEvent.Type.DELETED.INTERNAL.
EntityCollectionFieldDelegate<C extends com.vaadin.flow.component.AbstractField<?,Set<T>> & SupportsMetaClass,T,V>
Diff object for Entity Snapshots
Used to clearly identify entity.
Property selection performs as follows:
Property selection performs as follows:
Id property used if it has UUID type and JmixGeneratedValue annotation,
any other UUID @JmixGeneratedValue property chosen if @Id property doesn't satisfy conditions above,
interface isn't applied otherwise.
Interface to be implemented by optimistically locked entities.
Provides methods to extract entities and populate their properties by values from the imported data
Fetches entities by fetch plans by accessing reference attributes.
An object that contains the following details if an entity import fails:
An instance of
ImportedDataItem
Extracted entity
Error message
Error type: EntityImportErrorType
Bean that is used for exporting a collection of entities and importing them.
Use
EntityImportPlanBuilder for building instances of EntityImportPlan.Builds
EntityImportPlans.Class that is used for building an
EntityImportPlan based on the JSON object that represents an entity.Factory for
EntityImportPlanBuilder.Interface to be implemented by beans that initialize new entity instances created via
Metadata.create(Class).Used by enhancing process
Event that is fired then item collection is changed.
An interface for entity JSON transformers used by the REST API
This bean allows to register and fire entity listeners.
A Spring application event which is sent when the entity is loaded from the data store.
Allows to log entity lifecycle events: create, modify, delete.
Record containing changed entity attribute.
Record containing information about entity lifecycle event.
Type of operation on entity.
Defines entity resource policy in annotated resource role (see
ResourceRole).Action for
EntityPolicyAPI to populate the entity by property values using property mappings and raw values source.
Event object for
EntityPropertyChangeListener.Interface to track changes in data model objects.
Diff between properties in entity snapshots
Normalizes references between items of a collection.
Allows to restore entities have been soft-deleted previously
A Spring application event which is sent when the entity is saved to the data store.
Class that is used for serialization and deserialization of entities to JSON.
Class is used for storing a collection of entities already processed during the serialization.
An object that configures how to serialize the entity to JSON.
Implementation of
Set<Entity> with convenient methods for getting entities by a prototype instance
or by a class and id.Interface defining methods for creating and getting operations on entity snapshots.
Creates and analyzes entity snapshots.
Class is used for converting
EntitySnapshot objects
into non-persistent EntitySnapshotModel entities which may be
displayed in UIProvides information about entities states.
That class is used in report wizard creator cause that wizard need info about entity attributes
A comparison function, which imposes a ordering for entity attribute values.
An event fired when related entity instance is changed.
Interface to be implemented by enums that serve as entity attribute types.
REST controller that is used for getting an information about enums
A helper class to be used in
EnumClass implementations to convert identifiers to enum values.EventHub class implementing the event listening model with concrete event classes.
Generic Event router with lazily initialized event map.
Class is used by
ExportAction for exporting all records from the database.Calculates the width of a column, based on the values within it.
Action for export table content in XLSX format
Use this class to export
DataGrid into Excel format.Annotation for method that operates on UI thread and can change shared UI state.
Indicates that the annotated program element is considered usable in applications but is unstable.
Annotation must be put on a method of an interface that defines a resource role (see
ResourceRole).Base action for export table content with defined exporter.
An access context to check permissions on entity attributes when serializing entities to/from JSON.
Encapsulates functionality for working with extended entities.
This interface implementation should presents extraction context dependent state
This interface implementation should create immutable extraction context object
Default data extraction context implementation
This interface implementation should contains data extraction logic
This interface implementation may holding relation between report band orientation and related controller logic
if relation not set, default controller should be returned
Non-visual component of a
View.Interface for Spring Beans providing non-visual components for views.
Factory to create UI facets.
Specifies how to fetch a referenced entity from the database.
Class to declare a graph of objects that must be retrieved from the database.
Specifies fetch plan name that will be applied to entities on extraction.
Builds
FetchPlans.This exception is raised when you try to get nonexistent fetch plan by entity/name.
Defines a
FetchPlan property.Represents a repository of shared
FetchPlan objects, accessible by names.Implementation of the
FetchPlanRepository.Factory for
FetchPlanBuilder.Class that is used for serialization and deserialization of fetch plan to JSON.
An object that configures how to serialize a fetch plan to JSON.
Updates mapping by setting a correct fetch type - lazy or eager.
REST API controller that is used for downloading files
A reference pointing to a file located in
FileStorage.Data provider for FileDescriptor
Interface of a component to store and load files defined by file references.
Provides access to all registered file storage beans of the application.
Defines when file will be placed into FileStorage.
This exception can occur while uploading/downloading files using
FileTransferService.A service for uploading and downloading files to/from
FileStorages.REST API controller that is used for uploading files
FileUploadFailedEvent<C extends com.vaadin.flow.component.Component>
Event is fired when
FailedEvent of Upload is occurred.FileUploadFileRejectedEvent<C extends com.vaadin.flow.component.Component>
Event is fired when
FileRejectedEvent of Upload is occurred.FileUploadFinishedEvent<C extends com.vaadin.flow.component.Component>
Event is fired when
FinishedEvent of Upload is occurred.FileUploadProgressEvent<C extends com.vaadin.flow.component.Component>
Event is fired when
ProgressUpdateEvent of Upload is occurred.FileUploadStartedEvent<C extends com.vaadin.flow.component.Component>
Event is fired when
StartedEvent of Upload is occurred.FileUploadSucceededEvent<C extends com.vaadin.flow.component.Component>
Event is fired when
SucceededEvent of Upload is occurred.Watches for the file or sub-directory changes in the given directory.
Component that can be used for filtering entities returned by the
DataLoader.Registers a UI filter component in the framework.
Builds registration object that is used for adding or overriding UI filter components in the framework
Registers UI filter components that should be used by the framework.
Defines holiday for specific date in annotated business calendar (see
BusinessCalendar).Presents holiday for specific date.
Defines holiday that has the same date independent of year (like "4th of July") in annotated business calendar (see
BusinessCalendar).Presents holiday that occurs every year in the same date.
Used in Studio.
Class is used to run a report using various additional criteria:
Use the
Report entity or report code
ReportTemplate entity or template code: if none of these fields is set, the default template is used.
Output type
Output name pattern
Input parameters
Use the
ReportRunner bean to obtain an instance of the FluentReportRunner.Class is used to run a report using various additional criteria:
Use the
Report entity or report code
ReportTemplate entity or template code: if none of these fields is set, the default template is used.
Output type
Output name pattern
Input parameters
Screen: screen or screen fragment from which the report runs
Show a dialog to input the report parameters (defined by ParametersDialogShowMode)
Run a report synchronously or in the background (by default, a report runs synchronously)
Use the
UiReportRunner bean to obtain an instance of the FluentUiReportRunner.Localized format strings container.
Registry for
FormatStringsMarker interface to indicate that the implementing class can be used as a formatter.
The object is single input parameter for formatter constructor
If you need you formatter be created by factory - it should accept this object as constructor parameter
Specific bean for loading formatters.
Provides access to frontend tools (Node.js and npm, pnpm) and optionally
installs the tools if needed.
A class for static methods and definitions that might be used in different
locations.
Thrown when the command execution fails.
Thrown when detecting the version of a tool fails.
Generates embeddable web component files in npm mode, hiding the complexity
caused by using a different class loader.
Collect generated-flow-imports content for project to use to determine if
dev-bundle contains all required imports.
A versatile tool for filtering the data it is bound to.
Event sent when the
Configuration is changed.Event sent when the
Configuration is updated.Defines GraphQL resource policy in annotated resource role (see
ResourceRole).Export actions configuration interface
Loads data using groovy script
Script should return list of maps
Example:
return [['a':123, 'b':321], ['a':456, 'b':params['param1']]]
Realization of this interface is intended to prepare a map of parameters filled with beans or other objects
This component can contain
FilterComponents and can be used for filtering entities
returned by the DataLoader.This class is not thread-safe and should not be accessed concurrently from multiple threads without proper
synchronization.
Interface to be implemented by entities that are not included in static metadata, but can provide a
MetaClass
specifically for each instance.Interface to be implemented by containers that can be loaded by loaders.
Interface to be implemented by classes that represent application user and that wrap the
OidcUser.Interface for UI components that provide additional objects for framework as part of component API.
The implementation of additional criteria for multi tenants.
Provides user time zone information.
Gathers information about holidays for annotated business calendar.
Non-persistent entity used to display holidays of certain business calendar in UI
Handle HTML with format string: ${html}
Document formatter for '.html' and '.ftl' file types
Convenient class for methods that receive Id of an entity as a parameter.
Helper class which represent a collection of
IdProvides conversion of
Id to and from the string representation.Can be applied to an attribute of
TemporalType.TIMESTAMP data type to always ignore the user time zone
when displaying and entering values.Exception that is thrown in case of incorrect access to a shared data from a thread that does not own necessary lock.
Exception that is thrown in case of incorrect access to a shared data from a thread that does not own necessary lock.
Handle images with format string: ${image:100x100}
An object that allows configuring import process of entities from JSON, XML, CSV, XLSX.
Builds an instance of
ImportConfiguration using the following parameters:
Entity class (required): class of entity that will be imported using created import configuration
Input data format (required): xlsx, csv, json or xml.
Property mappings: list of PropertyMapping
Transaction strategy: ImportTransactionStrategy.Represents the result of input data processing that contains:
List of
ImportedDataItems: one imported data item contains the raw values of properties for one entity to import.
Data field names: names of the fields from input data (XLSX, CSV - column names specified in the first row,
JSON - field names from JSON object, XML - tag names).
Parses the data from source and returns an instance of
ImportedData containing list of ImportedDataItem with raw valuesRepresents a source of raw values for properties for one entity to import.
Represents an object in JSON or XML with the following info:
Data field name: for JSON - field name, for XML - tag name
Raw values map: for JSON - raw values of JSON object fields by field names,
for XML: values of child tags by tag names
JSON example:
The "customer" object represents
JSON example:
The "customer" object represents
ImportedObject with data field name = "customer" and two raw values: "name" and "email".Represents an object list in JSON or XML with the following info:
Data field name: for JSON - field name, for XML - tag name
List of
JSON example:
The "items" JSON array represents
ImportedObjects
JSON example:
The "items" JSON array represents
ImportedObjectList with data field name = "items" and two ImportedObjects.An object that contains the following information about the import execution result:
Success: whether entities import is executed successfully or not
List of entity ids that are successfully imported
List of
EntityImportErrors created for not imported entities
Error message
The way how to import the entities:
Single transaction: if any entity import fails, the import process fails
Transaction per entity: if any entity import fails, the import process continues
Transaction per batch: the entities are imported by batches.
Thrown when initialization of internal parts of reporting fails
Example: you have provided wrong database driver class name
An access context to check permissions on CRUD operations by testing predicates.
In-memory implementation of
RegisteredClientRoleAssignmentRepository.RoleAssignmentProvider that stores role assignments in memory.A
UserSubstitutionProvider that stores UserSubstitution in memory.Contains supported input data formats
Describes result of handler that can be used with
DialogAction in the input dialog.Describes input dialog validation context.
Action can be used in
InputDialog.Describes field that can be used in
InputDialog.Annotation for declarative handler methods in UI controllers.
Exception indicating a failure during installation of node and npm.
Sets primary subject for injection to target classes.
The root interface in the data containers hierarchy.
Event sent when the entity instance selected in the container is replaced with another instance or null.
Event sent on changing a property value of the contained entity instance.
Loader of a single entity instance.
Event sent after successful loading of an entity instance, merging it into
DataContext and setting to
the container.Event sent before loading an entity instance.
Specifies an entity attribute or method to provide an instance name - a human-readable text that represents an entity instance.
Provide instance name and instance name properties.
Container that holds a single instance which is loaded as a property of another entity.
Indicates that the annotated program element is considered an internal implementation detail and should
not be used in application code.
Defines what Java class is handled by the annotated datatype.
Class loader is used for building class instances from ".class" files.
Substitutes variables of a within a string by values.
Query implementation for Jmix.
RepositoryQuery for query methods annotated with @Query.Central Jmix data repository interface.
Implementation of base repository methods used by application repository beans.
Indicates that the annotated class is an entity and must be represented in the metadata.
Mostly copied from
FilterBasedLdapUserSearch in order to add JmixFilterBasedLdapUserSearch.searchForUsersBySubstring(java.lang.String) method.Indicates an entity attribute that must be assigned by the framework right after creating an entity instance.
This annotation should be used on an id attribute if the attribute has no other appropriate annotation
recognized by the framework (such as
Id).Component supports data binding with entity properties.
Set of theme variants applicable for
JmixImage component.Converts
Jwt into Authentication.An implementation of an AbstractOAuth2TokenAuthenticationToken representing a Jwt Authentication.
Extension of the default strategy for obtaining user role information from the directory.
GrantedAuthoritiesMapper that maps authorities to
RoleGrantedAuthoritys.Extension of Spring LDAP's LdapTemplate class which adds extra functionality required by Jmix.
Extension of LdapUserSearch interface which adds extra method required by Jmix.
Helper class for building an instance of
SpringLiquibase using the LiquibaseProperties.Describes menu item that should navigate to the view.
JmixMenuManager<C extends com.vaadin.flow.component.Component,I extends com.vaadin.flow.component.contextmenu.MenuItemBase<?,I,S>,S extends com.vaadin.flow.component.contextmenu.SubMenuBase<?,I,S>>
Indicates that the
@Configuration class is a main configuration of a Jmix module.Describes a Jmix module which the current application depends on.
Holds the list of
JmixModuleDescriptors.Helps to select a bean that belongs to the lower module in the hierarchy of
@JmixModule dependencies (where
core is on top and an application is at bottom).Scans classpath of all Jmix modules used in the application and detects classes according to
ClasspathScanCandidateDetector beans registered in the Spring context.Sorts
JmixModuleDescriptors using the topological sort algorithm.An interface to be implemented by a user Principal that is registered with an OpenID Connect 1.0 Provider.
Mapped superclass to be extended by JPA entity that stores user information.
Marker interface for OidcUserService that is used by auto-configuration.
Defines constants for higher and lower precedence for
Ordered or
annotated with Order beans of the Jmix modules.Parameter extension required to support FetchPlan special parameter.Parameters extension required to support FetchPlan special parameter.Specifies an entity attribute if
JmixEntity.annotatedPropertiesOnly() is set to true.Determines query type and creates
RepositoryQueries for Jmix data repositoriesQueryMethod extension required to support FetchPlan special parameter.ImportBeanDefinitionRegistrar for Jmix data repositories.JmixRepositoryFactoryBean<T extends org.springframework.data.repository.Repository<S,ID>,S,ID extends Serializable>
A set of constants with order values of
SecurityFilterChain used in Jmix
modules.Base
RepositoryQuery class for repository queries constructed by method name.An event to mark that the selected tab has changed.
Workaround on Windows OS if you build project using gradle with long class path.
Extension starts Vaadin Flow before each test and configures view packages and authentication.
Contains properties for the upload dialog.
Provides core user information.
Used in Studio.
Workaround on Windows OS if you build project using gradle with long class path.
Uses all instances of
JoinExpressionProvider beans to create and apply additional join criteria to the mapping.Generates additional join expression for entity mappings.
INTERNAL.
Beans implementing this interface are notified by JPA implementation on their
specific events.
Stores cascaded entities in addition to standard
SaveContext dataCondition that represents JPQL query with "where" and optional "join" sections.
JpqlFilter is a UI component used for filtering entities returned by the
DataLoader.Builds
Query instance to use in DataService.QueryStringProcessor implementation that provides support for abbreviated JPQL queries.Provided query should return usernames instead of users itself, like
Defines JPQL row-level policy in annotated row level role (see
RowLevelRole).Interface to be implemented by a Spring bean to generate sort expression for datatype and LOB properties.
Provides bypass of BandData tree.
Class is used by
ExportAction for exporting all records from the database to JSON format.Loads data from json string
Uses JsonPath to access necessary parts of json object
Example:
JSON:
{ "store": {
"book": [
{ "category": "reference",
"author": "Nigel Rees",
"title": "Sayings of the Century",
"price": 8.95
},
{ "category": "fiction",
"author": "Evelyn Waugh",
"title": "Sword of Honour",
"price": 12.99,
"isbn": "0-553-21311-3"
}
],
"bicycle": {
"color": "red",
"price": 19.95
}
}
}
Query string:
parameter=param1 $.store.book[*]
We get json string from parameter param1 and select all "book" objects from the "store" object
Action for export table content as JSON
Use this class to export
DataGrid into JSON format.Enum for JSON transformation direction
Container for a collection of
KeyValueEntity instances.Loader of
KeyValueEntity collections.Event sent after successful loading of entities and setting to
the container.
Event sent before loading entities.
Container for a single
KeyValueEntity instance.Entity that contains a variable set of attributes.
Loads a single instance of
KeyValueEntity.Event sent after successful loading of a KeyValueEntity instance and setting it to
the container.
Event sent before loading a KeyValueEntity instance.
MetaClass for
KeyValueEntity.MetaProperty for
KeyValueEntity.Deprecated.
Allows providing mapping between LDAP group name and Jmix role codes.
Extension point for fetching additional user roles for LDAP user.
Implementation of UserRepository that searches for users in LDAP.
A component that displays list of items.
Defines classes of entity lifecycle listeners
Describes menu item that can contain other menu items.
Describes menu item.
Provides a fluent interface to configure navigation parameters and navigate to an entity list
View.Class that defines parameters for loading entities from the database via
DataManager.Class that defines a query to be executed for data loading.
Marker interface for component loaders.
Utility class contains common methods to apply Spring Data repositories special query parameters on
FluentLoader.Facilitates parsing data from XML.
Allows resolving the current
Locale as method argument.POJO class that is supposed to be used as JSON item in
EnhancedLoginForm.The LocaleResolver class transforms locales to strings and vice versa to support messages localization.
INTERNAL!
Supposed to use when showing
Dialog or some View.The
LockDescriptor contains configuration information about a pessimistic lock.Interface that provides
LockDescriptor objects for LockManager.Describes a pessimistic lock of an object.
A special case of
LockInfo that is returned from LockManager
methods to indicate that locking is not supported for a specified object type.Configuration element of
EntityLog bean.Configuration element of
EntityLog bean.Logical condition (AND, OR) which contains other conditions.
Component which can contain other filter components and can be used for filtering entities
returned by the
DataLoader.LogicalFilterComponent.FilterComponentsChangeEvent<C extends com.vaadin.flow.component.Component & LogicalFilterComponent<C>>
Operation representing corresponding logical filtering condition.
Class that provides authentication via
AuthenticationManager.Filter that sets up MDC (Mapped Diagnostic Context) for each http request.
A component which can be set as lookup component for a view.
Annotation for lookup view controllers which specifies ID of a UI component to be used for getting a value
returned from the lookup.
Interface of views that display a list of entities and can return instances selected by the user.
Context object which is passed to the selection validator set by
LookupView.setSelectionValidator(Predicate).Provides a fluent interface to configure and open a lookup view
in a
DialogWindow.Provides a fluent interface to configure and open a lookup view with
the specific class in a
DialogWindow.Updates mapping properties according to requirements.
POJO to store all information needed to process entity mappings.
Holds information about the main menu structure.
Main menu item descriptor.
Defines menu resource policy in annotated resource role.
Defines options of the
DataContext.merge(Object, MergeOptions) operation.Class that provides messages from a message group bound to view controller.
Interface to provide a caption of property, for example if the property is a dynamic attribute.
Central interface to work with localized messages.
Controller that returns localized messages
Class that executes business logic required by the
MessagesController.Defines additional basenames for Jmix's
MessageSource.Utility class to provide common functionality related to localized messages.
Marks an annotation as being a meta-annotation for entity classes and attributes.
Metadata object representing an entity.
Central interface to provide metadata-related functionality.
Interface to provide additional properties of MetaClass, e.g.
INTERNAL.
Ancestor of main metadata objects:
MetaClass and MetaPropertyUtility class to provide common metadata-related functionality.
INTERNAL
INTERNAL
INTERNAL.
Metadata object representing an entity attribute.
Property type
Object representing a relative path to a property from certain MetaClass
Strategy interface to handle the value returned from the invocation of a
handler method .
Resolves method parameters by delegating to a list of registered
MethodArgumentResolvers.Utility class to provide
Method argument values from MethodArgumentResolverContains
MethodMetadata analyse logic such as ApplyConstraints determination.Event is used to inform the assignee details fragment about the modification of the collection from the
multi-instance characteristics fragment.
A view that can change selection mode of its lookup component.
Helper for login screen.
Standard multi value select action for selection the field value.
An item of the tree in the "My Tasks" screen.
Interface to be implemented by containers that work with entities that are properties of other entities.
Node installation class.
An executor that it's run when the servlet context is initialised in dev-mode
or when flow-maven-plugin goals are run.
Base abstract class for frontend updaters that needs to be run when in
dev-mode or from the flow maven plugin.
An
Used by enhancing process when
EntityEntry implementation for model objects without identifiers.Used by enhancing process when
JmixEntity does not include any of annotations:
Id
EmbeddedId
JmixId
Dummy implementation of
DataContext used for read-only views like entity list views.Empty implementation of the
DataStore interface.Raised on attempt to open an unknown view.
Configures and displays popup notifications.
A builder that configures and displays notifications.
Notification type.
Use for kotlin non-null references to prevent eager instantiation of lazy-loaded fields.
Use for kotlin non-null references to prevent eager instantiation of lazy-loaded fields.
Common placeholders interface for null values.
Used by enhancing process.
Class is used as a default value for attribute of
EntityPolicy and EntityAttributePolicy annotationsBase interface for number type validators which contains all numeric restrictions.
Specifies a format
NumberFormat.pattern() and optional NumberFormat.decimalSeparator() and NumberFormat.groupingSeparator() for
an entity attribute of the Number type.Number formatter to be used in view descriptors and controllers.
Intermediate cache for generated ids of entities with long/integer PK.
Generates ids for entities with long/integer PK using database sequences.
Converts parameters from string to object and from object to string
Implementation for XInputStream
Proxy stream
Configures UI endpoint protection
Configures API endpoints (REST, GraphQL, etc.) protection.
Event fired after OIDC resource server API call.
Event is fired before OIDC resource server API call.
A copy of io.jmix.authserver.filter.AsResourceServerEventSecurityFilter.
Interface is responsible for transforming an instance of
OidcUser (from Spring Security) to JmixOidcUser which may be used by Jmix application.Marks a link to other entity for specific soft deletion behaviour.
Taken into account by persistence when "this" entity is deleted.
See also
Taken into account by persistence when "this" entity is deleted.
See also
DeletePolicyMarks a link to other entity for specific soft deletion behaviour.
Taken into account by persistence when "linked" entity (which is referenced by the marked field) is deleted.
See also
Taken into account by persistence when "linked" entity (which is referenced by the marked field) is deleted.
See also
DeletePolicyStarts and stops an OOo server.
This bean generates OpenAPI documentation according to the 3.1 specification.
Thrown when formatter catches Open/Libre Office internal errors
Operation result object.
Build a
NodeExecutor instance.Interface to be implemented by some entities that order display can be changed in UI.
This class is used to store task outcomes results in a process variable.
Base interface for components that make a data binding to load data by pages.
The event that is fired after data refresh.
The event that is fired before refreshing the data, when the user clicks next, previous, etc.
ParameterComponentGenerationStrategy.FieldCreator<T extends com.vaadin.flow.component.AbstractField>
A
Datatype that exposes some internal parameters.Modifies JPQL query parameters according to the tree of conditions.
Report parameter for lazy data loading in core module
Options that allow to show a dialog to input the report parameters or not.
Utility class for instantiation immutable
Map<String, Object>.Runs all existing
PasswordValidators and returns the list of validation errors.Contains parameters of password validation.
Exception to be thrown by
PasswordValidator implementations.Interface to be implemented by beans that validate password when it is created or changed for a user.
Controller that is used for getting current user permissions
Class is used for getting current user permissions for the REST API.
Indicates whether to enable pessimistic locking of entity instances.
Platform contains information about system architecture and OS.
An granted authority that stores security policies.
Provides all security policies of the current user.
Event is fired during authentication process to verify the status of the loaded UserDetails
after validation of the credentials takes place.
Verifies the status of the loaded UserDetails after validation of the credentials takes place.
Event is fired during authentication process to verify the status of the loaded UserDetails
before validation of the credentials takes place.
Verifies the status of the loaded UserDetails before validation of the credentials takes place.
Simple static methods to be called at the start of your own methods to verify correct arguments and state.
Deprecated.
Annotation must be put on a method of an interface that defines a row level role (see
RowLevelRole).This interface implementation should holding relation between name of data loader type (ex: sql)
and custom params preprocessor
if relation not set, implementation should present default params preprocessor
Annotation for detail view controllers that sets this controller as default detail view for entities
of the specified type.
Annotation for list view controllers that sets this controller as default list view for entities
of the specified type.
Annotation for lookup view controllers that sets this controller as default lookup view for entities
of the specified type.
An event listener that publishes a Spring application event when a process is completed.
Serves as factory for getting ProcessFormContext
Helper class for
FormData methods.Classes that implement the interface are responsible for creation of start and task forms with a particular form type.
An event listener that publishes a Spring application event when a process is started and
sets an initiator of process into process variables if appropriate property is set.
A process starting builder used in custom process forms.
Base interface that points that implementation of this interface is root fragment for one of bpmn element(such as Service task, User task etc)
Condition for filtering by entity property.
String constants defining comparison operations.
Explicitly defined datatype that overrides a datatype inferred from the attribute Java type.
A UI component used for filtering entities returned by the
DataLoader.Operation representing corresponding filtering condition.
Operation type representing the required field type for editing
a property value with the given operation.
Event sent when the
operation property is changed.Property mapping describes how to map a field from input data with entity property.
An object that contains info to get a result value of an entity property from the raw value
Property path descriptor.
Proxy configuration used for downloads and executions.
Class for holding proxy information.
This interface used for proxy wrapping
Used to set into application properties required property '
org.quartz.jobStore.driverDelegateClass' that
used by Quartz to understand the particular ‘dialects’ of varies database systems.Serves as proxy from Jmix to the Quartz engine for fetch information about jobs and triggers and update them
Controller that is used for operations with predefined JPQL queries
Annotation to specify custom query for Jmix Query methods
Cache that contains queries and a collection of object identifiers
Interface to be implemented by JPQL constant handlers.
Allows to specify query hints for particular repository query.
The interface implementation should provides custom query preprocessing before data loading
Interface to be implemented by JPQL macro handlers.
Interface to be implemented by beans that provide values for query parameters if they are not set explicitly.
Encapsulates invocations of registered
QueryParamValueProviders.Parses JPQL query and returns some information about it.
Supports functionality that allows queries from previously selected results.
Supports functionality that allows queries from previously selected results.
Executes SQL queries with pluggable strategies for handling
ResultSets.Interface to be implemented by beans that pre-process query text before setting it to
LoadContext.Query.Transforms JPQL query
Factory to get
QueryParser and QueryTransformer instances.Object encapsulating common properties of
MetaProperty.Relation type for reference property
Interface for source of extracted raw values
Modifies the query depending on current security constraints.
Interface of views that support read-only mode.
Serializable, unmodifiable collection view for
LinkedMap.Bean that encapsulates the default logic of changing views read-only mode.
Enables working with references to entities without loading them from the database.
A wrapper for the reference ID value returned by
ReferenceIdProvider.getReferenceId(Object, String) method.Enum describes a behavior for references during entities import: missing reference can be ignored
or an exception can be thrown.
Available policies for import of reference property: Create: the reference is always created.
Mapping for reference property that is mapped by multiple data fields from the input data.
Mapping for reference property by one lookup property that has a raw value in the input data.
Utility class to provide common functionality for entities with different type of primary keys
Utility class to simplify work with Java reflection.
Regexp validator checks that String value is matched with specified regular expression.
Immutable property class
A record stores a list resource and rol-level roles assigned to OAuth2 client.
Repository for storing and retrieving
RegisteredClientRoleAssignmentClass that provides fluent interface for removing entity instances.
Event sent when the remove operation is cancelled by user in the confirmation dialog.
Event sent after selected entities are removed.
Event sent before selected entities are removed.
Remove builder.
Represents predefined scenarios of trigger execution repeating
Counterpart of
ReplaceEntity.Indicates that the entity extends and replaces some original entity.
Attention! This entity should be detached for correct work.
This interface describes main report object.
A listener for
AsResourceServerBeforeInvocationEvent that checks "reports.rest.enabled" specific policy
for /rest/reports/** requests, managed by resource server of the Authorization Server add-on.This interface describes Band abstraction.
This interface describes a logic which load rows of data using report query, parent band and params
Class wraps ComboBox value change listener and manages its registration.
Handles reporting exceptions.
This interface describes a format for certain result field.
This interface describes logic which transform resulting values.
This interface describes a logic which construct resulting document
This interface describes a factory which spawns formatters.
Thrown when formatter's logic fails
Provides methods to import and export reports
Contains import information about created reports or updated reports
This class is entry point for reporting functionality
Use it to print reports
Base YARG exception
Thrown when report unmarshalling from xml or report validation by xsd fails
This interface describes a factory which spawns data loaders.
A copy of
ReportAsResourceServerBeforeInvocationEventListener that works with OIDC add-on events.This interface describes reporting result object.
This class contains list of supported output types.
This interface describes report input parameter
This interface describes logic which transform input parameters.
This interface describes certain query which load some data.
Class stores the following information required for report running:
The instance of the class may be created using the constructor or using the
Report entity
ReportTemplate entity: if not specified the default template is used
Input parameters
Type of output document
Output name pattern
The instance of the class may be created using the constructor or using the
ReportRunner bean.Interface is used for running reports
Provides fluent interface for opening script editor
Role that grants full access to working with reports.
Reporting configuration interface.
Role that grants minimal permissions to run reports using REST API.
Role that grants minimal permissions to run reports.
Class to serialize and deserialize reports
Template for
ReportThis interface describes report template document.
Interface contains utility methods for working with report zip archives
ResetPasswordAction<E extends org.springframework.security.core.userdetails.UserDetails>
Describes a permission to a resource.
Class holds standard values for
ResourcePolicy effect field.Non-persistent entity used to display resource policies in UI
Class stores constants for
ResourcePolicy type field values.Class is a container for security resource policies.
Indicates that annotated interface is a "Resource Role".
Non-persistent entity used to display resource roles in UI
Interface must be implemented by classes that provide resource roles from a particular source type.
Central infrastructure interface for loading resources.
Bean validation constraint group used by REST-API for data validation.
A listener for
AsResourceServerBeforeInvocationEvent that checks "rest.enabled" specific permission for
each REST API request, managed by resource server of Authorization Server add-on.Class for REST API search filter JSON parsing
The result of JSON entities filter parsing.
Class is used for loading and storing JSON transformers.
REST API authentication utility class
A copy of
RestAsResourceServerBeforeInvocationEventListener that works with OIDC add-on events.Class is used for loading and storing of predefined JPQL queries that are used by the REST API.
Class stores an information about the predefined JPQL query
Class stores an information about the predefined JPQL query parameter
Class is used for loading and storing an information about service methods that are available for REST API.
Implementations of this interface convert ResultSets into other objects.
Interface to be implemented by classes that provide
RoleAssignment.Repository of
RoleAssignmentClass is used for converting
ResourceRole, RowLevelRole objects
into non-persistent ResourceRoleModel, RowLevelRoleModel entities which may be
displayed in UIInterface must be implemented by classes that provide resource/row level roles from a particular source type.
Utility bean that facilitates url modifications and generations.
Represents row level policy in-memory predicate.
Defines a constraint that restricts data a user can read or modify.
Non-persistent entity used to display row level policies in UI
Represents row level policy in-memory predicate.
Class is a container for security row level policies.
Indicates that annotated interface is a "Row Level Role".
Non-persistent entity used to display roles in UI
Interface must be implemented by classes that provide row level roles from a particular source type.
Standard action for printing reports for a list of entity instances associated with a list component.
Describes parameters necessary for report run
Standard action for running the reports associated with current screen or list component.
Defines collections of entities to be saved or removed, as well as parameters of saving.
Holds entities being saved by
RdbmsStore during a transaction.Object factory for SAXParser object pool.
Defines scheduled business day in annotated business calendar (see
BusinessCalendar).Gathers information about scheduled business days for annotated business calendar.
This interface describes logic which evaluates groovy scripts
Formats period in form of: {hours} h {minutes} min {seconds} sec.
Annotation that indicates that annotated element is secret.
Indicates that the action can be affected by UI permissions.
Callback interface which is invoked by the action to determine its enabled state.
Action that changes its
enabled property depending on a selected item in a bound Grid.Provides methods to check permissions of the current user.
Helper class to get/set Authentication in the current
SecurityContext.Predefined security scope constants for Backoffice UI and REST/GraphQL API.
Stores information about:
data that has been filtered by row level security;
Entity to store information about sending emails.
Represents sequence with name, store, start value and increment.
Provides access to the database sequences.
Interface defining methods for managing database sequences.
Helper class needed to deserialize classes with beans
Data for a info message to the debug window.
Controller that is used for service method invocations with the REST API
Class that executes business logic required by the
ServicesController.Meta-model entry point.
Interface to work with current session and its attributes.
Interface stores internal methods for
Session implementations.Takes query parameter values from current session attributes set using
SessionData.ShortcutActionHandler<C extends com.vaadin.flow.component.Component>
ShortcutActionsHolderBinding<H extends com.vaadin.flow.component.Component,A extends Action,C extends com.vaadin.flow.component.Component>
ShortcutActionsHolderBindingImpl<H extends com.vaadin.flow.component.Component,A extends Action,C extends com.vaadin.flow.component.Component>
System role that grants permissions for the entity info functionality.
Standard action for displaying the report execution history.
ShowRoleAssignmentsAction<E extends org.springframework.security.core.userdetails.UserDetails>
Exception that is used to interrupt an execution flow without any messages to the user.
Mapping for the simple property of entity.
Component which cannot contain other filter component but can be used for filtering entities
returned by the
DataLoader.Class for password change event for a single user (typically, as a result of manual change).
Size validator is applicable for Collections and String values.
The implementation of additional criterion for soft delete.
Generates expression to support soft delete feature in Jmix.
Modifies mapping to support soft delete feature.
Defines sorting of queries.
Sort direction.
Sort order defines a property and corresponding
Sort.Direction.Interface for sorting data in
CollectionContainers.Factory bean for sorters.
An access context to check permissions on arbitrary named functionality.
Defines specific resource policy in annotated resource role (see
ResourceRole).Provides an information about specific policies defined in the application.
Class stores an information about specific security policy that may be used in the application
SQL (and JPQL also) implementation of params preprocessor
Preprocessor searches params in sql fragment and preparing them for
data linking between query bands, that contains data for vertical and horizontal band distribution.
Loads data from database using sql
You can use aliases for output values
Example:
select login as "Login", password as "Password" from user where create_ts > ${startDate}
${startDate} is alias of the input parameter, which will be passed to the query
Utility class for working with the current stack trace.
The default AddonAuthenticationManagerSupplier supplier that provides AuthenticationManager used by basic
application.
Class returns a collection of "standard" providers that may be used in AuthenticationManagers created in different
security configurations.
A close action implementation used in the base views provided by the framework:
View,
StandardDetailView, StandardListView.Base class of entity detail views.
Event sent after saving the view data context.
Event sent before saving the view data context.
Event sent before the new entity instance is set to edited entity container.
Event sent when the view is validated on saving the view data context.
Standard implementation of the
EntityJsonTransformer.Base class of entity list views.
Base class of main views containing
AppLayout.A possible outcome of views extending
StandardDetailView and StandardListView.The serialization implementation using standard Java serialization and allowing beans to be restored on deserialization
Base class of regular views opened either inside
AppLayout or in a DialogWindow.Specifies a data store name for an entity.
Defines a data store used in the application.
Describes the type of a data store.
Utility class for accessing registered data store names.
Substitutes variables within a string by values.
Annotation marks which elements should be ignored in the Studio.
Type of
StudioProperty.Annotation for declarative event handler methods in UI controllers.
A registration object for removing an event listener added to a source.
Authentication object used by the user substitution mechanism.
An interface to be implemented by
ViewNavigator that fires SupportsAfterViewNavigationHandler.AfterViewNavigationEvent.Enum for describing the position of label components.
An interface used in describing the responsive layouting behavior of an implementing layout.
SupportsStatusChangeHandler<C extends com.vaadin.flow.component.Component>
A component that supports delegation of status changes e.g.
SupportsStatusChangeHandler.StatusContext<C extends com.vaadin.flow.component.Component>
SupportsTypedValue<C extends com.vaadin.flow.component.Component,E extends com.vaadin.flow.component.HasValue.ValueChangeEvent<P>,V,P>
Implementation of the
OidcUserMapper that not only maps the external user object to the persistent user
entity, but also stores the user and optionally their role assignment to the database.Provides ad-hoc authentication, i.e.
Operation with a result to be used in
SystemAuthenticator.withSystem(AuthenticatedOperation)
and SystemAuthenticator.withUser(String, AuthenticatedOperation).Indicates that annotated entity/field is low-level and should not be available for end-user in various entity/field lists.
Can be used to notify
ViewController about task completion.A user task completion builder used in custom process forms
Copies JavaScript and CSS files from JAR files into a given folder.
Copies JavaScript files from the given local frontend folder.
Copies template files to the target folder so as to be available for parsing
at runtime in production mode.
Copy themes files from {projectFolder}/frontend/themes
to {projectFolder}/.jmix/screen-designer/frontend/themes
A task for generating the bootstrap file
FrontendUtils.BOOTSTRAP_FILE_NAME during `package` Maven goal.Generate the TS files for endpoints, and the Client API file.
A task for generating the feature flags file
FrontendUtils.FEATURE_FLAGS_FILE_NAME during `package` Maven goal.Generate the Vaadin TS files for endpoints, and the Client API file.
Generate
index.html if it is missing in frontend folder.Generate
index.ts if it is missing in frontend folder.Generate OpenAPI json file for Vaadin Endpoints.
Creates the
package.json if missing.Generate
index.html if it is missing in frontend folder.Generate
tsconfig.json if it is missing in project folder.Generate
types.d.ts if it is missing in project folder and
tsconfig.json exists in project folder.Generate
vite-devmode.ts if it is missing in frontend/generated
folder.Task that installs any Flow webpack plugins into node_modules/@vaadin for use
with webpack compilation.
Lifecycle object that is passed to
BackgroundTask.run(TaskLifeCycle) method to allow working thread to
interact with the execution environment.Class is used for building condition expressions for outcomes of multi-instance user tasks.
Class returns a list of sequence flow condition types.
Compiles the dev mode bundle if it is out of date.
Run
npm install after dependencies have been updated.Container for npm installation statistics.
An updater that it's run when the servlet context is initialised in dev-mode
or when flow-maven-plugin goals are run in order to update Flow imports file
and "jar-resources" contents by visiting all
classes with
JsModule and Theme annotations.Updates
package.json by visiting NpmPackage annotations
found in the classpath.Creates a vaadin-dev-server-settings.json file for use with dev server
configuration.
Task generating the theme definition file 'theme.js' for importing
application theme into the generated frontend directory.
Updates the Vite configuration files according with current project settings.
API for uploading files to the temporary storage.
Listener to be notified about the progress of uploading file into the temporary storage.
Helper for working with tenant entity.
Marked entity field will be used to store information about user tenant.
Provides the current tenant id.
Implementation of
TenantProvider based on CurrentAuthentication.The main goal of this class is supporting backward navigation in UI integration tests.
The main goal of this class is supporting backward navigation in UI integration tests.
Mocked servlet context.
Disables atmosphere because testing server-side
View does not require
connection with client-side.Mocks
HttpServletRequest.The main goal of this class is supporting backward navigation in UI integration tests.
A wrapper for the Theme instance that use reflection for executing its
methods.
TimeDatatype works with java.sql.Time but is parametrized with java.util.Date
to avoid problems with casting.Global time source interface.
Standard implementation of
TimeSource interface.Base interface for date/time validators which contains all restrictions.
A
Datatype that supports correct presentation with timezone.The class is used for converting a list of role codes specified for the client in properties file into the list of
RoleGrantedAuthority.Annotation for event types that forces
EventHub to unsubscribe listeners for this event type after invocation.Abstract typed
MethodArgumentResolver classClass checks UI access permission.
Interface that allows to read/write state of UI from background threads.
Provides
Locale from VaadinSession.getCurrent() instance that should be used if current
authentication is anonymous.Bean validation constraint group used by UI for fields validation.
Factory for creating UI components.
Factory to create UI components using
ComponentGenerationStrategy.Bean validation constraint group used by UI for cross-field validation.
Bean validation constraint group used by UI for cross-field validation.
Sends application events that should be handled in the components (e.g.
Interface to be implemented by exception handlers
Class stores the information required for report running from UI.
Interface is used for running reports from UI
The annotation is used for testing Flow UI views on JUnit.
Dummy class.
Interface to be implemented by classes for managing application authentication.
Class provides helper methods for testing.
Event that is fired for UI when substitutions for a user are changed.
Central interface to provide CRUD functionality for entities.
Handles database unique constraint violations.
Allows configuring how to process a case if the entity with the same values of the particular properties already exists.
Exception thrown for when a node task that is not in the task list is
encountered.
Thrown when user provides template file not supported by any formatter declared in formatter factory
Thrown when user choose data loader not supported in data loader factory
Class provides helper methods to work with
JmixUploadI18N.An interface to be implemented by an object that binds UI component with query parameters.
An event which is fired when a query parameters binder informs that
its internal state has been changed and it should be reflected on
URL's query parameters.
Allows resolving the current authorized
UserDetails as method argument.Extracts from given process definition XML all process variables with UserDetails type.
Instances of this class are set as authentication principal to the security context when resource server API are
accessed
Maps LDAP user to user details obtained from
UserDetailsService.This event is used to notify listeners about user invalidation: when the user has been disabled.
Indicates that an annotated class is a "userGroupListProvider".
REST controller that is used for getting an information about the current user
Class that is used by the
UserInfoController for getting an information
about the current userIndicates that an annotated class is a "userListProvider".
Interface provides API for some actions with users
Non-persistent entity used to display usernames in UI
Base class for user password changed event.
Class for user password reset event.
Indicates that an annotated class is a "userProvider".
This event is used to notify listeners about user invalidation: when the user has been removed.
An extended
UserDetailsService defining methods specific to Jmix.Provides information about current active user sessions
Event published after user substituted and new
Authentication is set to current SecurityContext.Class stores user substitution information.
Interface is used for getting possible substituted users and for performing the substitution operation.
Interface to be implemented by classes that provide
UserSubstitution.Event that is fired when substitutions for a user are changed.
An event listener that publishes a Spring application event when a user task is assigned to a user.
An event listener that publishes a Spring application event when a user task is completed.
An event listener that publishes a Spring application event when a user task is created.
Central interface for working with user task results.
Deprecated.
Updates entity mappings to add UUID support even for databases that do not support UUID datatype directly.
Provides static method to create UUIDs.
Describes validation errors.
Exception to be thrown by field validators.
Thrown when data loader met invalid input parameters
Marker interface to indicate that the implementing class can be used as a validator.
Specific bean for loading validators.
Class that defines parameters for loading values from the database via
UnconstrainedDataManager.loadValues(ValueLoadContext).Class that defines a query to be executed for loading values.
Utility class to format and parse component paths.
Data component holding a typed value.
An event that is fired when value of source is changed.
Provides instances of
ValueSource, for instance, for child components.REST controller that is used for getting REST API version
Class that is used by
VersionController for getting REST API versionBase class for UI views.
The second (after
View.BeforeCloseEvent) event in the view closing process.The first event in the view closing process.
The second (after
View.InitEvent) event in the view opening process.The first event in the view opening process.
An event informing which query parameters the view is opened with.
The last (after
View.BeforeShowEvent) event in the view opening process.Class provides mechanism for setting/getting attributes that uses
VaadinSession as store.Class describes attributes map that corresponds to a certain view in a browser tab.
Provides a fluent interface to configure navigation parameters and navigate to a
View.Indicates that the annotated class is a view controller.
Class provides information about view controller.
Configuration that performs ClassPath scanning of
ViewControllers and provides ViewControllerDefinition.Class sorts the list of
ViewControllersConfiguration in the same order as Jmix modules containing the screens
have been sorted.Interface defining methods for interacting with data API elements of a view.
Indicates that the annotated
ViewController is linked to an XML template.Class is designed for processing navigation in UI integration tests.
Provides a fluent interface to configure navigation parameters and navigate to a
View.Provides fluent interface for navigating to views.
Interface to be implemented by actions that open a view.
Defines view resource policy in annotated resource role.
Provides information about all registered views.
Creates UI view instances.
Callbacks holder for save changes dialog.
Callbacks holder for unsaved changes dialog.
Loads view XML descriptors.
Parses view XML taking into account 'assign' elements.
Handles communication with a Vite server.
Communicates with a Vite server through a websocket connection.
The websocket endpoint for Vite.
Connects a browser-server websocket connection with a server-Vite websocket
connection.
Under the hood it is
CronHoliday, used for more convenient work with weekly holidays, like "Every Sunday" or
"Every Saturday" e.g.Defines weekly holiday in annotated business calendar (see
BusinessCalendar).Provides a fluent interface to configure and open a view in a
DialogWindow.Document formatter for '.xls' file types
Bounds of region [(x,y) : (x1, y1)]
Cell range at sheet
Provides inheritance of screen XML descriptors.
QueryParamValueProviders.