Package io.jmix.ui.action.list

Class CreateAction<E>

java.lang.Object
io.jmix.ui.action.AbstractAction
io.jmix.ui.action.BaseAction
io.jmix.ui.action.ListAction
io.jmix.ui.action.list.CreateAction<E>
Type Parameters:
E - type of entity
All Implemented Interfaces:
Action, Action.AdjustWhenScreenReadOnly, Action.ExecutableAction, Action.HasPrimaryState, Action.HasTarget, Action.ScreenOpeningAction, Action.SecuredAction
@StudioAction(target="io.jmix.ui.component.ListComponent", description="Creates an entity instance using its editor screen", availableInScreenWizard=true) @ActionType("create") public class CreateAction<E> extends ListAction implements Action.AdjustWhenScreenReadOnly, Action.ScreenOpeningAction, Action.ExecutableAction
Standard action for creating an entity instance using its editor screen.

Should be defined for a list component (Table, DataGrid, etc.) in a screen XML descriptor.

The action instance can be parameterized using the nested properties XML element or programmatically in the screen controller.

  • Field Details

  • Constructor Details

    • CreateAction

      public CreateAction()

    • CreateAction

      public CreateAction(String id)

  • Method Details

    • getOpenMode

      @Nullable public OpenMode getOpenMode()
      Description copied from interface: Action.ScreenOpeningAction
      Returns the screen open mode if it was set by Action.ScreenOpeningAction.setOpenMode(OpenMode) or in the screen XML, otherwise returns null.
      Specified by:
      getOpenMode in interface Action.ScreenOpeningAction

    • setOpenMode

      @StudioPropertiesItem public void setOpenMode(@Nullable OpenMode openMode)
      Description copied from interface: Action.ScreenOpeningAction
      Sets the screen open mode.
      Specified by:
      setOpenMode in interface Action.ScreenOpeningAction
      Parameters:
      openMode - the open mode to set

    • getScreenId

      @Nullable public String getScreenId()
      Returns the editor screen id if it was set by setScreenId(String) or in the screen XML. Otherwise returns null.
      Specified by:
      getScreenId in interface Action.ScreenOpeningAction

    • setScreenId

      @StudioPropertiesItem public void setScreenId(@Nullable String screenId)
      Sets the editor screen id.
      Specified by:
      setScreenId in interface Action.ScreenOpeningAction
      Parameters:
      screenId - the screen id to set

    • getScreenClass

      @Nullable public Class<? extends Screen> getScreenClass()
      Returns the editor screen class if it was set by setScreenClass(Class) or in the screen XML. Otherwise returns null.
      Specified by:
      getScreenClass in interface Action.ScreenOpeningAction

    • setScreenClass

      @StudioPropertiesItem public void setScreenClass(@Nullable Class<? extends Screen> screenClass)
      Sets the editor screen class.
      Specified by:
      setScreenClass in interface Action.ScreenOpeningAction
      Parameters:
      screenClass - the screen class to set

    • setScreenOptionsSupplier

      public void setScreenOptionsSupplier(Supplier<ScreenOptions> screenOptionsSupplier)
      Sets the editor screen options supplier. The supplier provides ScreenOptions to the opened screen.

      The preferred way to set the supplier is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "screenOptionsSupplier")
 protected ScreenOptions petsTableCreateScreenOptionsSupplier() {
     return new MapScreenOptions(ParamsMap.of("someParameter", 10));
 }
      Specified by:
      setScreenOptionsSupplier in interface Action.ScreenOpeningAction

    • setScreenConfigurer

      public void setScreenConfigurer(Consumer<Screen> screenConfigurer)
      Sets the editor screen configurer. Use the configurer if you need to provide parameters to the opened screen through setters.

      The preferred way to set the configurer is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "screenConfigurer")
 protected void petsTableCreateScreenConfigurer(Screen editorScreen) {
     ((PetEdit) editorScreen).setSomeParameter(someValue);
 }
      Specified by:
      setScreenConfigurer in interface Action.ScreenOpeningAction

    • setAfterCloseHandler

      public void setAfterCloseHandler(Consumer<Screen.AfterCloseEvent> afterCloseHandler)
      Sets the handler to be invoked when the editor screen closes.

      The preferred way to set the handler is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "afterCloseHandler")
 protected void petsTableCreateAfterCloseHandler(AfterCloseEvent event) {
     if (event.closedWith(StandardOutcome.COMMIT)) {
         System.out.println("Committed");
     }
 }
      Specified by:
      setAfterCloseHandler in interface Action.ScreenOpeningAction

    • setNewEntitySupplier

      public void setNewEntitySupplier(Supplier<E> newEntitySupplier)
      Sets the new entity supplier. The supplier should return a new entity instance.

      The preferred way to set the supplier is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "newEntitySupplier")
 protected Pet petsTableCreateNewEntitySupplier() {
     Pet pet = metadata.create(Pet.class);
     pet.setName("a cat");
     return pet;
 }

    • setInitializer

      public void setInitializer(Consumer<E> initializer)
      Sets the new entity initializer. The initializer accepts the new entity instance and can perform its initialization.

      The preferred way to set the initializer is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "initializer")
 protected void petsTableCreateInitializer(Pet entity) {
     entity.setName("a cat");
 }

    • setAfterCommitHandler

      public void setAfterCommitHandler(Consumer<E> afterCommitHandler)
      Sets the handler to be invoked when the editor screen commits the new entity.

      The preferred way to set the handler is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "afterCommitHandler")
 protected void petsTableCreateAfterCommitHandler(Pet entity) {
     System.out.println("Created " + entity);
 }

    • setTransformation

      public void setTransformation(Function<E,E> transformation)
      Sets the function to transform the committed in the editor screen entity before setting it to the target data container.

      The preferred way to set the function is using a controller method annotated with Install, e.g.: 

       @Install(to = "petsTable.create", subject = "transformation")
 protected Pet petsTableCreateTransformation(Pet entity) {
     return doTransform(entity);
 }

    • setMessages

      @Autowired protected void setMessages(Messages messages)

    • setIcons

      @Autowired protected void setIcons(Icons icons)

    • setUiComponentProperties

      @Autowired protected void setUiComponentProperties(UiComponentProperties componentProperties)

    • setScreenBuilders

      @Autowired public void setScreenBuilders(ScreenBuilders screenBuilders)

    • setAccessManager

      @Autowired public void setAccessManager(AccessManager accessManager)

    • isPermitted

      protected boolean isPermitted()
      Description copied from class: BaseAction
      Callback method which is invoked by the action to determine its enabled state.
      Overrides:
      isPermitted in class BaseAction
      Returns:
      true if the action is enabled for the current user

    • actionPerform

      public void actionPerform(Component component)
      Description copied from interface: Action
      Invoked by owning component to execute the action.
      Specified by:
      actionPerform in interface Action
      Overrides:
      actionPerform in class BaseAction
      Parameters:
      component - invoking component

    • execute

      public void execute()
      Executes the action.
      Specified by:
      execute in interface Action.ExecutableAction