The Node Class

The annotation

The annotation specifies the outcome provider and configuration class. The outcome provider can use the default SingleOutcomeNode or MultipleOutcomeNode, or a custom OutcomeProvider can be created and referenced from the annotation.

See the Choice Collector Node for an example of a custom outcome provider.

Any private constants

The config

The config interface defines the configuration data for a node. A node cannot have state, but it can have configuration data.

Note that you do not need to provide the implementation class for the Config interface you define. AM will create these automatically, as required.

An example is the Account lockout Node. The node can be configured to lock or unlock the users' account, based on it’s configuration.

Configuration is per-node. Different nodes of the same type in the same tree have their own configuration.

The config interface configures values using methods. To provide no default value to the tree administrator, provide the method's signature but not the implementation. To provide a default value to the tree administrator, mark the method as default and provide both a method and a value. For example:

public interface Config {

  //This will have no default value for the UI
  @Attribute(order = 10)
  String noDefaultAttribute();

  //This will default to the value LOCK.
  @Attribute(order = 20)
  default LockStatus lockAction() {
    return LockStatus.LOCK;
  }
}

The Config above would resemble the following in the tree designer view:

The @Attribute annotation is required. It can be configured with an order value, which determines the position of the attribute in the UI, and with validators, to validate the values being set.

In the example above, a custom enum called LockStatus is returned. The options are displayed to the user automatically.

The constructor

Dependencies should be injected by using Guice as this makes it easier to unit test your node. For example, you should accept the config as a parameter.

You may also wish to obtain AM core classes, such as CoreWrapper, instances of third-party dependencies, or your own types.

@Inject
public AccountLockoutNode(CoreWrapper coreWrapper, @Assisted Config config)
throws NodeProcessException {
  this.coreWrapper = coreWrapper;
  this.config = config;
}

The process method

The process method takes a TreeContext parameter, does some processing, and returns an Action object.

An action encapsulates changes to state and flow control. The TreeContext parameter is used to access the request, callbacks, shared state and other input.

The process method is where state is retrieved and stored. The returning Action can be a response of callback to the user, an update of state, or a choice of outcome.

The choice of outcome in a simple decision node would be true or false, resulting in the authentication tree flow moving from the current node to a node at the relevant connection.

Any private methods

Optionally, a custom outcome provider