D-Net

package eu.dnetlib.actionmanager.actions;

import java.util.List;

import java.util.Map;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.io.DocumentSource;

import org.dom4j.io.SAXReader;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.core.io.Resource;

import com.google.common.collect.Lists;

import eu.dnetlib.actionmanager.common.Agent;

import eu.dnetlib.actionmanager.common.Operation;

import eu.dnetlib.actionmanager.common.Provenance;

import eu.dnetlib.actionmanager.rmi.ActionManagerException;

import eu.dnetlib.data.proto.TypeProtos.Type;

import eu.dnetlib.miscutils.datetime.DateUtils;

/**

 * Factory bean to create Actions bypassing the Action Manager API

 * 

 * @author michele

 */

public class ActionFactory {

	private static final Log log = LogFactory.getLog(ActionFactory.class);

	private Map<String, Resource> xslts;

	final TransformerFactory tFactory = TransformerFactory.newInstance();

	/**

	 * Creates a list of AtomicAction(s) to handle an UPDATE. Produces one Oaf, stored in CF = [entity]:update_[timestamp]

	 * 

	 * @param set

	 *            the given set.

	 * @param agent

	 *            the given agent.

	 * @param originalId

	 *            main entity identifier to be updated (already existing in the information space).

	 * @param entityType

	 *            one of: result, person, project, datasource, organization {@link eu.dnetlib.data.proto.TypeProtos.Type}.

	 * @param updateContent

	 *            content to be updated over the original main entity. Oaf#OafEntity#[entity]#id must be consistent with the originalId.

	 *            note that: the given trust level has to be [>.9 | NEUTRAL | INFINITE] in order to gain visibility after the merging

	 *            process.

	 * @return the list of AtomicActions.

	 */

	public List<AtomicAction> createUpdateActions(final String set,

			final Agent agent,

			final String originalId,

			final Type entityType,

			final byte[] updateContent) {

		List<AtomicAction> res = Lists.newArrayList();

		res.add(createAtomicAction(set, agent, originalId, entityType.toString(), "update_" + DateUtils.now(), updateContent));

		return res;

	}

	public AtomicAction createAtomicAction(final String set,

			final Agent agent,

			final String targetKey,

			final String targetColFamily,

			final String targetCol,

			final byte[] targetContent) {

		AtomicAction action = new AtomicAction(set, agent);

		action.setTargetRowKey(targetKey);

		action.setTargetColumnFamily(targetColFamily);

		action.setTargetColumn(targetCol);

		action.setTargetValue(targetContent);

		return action;

	}

	public XsltInfoPackageAction generateInfoPackageAction(final String xsltResource,

			final String rawSet,

			final Agent agent,

			final Operation operation,

			final String infoPackage,

			final Provenance provenance,

			final String nsprefix,

			final String trust) throws ActionManagerException {

		final Transformer transformer = prepareXsltTransformer(xsltResource);

		return new XsltInfoPackageAction(rawSet, agent, operation, infoPackage, provenance, nsprefix, trust, transformer, this);

	}

	public Transformer prepareXsltTransformer(final String xsltName) throws ActionManagerException {

		try {

			if (!xslts.containsKey(xsltName)) { throw new ActionManagerException("XSLT " + xsltName + " not found"); }

			final Document doc = new SAXReader().read(xslts.get(xsltName).getInputStream());

			if (log.isDebugEnabled()) {

				log.debug("using transformer factory: '" + tFactory.getClass().getName() + "'");

				log.debug("xslt: \n" + doc.asXML());

			}

			return tFactory.newTransformer(new DocumentSource(doc));

		} catch (Exception e) {

			throw new ActionManagerException("Problem with xslt resource " + xsltName, e);

		}

	}

	public Map<String, Resource> getXslts() {

		return xslts;

	}

	@Required

	public void setXslts(final Map<String, Resource> xslts) {

		this.xslts = xslts;

	}

}