AbstractScriptedPropertyTransformation.java

/*
 * Copyright (c) 2012 Data Harmonisation Panel
 * 
 * All rights reserved. This program and the accompanying materials are made
 * available under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Contributors:
 *     Data Harmonisation Panel <http://www.dhpanel.eu>
 */

package eu.esdihumboldt.hale.common.scripting.transformation;

import java.text.MessageFormat;
import java.util.Map;

import javax.script.ScriptException;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;

import eu.esdihumboldt.hale.common.align.model.ParameterValue;
import eu.esdihumboldt.hale.common.align.model.impl.PropertyEntityDefinition;
import eu.esdihumboldt.hale.common.align.transformation.engine.TransformationEngine;
import eu.esdihumboldt.hale.common.align.transformation.function.PropertyTransformation;
import eu.esdihumboldt.hale.common.align.transformation.function.PropertyValue;
import eu.esdihumboldt.hale.common.align.transformation.function.TransformationException;
import eu.esdihumboldt.hale.common.align.transformation.function.impl.AbstractPropertyTransformation;
import eu.esdihumboldt.hale.common.align.transformation.report.TransformationLog;
import eu.esdihumboldt.hale.common.core.io.Value;
import eu.esdihumboldt.hale.common.scripting.Script;
import eu.esdihumboldt.hale.common.scripting.ScriptExtension;
import eu.esdihumboldt.hale.common.scripting.ScriptFactory;

/**
 * Base class for {@link PropertyTransformation} that supports evaluating
 * scripted parameters.
 * 
 * @param <E> the transformation engine type
 * @author Kai Schwierczek
 */
public abstract class AbstractScriptedPropertyTransformation<E extends TransformationEngine>
		extends AbstractPropertyTransformation<E> {

	private ListMultimap<String, Value> transformedParameters;

	@Override
	protected final ListMultimap<String, Object> evaluate(String transformationIdentifier, E engine,
			ListMultimap<String, PropertyValue> variables,
			ListMultimap<String, PropertyEntityDefinition> resultNames,
			Map<String, String> executionParameters, TransformationLog log)
					throws TransformationException {
		ListMultimap<String, ParameterValue> originalParameters = getParameters();
		ListMultimap<String, Value> transformedParameters = ArrayListMultimap.create();

		if (originalParameters != null) {
			for (Map.Entry<String, ParameterValue> entry : originalParameters.entries()) {
				if (!entry.getValue().needsProcessing()) {
					Value value = entry.getValue().intern();
					if (!value.isRepresentedAsDOM()) {
						value = Value.simple(getExecutionContext().getVariables()
								.replaceVariables(value.getStringRepresentation()));
					}
					transformedParameters.put(entry.getKey(), value);
				}
				else {
					// type is a script
					ScriptFactory factory = ScriptExtension.getInstance()
							.getFactory(entry.getValue().getType());
					if (factory == null)
						throw new TransformationException("Couldn't find factory for script id "
								+ entry.getValue().getType());
					Script script;
					try {
						script = factory.createExtensionObject();
					} catch (Exception e) {
						throw new TransformationException("Couldn't create script from factory", e);
					}
					Object result;
					try {
						String scriptStr = entry.getValue().as(String.class);
						if (script.requiresReplacedTransformationVariables()) {
							// replace transformation variables
							scriptStr = getExecutionContext().getVariables()
									.replaceVariables(scriptStr);
						}
						result = script.evaluate(scriptStr, variables.values(),
								getExecutionContext());
					} catch (ScriptException e) {
						throw new TransformationException(
								"Couldn't evaluate a transformation parameter", e);
					}
					// XXX use conversion service instead of valueOf?
					transformedParameters.put(entry.getKey(), Value.simple(result));
				}
			}
		}

		this.transformedParameters = Multimaps.unmodifiableListMultimap(transformedParameters);

		return evaluateImpl(transformationIdentifier, engine, variables, resultNames,
				executionParameters, log);
	}

	/**
	 * Execute the evaluation function as configured. The transformed parameters
	 * are available in here.
	 * 
	 * @param transformationIdentifier the transformation function identifier
	 * @param engine the transformation engine that may be used for the function
	 *            execution
	 * @param variables the input variables
	 * @param resultNames the expected results (names associated with the
	 *            corresponding entity definitions)
	 * @param executionParameters additional parameters for the execution, may
	 *            be <code>null</code>
	 * @param log the transformation log to report any information about the
	 *            execution of the transformation to
	 * @return the evaluation result
	 * @throws TransformationException if an unrecoverable error occurs during
	 *             transformation
	 */
	protected abstract ListMultimap<String, Object> evaluateImpl(String transformationIdentifier,
			E engine, ListMultimap<String, PropertyValue> variables,
			ListMultimap<String, PropertyEntityDefinition> resultNames,
			Map<String, String> executionParameters, TransformationLog log)
					throws TransformationException;

	/**
	 * Returns the transformed parameters.
	 * 
	 * @return the transformed parameters
	 */
	protected ListMultimap<String, Value> getTransformedParameters() {
		return transformedParameters;
	}

	/**
	 * Get the first evaluated parameter defined with the given parameter name.
	 * Throws a {@link TransformationException} if such a parameter doesn't
	 * exist.
	 * 
	 * @param parameterName the parameter name
	 * @return the parameter value
	 * @throws TransformationException if a parameter with the given name
	 *             doesn't exist
	 */
	protected Value getTransformedParameterChecked(String parameterName)
			throws TransformationException {
		if (transformedParameters == null || transformedParameters.get(parameterName) == null
				|| transformedParameters.get(parameterName).isEmpty()) {
			throw new TransformationException(
					MessageFormat.format("Mandatory parameter {0} not defined", parameterName));
		}

		return transformedParameters.get(parameterName).get(0);
	}

	/**
	 * Get the first evaluated parameter defined with the given parameter name.
	 * If no such parameter exists, the given default value is returned.
	 * 
	 * @param parameterName the parameter name
	 * @param defaultValue the default value for the parameter
	 * @return the parameter value, or the default if none is specified
	 */
	protected Value getTransformedOptionalParameter(String parameterName, Value defaultValue) {
		if (transformedParameters == null || transformedParameters.get(parameterName) == null
				|| transformedParameters.get(parameterName).isEmpty()) {
			return defaultValue;
		}

		return transformedParameters.get(parameterName).get(0);
	}
}