/**
* 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.content.packager;
import java.util.Enumeration;
import java.util.Properties;
import javax.servlet.ServletRequest;
/**
* Parameter list for SIP and DIP packagers. It's really just
* a Java Properties object extended so each parameter can have
* multiple values. This was necessary so it can represent Servlet
* parameters, which have multiple values. It is also helpful to
* indicate e.g. metadata choices for package formats like METS that
* allow many different metadata segments.
*
* @author Larry Stone
* @version $Revision$
*/
public class PackageParameters extends Properties
{
// Use non-printing FS (file separator) as arg-sep token, like Perl $;
protected static final String SEPARATOR = "\034";
// Regular expression to match the separator token:
protected static final String SEPARATOR_REGEX = "\\034";
public PackageParameters()
{
super();
}
public PackageParameters(Properties defaults)
{
super(defaults);
}
/**
* Creates new parameters object with the parameter values from
* a servlet request object.
*
* @param request - the request from which to take the values
* @return new parameters object.
*/
public static PackageParameters create(ServletRequest request)
{
PackageParameters result = new PackageParameters();
Enumeration pe = request.getParameterNames();
while (pe.hasMoreElements())
{
String name = (String)pe.nextElement();
String v[] = request.getParameterValues(name);
if (v.length == 0)
{
result.setProperty(name, "");
}
else if (v.length == 1)
{
result.setProperty(name, v[0]);
}
else
{
StringBuffer sb = new StringBuffer();
for (int i = 0; i < v.length; ++i)
{
if (i > 0)
{
sb.append(SEPARATOR);
}
sb.append(v[i]);
}
result.setProperty(name, sb.toString());
}
}
return result;
}
/**
* Adds a value to a property; if property already has value(s),
* this is tacked onto the end, otherwise it acts like setProperty().
*
* @param key - the key to be placed into this property list.
* @param value - the new value to add, corresponding to this key.
* @return the previous value of the specified key in this property list, or
* null if it did not have one.
*/
public Object addProperty(String key, String value)
{
String oldVal = getProperty(key);
if (oldVal == null)
{
setProperty(key, value);
}
else
{
setProperty(key, oldVal + SEPARATOR + value);
}
return oldVal;
}
/**
* Returns multiple property values in an array.
*
* @param key - the key to look for in this property list.
* @return all values in an array, or null if this property is unset.
*/
public String[] getProperties(String key)
{
String val = getProperty(key);
if (val == null)
{
return null;
}
else
{
return val.split(SEPARATOR_REGEX);
}
}
/**
* Returns boolean form of property with selectable default
* @param key the key to look for in this property list.
* @param defaultAnswer default to return if there is no such property
* @return the boolean derived from the value of property, or default
* if it was not specified.
*/
public boolean getBooleanProperty(String key, boolean defaultAnswer)
{
String stringValue = getProperty(key);
if (stringValue == null)
{
return defaultAnswer;
}
else
{
return stringValue.equalsIgnoreCase("true") ||
stringValue.equalsIgnoreCase("on") ||
stringValue.equalsIgnoreCase("yes");
}
}
/**
* Utility method to tell if workflow is enabled for Item ingestion.
* Checks the Packager parameters.
* <p>
* Defaults to 'true' if previously unset, as by default all
* DSpace Workflows should be enabled.
*
* @return boolean result
*/
public boolean workflowEnabled()
{
return getBooleanProperty("useWorkflow", true);
}
/***
* Utility method to enable/disable workflow for Item ingestion.
*
* @param value boolean value (true = workflow enabled, false = workflow disabled)
*/
public void setWorkflowEnabled(boolean value)
{
addProperty("useWorkflow", String.valueOf(value));
}
/***
* Utility method to tell if restore mode is enabled.
* Checks the Packager parameters.
* <p>
* Restore mode attempts to restore an missing/deleted object completely
* (including handle), based on contents of a package.
* <p>
* NOTE: restore mode should throw an error if it attempts to restore an
* object which already exists. Use 'keep-existing' or 'replace' mode to
* either skip-over (keep) or replace existing objects.
* <p>
* Defaults to 'false' if previously unset. NOTE: 'replace' mode and
* 'keep-existing' mode are special types of "restores". So, when either
* replaceModeEnabled() or keepExistingModeEnabled() is true, this method
* should also return true.
*
* @return boolean result
*/
public boolean restoreModeEnabled()
{
return (getBooleanProperty("restoreMode", false) ||
replaceModeEnabled() ||
keepExistingModeEnabled());
}
/***
* Utility method to enable/disable restore mode.
* <p>
* Restore mode attempts to restore an missing/deleted object completely
* (including handle), based on a given package's contents.
* <p>
* NOTE: restore mode should throw an error if it attempts to restore an
* object which already exists. Use 'keep-existing' or 'replace' mode to
* either skip-over (keep) or replace existing objects.
*
* @param value boolean value (true = restore enabled, false = restore disabled)
*/
public void setRestoreModeEnabled(boolean value)
{
addProperty("restoreMode", String.valueOf(value));
}
/***
* Utility method to tell if replace mode is enabled.
* Checks the Packager parameters.
* <p>
* Replace mode attempts to overwrite an existing object and replace it
* with the contents of a package. Replace mode is considered a special type
* of "restore", where the current object is being restored to a previous state.
* <p>
* Defaults to 'false' if previously unset.
*
* @return boolean result
*/
public boolean replaceModeEnabled()
{
return getBooleanProperty("replaceMode", false);
}
/***
* Utility method to enable/disable replace mode.
* <p>
* Replace mode attempts to overwrite an existing object and replace it
* with the contents of a package. Replace mode is considered a special type
* of "restore", where the current object is being restored to a previous state.
*
* @param value boolean value (true = replace enabled, false = replace disabled)
*/
public void setReplaceModeEnabled(boolean value)
{
addProperty("replaceMode", String.valueOf(value));
}
/***
* Utility method to tell if 'keep-existing' mode is enabled.
* Checks the Packager parameters.
* <p>
* Keep-Existing mode is identical to 'restore' mode, except that it
* skips over any objects which are found to already be existing. It
* essentially restores all missing objects, but keeps existing ones intact.
* <p>
* Defaults to 'false' if previously unset.
*
* @return boolean result
*/
public boolean keepExistingModeEnabled()
{
return getBooleanProperty("keepExistingMode", false);
}
/***
* Utility method to enable/disable 'keep-existing' mode.
* <p>
* Keep-Existing mode is identical to 'restore' mode, except that it
* skips over any objects which are found to already be existing. It
* essentially restores all missing objects, but keeps existing ones intact.
*
* @param value boolean value (true = replace enabled, false = replace disabled)
*/
public void setKeepExistingModeEnabled(boolean value)
{
addProperty("keepExistingMode", String.valueOf(value));
}
/***
* Utility method to tell if Items should use a Collection's template
* when they are created.
* <p>
* Defaults to 'false' if previously unset.
*
* @return boolean result
*/
public boolean useCollectionTemplate()
{
return getBooleanProperty("useCollectionTemplate", false);
}
/***
* Utility method to enable/disable Collection Template for Item ingestion.
* <p>
* When enabled, the Item will be installed using the parent collection's
* Item Template
*
* @param value boolean value (true = template enabled, false = template disabled)
*/
public void setUseCollectionTemplate(boolean value)
{
addProperty("useCollectionTemplate", String.valueOf(value));
}
/***
* Utility method to tell if recursive mode is enabled.
* Checks the Packager parameters.
* <p>
* Recursive mode should be enabled anytime one of the *All() methods
* is called (e.g. ingestAll(), replaceAll() or disseminateAll()). It
* recursively performs the same action on all related objects.
* <p>
* Defaults to 'false' if previously unset.
*
* @return boolean result
*/
public boolean recursiveModeEnabled()
{
return getBooleanProperty("recursiveMode", false);
}
/***
* Utility method to enable/disable recursive mode.
* <p>
* Recursive mode should be enabled anytime one of the *All() methods
* is called (e.g. ingestAll(), replaceAll() or disseminateAll()). It
* recursively performs the same action on all related objects.
*
* @param value boolean value (true = recursion enabled, false = recursion disabled)
*/
public void setRecursiveModeEnabled(boolean value)
{
addProperty("recursiveMode", String.valueOf(value));
}
}