DSpace/dspace-api/src/main/java/org/dspace/curate/ResolvedTask.java

/**
 * The contents of this file are subject to the license and copyright
 * detailed in the LICENSE and NOTICE files at the root of the source
 * tree and available online at
 *
 * http://www.dspace.org/license/
 */
package org.dspace.curate;

import java.io.IOException;

import org.dspace.content.DSpaceObject;
import org.dspace.core.Context;

/**
 * ResolvedTask wraps an implementation of one of the CurationTask or
 * ScriptedTask interfaces and provides for uniform invocation based on
 * CurationTask methods.
 *
 * @author richardrodgers
 */
public class ResolvedTask
{
	// wrapped objects
	private CurationTask cTask;
	private ScriptedTask sTask;
	// local name of task
	private String taskName;
	// annotation data
	private boolean distributive = false;
	private boolean mutative = false;
	private Curator.Invoked mode = null;
    private int[] codes = null;
	
	
	protected ResolvedTask(String taskName, CurationTask cTask)
	{
		this.taskName = taskName;
		this.cTask = cTask;
		// process annotations
		Class ctClass = cTask.getClass();
		distributive = ctClass.isAnnotationPresent(Distributive.class);
		mutative = ctClass.isAnnotationPresent(Mutative.class);
		Suspendable suspendAnno = (Suspendable)ctClass.getAnnotation(Suspendable.class);
        if (suspendAnno != null)
        {
            mode = suspendAnno.invoked();
            codes = suspendAnno.statusCodes();
        }
	}
	
	protected ResolvedTask(String taskName, ScriptedTask sTask)
	{
		this.taskName = taskName;
		this.sTask = sTask;
		// annotation processing TBD
	}
	
    /**
     * Initialize task - parameters inform the task of it's invoking curator.
     * Since the curator can provide services to the task, this represents
     * curation DI.
     * 
     * @param curator the Curator controlling this task
     * @throws IOException if IO error
     */
    public void init(Curator curator) throws IOException
    {
    	if (unscripted())
    	{
    		cTask.init(curator, taskName);
    	}
    	else
    	{
    		sTask.init(curator, taskName);
    	}
    }

    /**
     * Perform the curation task upon passed DSO
     *
     * @param dso the DSpace object
     * @return status code
     * @throws IOException if error
     */
    public int perform(DSpaceObject dso) throws IOException
    {
    	return (unscripted()) ? cTask.perform(dso) : sTask.performDso(dso);
    }

    /**
     * Perform the curation task for passed id
     * 
     * @param ctx DSpace context object
     * @param id persistent ID for DSpace object
     * @return status code
     * @throws IOException if error
     */
    public int perform(Context ctx, String id) throws IOException
    {
    	return (unscripted()) ? cTask.perform(ctx, id) : sTask.performId(ctx, id);	
    }
    
    /**
     * Returns local name of task
     * @return name
     *         the local name of the task
     */
    public String getName()
    {
    	return taskName;
    }
    
    /**
     * Returns whether task should be distributed through containers
     * 
     * @return whether task should be distributed through containers
     */
    public boolean isDistributive()
    {
    	return distributive;
    }
    
    /**
     * Returns whether task alters (mutates) it's target objects
     * 
     * @return whether task alters (mutates) it's target objects
     */
    public boolean isMutative()
    {
    	return mutative;
    }
    
    public Curator.Invoked getMode()
    {
    	return mode;
    }
    
    public int[] getCodes()
    {
    	return codes;
    }
    
    /**
     * Returns whether task is not scripted (curation task)
     * 
     * @return true if this task is not scripted
     */
    private boolean unscripted()
    {
    	return sTask == null;
    }
}