Define Java Transformation Processors

1. Under Transformation processors, click Add processor.
2. In Add processor, select Java, give a name to the processor, and then choose one of the following default processors.

   Transformation Processor	Description
   Basic Arc Creation Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. CreateArcBasedOnMetaValueTransformationProcessor Creates an arc from the processed document. The target is the value of the given meta name.
   Basic Document Creation Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. CreateDocumentBasedOnMetaValueTransformationProcessor Creates a managed document from the processed document. The target is the value of the given meta name.
   Set Directive Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. SetDirectiveTransformationProcessor Sets the given directive on the processed document
   Set Meta Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. SetMetaTransformationProcessor Set the given meta on the processed document
   Set Type Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. SetTypeTransformationProcessor Sets the given type on the processed document
   Split Text Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. SplitTextTransformationProcessor Splits the given source meta using the specified delimiting regex pattern, and add/set the result to the target meta. Note: The target meta must be multivalued to contain all text chunks resulting from the split operation.
   Storage Service Key Linker Processor	Class Id: com.exalead.cloudview.consolidation.processors.java.classic. StorageServiceKeyLinkerTransformationProcessor Create arcs between the Storage Service data and the document it is linked to. For a use case example, see UC-8: Consolidating Data from Storage Service.

3. Click Apply.

To define a Java Transformation processor in the create/update action context, you need to implement the IJavaAllUpdatesTransformationProcessor interface.

/**
 * Defines the interface for all the Java transformation processors that
 * need to perform operations in a non-delete context.
 */
public interface IJavaAllUpdatesTransformationProcessor extends IJavaTransformationProcessor {
    /**
    * Performs the add or update operations of the client’s processor for the 
    * the document transmitted, with the help of the handler provided.
    * @param handler The transformation handler providing the allowed operations for the processor.
    * @param document The reference document.
    * @throws Exception Occurs for whatever reason in the client's implementation.
    * The exception will most likely be wrapped with contextual information before further propagation.
    */
    public void process(final IJavaAllUpdatesTransformationHandler handler, 
                        final IMutableTransformationDocument document) throws Exception;
}

The parent interface is defined as follows:

/**
 * Defines the common operations for all Java transformation processors.
 */
public interface IJavaTransformationProcessor extends CVComponent {
    /**
    * Returns a document type on which the processor will perform a transformation.
    * If one returns null or an empty string, then it will be applied on all source documents.
    * @return A valid document type or null or empty string.
    */
    public String getTransformationDocumentType();
}

The following picture shows the complete class hierarchy associated with the Java transformation processors in the create/update action context.

The handlers hierarchy (in green) defines the list of operations allowed for the processor and for the particular action context. The documents hierarchy (in purple) defines the document received with the transformations allowed on them.

If you implement the IJavaAllUpdatesTransformationProcessor interface as requested, you then have to implement the two following methods with a particular constructor receiving the component config.

@CVComponentDescription("My First Transformation Processor Component")
@CVPluginVersion("1.0")
@CVComponentConfigClass(configClass=MyComponentConfig.class)
public class MyFirstTransformationProcessor implements IJavaAllUpdatesTransformationProcessor {
    public MyFirstTransformationProcessor(final MyComponentConfig config) {
    }

    @Override
    public String getTransformationDocumentType() {
        return "city";
    }

    @Override
    public void process(final IJavaAllUpdatesTransformationHandler handler,
                         final IMutableTransformationDocument document) throws Exception {
        // Do nothing, that is transmit all "city" documents to the next processor 
        // or to the Consolidation Store.
        logger.info("Processing " + document.getURI());
    }
        private final Logger logger = Logger.getLogger("app-name.conso-server.transformation");

}

Once the code above in packaged and deployed on the Exalead CloudView instance, you can define its associated source as shown below.

In this simple example:

• We defined a constructor with the component config instance that you can use to customize the processor using end-user properties. Here we do not store the instance because we have no use for it. In general, we would save the instance in the processor class and use it in the process method to read specific properties. A component configuration is always required for the definition of each of your Java processors.

• The processor treats the documents coming from the cities source connector.

• The processor also treats, from such source, documents with the city type only. The rules of selection are detailed in Processor Type Inheritance and Runtime Selection.

• The process method contains the processor implementation. Here it contains no action (except from the logging), so all city documents from the cities source connector is automatically transmitted to the next available transformation processor, or to the Consolidation Store.

You can reduce the config class to the following implementation:

public final class MyComponentConfig implements CVComponentConfig {
  // No property defined
}

Similarly, in the delete action context you need to implement the IJavaDeleteTransformationProcessor interface. The methods to implement are mostly the same, except from the process method, which has a different signature, to emphasize that in such context, allowed operations are different from in the other one. Here is the class hierarchy defined in a delete action context: