Actor Editor

Overview

Actor Editor is a tool which enables creation of new Actors either based on an existing Actor or from scratch, based on your own Java class.

The Actor Editor is displayed as a dummy flow with one Actor that can be setup / modified using the extended Actor's Properties window.

When creating a new Actor, you need to do the following:

• Set either the Parent Actor to inherit from the existing Actor or the Class to be used for custom logic.
• Define inputs and outputs as required.
• Test your Actor by running it in Debug mode.

This article describes the following:

• How to create an inherited Actor.
• How to create a new Actor from scratch.
• How to modify the Actor's input arguments.
• How to create custom editor (plug-in) for Actor's input arguments.

How Do I Create an Inherited Actor?

The Actor Editor can be used to create a new inherited Actor or modify an existing one via its [Actor Name].actor file. The Actor must inherit either from another Actor or from an Inner Flow that has been saved as an Actor.

To create a new Actor, do the following:

1. Right click the Broadway > New Actor.
2. Populate the new Actor's name and click OK to open the Actor Editor.
3. Select the Parent Actor to get the parent's input and output arguments.
4. Debug the Actor by running it from the Main menu toolbar. If the Actor receives input parameters, they can be set using the Debug / Run Arguments.
5. Save the Actor.

To modify an Actor, do the following:

1. Go to the Broadway folder in the project tree and double click the *.actor file to open the Actor Editor.
2. Modify the required settings, for example set a value of an input argument.
3. Debug the Actor by running it from the Main menu toolbar. The Actor's input parameters can be set using the Debug / Run Arguments.
4. Save the Actor. The change impacts every flow where this Actor is used.

How Do I Create a New Actor from Scratch?

Broadway enables you to create an Actor that inherits its properties and behaviors from a custom Java class rather than from another Actor.

To create a new Actor from scratch, do the following:

1. Create your own Java class: Right click the Java folder in the Project tree either in the Shared Object or under the Logical Unit. Then click New Java File.

2. Define the class as follows to inherit the core Actor's properties and behaviors:

   public class <class_name> implements Actor {
   }

Or

   public class <class_name> extends <core_actor_name> {
   }

3. Implement an action method to define the Actor's logic. For example, when the Actor has an input argument caseId and an output argument status, the method will be as follows:

  @Override
  public void action(Data input, Data output) throws Exception {
      final String caseId = input.string("caseId");
      try {
          //your logic ....
          output.put ("status", "OK");
      } catch (Exception e){
          handleError(e, output);
      }
  }

4. If the Actor maintains a state, implement a close method to reset it.

5. Since the Actors are serialized when running in Recovery mode and their input/output values are serialized to be displayed in the Data Viewer, make sure that Actor, its members and input/output fields are either serializable or transient.

6. Once this new Java class is ready, create a new Actor. Right click the Broadway folder and click New Actor.

7. Populate the Class with your Java class's path. For example, when the Java class is located under the Logical Unit, the class is:

   com.k2view.cdbms.usercode.lu.<lu_name>.<class_name>

8. Click Add Input and Add Output to define the Actor's input and output arguments according to the Java class definition. Note that the Actor's input and output arguments must correspond the Java class definition.

How Do I Modify the Input Argument Type?

The Actor's input argument type can be modified from the default type to other type using the plug-ins.

To change the type, do the following:

1. In the Actor Editor, click Add Input to add a input argument and then click> Set Editor in the input field to open the editor.

   

2. Modify the default to one of the following types as follows:

   • To define a drop-down list of values:

    {
      "id": "com.k2view.dropdown",
      "options": [
        "1",
        "2"
      ]
    }
   

   • To define an input from a list of Broadway flows:

    { 
        "id": "com.k2view.innerflow" 
    }
   

   • To define an input from a list of Logical Units:

    {
      "id": "com.k2view.logicalUnit",
      "addEmptyEntry": true
    }
   

   • To define an input from a list of Interfaces:

    {
      "id": "com.k2view.interface",
      "interfaceType": [
        "database"
      ]
    }
   

   • The full list of existing editors can be found in under Server/fabric/staticWeb/editors folder.

3. Click Submit to close the editor.

4. Then clickagain and switch the Link Type from Link to Const.

   

How Do I Create a Custom Editor?

Broadway allows creating custom editors (plug-ins) for input argument types on a project level. In order to create a custom editor, do the following:

1. Create a folder called as your editor's name under the Server/fabric/staticWeb/editors folder.

   • This folder must include the index.html file and optionally any other folders and/or files required by this editor.
   • As the product built-in editors are also located in the same folder, the custom editor’s folder naming convention is not to start with “com.k2view”.

2. In the index.html file, implement the broadwayPluginLoad function that receives a broadwayPluginAPI object.

   • The examples of the function implementation can be found in the staticWeb under any of the existing editors.

3. In the Actor Editor, click Add Input to add a input argument and then click> Set Editor in the input field to open the editor. Then modify the default to the name of your editor.

4. If your editor receives additional inputs, add them to the definition map in the same way as for the existing editors (see the examples above).

Note that the Server/fabric/staticWeb/editors folder includes all the existing built-in editors. Thus even though you can modify the code of the built-in editor, it's not recommended to do so because your changes will be lost during the Fabric's version upgrade.

Examples of New Actor Creation

New Actor Which Inherits from Existing Actor

Let's create a new CheckMaxVal Actor that inherits its properties and behaviors from a JavaScript Actor: It receives two integers and returns their maximum value. Do the following:

1. Right click the Broadway folder in the Project tree and click New Actor.

2. Populate the CheckMaxVal Actor's name and click OK.

3. Define the Actor as follows:

   • Set Badge to Max.
   • Clickin the Parent field to select the JavaScript Actor using the Add Actors window.
   • Populate the script input argument with the regex: a > b ? a : b.
   • Click Add Input to add two input arguments and update their names to a and b.

4. Set the values of an Actor's input parameters using the Debug / Run Arguments in the Main menu toolbar and debug the Actor.

5. Once the debug has finished, close the Actor Editor and add the Actor to the required flow.

New Actor Which Inherits from Custom Java Class

When creating a new Actor which inherits from custom Java class, do all the steps until the selection of Parent. Instead, populate the Class with your customer Java class name.

Then define the required input and output arguments and run the Actor to debug it.

​

If an input field should be different than default, click> Advanced in the input field and change the type in the editor. For example, as follows:

{
  "id": "com.k2view.dropdown",
  "options": [
    "1",
    "2",
    "3",
    "4",
    "5"
  ]
}

​