setOpenType() allows you to specify new entity edit screen open mode. THIS_TAB by default.

<table id="usersTable">
  <actions>
      <action id="create" openType="DIALOG"/>

setWindowId() allows you to specify the identifier of the entity edit screen. By default, {entity_name}.edit is used, for example sales$Customer.edit.

setWindowParams() allows you to set edit screen parameters passed into its init() method. The parameters can be further used directly in the datasource query via the param$ prefix or injected into the screen controller using the @WindowParam annotation.

setWindowParamsSupplier() is different from setWindowParams() in that it allows you to get parameter values right before the action is invoked. Supplied parameters are merged with ones set by the setWindowParams() method and can override them. For example:

createAction.setWindowParamsSupplier(() -> {
   Customer customer = metadata.create(Customer.class);
   customer.setCategory(/* some value dependent on the current state of the screen */);
   return ParamsMap.of("customer", customer);
});

setInitialValues() allows you to set initial values of attributes of the entity being created. It takes a Map object, where keys are attribute names, and values are attribute values. For example:

Map<String, Object> values = new HashMap<>();
values.put("type", CarType.PASSENGER);
carCreateAction.setInitialValues(values);

setInitialValuesSupplier() is different from setInitialValues() in that it allows you to get values right before the action is invoked. Supplied values are merged with ones set by the setInitialValues() method and can override them. For example:

carCreateAction.setInitialValuesSupplier(() ->
    ParamsMap.of("type", /* value depends on the current state of the screen */));

setBeforeActionPerformedHandler() allows you to provide a handler which will be invoked by the action before its execution. The method should return true to proceed with the execution and false to abort. For example:

customersTableCreate.setBeforeActionPerformedHandler(() -> {
    showNotification("The new customer instance will be created");
    return isValid();
});

afterCommit() is invoked by the action after the new entity has been successfully committed and the edit screen has been closed. This method does not have implementation and can be overridden in inheritors to handle this event.

setAfterCommitHandler() allows you to provide a handler which will be called after the new entity has been successfully committed and the edit screen has been closed. This handler can be used instead of overriding afterCommit() to avoid creating the action subclass. For example:

@Named("customersTable.create")
private CreateAction customersTableCreate;

@Override
public void init(Map<String, Object> params) {
    customersTableCreate.setAfterCommitHandler(new CreateAction.AfterCommitHandler() {
        @Override
        public void handle(Entity entity) {
            showNotification("Committed", NotificationType.HUMANIZED);
        }
    });
}

afterWindowClosed() is the last method invoked by the action after closing the edit screen regardless of whether the new entity has been committed or not. This method does not have implementation and can be overridden in inheritors to handle this event.

setAfterWindowClosedHandler() allows you to provide a handler which will be called after closing the edit screen regardless of whether the new entity has been committed or not. This handler can be used instead of overriding afterWindowClosed() to avoid creating the action subclass.

setOpenType() allows you to specify entity edit screen open mode. THIS_TAB by default.

<table id="usersTable">
  <actions>
      <action id="edit" openType="DIALOG"/>

setWindowId() allows you to specify entity edit screen identifier. {entity_name}.edit is used by default, for example, sales$Customer.edit.

setWindowParams() allows you to set edit screen parameters, passed to its init() method. The parameters can be further used directly in the datasource query via the param$ prefix or injected into the screen controller using the @WindowParam annotation.

setWindowParamsSupplier() is different from setWindowParams() in that it allows you to get parameter values right before the action is invoked. Supplied parameters are merged with ones set by the setWindowParams() method and can override them. For example:

customersTableEdit.setWindowParamsSupplier(() ->
    ParamsMap.of("category", /* some value dependent on the current state of the screen */));

setBeforeActionPerformedHandler() allows you to provide a handler which will be invoked by the action before its execution. The method should return true to proceed with the execution and false to abort. For example:

customersTableEdit.setBeforeActionPerformedHandler(() -> {
    showNotification("The customer instance will be edited");
    return isValid();
});

afterCommit() is invoked by the action after the entity has been successfully committed and the edit screen has been closed. This method does not have implementation and can be overridden in inheritors to handle this event.

setAfterCommitHandler() allows you to provide a handler which will be called after the new entity has been successfully committed and the edit screen has been closed. This handler can be used instead of overriding afterCommit() to avoid creating the action subclass. For example:

@Named("customersTable.edit")
private EditAction customersTableEdit;

@Override
public void init(Map<String, Object> params) {
    customersTableEdit.setAfterCommitHandler(new EditAction.AfterCommitHandler() {
        @Override
        public void handle(Entity entity) {
            showNotification("Committed", NotificationType.HUMANIZED);
        }
    });
}

afterWindowClosed() is the last method invoked by the action after closing the edit screen regardless of whether the edited entity has been committed or not. This method does not have implementation and can be overridden in inheritors to handle this event.

setAfterWindowClosedHandler() allows you to provide a handler which will be called after closing the edit screen regardless of whether the new entity has been committed or not. This handler can be used instead of overriding afterWindowClosed() to avoid creating the action subclass.

getBulkEditorIntegration() provides a possibility of bulk editing for the table records. The table should have the multiselect attribute enabled. The BulkEditor component will be opened, if multiple table lines are selected when the EditAction is called.

@Named("clientsTable.edit")
private EditAction clientsTableEdit;

@Override
public void init(Map<String, Object> params) {
    super.init(params);

    clientsTableEdit.getBulkEditorIntegration()
        .setEnabled(true)
        .setOpenType(WindowManager.OpenType.DIALOG);
}

setAutocommit() allows you to control the moment of entity removal from the database. By default commit() method is invoked after triggering the action and removing the entity from the datasource. As result, the entity is removed from the database. You can set autocommit property into false using setAutocommit() method or corresponding parameter of the constructor. In this case you will need to explicitly invoke the datasource commit() method to confirm the removal after removing the entity from the datasource.

setConfirmationMessage() allows you to set message text for the removal confirmation dialog.

setConfirmationTitle() allows you to set removal confirmation dialog title.

setBeforeActionPerformedHandler() allows you to provide a handler which will be invoked by the action before its execution. The method should return true to proceed with the execution and false to abort. For example:

customersTableRemove.setBeforeActionPerformedHandler(() -> {
    showNotification("The customer instance will be removed");
    return isValid();
});

afterRemove() is invoked by the action after the entity has been successfully removed. This method does not have implementation and can be overridden.

setAfterRemoveHandler() allows you to provide a handler which will be called after the new entity has been successfully removed. This handler can be used instead of overriding afterRemove() to avoid creating the action subclass. For example:

@Named("customersTable.remove")
private RemoveAction customersTableRemove;

@Override
public void init(Map<String, Object> params) {
    customersTableRemove.setAfterRemoveHandler(new RemoveAction.AfterRemoveHandler() {
        @Override
        public void handle(Set removedItems) {
            showNotification("Removed", NotificationType.HUMANIZED);
        }
    });
}

setRefreshParams() allows you to set parameters passed into the CollectionDatasource.refresh() method to be used in the query. By default, no parameters are passed.

setRefreshParamsSupplier() is different from setRefreshParams() in that it allows you to get parameter values right before the action is invoked. Supplied parameters are merged with ones set by the setRefreshParams() method and can override them. For example:

customersTableRefresh.setRefreshParamsSupplier(() ->
    ParamsMap.of("number", /* some value dependent on the current state of the screen */));

setOpenType() allows you to specify entity selection screen open mode. THIS_TAB by default.

<table id="usersTable">
    <actions>
        <action id="add" openType="DIALOG"/>

setWindowId() allows you to specify entity selection screen identifier. {entity_name}.lookup by default, for example, sales$Customer.lookup. If such screen does not exist, attempts to open {entity_name}.browse screen, for example, sales$Customer.browse.

setWindowParams() allows you to set selection screen parameters, passed into its init() method. The parameters can be further used directly in the datasource query via the param$ prefix or injected into the screen controller using the @WindowParam annotation.

setWindowParamsSupplier() is different from setWindowParams() in that it allows you to get parameter values right before the action is invoked. Supplied parameters are merged with ones set by the setWindowParams() method and can override them. For example:

tableAdd.setWindowParamsSupplier(() ->
    ParamsMap.of("customer", getItem()));

setHandler() allows you to set an object implementing Window.Lookup.Handler interface which will be passed to the selection screen. By default, AddAction.DefaultHandler object is used.

setBeforeActionPerformedHandler() allows you to provide a handler which will be invoked by the action before its execution. The method should return true to proceed with the execution and false to abort. For example:

customersTableAdd.setBeforeActionPerformedHandler(() -> {
    notifications.create()
            .withCaption("The new customer will be added")
            .show();
    return isValid();
});

setConfirm() – flag to show the removal confirmation dialog. You can also set this property via the action constructor. By default it is set to false.

setBeforeActionPerformedHandler() allows you to provide a handler which will be invoked by the action before its execution. The method should return true to proceed with the execution and false to abort. For example:

customersTableExclude.setBeforeActionPerformedHandler(() -> {
    showNotification("The selected customer will be excluded");
    return isValid();
});

setFileName() - sets the Excel file name without extension.

getFileName() - returns the Excel file name without extension.

setBeforeActionPerformedHandler() allows you to provide a handler which will be invoked by the action before its execution. The method should return true to proceed with the execution and false to abort. For example:

customersTableExcel.setBeforeActionPerformedHandler(() -> {
    showNotification("The selected data will ve downloaded as an XLS file");
    return isValid();
});