Before you declare the class, you must name the package.

Put the class in a package named appropriately. The package name is used to identify the Open Tool when installing it.

package com.myCompany.OpenTools;

There are two basic approaches to developing an Open Tool:

• Extend an existing class that you want to convert into an Open Tool. In this case, simply implement the interface IOpenTool directly on the existing class.

• Develop a new class. In this case, it is easiest to extend the abstract class OpenToolAbstract. This abstract class also contains additional helper methods for working with parameters.

  public class SimpleMessageBox extends OpenToolAbstract {
  

Almost every Open Tool must import the following Open Tool SDK packages:

import oracle.odi.sdk.opentools.IOpenTool; /* All Open Tool classes need these three classes */

import oracle.odi.sdk.opentools.IOpenToolParameter;

import oracle.odi.sdk.opentools.OpenToolExecutionException;

import oracle.odi.sdk.opentools.OpenToolAbstract; /* The abstract extended for the Open Tool */

import oracle.odi.sdk.opentools.OpenToolParameter; /* The class used for parameters */

In this particular example, a package to create the message box is also needed:

import javax.swing.JOptionPane; /* Needed for the message box used in this example */

Add a property to store the OpenToolParameter objects. This is used to both define them for the syntax, and to retrieve the values of the parameters from the eventual user. It is easiest to define the parameters of the Open Tool with a static array as follows. This array should be private, as it will be accessed through an accessor function.

private static final IOpenToolParameter[] mParameters = new IOpenToolParameter[]
{
    new OpenToolParameter("-TEXT", "Message text", "Text to show in the messagebox (Mandatory).", true),
    new OpenToolParameter("-TITLE", "Messagebox title", "Title of the messagebox.", false)
};

The four parameters passed to the OpenToolParameter() constructor are as follows:

1. The code of the parameter, including the initial hyphen. This code must correspond to the syntax returned by getSyntax().

2. The user-friendly name, which is used if the user is using the graphical interface to set parameters.

3. A descriptive help text.

4. Whether the parameter is mandatory. This is an indication to the user.

   Note:

   Oracle Data Integrator does not enforce the mandatory flag on parameters. Your class must be able to handle any combination of parameters being provided.

You must implement the accessor function getParameters() to retrieve the parameters:

public IOpenToolParameter[] getParameters()
{
      return mParameters;
}

Implement functions to return information about your Open Tool: getDescription(), getVersion(), getProvider().

public String getDescription() { return "This Open Tool displays a message box when executed."; }
public String getVersion() { return "v1.0"; }
public String getProvider() { return "My Company, Inc."; }

The getSyntax() function determines the name of the Open Tool as it is displayed in the Oracle Data Integrator graphical interface, and also the initial values of the parameter. Make sure the names of the parameters here match the names of the parameters returned by getParameters().

public String getSyntax()
{
        return "SimpleMessageBox \"-TEXT=<text message>\" \"-TITLE=<window title>\"";
}

The getIcon() method should then return paths to two appropriately sized images. It should look something like this:

public String getIcon(int pIconType)
{
        switch (pIconType)
        {
               case IOpenTool.SMALL_ICON:
               return "/com/myCompany/OpenTools/images/SimpleMessageBox_16.gif";
             case IOpenTool.BIG_ICON:
             return "/com/myCompany/OpenTools/images/SimpleMessageBox_32.gif";
             default:
             return "";
     }
}

Finally, the execute() method, which carries out the functionality provided by the Open Tool. In this case, a message box is shown. If you are extending the OpenToolAbstract class, use the getParameterValue() method to easily retrieve the values of parameters, as they are set at runtime.

public void execute() throws OpenToolExecutionException
{
     try
     {
     if (getParameterValue("-TITLE") == null || getParameterValue("-TITLE").equals("")) /* title was not filled in by user */
     {
               JOptionPane.showMessageDialog(null, (String) getParameterValue("-TEXT"), (String) "Message", JOptionPane.INFORMATION_MESSAGE);
          } else
          {
               JOptionPane.showMessageDialog(null, (String) getParameterValue("-TEXT"),
                       (String) getParameterValue("-TITLE"),
                       JOptionPane.INFORMATION_MESSAGE);
          }
     }
     /* Traps any exception and throw them as OpenToolExecutionException */
     catch (IllegalArgumentException e)
     {
          throw new OpenToolExecutionException(e);
     }
}