Replacing dspace/LICENSE file in dspace-1.6.0 tag

git-svn-id: http://scm.dspace.org/svn/repo/dspace/tags/dspace-1.6.0@4804 9c30dcfa-912a-0410-8fc2-9e0234be79fd

LICENSING_NOTICE.txt

@@ -0,0 +1,15 @@
+
+Licensing Notice
+
+Fedora Commons joined with the DSpace Foundation and began operating under
+the new name DuraSpace in July 2009.  DuraSpace holds the copyrights of
+the DSpace Foundation, Inc.
+
+The DSpace Foundation, Inc. is a 501(c)3 corporation established in July 2007 
+with a mission to promote and advance the dspace platform enabling management, 
+access and preservation of digital works. The Foundation was able to transfer 
+the legal copyright from Hewlett-Packard Company (HP) and Massachusetts 
+Institute of Technology (MIT) to the  DSpace Foundation in October 2007. Many 
+of the files in the source code may contain a copyright statement stating HP 
+and MIT posses the copyright, in these instances please note that the copy 
+right has transfered to the DSpace foundation, and subsequently to Duraspace.

README

@@ -0,0 +1,47 @@
+Installation instructions are included in this release package under
+
+ - dspace/docs/html/index.html
+or
+ - dspace/docs/pdf/DSpace-Manual.pdf
+
+DSpace version information can be found in this release package under
+ - dspace/CHANGES
+
+Documentation for the most recent stable release may be viewed online at
+dspace.org:
+
+ - http://dspace.org/current-release/latest-release/
+
+
+Installation instructions for other version may be different, so you
+are encouraged to obtain the corresponding documentation package from
+SourceForge, or to download the latest documentation snapshot from SVN
+
+To obtain files from the SVN repository and build, please see:
+
+ - https://scm.dspace.org/svn/repo/dspace/tags/
+
+
+Please refer any further problems to the dspace-tech@lists.sourceforge.net
+mailing list.
+
+ - http://sourceforge.net/mail/?group_id=19984
+
+
+Detailed Issue Tracking for DSpace is done on our JIRA Issue Tracker
+
+ - http://jira.dspace.org/
+
+
+To contribute to DSpace, please see:
+
+ - http://wiki.dspace.org/index.php/HowToContribute
+
+
+For more details about DSpace, including a list of service providers,
+places to seek help, news articles and lists of other users, please see:
+
+ - http://www.dspace.org/
+
+
+Copyright (c) 2002-2010, DuraSpace.  All rights reserved.

dspace-api/pom.xml

@@ -0,0 +1,201 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+   <modelVersion>4.0.0</modelVersion>
+   <groupId>org.dspace</groupId>
+   <artifactId>dspace-api</artifactId>
+   <name>DSpace Kernel :: API and Implementation</name>
+   <description>DSpace core data model and service APIs.</description>
+   <url>http://projects.dspace.org/dspace-api</url>
+
+   <!--
+      A Parent POM that Maven inherits DSpace Defaults
+      POM atrributes from.
+   -->
+   <parent>
+      <groupId>org.dspace</groupId>
+      <artifactId>dspace-parent</artifactId>
+      <version>1.6.0</version>
+   </parent>
+
+   <repositories>
+      <repository>
+         <id>maven.dspace.org-snapshot</id>
+         <name>DSpace Maven Snapshot Repository</name>
+         <url>http://maven.dspace.org/snapshot</url>
+         <releases>
+            <enabled>false</enabled>
+            <checksumPolicy>fail</checksumPolicy>
+         </releases>
+         <snapshots>
+            <enabled>true</enabled>
+            <updatePolicy>never</updatePolicy>
+            <checksumPolicy>fail</checksumPolicy>
+         </snapshots>
+      </repository>
+   </repositories>
+
+   <!--
+      The Subversion repository location is used by Continuum to update against
+      when changes have occured, this spawns a new build cycle and releases snapshots
+      into the snapshot repository below.
+   -->
+   <scm>
+      <connection>scm:svn:http://scm.dspace.org/svn/repo/dspace/tags/dspace-1.6.0/dspace</connection>
+      <developerConnection>scm:svn:https://scm.dspace.org/svn/repo/dspace/tags/dspace-1.6.0/dspace</developerConnection>
+      <url>http://scm.dspace.org/svn/repo/dspace/tags/dspace-1.6.0/dspace</url>
+   </scm>
+
+   <!--
+      Runtime and Compile Time dependencies for DSpace.
+   -->
+   <dependencies>
+      <dependency>
+         <groupId>org.dspace</groupId>
+         <artifactId>handle</artifactId>
+         <version>6.2</version>
+      </dependency>
+      <dependency>
+         <groupId>org.dspace</groupId>
+         <artifactId>jargon</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>org.dspace</groupId>
+         <artifactId>mets</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>org.textmining</groupId>
+         <artifactId>tm-extractors</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>org.apache.lucene</groupId>
+         <artifactId>lucene-core</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>org.apache.lucene</groupId>
+         <artifactId>lucene-analyzers</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-cli</groupId>
+         <artifactId>commons-cli</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-codec</groupId>
+         <artifactId>commons-codec</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-collections</groupId>
+         <artifactId>commons-collections</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-dbcp</groupId>
+         <artifactId>commons-dbcp</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-fileupload</groupId>
+         <artifactId>commons-fileupload</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-io</groupId>
+         <artifactId>commons-io</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-lang</groupId>
+         <artifactId>commons-lang</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>commons-pool</groupId>
+         <artifactId>commons-pool</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>javax.mail</groupId>
+         <artifactId>mail</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>javax.servlet</groupId>
+         <artifactId>servlet-api</artifactId>
+         <scope>provided</scope>
+      </dependency>
+      <dependency>
+         <groupId>jaxen</groupId>
+         <artifactId>jaxen</artifactId>
+         <exclusions>
+            <exclusion>
+               <artifactId>xom</artifactId>
+               <groupId>xom</groupId>
+            </exclusion>
+         </exclusions>
+      </dependency>
+      <dependency>
+         <groupId>jdom</groupId>
+         <artifactId>jdom</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>log4j</groupId>
+         <artifactId>log4j</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>oro</groupId>
+         <artifactId>oro</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>pdfbox</groupId>
+         <artifactId>pdfbox</artifactId>
+      </dependency>
+       <dependency>
+          <groupId>org.fontbox</groupId>
+          <artifactId>fontbox</artifactId>
+       </dependency>
+       <dependency>
+          <groupId>org.jempbox</groupId>
+          <artifactId>jempbox</artifactId>
+       </dependency>
+      <dependency>
+         <groupId>poi</groupId>
+         <artifactId>poi</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>rome</groupId>
+         <artifactId>rome</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>rome</groupId>
+         <artifactId>modules</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>xalan</groupId>
+         <artifactId>xalan</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>xerces</groupId>
+         <artifactId>xercesImpl</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>xml-apis</groupId>
+         <artifactId>xmlParserAPIs</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>javax.activation</groupId>
+         <artifactId>activation</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>com.ibm.icu</groupId>
+         <artifactId>icu4j</artifactId>
+      </dependency>
+      <dependency>
+        <groupId>org.dspace</groupId>
+        <artifactId>oclc-harvester2</artifactId>
+      </dependency>
+       <dependency>
+           <groupId>org.dspace</groupId>
+           <artifactId>dspace-services-api</artifactId>
+       </dependency>
+       <dependency>
+           <groupId>org.dspace</groupId>
+           <artifactId>dspace-services-impl</artifactId>
+       </dependency>
+      <dependency>
+         <groupId>commons-httpclient</groupId>
+         <artifactId>commons-httpclient</artifactId>
+      </dependency>
+   </dependencies>
+
+</project>

dspace-api/src/main/java/org/dspace/administer/CommunityFiliator.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/administer/CreateAdministrator.java

@@ -0,0 +1,264 @@
+/*
+ * CreateAdministrator.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.administer;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Locale;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.PosixParser;
+
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.I18nUtil;
+import org.dspace.eperson.EPerson;
+import org.dspace.eperson.Group;
+
+/**
+ * A command-line tool for creating an initial administrator for setting up a
+ * DSpace site. Prompts for an e-mail address, last name, first name and
+ * password from standard input. An administrator group is then created and the
+ * data passed in used to create an e-person in that group.
+ * <P>
+ * Alternatively, it can be used to take the email, first name, last name and
+ * desired password as arguments thus:
+ * 
+ * CreateAdministrator -e [email] -f [first name] -l [last name] -p [password]
+ * 
+ * This is particularly convenient for automated deploy scripts that require an 
+ * initial administrator, for example, before deployment can be completed
+ * 
+ * @author Robert Tansley
+ * @author Richard Jones
+ * 
+ * @version $Revision$
+ */
+public class CreateAdministrator
+{
+	/** DSpace Context object */
+	private Context context;
+	
+    /**
+     * For invoking via the command line.  If called with no command line arguments,
+     * it will negotiate with the user for the administrator details
+     * 
+     * @param argv
+     *            command-line arguments
+     */
+    public static void main(String[] argv)
+    	throws Exception
+    {
+    	CommandLineParser parser = new PosixParser();
+    	Options options = new Options();
+    	
+    	CreateAdministrator ca = new CreateAdministrator();
+    	
+    	options.addOption("e", "email", true, "administrator email address");
+    	options.addOption("f", "first", true, "administrator first name");
+    	options.addOption("l", "last", true, "administrator lastt name");
+    	options.addOption("c", "language", true, "administrator language");
+    	options.addOption("p", "password", true, "administrator password");
+    	
+    	CommandLine line = parser.parse(options, argv);
+    	
+    	if (line.hasOption("e") && line.hasOption("f") && line.hasOption("l") &&
+    			line.hasOption("c") && line.hasOption("p"))
+    	{
+    		ca.createAdministrator(line.getOptionValue("e"),
+    				line.getOptionValue("f"), line.getOptionValue("l"),
+    				line.getOptionValue("c"), line.getOptionValue("p"));
+    	}
+    	else
+    	{
+    		ca.negotiateAdministratorDetails();
+    	}
+    }
+    
+    /** 
+     * constructor, which just creates and object with a ready context
+     * 
+     * @throws Exception
+     */
+    private CreateAdministrator()
+    	throws Exception
+    {
+    	context = new Context();
+    }
+    
+    /**
+     * Method which will negotiate with the user via the command line to 
+     * obtain the administrator's details
+     * 
+     * @throws Exception
+     */
+    private void negotiateAdministratorDetails()
+    	throws Exception
+    {
+    	// For easier reading of typing
+    	BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
+    	
+    	System.out.println("Creating an initial administrator account");
+    	
+    	boolean dataOK = false;
+    	
+    	String email = null;
+    	String firstName = null;
+    	String lastName = null;
+    	String password1 = null;
+    	String password2 = null;
+    	String language = I18nUtil.DEFAULTLOCALE.getLanguage();
+    	
+    	while (!dataOK)
+    	{
+    		System.out.print("E-mail address: ");
+    		System.out.flush();
+    		
+    		email = input.readLine().trim();
+    		
+    		System.out.print("First name: ");
+    		System.out.flush();
+    		
+    		firstName = input.readLine().trim();
+    		
+    		System.out.print("Last name: ");
+    		System.out.flush();
+    		
+    		lastName = input.readLine().trim();
+   		
+            if (ConfigurationManager.getProperty("webui.supported.locales") != null)
+            {
+                System.out.println("Select one of the following languages: " + ConfigurationManager.getProperty("webui.supported.locales"));
+                System.out.print("Language: ");
+                System.out.flush();
+            
+    		    language = input.readLine().trim();
+    		    language = I18nUtil.getSupportedLocale(new Locale(language)).getLanguage();
+            }
+            
+    		System.out.println("WARNING: Password will appear on-screen.");
+    		System.out.print("Password: ");
+    		System.out.flush();
+    		
+    		password1 = input.readLine().trim();
+    		
+    		System.out.print("Again to confirm: ");
+    		System.out.flush();
+    		
+    		password2 = input.readLine().trim();
+    		
+    		if (!password1.equals("") && password1.equals(password2))
+    		{
+    			// password OK
+    			System.out.print("Is the above data correct? (y or n): ");
+    			System.out.flush();
+    			
+    			String s = input.readLine().trim();
+    			
+    			if (s.toLowerCase().startsWith("y"))
+    			{
+    				dataOK = true;
+    			}
+    		}
+    		else
+    		{
+    			System.out.println("Passwords don't match");
+    		}
+    	}
+    	
+    	// if we make it to here, we are ready to create an administrator
+    	createAdministrator(email, firstName, lastName, language, password1);
+    }
+    
+    /**
+     * Create the administrator with the given details.  If the user
+     * already exists then they are simply upped to administrator status
+     * 
+     * @param email	the email for the user
+     * @param first	user's first name
+     * @param last	user's last name
+     * @param ps	desired password
+     * 
+     * @throws Exception
+     */
+    private void createAdministrator(String email, String first, String last,
+    		String language, String pw)
+    	throws Exception
+    {
+    	// Of course we aren't an administrator yet so we need to
+    	// circumvent authorisation
+    	context.setIgnoreAuthorization(true);
+    	
+    	// Find administrator group
+    	Group admins = Group.find(context, 1);
+    	
+    	if (admins == null)
+    	{
+    		throw new Exception("Error, no admin group (group 1) found");
+    	}
+    	
+    	// Create the administrator e-person
+        EPerson eperson = EPerson.findByEmail(context,email);
+        
+        // check if the email belongs to a registered user,
+        // if not create a new user with this email
+        if (eperson == null)
+        {
+            eperson = EPerson.create(context);
+            eperson.setEmail(email);
+            eperson.setCanLogIn(true);
+            eperson.setRequireCertificate(false);
+            eperson.setSelfRegistered(false);
+        }
+    	
+    	eperson.setLastName(last);
+    	eperson.setFirstName(first);
+    	eperson.setLanguage(language);
+    	eperson.setPassword(pw);
+    	eperson.update();
+    	
+    	admins.addMember(eperson);
+    	admins.update();
+    	
+    	context.complete();
+    	
+    	System.out.println("Administrator account created");
+    }
+}

dspace-api/src/main/java/org/dspace/administer/DCType.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/administer/MetadataExporter.java

@@ -0,0 +1,318 @@
+package org.dspace.administer;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.PosixParser;
+import org.apache.xml.serialize.Method;
+import org.apache.xml.serialize.OutputFormat;
+import org.apache.xml.serialize.XMLSerializer;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.core.Context;
+import org.xml.sax.SAXException;
+
+
+/**
+ * @author Graham Triggs
+ *
+ * This class creates an xml document as passed in the arguments and
+ * from the metadata schemas for the repository.
+ * 
+ * The form of the XML is as follows
+ * 
+ * <metadata-schemas>
+ *   <schema>
+ *     <name>dc</name>
+ *     <namespace>http://dublincore.org/documents/dcmi-terms/</namespace>
+ *   </schema>
+ * </metadata-schemas>
+ */
+public class MetadataExporter
+{
+
+    /**
+     * @param args
+     * @throws ParseException 
+     * @throws SAXException 
+     * @throws IOException 
+     * @throws SQLException 
+     * @throws RegistryExportException 
+     */
+    public static void main(String[] args) throws ParseException, SQLException, IOException, SAXException, RegistryExportException
+    {
+        // create an options object and populate it
+        CommandLineParser parser = new PosixParser();
+        Options options = new Options();
+        options.addOption("f", "file",   true, "output xml file for registry");
+        options.addOption("s", "schema", true, "the name of the schema to export");
+        CommandLine line = parser.parse(options, args);
+        
+        String file   = null;
+        String schema = null;
+
+        if (line.hasOption('f'))
+        {
+            file   = line.getOptionValue('f');
+        }
+        else
+        {
+            usage();
+            System.exit(0);
+        }
+        
+        if (line.hasOption('s'))
+        {
+            schema = line.getOptionValue('s');
+        }
+
+        saveRegistry(file, schema);
+    }
+
+    public static void saveRegistry(String file, String schema) throws SQLException, IOException, SAXException, RegistryExportException
+    {
+        // create a context
+        Context context = new Context();
+        context.setIgnoreAuthorization(true);
+
+        OutputFormat xmlFormat = new OutputFormat(Method.XML, "UTF-8", true);
+        xmlFormat.setLineWidth(120);
+        xmlFormat.setIndent(4);
+        
+        XMLSerializer xmlSerializer = new XMLSerializer(new BufferedWriter(new FileWriter(file)), xmlFormat);
+        //        XMLSerializer xmlSerializer = new XMLSerializer(System.out, xmlFormat);
+        xmlSerializer.startDocument();
+        xmlSerializer.startElement("dspace-dc-types", null);
+        
+        // Save the schema defintion(s)
+        saveSchema(context, xmlSerializer, schema);
+
+        MetadataField[] mdFields = null;
+
+        // If a single schema has been specified
+        if (schema != null && !"".equals(schema))
+        {
+            // Get the id of that schema
+            MetadataSchema mdSchema = MetadataSchema.find(context, schema);
+            if (mdSchema == null)
+            {
+                throw new RegistryExportException("no schema to export");
+            }
+            
+            // Get the metadata fields only for the specified schema
+            mdFields = MetadataField.findAllInSchema(context, mdSchema.getSchemaID());
+        }
+        else
+        {
+            // Get the metadata fields for all the schemas
+            mdFields = MetadataField.findAll(context);
+        }
+        
+        // Output the metadata fields
+        for (MetadataField mdField : mdFields)
+        {
+            saveType(context, xmlSerializer, mdField);
+        }
+        
+        xmlSerializer.endElement("dspace-dc-types");
+        xmlSerializer.endDocument();
+        
+        // abort the context, as we shouldn't have changed it!!
+        context.abort();
+    }
+    
+    /**
+     * Serialize the schema registry. If the parameter 'schema' is null or empty, save all schemas
+     * @param context
+     * @param xmlSerializer
+     * @param schema
+     * @throws SQLException
+     * @throws SAXException
+     * @throws RegistryExportException
+     */
+    public static void saveSchema(Context context, XMLSerializer xmlSerializer, String schema) throws SQLException, SAXException, RegistryExportException
+    {
+        if (schema != null && !"".equals(schema))
+        {
+            // Find a single named schema
+            MetadataSchema mdSchema = MetadataSchema.find(context, schema);
+            
+            saveSchema(xmlSerializer, mdSchema);
+        }
+        else
+        {
+            // Find all schemas
+            MetadataSchema[] mdSchemas = MetadataSchema.findAll(context);
+            
+            for (MetadataSchema mdSchema : mdSchemas)
+            {
+                saveSchema(xmlSerializer, mdSchema);
+            }
+        }
+    }
+    
+    /**
+     * Serialize a single schema (namespace) registry entry
+     * 
+     * @param xmlSerializer
+     * @param mdSchema
+     * @throws SAXException
+     * @throws RegistryExportException
+     */
+    private static void saveSchema(XMLSerializer xmlSerializer, MetadataSchema mdSchema) throws SAXException, RegistryExportException
+    {
+        // If we haven't got a schema, it's an error
+        if (mdSchema == null)
+        {
+            throw new RegistryExportException("no schema to export");
+        }
+        
+        String name      = mdSchema.getName();
+        String namespace = mdSchema.getNamespace();
+        
+        if (name == null || "".equals(name))
+        {
+            System.out.println("name is null, skipping");
+            return;
+        }
+
+        if (namespace == null || "".equals(namespace))
+        {
+            System.out.println("namespace is null, skipping");
+            return;
+        }
+
+        // Output the parent tag
+        xmlSerializer.startElement("dc-schema", null);
+        
+        // Output the schema name
+        xmlSerializer.startElement("name", null);
+        xmlSerializer.characters(name.toCharArray(), 0, name.length());
+        xmlSerializer.endElement("name");
+
+        // Output the schema namespace
+        xmlSerializer.startElement("namespace", null);
+        xmlSerializer.characters(namespace.toCharArray(), 0, namespace.length());
+        xmlSerializer.endElement("namespace");
+
+        xmlSerializer.endElement("dc-schema");
+    }
+    
+    /**
+     * Serialize a single metadata field registry entry to xml
+     * 
+     * @param context
+     * @param xmlSerializer
+     * @param mdField
+     * @throws SAXException
+     * @throws RegistryExportException
+     * @throws SQLException
+     * @throws IOException 
+     */
+    private static void saveType(Context context, XMLSerializer xmlSerializer, MetadataField mdField) throws SAXException, RegistryExportException, SQLException, IOException
+    {
+        // If we haven't been given a field, it's an error
+        if (mdField == null)
+        {
+            throw new RegistryExportException("no field to export");
+        }
+        
+        // Get the data from the metadata field
+        String schemaName = getSchemaName(context, mdField);
+        String element = mdField.getElement();
+        String qualifier = mdField.getQualifier();
+        String scopeNote = mdField.getScopeNote();
+
+        // We must have a schema and element
+        if (schemaName == null || element == null)
+        {
+            throw new RegistryExportException("incomplete field information");
+        }
+
+        // Output the parent tag
+        xmlSerializer.startElement("dc-type", null);
+
+        // Output the schema name
+        xmlSerializer.startElement("schema", null);
+        xmlSerializer.characters(schemaName.toCharArray(), 0, schemaName.length());
+        xmlSerializer.endElement("schema");
+
+        // Output the element
+        xmlSerializer.startElement("element", null);
+        xmlSerializer.characters(element.toCharArray(), 0, element.length());
+        xmlSerializer.endElement("element");
+
+        // Output the qualifier, if present
+        if (qualifier != null)
+        {
+            xmlSerializer.startElement("qualifier", null);
+            xmlSerializer.characters(qualifier.toCharArray(), 0, qualifier.length());
+            xmlSerializer.endElement("qualifier");
+        }
+        else
+        {
+            xmlSerializer.comment("unqualified");
+        }
+        
+        // Output the scope note, if present
+        if (scopeNote != null)
+        {
+            xmlSerializer.startElement("scope_note", null);
+            xmlSerializer.characters(scopeNote.toCharArray(), 0, scopeNote.length());
+            xmlSerializer.endElement("scope_note");
+        }
+        else
+        {
+            xmlSerializer.comment("no scope note");
+        }
+        
+        xmlSerializer.endElement("dc-type");
+    }
+    
+    /**
+     * Helper method to retrieve a schema name for the field.
+     * Caches the name after looking up the id.
+     */
+    static Map<Integer, String> schemaMap = new HashMap<Integer, String>();
+    private static String getSchemaName(Context context, MetadataField mdField) throws SQLException, RegistryExportException
+    {
+        // Get name from cache
+        String name = schemaMap.get(new Integer(mdField.getSchemaID()));
+
+        if (name == null)
+        {
+            // Name not retrieved before, so get the schema now
+            MetadataSchema mdSchema = MetadataSchema.find(context, mdField.getSchemaID());
+            if (mdSchema != null)
+            {
+                name = mdSchema.getName();
+                schemaMap.put(new Integer(mdSchema.getSchemaID()), name);
+            }
+            else
+            {
+                // Can't find the schema
+                throw new RegistryExportException("Can't get schema name for field");
+            }
+        }
+        return name;
+    }
+    
+    /**
+     * Print the usage message to stdout
+     */
+    public static void usage()
+    {
+        String usage = "Use this class with the following options:\n" +
+                        " -f <xml output file> : specify the output file for the schemas\n" +
+                        " -s <schema> : name of the schema to export\n";
+        System.out.println(usage);
+    }
+}

dspace-api/src/main/java/org/dspace/administer/MetadataImporter.java

@@ -0,0 +1,296 @@
+/*
+ * MetadataImporter.java
+ * 
+ * Copyright (c) 2006, Imperial College London.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Imperial College nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.administer;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.PosixParser;
+
+import org.apache.xpath.XPathAPI;
+
+import org.dspace.administer.DCType;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.content.NonUniqueMetadataException;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.NamedNodeMap;
+
+import org.xml.sax.SAXException;
+
+/**
+ * @author Richard Jones
+ *
+ * This class takes an xml document as passed in the arguments and
+ * uses it to create metadata elements in the Metadata Registry if 
+ * they do not already exist
+ * 
+ * The format of the XML file is as follows:
+ * 
+ * <dspace-dc-types>
+ *   <dc-type>
+ *     <schema>icadmin</schema>
+ *     <element>status</element>
+ *     <qualifier>dateset</qualifier>
+ *     <scope_note>the workflow status of an item</scope_note>
+ *   </dc-type>
+ *   
+ *   [....]
+ *   
+ * </dspace-dc-types>
+ */
+public class MetadataImporter
+{
+	/**
+	 * main method for reading user input from the command line
+	 */
+    public static void main(String[] args)
+    	throws ParseException, SQLException, IOException, TransformerException,
+    			ParserConfigurationException, AuthorizeException, SAXException,
+    			NonUniqueMetadataException, RegistryImportException
+    {
+        boolean forceUpdate = false;
+        
+        // create an options object and populate it
+        CommandLineParser parser = new PosixParser();
+        Options options = new Options();
+        options.addOption("f", "file", true, "source xml file for DC fields");
+        options.addOption("u", "update", false, "update an existing schema");
+        CommandLine line = parser.parse(options, args);
+        
+        String file = null;
+        if (line.hasOption('f'))
+        {
+            file = line.getOptionValue('f');
+        }
+        else
+        {
+            usage();
+            System.exit(0);
+        }
+
+        forceUpdate = line.hasOption('u');
+        loadRegistry(file, forceUpdate);
+    }
+    
+    /**
+     * Load the data from the specified file path into the database
+     * 
+     * @param 	file	the file path containing the source data
+     */
+    public static void loadRegistry(String file, boolean forceUpdate)
+    	throws SQLException, IOException, TransformerException, ParserConfigurationException, 
+    		AuthorizeException, SAXException, NonUniqueMetadataException, RegistryImportException
+    {
+        // create a context
+        Context context = new Context();
+        context.setIgnoreAuthorization(true);
+        
+        // read the XML
+        Document document = RegistryImporter.loadXML(file);
+
+        // Get the nodes corresponding to types
+        NodeList schemaNodes = XPathAPI.selectNodeList(document, "/dspace-dc-types/dc-schema");
+        
+        // Add each one as a new format to the registry
+        for (int i = 0; i < schemaNodes.getLength(); i++)
+        {
+            Node n = schemaNodes.item(i);
+            loadSchema(context, n, forceUpdate);
+        }
+        
+        // Get the nodes corresponding to types
+        NodeList typeNodes = XPathAPI.selectNodeList(document, "/dspace-dc-types/dc-type");
+
+        // Add each one as a new format to the registry
+        for (int i = 0; i < typeNodes.getLength(); i++)
+        {
+            Node n = typeNodes.item(i);
+            loadType(context, n);
+        }
+        
+        context.complete();
+    }
+    
+    /**
+     * Process a node in the metadata registry XML file.  If the
+     * schema already exists, it will not be recreated
+     * 
+     * @param context
+     *            DSpace context object
+     * @param node
+     *            the node in the DOM tree
+     * @throws NonUniqueMetadataException
+     */
+    private static void loadSchema(Context context, Node node, boolean updateExisting)
+        throws SQLException, IOException, TransformerException,
+            AuthorizeException, NonUniqueMetadataException, RegistryImportException
+    {
+        // Get the values
+        String name = RegistryImporter.getElementData(node, "name");
+        String namespace = RegistryImporter.getElementData(node, "namespace");
+        
+        if (name == null || "".equals(name))
+        {
+            throw new RegistryImportException("Name of schema must be supplied");
+        }
+
+        if (namespace == null || "".equals(namespace))
+        {
+            throw new RegistryImportException("Namespace of schema must be supplied");
+        }
+
+        System.out.print("Registering Schema: " + name + " - " + namespace + " ... ");
+        
+        // check to see if the schema already exists
+        MetadataSchema s = MetadataSchema.find(context, name);
+        
+        if (s == null)
+        {
+            // Schema does not exist - create
+            MetadataSchema schema = new MetadataSchema(namespace, name);
+            schema.create(context);
+            System.out.println("created");
+        }
+        else
+        {
+            // Schema exists - if it's the same namespace, allow the type imports to continue
+            if (s.getNamespace().equals(namespace))
+            {
+                System.out.println("already exists, skipping to type import");
+                return;
+            }
+            
+            // It's a different namespace - have we been told to update?
+            if (updateExisting)
+            {
+                // Update the existing schema namespace and continue to type import
+                s.setNamespace(namespace);
+                s.update(context);
+                System.out.println("namespace updated (" + name + " = " + namespace + ")");
+            }
+            else
+            {
+                // Don't update the existing namespace - abort abort abort
+                System.out.println("schema exists, but with different namespace");
+                System.out.println("was: " + s.getNamespace());
+                System.out.println("xml: " + namespace);
+                System.out.println("aborting - use -u to force the update");
+                
+                throw new RegistryImportException("schema already registerd with different namespace - use -u to update");
+            }
+        }
+        
+    }
+    
+    /**
+     * Process a node in the metadata registry XML file. The node must
+     * be a "dc-type" node.  If the type already exists, then it
+     * will not be reimported
+     * 
+     * @param context
+     *            DSpace context object
+     * @param node
+     *            the node in the DOM tree
+     * @throws NonUniqueMetadataException
+     */
+    private static void loadType(Context context, Node node)
+            throws SQLException, IOException, TransformerException,
+            AuthorizeException, NonUniqueMetadataException, RegistryImportException
+    {
+        // Get the values
+        String schema = RegistryImporter.getElementData(node, "schema");
+        String element = RegistryImporter.getElementData(node, "element");
+        String qualifier = RegistryImporter.getElementData(node, "qualifier");
+        String scopeNote = RegistryImporter.getElementData(node, "scope_note");
+
+        // If the schema is not provided default to DC
+        if (schema == null)
+        {
+            schema = MetadataSchema.DC_SCHEMA;
+        }
+
+        System.out.print("Registering Metadata: " + schema + "." + element + "." + qualifier + " ... ");
+        
+        // Find the matching schema object
+        MetadataSchema schemaObj = MetadataSchema.find(context, schema);
+        
+        if (schemaObj == null)
+        {
+            throw new RegistryImportException("Schema '" + schema + "' is not registered");
+        }
+        
+        MetadataField mf = MetadataField.findByElement(context, schemaObj.getSchemaID(), element, qualifier);
+        if (mf != null)
+        {
+            System.out.println("already exists, skipping");
+            return;
+        }
+        
+        MetadataField field = new MetadataField();
+        field.setSchemaID(schemaObj.getSchemaID());
+        field.setElement(element);
+        field.setQualifier(qualifier);
+        field.setScopeNote(scopeNote);
+        field.create(context);
+        System.out.println("created");
+    }
+    
+    /**
+     * Print the usage message to stdout
+     */
+    public static void usage()
+    {
+        String usage = "Use this class with the following option:\n" +
+        				" -f <xml source file> : specify which xml source file " +
+        				"contains the DC fields to import.\n";
+        System.out.println(usage);
+    }
+}

dspace-api/src/main/java/org/dspace/administer/RegistryExportException.java

@@ -0,0 +1,84 @@
+/*
+ * RegistryImportException.java
+ * 
+ * Copyright (c) 2006, Imperial College London.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Imperial College nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.administer;
+
+/**
+ * @author Graham Triggs
+ *
+ * An exception to report any problems with registry exports
+ */
+public class RegistryExportException extends Exception
+{
+    private Exception e;
+    
+    /**
+     * Create an empty authorize exception
+     */
+    public RegistryExportException()
+    {
+        super();
+    }
+
+    /**
+     * create an exception with only a message
+     * 
+     * @param message
+     */
+    public RegistryExportException(String message)
+    {
+        super(message);
+    }
+    
+    /**
+     * create an exception with an inner exception and a message
+     * 
+     * @param   message
+     * @param   e
+     */
+    public RegistryExportException(String message, Throwable e)
+    {
+        super(message, e);
+    }
+    
+    /**
+     * create an exception with an inner exception
+     * 
+     * @param   e
+     */
+    public RegistryExportException(Throwable e)
+    {
+        super(e);
+    }
+    
+}

dspace-api/src/main/java/org/dspace/administer/RegistryImportException.java

@@ -0,0 +1,84 @@
+/*
+ * RegistryImportException.java
+ * 
+ * Copyright (c) 2006, Imperial College London.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Imperial College nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.administer;
+
+/**
+ * @author Richard Jones
+ *
+ * An exception to report any problems with registry imports
+ */
+public class RegistryImportException extends Exception
+{
+    private Exception e;
+    
+    /**
+     * Create an empty authorize exception
+     */
+    public RegistryImportException()
+    {
+        super();
+    }
+
+    /**
+     * create an exception with only a message
+     * 
+     * @param message
+     */
+    public RegistryImportException(String message)
+    {
+        super(message);
+    }
+    
+    /**
+     * create an exception with an inner exception and a message
+     * 
+     * @param	message
+     * @param	e
+     */
+    public RegistryImportException(String message, Throwable e)
+    {
+    	super(message, e);
+    }
+    
+    /**
+     * create an exception with an inner exception
+     * 
+     * @param	e
+     */
+    public RegistryImportException(Throwable e)
+    {
+    	super(e);
+    }
+    
+}

dspace-api/src/main/java/org/dspace/administer/RegistryImporter.java

@@ -0,0 +1,183 @@
+/*
+ * RegistryImporter.java
+ * 
+ * Copyright (c) 2006, Imperial College London.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Imperial College nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.administer;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.PosixParser;
+
+import org.apache.xpath.XPathAPI;
+
+import org.dspace.administer.DCType;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.content.NonUniqueMetadataException;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.NamedNodeMap;
+
+import org.xml.sax.SAXException;
+
+/**
+ * @author Richard Jones
+ *
+ * This class provides the tools that registry importers might need to
+ * use.  Basically some utility methods.  And actually, although it says
+ * I am the author, really I ripped these methods off from other
+ * classes
+ */
+public class RegistryImporter
+{
+    /**
+     * Load in the XML from file.
+     * 
+     * @param filename
+     *            the filename to load from
+     * 
+     * @return the DOM representation of the XML file
+     */
+    public static Document loadXML(String filename) 
+    	throws IOException, ParserConfigurationException, SAXException
+    {
+        DocumentBuilder builder = DocumentBuilderFactory.newInstance()
+                .newDocumentBuilder();
+
+        Document document = builder.parse(new File(filename));
+        
+        return document;
+    }
+    
+    /**
+     * Get the CDATA of a particular element. For example, if the XML document
+     * contains:
+     * <P>
+     * <code>
+     * &lt;foo&gt;&lt;mimetype&gt;application/pdf&lt;/mimetype&gt;&lt;/foo&gt;
+     * </code>
+     * passing this the <code>foo</code> node and <code>mimetype</code> will
+     * return <code>application/pdf</code>.
+     * </P>
+     * Why this isn't a core part of the XML API I do not know...
+     * 
+     * @param parentElement
+     *            the element, whose child element you want the CDATA from
+     * @param childName
+     *            the name of the element you want the CDATA from
+     * 
+     * @return the CDATA as a <code>String</code>
+     */
+    public static String getElementData(Node parentElement, String childName)
+            throws TransformerException
+    {
+        // Grab the child node
+        Node childNode = XPathAPI.selectSingleNode(parentElement, childName);
+
+        if (childNode == null)
+        {
+            // No child node, so no values
+            return null;
+        }
+
+        // Get the #text
+        Node dataNode = childNode.getFirstChild();
+
+        if (dataNode == null)
+        {
+            return null;
+        }
+
+        // Get the data
+        String value = dataNode.getNodeValue().trim();
+
+        return value;
+    }
+
+    /**
+     * Get repeated CDATA for a particular element. For example, if the XML
+     * document contains:
+     * <P>
+     * <code>
+     * &lt;foo&gt;
+     *   &lt;bar&gt;val1&lt;/bar&gt;
+     *   &lt;bar&gt;val2&lt;/bar&gt;
+     * &lt;/foo&gt;
+     * </code>
+     * passing this the <code>foo</code> node and <code>bar</code> will
+     * return <code>val1</code> and <code>val2</code>.
+     * </P>
+     * Why this also isn't a core part of the XML API I do not know...
+     * 
+     * @param parentElement
+     *            the element, whose child element you want the CDATA from
+     * @param childName
+     *            the name of the element you want the CDATA from
+     * 
+     * @return the CDATA as a <code>String</code>
+     */
+    public static String[] getRepeatedElementData(Node parentElement,
+            String childName) throws TransformerException
+    {
+        // Grab the child node
+        NodeList childNodes = XPathAPI.selectNodeList(parentElement, childName);
+
+        String[] data = new String[childNodes.getLength()];
+
+        for (int i = 0; i < childNodes.getLength(); i++)
+        {
+            // Get the #text node
+            Node dataNode = childNodes.item(i).getFirstChild();
+
+            // Get the data
+            data[i] = dataNode.getNodeValue().trim();
+        }
+
+        return data;
+    }
+}

dspace-api/src/main/java/org/dspace/administer/RegistryLoader.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -140,6 +138,7 @@ public class RegistryLoader
                 context.abort();
             }
 
+            System.err.println("Error: \n - " + e.getMessage());
             System.exit(1);
         }
     }

dspace-api/src/main/java/org/dspace/administer/StructBuilder.java

@@ -0,0 +1,616 @@
+/*
+ * StructBuilder.java
+ * 
+ * Copyright (c) 2006, Imperial College.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Imperial College nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.administer;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.PosixParser;
+import org.apache.xpath.XPathAPI;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+import org.jdom.Element;
+import org.jdom.output.XMLOutputter;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+/**
+ * This class deals with importing community and collection structures from
+ * an XML file.
+ * 
+ * The XML file structure needs to be:
+ * 
+ * <import_structure>
+ *     <community>
+ *         <name>....</name>
+ *         <community>...</community>
+ *         <collection>
+ *             <name>....</name>
+ *         </collection>
+ *     </community>
+ * </import_structure>
+ * 
+ * it can be arbitrarily deep, and supports all the metadata elements
+ * that make up the community and collection metadata.  See the system
+ * documentation for more details
+ * 
+ * @author Richard Jones
+ *
+ */
+
+public class StructBuilder
+{
+    /** the output xml document which will contain updated information about the 
+     * imported structure
+     */
+    private static org.jdom.Document xmlOutput = new org.jdom.Document(new Element("imported_structure"));
+    
+    /** a hashtable to hold metadata for the collection being worked on */
+    private static Hashtable collectionMap = new Hashtable();
+    
+    /** a hashtable to hold metadata for the community being worked on */
+    private static Hashtable communityMap = new Hashtable();
+    
+    /**
+     * Main method to be run from the command line to import a structure into
+     * DSpace
+     * 
+     * This is of the form:
+     * 
+     * StructBuilder -f [xml source] -e [administrator email] -o [output file]
+     * 
+     * The output file will contain exactly the same as the source xml document, but
+     * with the handle for each imported item added as an attribute.
+     */
+    public static void main(String[] argv) 
+    	throws Exception
+    {
+        CommandLineParser parser = new PosixParser();
+
+    	Options options = new Options();
+
+    	options.addOption( "f", "file", true, "file");
+    	options.addOption( "e", "eperson", true, "eperson");
+    	options.addOption("o", "output", true, "output");
+    	
+    	CommandLine line = parser.parse( options, argv );
+    	
+    	String file = null;
+    	String eperson = null;
+    	String output = null;
+    	
+    	if (line.hasOption('f'))
+    	{
+    	    file = line.getOptionValue('f');
+    	}
+    	
+    	if (line.hasOption('e'))
+    	{
+    	    eperson = line.getOptionValue('e');
+    	}
+    	
+    	if (line.hasOption('o'))
+    	{
+    	    output = line.getOptionValue('o');
+    	}
+    	
+    	if (output == null || eperson == null || file == null)
+    	{
+    	    usage();
+    	    System.exit(0);
+    	}
+    	
+        // create a context
+        Context context = new Context();
+        
+        // set the context
+        context.setCurrentUser(EPerson.findByEmail(context, eperson));
+ 
+        // load the XML
+        Document document = loadXML(file);
+        
+        // run the preliminary validation, to be sure that the the XML document
+        // is properly structured
+        validate(document);
+        
+        // load the mappings into the member variable hashmaps
+        communityMap.put("name", "name");
+        communityMap.put("description", "short_description");
+        communityMap.put("intro", "introductory_text");
+        communityMap.put("copyright", "copyright_text");
+        communityMap.put("sidebar", "side_bar_text");
+        
+        collectionMap.put("name", "name");
+        collectionMap.put("description", "short_description");
+        collectionMap.put("intro", "introductory_text");
+        collectionMap.put("copyright", "copyright_text");
+        collectionMap.put("sidebar", "side_bar_text");
+        collectionMap.put("license", "license");
+        collectionMap.put("provenance", "provenance_description");
+        
+        // get the top level community list
+        NodeList first = XPathAPI.selectNodeList(document, "/import_structure/community");
+        
+        // run the import starting with the top level communities
+        Element[] elements = handleCommunities(context, first, null);
+        
+        // generate the output
+        Element root = xmlOutput.getRootElement();
+        for (int i = 0; i < elements.length; i++)
+        {
+            root.addContent(elements[i]);
+        }
+        
+        // finally write the string into the output file
+        try 
+        {
+            BufferedWriter out = new BufferedWriter(new FileWriter(output));
+            out.write(new XMLOutputter().outputString(xmlOutput));
+            out.close();
+        } 
+        catch (IOException e) 
+        {
+            System.out.println("Unable to write to output file " + output);
+            System.exit(0);
+        }
+        
+        context.complete();
+    }
+    
+    /**
+     * Output the usage information
+     */
+    private static void usage()
+    {
+        System.out.println("Usage: java StructBuilder -f <source XML file> -o <output file> -e <eperson email>");
+        System.out.println("Communitities will be created from the top level, and a map of communities to handles will be returned in the output file");
+        return;
+    }
+    
+    /**
+     * Validate the XML document.  This method does not return, but if validation
+     * fails it generates an error and ceases execution
+     * 
+     * @param	document	the XML document object
+     * @throws TransformerException
+     * 
+     */
+    private static void validate(org.w3c.dom.Document document)
+    	throws TransformerException
+    {
+        StringBuffer err = new StringBuffer();
+        boolean trip = false;
+        
+        err.append("The following errors were encountered parsing the source XML\n");
+        err.append("No changes have been made to the DSpace instance\n\n");
+        
+        NodeList first = XPathAPI.selectNodeList(document, "/import_structure/community");
+        if (first.getLength() == 0)
+        {
+            err.append("-There are no top level communities in the source document");
+            System.out.println(err.toString());
+            System.exit(0);
+        }
+        
+        String errs = validateCommunities(first, 1);
+        if (errs != null)
+        {
+            err.append(errs);
+            trip = true;
+        }
+        
+        if (trip)
+        {
+            System.out.println(err.toString());
+            System.exit(0);
+        }
+    }
+    
+    /**
+     * Validate the communities section of the XML document.  This returns a string
+     * containing any errors encountered, or null if there were no errors
+     * 
+     * @param communities the NodeList of communities to validate
+     * @param level the level in the XML document that we are at, for the purposes
+     * 			of error reporting
+     * 
+     * @return the errors that need to be generated by the calling method, or null if
+     * 			no errors.
+     */
+    private static String validateCommunities(NodeList communities, int level)
+    	throws TransformerException
+    {
+        StringBuffer err = new StringBuffer();
+        boolean trip = false;
+        String errs = null;
+        
+        for (int i = 0; i < communities.getLength(); i++)
+        {
+            Node n = communities.item(i);
+	        NodeList name = XPathAPI.selectNodeList(n, "name");
+	        if (name.getLength() != 1)
+	        {
+	            String pos = Integer.toString(i + 1);
+	            err.append("-The level " + level + " community in position " + pos);
+	            err.append(" does not contain exactly one name field\n");
+	            trip = true;
+	        }
+	        
+	        // validate sub communities
+	        NodeList subCommunities = XPathAPI.selectNodeList(n, "community");
+	        String comErrs = validateCommunities(subCommunities, level + 1);
+	        if (comErrs != null)
+	        {
+	            err.append(comErrs);
+	            trip = true;
+	        }
+	        
+	        // validate collections
+	        NodeList collections = XPathAPI.selectNodeList(n, "collection");
+	        String colErrs = validateCollections(collections, level + 1);
+	        if (colErrs != null)
+	        {
+	            err.append(colErrs);
+	            trip = true;
+	        }
+        }
+        
+        if (trip)
+        {
+            errs = err.toString();
+        }
+        
+        return errs;
+    }
+    
+    /**
+     * validate the collection section of the XML document.  This generates a
+     * string containing any errors encountered, or returns null if no errors
+     * 
+     * @param collections a NodeList of collections to validate
+     * @param level the level in the XML document for the purposes of error reporting
+     * 
+     * @return the errors to be generated by the calling method, or null if none
+     */
+    private static String validateCollections(NodeList collections, int level)
+    	throws TransformerException
+    {
+        StringBuffer err = new StringBuffer();
+        boolean trip = false;
+        String errs = null;
+        
+        for (int i = 0; i < collections.getLength(); i++)
+        {
+            Node n = collections.item(i);
+	        NodeList name = XPathAPI.selectNodeList(n, "name");
+	        if (name.getLength() != 1)
+	        {
+	            String pos = Integer.toString(i + 1);
+	            err.append("-The level " + level + " collection in position " + pos);
+	            err.append(" does not contain exactly one name field\n");
+	            trip = true;
+	        }
+        }
+        
+        if (trip)
+        {
+            errs = err.toString();
+        }
+        
+        return errs;
+    }
+    
+    /**
+     * Load in the XML from file.
+     * 
+     * @param filename
+     *            the filename to load from
+     * 
+     * @return the DOM representation of the XML file
+     */
+    private static org.w3c.dom.Document loadXML(String filename) 
+    	throws IOException, ParserConfigurationException, SAXException
+    {
+        DocumentBuilder builder = DocumentBuilderFactory.newInstance()
+                .newDocumentBuilder();
+
+        org.w3c.dom.Document document = builder.parse(new File(filename));
+        
+        return document;
+    }
+    
+    /**
+     * Return the String value of a Node
+     * 
+     * @param node the node from which we want to extract the string value
+     * 
+     * @return the string value of the node
+     */
+    public static String getStringValue(Node node)
+    {
+        String value = node.getNodeValue();
+
+        if (node.hasChildNodes())
+        {
+            Node first = node.getFirstChild();
+
+            if (first.getNodeType() == Node.TEXT_NODE)
+            {
+                return first.getNodeValue().trim();
+            }
+        }
+
+        return value;
+    }
+    
+    /**
+     * Take a node list of communities and build the structure from them, delegating
+     * to the relevant methods in this class for sub-communities and collections
+     * 
+     * @param context the context of the request
+     * @param communities a nodelist of communities to create along with their subjstructures
+     * @param parent the parent community of the nodelist of communities to create
+     * 
+     * @return an element array containing additional information regarding the 
+     * 			created communities (e.g. the handles they have been assigned)
+     */
+    private static Element[] handleCommunities(Context context, NodeList communities, Community parent)
+    	throws TransformerException, SQLException, Exception
+    {
+        Element[] elements = new Element[communities.getLength()];
+        
+        for (int i = 0; i < communities.getLength(); i++)
+        {
+            Community community;
+            Element element = new Element("community");
+            
+            // create the community or sub community
+            if (parent != null)
+            {
+                community = parent.createSubcommunity();
+            }
+            else
+            {
+                community = Community.create(null, context);
+            }
+            
+            // default the short description to be an empty string
+            community.setMetadata("short_description", " ");
+            
+            // now update the metadata
+            Node tn = communities.item(i);
+            Enumeration keys = communityMap.keys();
+            while (keys.hasMoreElements())
+            {
+                Node node = null;
+                String key = (String) keys.nextElement();
+                NodeList nl = XPathAPI.selectNodeList(tn, key);
+                if (nl.getLength() == 1)
+                {
+                    node = nl.item(0);
+                    community.setMetadata((String) communityMap.get(key), getStringValue(node));
+                }
+            }
+            
+            // FIXME: at the moment, if the community already exists by name
+            // then this will throw a PSQLException on a duplicate key
+            // violation
+            // Ideally we'd skip this row and continue to create sub
+            // communities
+            // and so forth where they don't exist, but it's proving
+            // difficult
+            // to isolate the community that already exists without hitting
+            // the database directly.
+            community.update();
+            
+            // build the element with the handle that identifies the new
+            // community
+            // along with all the information that we imported here
+            // This looks like a lot of repetition of getting information
+            // from above
+            // but it's here to keep it separate from the create process in
+            // case
+            // we want to move it or make it switchable later
+            element.setAttribute("identifier", community.getHandle());
+            
+            Element nameElement = new Element("name");
+            nameElement.setText(community.getMetadata("name"));
+            element.addContent(nameElement);
+            
+            if (community.getMetadata("short_description") != null)
+            {
+                Element descriptionElement = new Element("description");
+                descriptionElement.setText(community.getMetadata("short_description"));
+                element.addContent(descriptionElement);
+            }
+            
+            if (community.getMetadata("introductory_text") != null)
+            {
+                Element introElement = new Element("intro");
+                introElement.setText(community.getMetadata("introductory_text"));
+                element.addContent(introElement);
+            }
+            
+            if (community.getMetadata("copyright_text") != null)
+            {
+                Element copyrightElement = new Element("copyright");
+                copyrightElement.setText(community.getMetadata("copyright_text"));
+                element.addContent(copyrightElement);
+            }
+            
+            if (community.getMetadata("side_bar_text") != null)
+            {
+                Element sidebarElement = new Element("sidebar");
+                sidebarElement.setText(community.getMetadata("side_bar_text"));
+                element.addContent(sidebarElement);
+            }
+            
+            // handle sub communities
+            NodeList subCommunities = XPathAPI.selectNodeList(tn, "community");
+            Element[] subCommunityElements = handleCommunities(context, subCommunities, community);
+            
+            // handle collections
+            NodeList collections = XPathAPI.selectNodeList(tn, "collection");
+            Element[] collectionElements = handleCollections(context, collections, community);
+            
+            int j;
+            for (j = 0; j < subCommunityElements.length; j++)
+            {
+                element.addContent(subCommunityElements[j]);
+            }
+            for (j = 0; j < collectionElements.length; j++)
+            {
+                element.addContent(collectionElements[j]);
+            }
+            
+            elements[i] = element;
+        }
+        
+        return elements;
+    }
+    
+    /**
+     *  Take a node list of collections and create the structure from them
+     * 
+     * @param context the context of the request
+     * @param collections the node list of collections to be created
+     * @param parent the parent community to whom the collections belong
+     * 
+     * @return an Element array containing additional information about the
+     * 			created collections (e.g. the handle)
+     */
+    private static Element[] handleCollections(Context context, NodeList collections, Community parent)
+    	throws TransformerException, SQLException, AuthorizeException, IOException, Exception
+    {
+        Element[] elements = new Element[collections.getLength()];
+        
+        for (int i = 0; i < collections.getLength(); i++)
+        {
+            Element element = new Element("collection");
+            Collection collection = parent.createCollection();
+            
+            // default the short description to the empty string
+            collection.setMetadata("short_description", " ");
+            
+            // import the rest of the metadata
+            Node tn = collections.item(i);
+            Enumeration keys = collectionMap.keys();
+            while (keys.hasMoreElements())
+            {
+                Node node = null;
+                String key = (String) keys.nextElement();
+                NodeList nl = XPathAPI.selectNodeList(tn, key);
+                if (nl.getLength() == 1)
+                {
+                    node = nl.item(0);
+                    collection.setMetadata((String) collectionMap.get(key), getStringValue(node));
+                }
+            }
+            
+            collection.update();
+            
+            element.setAttribute("identifier", collection.getHandle());
+            
+            Element nameElement = new Element("name");
+            nameElement.setText(collection.getMetadata("name"));
+            element.addContent(nameElement);
+            
+            if (collection.getMetadata("short_description") != null)
+            {
+                Element descriptionElement = new Element("description");
+                descriptionElement.setText(collection.getMetadata("short_description"));
+                element.addContent(descriptionElement);
+            }
+            
+            if (collection.getMetadata("introductory_text") != null)
+            {
+                Element introElement = new Element("intro");
+                introElement.setText(collection.getMetadata("introductory_text"));
+                element.addContent(introElement);
+            }
+            
+            if (collection.getMetadata("copyright_text") != null)
+            {
+                Element copyrightElement = new Element("copyright");
+                copyrightElement.setText(collection.getMetadata("copyright_text"));
+                element.addContent(copyrightElement);
+            }
+            
+            if (collection.getMetadata("side_bar_text") != null)
+            {
+                Element sidebarElement = new Element("sidebar");
+                sidebarElement.setText(collection.getMetadata("side_bar_text"));
+                element.addContent(sidebarElement);
+            }
+            
+            if (collection.getMetadata("license") != null)
+            {
+                Element sidebarElement = new Element("license");
+                sidebarElement.setText(collection.getMetadata("license"));
+                element.addContent(sidebarElement);
+            }
+            
+            if (collection.getMetadata("provenance_description") != null)
+            {
+                Element sidebarElement = new Element("provenance");
+                sidebarElement.setText(collection.getMetadata("provenance_description"));
+                element.addContent(sidebarElement);
+            }
+            
+            elements[i] = element;
+        }
+        
+        return elements;
+    }
+    
+}

dspace-api/src/main/java/org/dspace/administer/Upgrade101To11.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/administer/Upgrade11To12.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/bulkedit/BulkEditChange.java

@@ -0,0 +1,291 @@
+/*
+ * BulkEditChange.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.bulkedit;
+
+import org.dspace.content.Item;
+import org.dspace.content.DCValue;
+import org.dspace.content.Collection;
+
+import java.util.ArrayList;
+
+/**
+ * Utility class to store changes to item that may occur during a batch edit.
+ *
+ * @author Stuart Lewis
+ */
+public class BulkEditChange
+{
+    /** The item these changes relate to */
+    private Item item;
+
+    /** The ArrayList of hashtables with the new elements */
+    private ArrayList<DCValue> adds;
+
+    /** The ArrayList of hashtables with the removed elements */
+    private ArrayList<DCValue> removes;
+
+    /** The ArrayList of hashtablles with the unchanged elements */
+    private ArrayList<DCValue> constant;
+
+    /** The ArrayList of the complete set of new values (constant + adds) */
+    private ArrayList<DCValue> complete;
+
+    /** The Arraylist of old collections the item has been moved from */
+    private ArrayList<Collection> oldOwningCollections;
+
+    /** The Arraylist of new collections the item has been moved into */
+    private ArrayList<Collection> newOwningCollections;
+
+    /** Is this a new item */
+    private boolean newItem;
+
+    /** Have any changes actually been made? */
+    private boolean empty;
+
+
+    /**
+     * Initalise a change holder for a new item 
+     */
+    public BulkEditChange()
+    {
+        // Set the item to be null
+        item = null;
+        newItem = true;
+        empty = true;
+
+        // Initialise the arrays
+        adds = new ArrayList<DCValue>();
+        removes = new ArrayList<DCValue>();
+        constant = new ArrayList<DCValue>();
+        complete = new ArrayList<DCValue>();
+        oldOwningCollections = new ArrayList<Collection>();
+        newOwningCollections = new ArrayList<Collection>();
+    }
+
+    /**
+     * Initalise a new change holder for an existing item
+     *
+     * @param i The Item to store
+     */
+    public BulkEditChange(Item i)
+    {
+        // Store the item
+        item = i;
+        newItem = false;
+        empty = true;
+
+        // Initalise the arrays
+        adds = new ArrayList<DCValue>();
+        removes = new ArrayList<DCValue>();
+        constant = new ArrayList<DCValue>();
+        complete = new ArrayList<DCValue>();
+        oldOwningCollections = new ArrayList<Collection>();
+        newOwningCollections = new ArrayList<Collection>();
+    }
+
+    /**
+     * Store the item - used when a new item is created
+     *
+     * @param i The item
+     */
+    public void setItem(Item i)
+    {
+        // Store the item
+        item = i;
+    }
+
+    /**
+     * Add an added metadata value
+     *
+     * @param dcv The value to add
+     */
+    public void registerAdd(DCValue dcv)
+    {
+        // Add the added value
+        adds.add(dcv);
+        complete.add(dcv);
+        empty = false;
+    }
+
+    /**
+     * Add a removed metadata value
+     *
+     * @param dcv The value to remove
+     */
+    public void registerRemove(DCValue dcv)
+    {
+        // Add the removed value
+        removes.add(dcv);
+        empty = false;
+    }
+
+    /**
+     * Add an unchanged metadata value
+     *
+     * @param dcv The value to keep unchanged
+     */
+    public void registerConstant(DCValue dcv)
+    {
+        // Add the removed value
+        constant.add(dcv);
+        complete.add(dcv);
+    }
+
+    /**
+     * Add a new owning Collection
+     *
+     * @param c The new owning Collection
+     */
+    public void registerNewOwningCollection(Collection c)
+    {
+        // Add the new owning Collection\
+        newOwningCollections.add(c);
+        empty = false;
+    }
+
+    /**
+     * Add an old owning Collection
+     *
+     * @param c The old owning Collection
+     */
+    public void registerOldOwningCollection(Collection c)
+    {
+        // Add the old owning Collection\
+        oldOwningCollections.add(c);
+        empty = false;
+    }
+
+    /**
+     * Get the DSpace Item that these changes are applicable to.
+     *
+     * @return The item
+     */
+    public Item getItem()
+    {
+        // Return the item
+        return item;
+    }
+
+    /**
+     * Get the list of elements and their values that have been added.
+     *
+     * @return the list of elements and their values that have been added.
+     */
+    public ArrayList<DCValue> getAdds()
+    {
+        // Return the array
+        return adds;
+    }
+
+    /**
+     * Get the list of elements and their values that have been removed.
+     *
+     * @return the list of elements and their values that have been removed.
+     */
+    public ArrayList<DCValue> getRemoves()
+    {
+        // Return the array
+        return removes;
+    }
+
+    /**
+     * Get the list of unchanged values
+     *
+     * @return the list of unchanged values
+     */
+    public ArrayList<DCValue> getConstant()
+    {
+        // Return the array
+        return constant;
+    }
+
+    /**
+     * Get the list of all values
+     *
+     * @return the list of all values
+     */
+    public ArrayList<DCValue> getComplete()
+    {
+        // Return the array
+        return complete;
+    }
+
+    /**
+     * Get the list of new owning Collections
+     *
+     * @return the list of new owning collections
+     */
+    public ArrayList<Collection> getNewOwningCollections()
+    {
+        // Return the array
+        return newOwningCollections;
+    }
+
+    /**
+     * Get the list of old owning Collections
+     *
+     * @return the list of old owning collections
+     */
+    public ArrayList<Collection> getOldOwningCollections()
+    {
+        // Return the array
+        return oldOwningCollections;
+    }
+
+    /**
+     * Does this change object represent a new item?
+     *
+     * @return Whether or not this is for a new item
+     */
+    public boolean isNewItem()
+    {
+        // Return the new item status
+        return newItem;
+    }
+
+    /**
+     * Have any changes actually been recorded, or is this empty?
+     *
+     * @return Whether or not changes have been made
+     */
+    public boolean hasChanges()
+    {
+        return !empty;
+    }
+}

dspace-api/src/main/java/org/dspace/app/bulkedit/DSpaceCSV.java

@@ -0,0 +1,577 @@
+/*
+ * DSpaceCSV.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.bulkedit;
+
+import org.dspace.content.*;
+import org.dspace.content.Collection;
+import org.dspace.core.ConfigurationManager;
+
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import java.io.*;
+
+/**
+ * Utility class to read and write CSV files
+ *
+ * @author Stuart Lewis
+ */
+public class DSpaceCSV
+{
+    /** The headings of the CSV file */
+    private ArrayList<String> headings;
+
+    /** An array list of CSV lines */
+    private ArrayList<DSpaceCSVLine> lines;
+
+    /** A counter of how many CSV lines this object holds */
+    private int counter;
+
+    /** The value separator (defaults to double pipe '||') */
+    protected static String valueSeparator;
+
+    /** The value separator in an escaped form for using in regexs */
+    protected static String escpaedValueSeparator;
+
+    /** The field separator (defaults to comma) */
+    protected static String fieldSeparator;
+
+    /** The field separator in an escaped form for using in regexs */
+    protected static String escapedFieldSeparator;
+
+    /** Whether to export all metadata such as handles and provenance information */
+    private boolean exportAll;
+
+    /** A list of metadata elements to ignore */
+    private Hashtable ignore;
+
+
+    /**
+     * Create a new instance of a CSV line holder
+     *
+     * @param exportAll Whether to export all metadata such as handles and provenance information
+     */
+    public DSpaceCSV(boolean exportAll)
+    {
+        // Initalise the class
+        init();
+
+        // Stoee the exportAll setting
+        this.exportAll = exportAll;
+    }
+
+    /**
+     * Create a new instance, reading the lines in from file
+     *
+     * @param f The file to read from
+     *
+     * @throws Exception thrown if there is an error reading or processing the file
+     */
+    public DSpaceCSV(File f) throws Exception
+    {
+        // Initalise the class
+        init();
+
+        // Open the CSV file
+        BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(f),"UTF8"));
+
+        // Read the heading line
+        String head = input.readLine();
+        String[] headingElements = head.split(escapedFieldSeparator);
+        for (String element : headingElements)
+        {
+            // Remove surrounding quotes if there are any
+            if ((element.startsWith("\"")) && (element.endsWith("\"")))
+            {
+                element = element.substring(1, element.length() - 1);
+            }
+
+            if (!"id".equals(element))
+            {
+                // Store the heading
+                headings.add(element);
+            }
+        }
+
+        // Read each subsequent line
+        String line;
+        while ((line = input.readLine()) != null){
+            // Are there an odd number of quotes?
+            while (((" " + line + " ").split("\"").length)%2 == 0)
+            {
+                line = line + "\n" + input.readLine();
+            }
+
+            // Parse the item metadata
+            addItem(line);
+        }
+    }
+
+    /**
+     * Initalise this class with values from dspace.cfg
+     */
+    private void init()
+    {
+        // Set the value separator
+        setValueSeparator();
+        
+        // Set the field separator
+        setFieldSeparator();
+
+        // Create the headings
+        headings = new ArrayList<String>();
+
+        // Create the blank list of items
+        lines = new ArrayList<DSpaceCSVLine>();
+
+        // Initalise the counter
+        counter = 0;
+
+        // Set the metadata fields to ignore
+        ignore = new Hashtable();
+        String toIgnore = ConfigurationManager.getProperty("bulkedit.ignore-on-export");
+        if ((toIgnore == null) || ("".equals(toIgnore.trim())))
+        {
+            // Set a default value
+            toIgnore = "dc.date.accession, dc.date.available, " +
+                       "dc.description.provenance";
+        }
+        String[] toIgnoreArray = toIgnore.split(",");
+        for (String toIgnoreString : toIgnoreArray)
+        {
+            if (!"".equals(toIgnoreString.trim()))
+            {
+                ignore.put(toIgnoreString.trim(), toIgnoreString.trim());
+            }
+        }
+    }
+
+    /**
+     * Set the value separator for multiple values stored in one csv value.
+     *
+     * Is set in dspace.cfg as bulkedit.valueseparator
+     *
+     * If not set, defaults to double pipe '||'
+     */
+    private void setValueSeparator()
+    {
+        // Get the value separator
+        valueSeparator = ConfigurationManager.getProperty("bulkedit.valueseparator");
+        if ((valueSeparator != null) && (!"".equals(valueSeparator.trim())))
+        {
+            valueSeparator = valueSeparator.trim();
+        }
+        else
+        {
+            valueSeparator = "||";
+        }
+
+        // Now store the escaped version
+        Pattern spchars = Pattern.compile("([\\\\*+\\[\\](){}\\$.?\\^|])");
+        Matcher match = spchars.matcher(valueSeparator);
+        escpaedValueSeparator = match.replaceAll("\\\\$1");
+    }
+
+    /**
+     * Set the field separator use to separate fields in the csv.
+     *
+     * Is set in dspace.cfg as bulkedit.fieldseparator
+     *
+     * If not set, defaults to comma ','.
+     *
+     * Special values are 'tab', 'hash' and 'semicolon' which will
+     * get substituted from the text to the value.
+     */
+    private void setFieldSeparator()
+    {
+        // Get the value separator
+        fieldSeparator = ConfigurationManager.getProperty("bulkedit.fieldseparator");
+        if ((fieldSeparator != null) && (!"".equals(fieldSeparator.trim())))
+        {
+            fieldSeparator = fieldSeparator.trim();
+            if ("tab".equals(fieldSeparator))
+            {
+                fieldSeparator = "\t";
+            }
+            else if ("semicolon".equals(fieldSeparator))
+            {
+                fieldSeparator = ";";
+            }
+            else if ("hash".equals(fieldSeparator))
+            {
+                fieldSeparator = "#";
+            }
+            else
+            {
+                fieldSeparator = fieldSeparator.trim();
+            }
+        }
+        else
+        {
+            fieldSeparator = ",";
+        }
+
+        // Now store the escaped version
+        Pattern spchars = Pattern.compile("([\\\\*+\\[\\](){}\\$.?\\^|])");
+        Matcher match = spchars.matcher(fieldSeparator);
+        escapedFieldSeparator = match.replaceAll("\\\\$1");
+    }
+
+    /**
+     * Add a DSpace item to the CSV file
+     *
+     * @param i The DSpace item
+     *
+     * @throws Exception if something goes wrong with adding the Item
+     */
+    public void addItem(Item i) throws Exception
+    {
+        // Create the CSV line
+        DSpaceCSVLine line = new DSpaceCSVLine(i.getID());
+
+        // Add in owning collections
+        Collection[] collections = i.getCollections();
+        for (Collection c : collections)
+        {
+           line.add("collection", c.getHandle());
+        }
+
+        // Populate it
+        DCValue md[] = i.getMetadata(Item.ANY, Item.ANY, Item.ANY, Item.ANY);
+        for (DCValue value : md)
+        {
+            // Get the key (schema.element)
+            String key = value.schema + "." + value.element;
+
+            // Add the qualifer if there is one (schema.element.qualifier)
+            if (value.qualifier != null)
+            {
+                key = key + "." + value.qualifier;
+            }
+
+            // Add the language if there is one (schema.element.qualifier[langauge])
+            //if ((value.language != null) && (!"".equals(value.language)))
+            if (value.language != null)
+            {
+                key = key + "[" + value.language + "]";
+            }
+
+            // Store the item
+            if (exportAll || okToExport(value))
+            {
+                line.add(key, value.value);
+                if (!headings.contains(key))
+                {
+                    headings.add(key);
+                }
+            }
+        }
+        lines.add(line);
+        counter++;
+    }
+
+    /**
+     * Add an item to the CSV file, from a CSV line of elements
+     *
+     * @param line The line of elements
+     * @throws Exception Thrown if an error occurs when adding the item
+     */
+    public void addItem(String line) throws Exception
+    {
+        // Check to see if the last character is a field separator, which hides the last empy column
+        boolean last = false;
+        if (line.endsWith(fieldSeparator))
+        {
+            // Add a space to the end, then remove it later
+            last = true;
+            line += " ";
+        }
+        
+        // Split up on field separator
+        String[] parts = line.split(escapedFieldSeparator);
+        ArrayList<String> bits = new ArrayList<String>();
+        bits.addAll(Arrays.asList(parts));
+
+        // Merge parts with embedded separators
+        boolean alldone = false;
+        while (!alldone)
+        {
+            boolean found = false;
+            int i = 0;
+            for (String part : bits)
+            {
+                int bitcounter = part.length() - part.replaceAll("\"", "").length();
+                if ((part.startsWith("\"")) && ((!part.endsWith("\"")) || ((bitcounter %2) == 1)))
+                {
+                    found = true;
+                    String add = bits.get(i) + fieldSeparator + bits.get(i + 1);
+                    bits.remove(i);
+                    bits.add(i, add);
+                    bits.remove(i + 1);
+                    break;
+                }
+                i++;
+            }
+            alldone = !found;
+        }
+
+        // Deal with quotes around the elements
+        int i = 0;
+        for (String part : bits)
+        {
+            if ((part.startsWith("\"")) && (part.endsWith("\"")))
+            {
+                part = part.substring(1, part.length() - 1);
+                bits.set(i, part);
+            }
+            i++;
+        }
+
+        // Remove embedded quotes
+        i = 0;
+        for (String part : bits)
+        {
+            if (part.contains("\"\""))
+            {
+                part = part.replaceAll("\"\"", "\"");
+                bits.set(i, part);
+            }
+            i++;
+        }
+
+        // Add elements to a DSpaceCSVLine
+        String id = parts[0].replaceAll("\"", "");
+        DSpaceCSVLine csvLine;
+                
+        // Is this an existing item, or a new item (where id = '+')
+        if ("+".equals(id))
+        {
+            csvLine = new DSpaceCSVLine();
+        }
+        else
+        {
+            try
+            {
+                csvLine = new DSpaceCSVLine(Integer.parseInt(id));
+            }
+            catch (NumberFormatException nfe)
+            {
+                System.err.println("Invalid item identifier: " + id);
+                System.err.println("Please check your CSV file for informaton. " +
+                                   "Item id must be numeric, or a '+' to add a new item");
+                throw(nfe);
+            }
+        }
+
+        // Add the rest of the parts
+        i = 0;
+        for (String part : bits)
+        {
+            if (i > 0)
+            {
+                // Is this a last empty item?
+                if ((last) && (i == headings.size()))
+                {
+                    part = "";
+                }
+
+                // Make sure we register that this column was there
+                csvLine.add(headings.get(i - 1), null);
+                String[] elements = part.split(escpaedValueSeparator);
+                for (String element : elements)
+                {
+                    if ((element != null) && (!"".equals(element)))
+                    {
+                        csvLine.add(headings.get(i - 1), element);
+                    }
+                }
+            }
+            i++;
+        }
+        lines.add(csvLine);
+        counter++;
+    }
+
+    /**
+     * Get the lines in CSV holders
+     *
+     * @return The lines
+     */
+    public ArrayList<DSpaceCSVLine> getCSVLines()
+    {
+        // Return the lines
+        return lines;
+    }
+
+    /**
+     * Get the CSV lines as an array of CSV formatted strings
+     *
+     * @return the array of CSV formatted Strings
+     */
+    public String[] getCSVLinesAsStringArray()
+    {
+        // Create the headings line
+        String[] csvLines = new String[counter + 1];
+        csvLines[0] = "id" + fieldSeparator + "collection";
+        Collections.sort(headings);
+        for (String value : headings)
+        {
+            csvLines[0] = csvLines[0] + fieldSeparator + value;
+        }
+
+        Iterator<DSpaceCSVLine> i = lines.iterator();
+        int c = 1;
+        while (i.hasNext())
+        {
+            csvLines[c++] = i.next().toCSV(headings);
+        }
+
+        return csvLines;
+    }
+
+    /**
+     * Save the CSV file to the given filename
+     *
+     * @param filename The filename to save the CSV file to
+     *
+     * @throws IOException Thrown if an error occurs when writing the file
+     */
+    public void save(String filename) throws IOException
+    {
+        // Save the file
+        BufferedWriter out = new BufferedWriter(
+                             new OutputStreamWriter(
+                             new FileOutputStream(filename), "UTF8"));
+        for (String csvLine : getCSVLinesAsStringArray()) {
+            out.write(csvLine + "\n");
+        }
+        out.flush();
+        out.close();
+    }
+
+    /**
+     * Is it Ok to export this value? When exportAll is set to false, we don't export
+     * some of the metadata elements.
+     *
+     * The list can be configured via the key bulkedit.ignore-on-export in dspace.cfg
+     *
+     * @param md The DCValue to examine
+     * @return Whether or not it is OK to export this element
+     */
+    private boolean okToExport(DCValue md)
+    {
+        // First check the metadata format, and K all non DC elements
+        if (!"dc".equals(md.schema))
+        {
+            return true;
+        }
+
+        // Now compare with the list to ignore
+        String key = md.schema + "." + md.element;
+        if (md.qualifier != null)
+        {
+            key += "." + md.qualifier;
+        }
+        if (ignore.get(key) != null) {
+            return false;
+        }
+
+        // Must be OK, so don't ignore
+        return true;
+    }
+
+    /**
+     * Return the csv file as one long formatted string
+     *
+     * @return The formatted String as a csv
+     */
+    public String toString()
+    {
+        // Return the csv as one long string
+        StringBuffer csvLines = new StringBuffer();
+        String[] lines = this.getCSVLinesAsStringArray();
+        for (String line : lines)
+        {
+            csvLines.append(line).append("\n");
+        }
+        return csvLines.toString();
+    }
+
+    /**
+     * Test main method to check the marshalling and unmarshalling of strings in and out of CSV format
+     *
+     * @param args Not used
+     * @throws Exception Thrown if something goes wrong
+     */
+    public static void main(String[] args) throws Exception
+    {
+        // Test the CSV parsing
+        String[] csv = {"id,\"dc.title\",dc.contributor.author,dc.description.abstract",
+                        "1,Easy line,\"Lewis, Stuart\",A nice short abstract",
+                        "2,Two authors,\"Lewis, Stuart||Bloggs, Joe\",Two people wrote this item",
+                        "3,Three authors,\"Lewis, Stuart||Bloggs, Joe||Loaf, Meat\",Three people wrote this item",
+                        "4,\"Two line\ntitle\",\"Lewis, Stuart\",abstract",
+                        "5,\"\"\"Embedded quotes\"\" here\",\"Lewis, Stuart\",\"Abstract with\ntwo\nnew lines\"",
+                        "6,\"\"\"Unbalanced embedded\"\" quotes\"\" here\",\"Lewis, Stuart\",\"Abstract with\ntwo\nnew lines\"",};
+
+        // Write the string to a file
+        String filename = "test.csv";
+        BufferedWriter out = new BufferedWriter(
+                             new OutputStreamWriter(
+                             new FileOutputStream(filename), "UTF8"));
+        for (String csvLine : csv) {
+            out.write(csvLine + "\n");
+        }
+        out.flush();
+        out.close();
+        System.gc();
+
+        // test the CSV parsing
+        DSpaceCSV dcsv = new DSpaceCSV(new File(filename));
+        String[] lines = dcsv.getCSVLinesAsStringArray();
+        for (String line : lines)
+        {
+            System.out.println(line);          
+        }
+
+        // Delete the test file
+        File toDelete = new File(filename);
+        toDelete.delete();
+    }
+}

dspace-api/src/main/java/org/dspace/app/bulkedit/DSpaceCSVLine.java

@@ -0,0 +1,212 @@
+/*
+ * DSpaceCSVLine.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.bulkedit;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.util.Iterator;
+
+/**
+ * Utility class to store a line from a CSV file
+ *
+ * @author Stuart Lewis
+ */
+public class DSpaceCSVLine
+{
+    /** The item id of the item represented by this line. -1 is for a new item */
+    private int id;
+
+    /** The elements in this line in a hashtable, keyed by the metadata type */
+    private Hashtable<String, ArrayList> items;
+
+    /**
+     * Create a new CSV line
+     *
+     * @param id The item ID of the line
+     */
+    public DSpaceCSVLine(int id)
+    {
+        // Store the ID + separator, and initalise the hashtable
+        this.id = id;
+        items = new Hashtable<String, ArrayList>();
+    }
+
+    /**
+     * Create a new CSV line for a new item
+     */
+    public DSpaceCSVLine()
+    {
+        // Set the ID to be -1, and initalise the hashtable
+        this.id = -1;
+        this.items = new Hashtable<String, ArrayList>();
+    }
+
+    /**
+     * Get the item ID that this line represents
+     *
+     * @return The item ID
+     */
+    public int getID()
+    {
+        // Return the ID
+        return id;
+    }
+
+    /**
+     * Add a new metadata value to this line
+     *
+     * @param key The metadata key (e.g. dc.contributor.author)
+     * @param value The metadata value
+     */
+    public void add(String key, String value)
+    {
+        // Create the array list if we need to
+        if (items.get(key) == null)
+        {
+            items.put(key, new ArrayList<String>());
+        }
+
+        // Store the item if it is not null
+        if (value != null)
+        {
+            items.get(key).add(value);
+        }
+    }
+
+    /**
+     * Get all the values that match the given metadata key. Will be null if none exist.
+     *
+     * @param key The metadata key
+     * @return All the elements that match
+     */
+    public ArrayList<String> get(String key)
+    {
+        // Return any relevant values
+        return items.get(key);
+    }
+
+    /**
+     * Get all the metadata keys that are represented in this line
+     *
+     * @return An enumeration of all the keys
+     */
+    public Enumeration<String> keys()
+    {
+        // Return the keys
+        return items.keys();
+    }
+
+    /**
+     * Write this line out as a CSV formatted string, in the order given by the headings provided
+     *
+     * @param headings The headings which define the order the elements must be presented in
+     * @return The CSV formatted String
+     */
+    protected String toCSV(ArrayList<String> headings)
+    {
+        // Add the id
+        String bits = "\"" + id + "\"" + DSpaceCSV.fieldSeparator;
+        bits += valueToCSV(items.get("collection")) + DSpaceCSV.fieldSeparator;
+
+        // Add the rest of the elements
+        Iterator<String> i = headings.iterator();
+        String key;
+        while (i.hasNext())
+        {
+            key = i.next();
+            if ((items.get(key) != null) && (!"collection".equals(key)))
+            {
+                bits = bits + valueToCSV(items.get(key));
+            }
+
+            if (i.hasNext())
+            {
+                bits = bits + DSpaceCSV.fieldSeparator;
+            }
+        }
+        return bits;
+    }
+
+    /**
+     * Internal method to create a CSV formatted String joining a given set of elements
+     *
+     * @param values The values to create the string from
+     * @return The line as a CSV formatted String
+     */
+    private String valueToCSV(ArrayList<String> values)
+    {
+        // Concatenate any fields together 
+        String s = "";
+
+        // Check there is some content
+        if (values == null)
+        {
+            return s;
+        }
+
+        // Get on with the work
+        if (values.size() == 1)
+        {
+            s = values.get(0);
+        }
+        else
+        {
+            Iterator i = values.iterator();
+            while (i.hasNext())
+            {
+                s = s + i.next();
+                if (i.hasNext())
+                {
+                    s = s + DSpaceCSV.valueSeparator;
+                }
+            }
+        }
+
+        // Replace internal quotes with two sets of quotes
+        s = s.replaceAll("\"", "\"\"");
+
+        // Wrap in quotes
+        s = "\"" + s + "\"";
+
+        // Return the csv formatted string
+        return s;
+    }
+}
+

dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataExport.java

@@ -0,0 +1,297 @@
+/*
+ * MetadataExport.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.bulkedit;
+
+import org.apache.commons.cli.*;
+import org.apache.log4j.Logger;
+
+import org.dspace.content.*;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.handle.HandleManager;
+
+import java.util.ArrayList;
+import java.sql.SQLException;
+
+/**
+ * Metadata exporter to allow the batch export of metadata into a file
+ *
+ * @author Stuart Lewis
+ */
+public class MetadataExport
+{
+    /** The Context */
+    private Context c;
+
+    /** The items to export */
+    private ItemIterator toExport;
+
+    /** Whether to export all metadata, or just normally edited metadata */
+    private boolean exportAll;
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(MetadataExport.class);
+
+    /**
+     * Set up a new metadata export
+     *
+     * @param c The Context
+     * @param toExport The ItemIterator of items to export
+     * @param exportAll whether to export all metadata or not (include handle, provenance etc)
+     */
+    public MetadataExport(Context c, ItemIterator toExport, boolean exportAll)
+    {
+        // Store the export settings
+        this.c = c;
+        this.toExport = toExport;
+        this.exportAll = exportAll;
+    }
+
+    /**
+     * Method to export a community (and sub-communites and collections)
+     *
+     * @param c The Context
+     * @param toExport The Community to export
+     * @param exportAll whether to export all metadata or not (include handle, provenance etc)
+     */
+    public MetadataExport(Context c, Community toExport, boolean exportAll)
+    {
+        try
+        {
+            // Try to export the community
+            this.c = c;
+            this.toExport = new ItemIterator(c, buildFromCommunity(toExport, new ArrayList(), 0));
+            this.exportAll = exportAll;
+        }
+        catch (SQLException sqle)
+        {
+            // Something went wrong...
+            System.err.println("Error running exporter:");
+            sqle.printStackTrace(System.err);
+            System.exit(1);
+        }
+    }
+
+    /**
+     * Build an array list of item ids that are in a community (include sub-communities and collections)
+     *
+     * @param community The community to build from
+     * @param itemIDs The itemID (used for recuriosn - use an empty ArrayList)
+     * @param indent How many spaces to use when writing out the names of items added
+     * @return The list of item ids
+     * @throws SQLException
+     */
+    private ArrayList buildFromCommunity(Community community, ArrayList itemIDs, int indent)
+                                                                               throws SQLException
+    {
+        // Add all the collections
+        Collection[] collections = community.getCollections();
+        for (Collection collection : collections)
+        {
+            for (int i = 0; i < indent; i++) System.out.print(" ");
+            ItemIterator items = collection.getAllItems();
+            while (items.hasNext())
+            {
+                int id = items.next().getID();
+                // Only add if not already included (so mapped items only appear once)
+                if (!itemIDs.contains(id))
+                {
+                    itemIDs.add(id);
+                }
+            }
+        }
+
+        // Add all the sub-communities
+        Community[] communities = community.getSubcommunities();
+        for (Community subCommunity : communities)
+        {
+            for (int i = 0; i < indent; i++) System.out.print(" ");
+            buildFromCommunity(subCommunity, itemIDs, indent + 1);
+        }
+
+        return itemIDs;
+    }
+
+    /**
+     * Run the export
+     *
+     * @return the exported CSV lines
+     */
+    public DSpaceCSV export()
+    {
+        try
+        {
+            // Process each item
+            DSpaceCSV csv = new DSpaceCSV(exportAll);
+            while (toExport.hasNext())
+            {
+                csv.addItem(toExport.next());
+            }
+
+            // Return the results
+            return csv;
+        }
+        catch (Exception e)
+        {
+            return null;
+        }
+    }
+
+    /**
+     * Print the help message
+     *
+     * @param options The command line options the user gave
+     * @param exitCode the system exit code to use
+     */
+    private static void printHelp(Options options, int exitCode)
+    {
+        // print the help message
+        HelpFormatter myhelp = new HelpFormatter();
+        myhelp.printHelp("MetadataExport\n", options);
+        System.out.println("\nfull export: metadataexport -f filename");
+        System.out.println("partial export: metadataexport -i handle -f filename");
+        System.exit(exitCode);
+    }
+
+    /**
+	 * main method to run the metadata exporter
+	 *
+	 * @param argv the command line arguments given
+	 */
+    public static void main(String[] argv) throws Exception
+    {
+        // Create an options object and populate it
+        CommandLineParser parser = new PosixParser();
+
+        Options options = new Options();
+
+        options.addOption("i", "id", true, "ID or handle of thing to export (item, collection, or community)");
+        options.addOption("f", "file", true, "destination where you want file written");
+        options.addOption("a", "all", false, "include all metadata fields that are not normally changed (e.g. provenance)");
+        options.addOption("h", "help", false, "help");
+
+        CommandLine line = null;
+
+        try
+        {
+            line = parser.parse(options, argv);
+        }
+        catch (ParseException pe)
+        {
+            System.err.println("Error with commands.");
+            printHelp(options, 1);
+            System.exit(0);
+        }
+
+        if (line.hasOption('h'))
+        {
+            printHelp(options, 0);
+        }
+
+        // Check a filename is given
+        if (!line.hasOption('f'))
+        {
+            System.err.println("Required parameter -f missing!");
+            printHelp(options, 1);
+        }
+        String filename = line.getOptionValue('f');
+
+        // Create a context
+        Context c = new Context();
+        c.turnOffAuthorisationSystem();
+
+        // The things we'll export
+        ItemIterator toExport = null;
+        MetadataExport exporter = null;
+
+        // Export everything?
+        boolean exportAll = line.hasOption('a');
+
+        // Check we have an item OK
+        if (!line.hasOption('i'))
+        {
+            System.out.println("Exporting whole repository WARNING: May take some time!");
+            exporter = new MetadataExport(c, Item.findAll(c), exportAll);
+        }
+        else
+        {
+            String handle = line.getOptionValue('i');
+            DSpaceObject dso = HandleManager.resolveToObject(c, handle);
+            if (dso == null)
+            {
+                System.err.println("Item '" + handle + "' does not resolve to an item in your repository!");
+                printHelp(options, 1);
+            }
+
+            if (dso.getType() == Constants.ITEM)
+            {
+                System.out.println("Exporting item '" + dso.getName() + "' (" + handle + ")");
+                ArrayList item = new ArrayList();
+                item.add(dso.getID());
+                exporter = new MetadataExport(c, new ItemIterator(c, item), exportAll);
+            }
+            else if (dso.getType() == Constants.COLLECTION)
+            {
+                System.out.println("Exporting collection '" + dso.getName() + "' (" + handle + ")");
+                Collection collection = (Collection)dso;
+                toExport = collection.getAllItems();
+                exporter = new MetadataExport(c, toExport, exportAll);
+            }
+            else if (dso.getType() == Constants.COMMUNITY)
+            {
+                System.out.println("Exporting community '" + dso.getName() + "' (" + handle + ")");
+                exporter = new MetadataExport(c, (Community)dso, exportAll);
+            }
+            else
+            {
+                System.err.println("Error identifying '" + handle + "'");
+                System.exit(1);
+            }
+        }
+
+        // Perform the export
+        DSpaceCSV csv = exporter.export();
+
+        // Save the files to the file
+        csv.save(filename);        
+
+        // Finsh off and tidy up
+        c.restoreAuthSystemState();
+        c.complete();
+    }
+}

dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImportException.java

@@ -0,0 +1,56 @@
+/*
+ * MetadataImportException.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.bulkedit;
+
+/**
+ * Metadata importer exception
+ *
+ * @author Stuart Lewis
+ */
+public class MetadataImportException extends Exception
+{
+    /**
+     * Instantiate a new MetadataImportException
+     *
+     * @param message the error message
+     */
+    public MetadataImportException(String message)
+    {
+       super(message);
+    }
+}

dspace-api/src/main/java/org/dspace/app/checker/ChecksumChecker.java

@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2004-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -13,8 +12,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -258,6 +256,7 @@ public class ChecksumChecker
         checker.setDispatcher(dispatcher);
         checker.setCollector(logger);
         checker.process();
+        System.exit(0);
     }
 
     /**

dspace-api/src/main/java/org/dspace/app/harvest/Harvest.java

@@ -0,0 +1,561 @@
+/*
+ * Harvest.java
+ *
+ * Version: $Revision: 1 $
+ *
+ * Date: $Date: 2007-11-28 15:07:34 -0600 (Wed, 28 Nov 2007) $
+ *
+ * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
+ * Institute of Technology.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Hewlett-Packard Company nor the name of the
+ * Massachusetts Institute of Technology nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.harvest;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.Vector;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.PosixParser;
+import org.apache.xpath.XPathAPI;
+import org.dspace.app.itemimport.ItemImport;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.authorize.ResourcePolicy;
+import org.dspace.browse.IndexBrowse;
+import org.dspace.content.Bitstream;
+import org.dspace.content.BitstreamFormat;
+import org.dspace.content.Bundle;
+import org.dspace.content.Collection;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.FormatIdentifier;
+import org.dspace.harvest.HarvestedCollection;
+import org.dspace.content.InstallItem;
+import org.dspace.content.Item;
+import org.dspace.content.ItemIterator;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.harvest.OAIHarvester;
+import org.dspace.content.WorkspaceItem;
+import org.dspace.harvest.OAIHarvester.HarvestingException;
+import org.dspace.content.crosswalk.CrosswalkException;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+import org.dspace.eperson.Group;
+import org.dspace.handle.HandleManager;
+import org.dspace.workflow.WorkflowManager;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+/**
+ *  Test class for harvested collections.
+ *
+ * @author Alexey Maslov
+ */
+public class Harvest
+{
+	private static Context context;
+	
+    public static void main(String[] argv) throws Exception
+    {
+        // create an options object and populate it
+        CommandLineParser parser = new PosixParser();
+
+        Options options = new Options();
+
+        options.addOption("p", "purge", false, "delete all items in the collection");
+        options.addOption("r", "run", false, "run the standrad harvest procedure");
+        options.addOption("g", "ping", false, "test the OAI server and set");
+        options.addOption("o", "once", false, "run the harvest procedure with specified parameters");
+        options.addOption("s", "setup", false, "Set the collection up for harvesting");
+        options.addOption("S", "start", false, "start the harvest loop");
+        options.addOption("R", "reset", false, "reset harvest status on all collections");
+        options.addOption("P", "purge", false, "purge all harvestable collections");
+        
+
+        options.addOption("e", "eperson", true, "eperson");
+        options.addOption("c", "collection", true, "harvesting collection (handle or id)");
+        options.addOption("t", "type", true, "type of harvesting (0 for none)");
+        options.addOption("a", "address", true, "address of the OAI-PMH server");
+        options.addOption("i", "oai_set_id", true, "id of the PMH set representing the harvested collection");
+        options.addOption("m", "metadata_format", true, "the name of the desired metadata format for harvesting, resolved to namespace and crosswalk in dspace.cfg");
+
+        options.addOption("h", "help", false, "help");
+
+        CommandLine line = parser.parse(options, argv);
+
+        String command = null; 
+        String eperson = null;
+        String collection = null;
+        String oaiSource = null;
+        String oaiSetID = null;
+        String metadataKey = null;
+        int harvestType = 0;
+        
+        if (line.hasOption('h'))
+        {
+            HelpFormatter myhelp = new HelpFormatter();
+            myhelp.printHelp("Harvest\n", options);
+            System.out
+    				.println("\nPING OAI server: Harvest -g -s oai_source -i oai_set_id");
+            System.out
+					.println("RUNONCE harvest with arbitrary options: Harvest -o -e eperson -c collection -t harvest_type -a oai_source -i oai_set_id -m metadata_format");
+            System.out
+                    .println("SETUP a collection for harvesting: Harvest -s -c collection -t harvest_type -a oai_source -i oai_set_id -m metadata_format");
+            System.out
+            		.println("RUN harvest once: Harvest -r -e eperson -c collection");
+            System.out
+    				.println("START harvest scheduler: Harvest -S");
+            System.out
+					.println("RESET all harvest status: Harvest -R");
+            System.out
+                    .println("PURGE a collection of items and settings: Harvest -p -e eperson -c collection");
+            System.out
+					.println("PURGE all harvestable collections: Harvest -P -e eperson");
+            
+            
+
+            System.exit(0);
+        }
+
+        if (line.hasOption('s')) {
+            command = "config";
+        }
+        if (line.hasOption('p')) {
+            command = "purge";
+        }
+        if (line.hasOption('r')) {
+            command = "run";
+        }
+        if (line.hasOption('g')) {
+            command = "ping";
+        }
+        if (line.hasOption('o')) {
+            command = "runOnce";
+        }
+        if (line.hasOption('S')) {
+            command = "start";
+        }
+        if (line.hasOption('R')) {
+            command = "reset";
+        }
+        if (line.hasOption('P')) {
+            command = "purgeAll";
+        }
+
+        
+        if (line.hasOption('e')) {
+            eperson = line.getOptionValue('e');
+        }
+        if (line.hasOption('c')) {
+            collection = line.getOptionValue('c');
+        }
+        if (line.hasOption('t')) {
+            harvestType = Integer.parseInt(line.getOptionValue('t'));
+        } else {
+        	harvestType = 0;
+        }
+        if (line.hasOption('a')) {
+            oaiSource = line.getOptionValue('a');
+        }
+        if (line.hasOption('i')) {
+            oaiSetID = line.getOptionValue('i');
+        }
+        if (line.hasOption('m')) {
+            metadataKey = line.getOptionValue('m');
+        }
+        
+
+        // Instantiate our class
+        Harvest harvester = new Harvest();
+        harvester.context = new Context();
+        
+        
+        // Check our options
+        if (command == null)
+        {
+            System.out
+                    .println("Error - no parameters specified (run with -h flag for details)");
+            System.exit(1);
+        }
+        // Run a single harvest cycle on a collection using saved settings.
+        else if (command.equals("run"))
+        {
+            if (collection == null || eperson == null)
+            {
+                System.out
+                        .println("Error - a target collection and eperson must be provided");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);
+            }
+            
+            harvester.runHarvest(collection, eperson);
+        }
+        // start the harvest loop
+        else if (command.equals("start")) 
+        {
+        	startHarvester();
+        }
+        // reset harvesting status
+        else if (command.equals("reset")) 
+        {
+        	resetHarvesting();
+        }
+        // purge all collections that are set up for harvesting (obviously for testing purposes only)
+        else if (command.equals("purgeAll")) 
+        {
+        	if (eperson == null)
+            {
+                System.out
+                        .println("Error - an eperson must be provided");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);
+            }
+        	
+        	List<Integer> cids = HarvestedCollection.findAll(context);
+        	System.out.println("Purging the following collections (deleting items and resetting harvest status): " + cids.toString());
+	    	for (Integer cid : cids) 
+	    	{
+	    		harvester.purgeCollection(cid.toString(), eperson);
+	    	}
+	    	context.complete();
+        }
+        // Delete all items in a collection. Useful for testing fresh harvests.
+        else if (command.equals("purge"))
+        {
+            if (collection == null || eperson == null)
+            {
+                System.out
+                        .println("Error - a target collection and eperson must be provided");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);
+            }
+            
+            harvester.purgeCollection(collection, eperson);
+            context.complete();
+            
+            //TODO: implement this... remove all items and remember to unset "last-harvested" settings
+        }
+        // Configure a collection with the three main settings 
+        else if (command.equals("config"))
+        {
+            if (collection == null)
+            {
+                System.out.println("Error -  a target collection must be provided");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);
+            }
+            if (oaiSource == null || oaiSetID == null)
+            {
+                System.out.println("Error - both the OAI server address and OAI set id must be specified");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);
+            }
+            if (metadataKey == null)
+            {
+            	System.out.println("Error - a metadata key (commonly the prefix) must be specified for this collection");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);            	
+            }
+            
+            harvester.configureCollection(collection, harvestType, oaiSource, oaiSetID, metadataKey);
+        }
+        else if (command.equals("ping"))
+        {
+            if (oaiSource == null || oaiSetID == null)
+            {
+                System.out.println("Error - both the OAI server address and OAI set id must be specified");
+                System.out.println(" (run with -h flag for details)");
+                System.exit(1);
+            }
+        }
+    }
+    
+    
+    /**
+     * check 
+     * @param collectionID
+     * @return
+     */
+    private Collection checkCollection(String collectionID) 
+    {
+    	Collection collection = resolveCollection(collectionID);
+    	try {
+    		HarvestedCollection hc = HarvestedCollection.find(context, collection.getID());
+	        if (!hc.isHarvestable()) {
+	        	System.out.println("Collection '"+ collection.getName() +"' is not set up for harvesting");
+	            System.exit(1);
+	        }
+    	} catch (SQLException se) {
+    		se.printStackTrace();
+    	}
+    	return collection;
+    }
+    
+    /*
+     * Resolve the ID into a collection and check to see if its harvesting options are set. If so, return
+     * the collection, if not, bail out. 
+     */
+    private Collection resolveCollection(String collectionID) {
+    	
+    	DSpaceObject dso;
+    	Collection targetCollection = null;
+    	
+    	try {
+	    	// is the ID a handle?
+	        if (collectionID.indexOf('/') != -1)
+	        {
+	            // string has a / so it must be a handle - try and resolve it
+	            dso = HandleManager.resolveToObject(context, collectionID);
+	
+	            // resolved, now make sure it's a collection
+	            if (dso == null || dso.getType() != Constants.COLLECTION)
+	                targetCollection = null;
+	            else
+	            	targetCollection = (Collection)dso;
+	        }
+	        // not a handle, try and treat it as an integer collection
+	        // database ID
+	        else if (collectionID != null)
+	        {
+	        	System.out.println("Looking up by id: " + collectionID + ", parsed as '" + Integer.parseInt(collectionID) + "', " + "in context: " + context);
+	            targetCollection = Collection.find(context, Integer.parseInt(collectionID));
+	        }
+	        // was the collection valid?
+	        if (targetCollection == null)
+	        {
+	        	System.out.println("Cannot resolve " + collectionID + " to collection");
+	            System.exit(1);
+	        }
+    	}
+    	catch (SQLException se) {
+    		se.printStackTrace();
+    	}
+    	
+    	return targetCollection;
+    }
+    
+    
+    private void configureCollection(String collectionID, int type, String oaiSource, String oaiSetId, String mdConfigId) {
+    	System.out.println("Running: configure collection");
+   	
+    	Collection collection = resolveCollection(collectionID);
+    	System.out.println(collection.getID());
+    	    	
+    	try {
+    		HarvestedCollection hc = HarvestedCollection.find(context, collection.getID());
+        	if (hc == null) {
+        		hc = HarvestedCollection.create(context, collection.getID());
+        	}
+    		
+    		context.turnOffAuthorisationSystem();
+    		hc.setHarvestParams(type, oaiSource, oaiSetId, mdConfigId);
+    		hc.setHarvestStatus(HarvestedCollection.STATUS_READY);
+    		hc.update();
+    		context.restoreAuthSystemState();
+    		context.complete();
+    	} 
+    	catch (Exception e) {
+    		System.out.println("Changes could not be committed");
+    		e.printStackTrace();
+    		System.exit(1);
+    	}
+    	finally {
+    		context.restoreAuthSystemState();
+    	}
+    }
+    
+    
+    /**
+     * Purges a collection of all harvest-related data and settings. All items in the collection will be deleted.
+     * 
+     * @param collectionID
+     * @param email
+     */
+    private void purgeCollection(String collectionID, String email) {
+    	System.out.println("Purging collection of all items and reseting last_harvested and harvest_message: " + collectionID);
+    	Collection collection = resolveCollection(collectionID);
+   	
+    	try 
+    	{
+    		EPerson eperson = EPerson.findByEmail(context, email);
+        	context.setCurrentUser(eperson);
+    		context.turnOffAuthorisationSystem();
+    		
+    		ItemIterator it = collection.getAllItems();
+    		IndexBrowse ib = new IndexBrowse(context);
+    		int i=0;
+    		while (it.hasNext()) {
+    			i++;
+    			Item item = it.next();
+    			System.out.println("Deleting: " + item.getHandle());
+    			ib.itemRemoved(item);
+    			collection.removeItem(item);
+    			// commit every 50 items
+    			if (i%50 == 0) {
+    				context.commit();
+    				i=0;
+    			}
+    		}
+    		
+    		HarvestedCollection hc = HarvestedCollection.find(context, collection.getID());
+    		if (hc != null) {
+	    		hc.setHarvestResult(null,"");
+	    		hc.setHarvestStatus(HarvestedCollection.STATUS_READY);
+	    		hc.setHarvestStartTime(null);
+	    		hc.update();
+    		}
+    		context.restoreAuthSystemState();    		
+    		context.commit();
+    	} 
+    	catch (Exception e) {
+    		System.out.println("Changes could not be committed");
+    		e.printStackTrace();
+    		System.exit(1);
+    	}
+    	finally {
+    		context.restoreAuthSystemState();
+    	}
+    }
+    
+    
+    /**
+     * Run a single harvest cycle on the specified collection under the authorization of the supplied EPerson 
+     */
+    private void runHarvest(String collectionID, String email) {
+    	System.out.println("Running: a harvest cycle on " + collectionID);
+    	
+    	System.out.print("Initializing the harvester... ");
+    	OAIHarvester harvester = null;
+    	try {
+    		Collection collection = resolveCollection(collectionID);
+        	HarvestedCollection hc = HarvestedCollection.find(context, collection.getID());
+    		harvester = new OAIHarvester(context, collection, hc);
+    		System.out.println("success. ");
+    	}
+    	catch (HarvestingException hex) {
+    		System.out.print("failed. ");
+    		System.out.println(hex.getMessage());
+    		System.exit(1);
+    	} catch (SQLException se) {
+			// TODO Auto-generated catch block
+			se.printStackTrace();
+		}
+    	    	
+    	try {
+    		// Harvest will not work for an anonymous user
+        	EPerson eperson = EPerson.findByEmail(context, email);
+        	System.out.println("Harvest started... ");
+        	context.setCurrentUser(eperson);
+    		harvester.runHarvest();
+    		context.complete();
+    	}
+    	catch (Exception e) {
+			// Not much else we can do at this point
+			e.printStackTrace();
+			System.exit(1);
+		}
+    	System.out.println("Harvest complete. ");
+    }
+    
+    
+    /**
+     * Resets harvest_status and harvest_start_time flags for all collections that have a row in the harvested_collections table 
+     */
+    private static void resetHarvesting() {
+    	System.out.print("Resetting harvest status flag on all collections... ");
+    	
+    	try 
+    	{
+	    	List<Integer> cids = HarvestedCollection.findAll(context);
+	    	for (Integer cid : cids) 
+	    	{
+	    		HarvestedCollection hc = HarvestedCollection.find(context, cid);
+	    		//hc.setHarvestResult(null,"");
+	    		hc.setHarvestStartTime(null);
+	    		hc.setHarvestStatus(HarvestedCollection.STATUS_READY);
+	    		hc.update();
+	    	}
+	    	context.commit();
+	    	System.out.println("success. ");
+    	}
+    	catch (Exception ex) {
+    		System.out.println("failed. ");
+    		ex.printStackTrace();
+    	}    	
+    }
+    
+    
+    /**
+     * Starts up the harvest scheduler. Terminating this process will stop the scheduler.
+     */
+    private static void startHarvester() 
+    {
+	    try 
+	    {
+	    	System.out.print("Starting harvest loop... ");
+	    	OAIHarvester.startNewScheduler();
+	    	System.out.println("running. ");
+    	}
+    	catch (Exception ex) {
+    		ex.printStackTrace();
+    	}
+    }
+    
+}

dspace-api/src/main/java/org/dspace/app/itemexport/ItemExportException.java

@@ -0,0 +1,59 @@
+/*
+ * ItemExportException.java
+ *
+ * Version: $Revision $
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemexport;
+
+/**
+ * An exception that can be thrown when error occur during item export
+ */
+public class ItemExportException extends Exception
+{
+    public static final int EXPORT_TOO_LARGE = 0;
+
+    private int reason;
+
+    public ItemExportException(int r, String message)
+    {
+        super(message);
+        reason = r;
+    }
+
+    public int getReason()
+    {
+        return reason;
+    }
+}

dspace-api/src/main/java/org/dspace/app/itemimport/ItemImport.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -39,21 +37,11 @@
  */
 package org.dspace.app.itemimport;
 
-import java.io.BufferedInputStream;
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.FilenameFilter;
-import java.io.IOException;
-import java.io.PrintWriter;
+import java.io.*;
 import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.StringTokenizer;
+import java.util.*;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipEntry;
 
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
@@ -67,6 +55,8 @@ import org.apache.commons.cli.Options;
 import org.apache.commons.cli.PosixParser;
 import org.apache.xpath.XPathAPI;
 import org.dspace.authorize.AuthorizeException;
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.authorize.ResourcePolicy;
 import org.dspace.content.Bitstream;
 import org.dspace.content.BitstreamFormat;
 import org.dspace.content.Bundle;
@@ -74,12 +64,14 @@ import org.dspace.content.Collection;
 import org.dspace.content.FormatIdentifier;
 import org.dspace.content.InstallItem;
 import org.dspace.content.Item;
+import org.dspace.content.MetadataField;
 import org.dspace.content.MetadataSchema;
 import org.dspace.content.WorkspaceItem;
 import org.dspace.core.ConfigurationManager;
 import org.dspace.core.Constants;
 import org.dspace.core.Context;
 import org.dspace.eperson.EPerson;
+import org.dspace.eperson.Group;
 import org.dspace.handle.HandleManager;
 import org.dspace.workflow.WorkflowManager;
 import org.w3c.dom.Document;
@@ -108,6 +100,8 @@ public class ItemImport
 {
     static boolean useWorkflow = false;
 
+    static boolean useWorkflowSendEmail = false;
+
     static boolean isTest = false;
 
     static boolean isResume = false;
@@ -148,6 +142,7 @@ public class ItemImport
         options.addOption("d", "delete", false,
                 "delete items listed in mapfile");
         options.addOption("s", "source", true, "source of items (directory)");
+        options.addOption("z", "zip", true, "name of zip file");
         options.addOption("c", "collection", true,
                 "destination collection(s) Handle or database ID");
         options.addOption("m", "mapfile", true, "mapfile items in mapfile");
@@ -155,6 +150,8 @@ public class ItemImport
                 "email of eperson doing importing");
         options.addOption("w", "workflow", false,
                 "send submission through collection's workflow");
+        options.addOption("n", "notification", false,
+                        "if sending submissions through the workflow, send notification emails");
         options.addOption("t", "test", false,
                 "test run - do not actually import items");
         options.addOption("p", "template", false, "apply template");
@@ -170,6 +167,7 @@ public class ItemImport
         String mapfile = null;
         String eperson = null; // db ID or email
         String[] collections = null; // db ID or handles
+        int status = 0;
 
         if (line.hasOption('h'))
         {
@@ -177,6 +175,8 @@ public class ItemImport
             myhelp.printHelp("ItemImport\n", options);
             System.out
                    .println("\nadding items:    ItemImport -a -e eperson -c collection -s sourcedir -m mapfile");
+            System.out
+                    .println("\nadding items from zip file:    ItemImport -a -e eperson -c collection -s sourcedir -z filename.zip -m mapfile");
             System.out
                     .println("replacing items: ItemImport -r -e eperson -c collection -s sourcedir -m mapfile");
             System.out
@@ -205,6 +205,10 @@ public class ItemImport
         if (line.hasOption('w'))
         {
             useWorkflow = true;
+            if (line.hasOption('n'))
+            {
+                useWorkflowSendEmail = true;
+            }
         }
 
         if (line.hasOption('t'))
@@ -245,6 +249,15 @@ public class ItemImport
                     .println("**Resume import** - attempting to import items not already imported");
         }
 
+        boolean zip = false;
+        String zipfilename = "";
+        String ziptempdir = ConfigurationManager.getProperty("org.dspace.app.itemexport.work.dir");
+        if (line.hasOption('z'))
+        {
+            zip = true;
+            zipfilename = sourcedir + System.getProperty("file.separator") + line.getOptionValue('z');
+        }
+
         // now validate
         // must have a command set
         if (command == null)
@@ -324,6 +337,36 @@ public class ItemImport
             System.exit(1);
         }
 
+        // does the zip file exist and can we write to the temp directory
+        if (zip)
+        {
+            File zipfile = new File(sourcedir);
+            if (!zipfile.canRead())
+            {
+                System.out.println("Zip file '" + sourcedir + "' does not exist, or is not readable.");
+                System.exit(1);
+            }
+
+            if (ziptempdir == null)
+            {
+                System.out.println("Unable to unzip import file as the key 'org.dspace.app.itemexport.work.dir' is not set in dspace.cfg");
+                System.exit(1);
+            }
+            zipfile = new File(ziptempdir);
+            if (!zipfile.isDirectory())
+            {
+                System.out.println("'" + ConfigurationManager.getProperty("org.dspace.app.itemexport.work.dir") +
+                                   "' as defined by the key 'org.dspace.app.itemexport.work.dir' in dspace.cfg " +
+                                   "is not a valid directory");
+                System.exit(1);
+            }
+            File tempdir = new File(ziptempdir);
+            tempdir.mkdirs();
+            sourcedir = ziptempdir + System.getProperty("file.separator") + line.getOptionValue("z");
+            ziptempdir = ziptempdir + System.getProperty("file.separator") +
+                         line.getOptionValue("z") + System.getProperty("file.separator");
+        }
+
         ItemImport myloader = new ItemImport();
 
         // create a context
@@ -408,6 +451,48 @@ public class ItemImport
 
         try
         {
+            // If this is a zip archive, unzip it first
+            if (zip)
+            {
+                ZipFile zf = new ZipFile(zipfilename);
+                ZipEntry entry;
+                Enumeration entries = zf.entries();
+                while (entries.hasMoreElements())
+                {
+                    entry = (ZipEntry)entries.nextElement();
+                    if (entry.isDirectory())
+                    {
+                        new File(ziptempdir + entry.getName()).mkdir();
+                    }
+                    else
+                    {
+                        System.out.println("Extracting file: " + entry.getName());
+                        int index = entry.getName().lastIndexOf('/');
+                        if (index == -1)
+                        {
+                            // Was it created on Windows instead?
+                            index = entry.getName().lastIndexOf('\\');
+                        }
+                        if (index > 0)
+                        {
+                            File dir = new File(ziptempdir + entry.getName().substring(0, index));
+                            dir.mkdirs();
+                        }
+                        byte[] buffer = new byte[1024];
+                        int len;
+                        InputStream in = zf.getInputStream(entry);
+                        BufferedOutputStream out = new BufferedOutputStream(
+                            new FileOutputStream(ziptempdir + entry.getName()));
+                        while((len = in.read(buffer)) >= 0)
+                        {
+                            out.write(buffer, 0, len);
+                        }
+                        in.close();
+                        out.close();
+                    }
+                }
+            }
+
             c.setIgnoreAuthorization(true);
 
             if (command.equals("add"))
@@ -439,6 +524,22 @@ public class ItemImport
             c.abort();
             e.printStackTrace();
             System.out.println(e);
+            status = 1;
+        }
+
+        // Delete the unzipped file
+        try
+        {
+            if (zip)
+            {
+                System.gc();
+                System.out.println("Deleting temporary zip directory: " + ziptempdir);
+                ItemImport.deleteDirectory(new File(ziptempdir));
+            }
+        }
+        catch (Exception ex)
+        {
+            System.out.println("Unable to delete temporary zip archive location: " + ziptempdir);
         }
 
         if (mapOut != null)
@@ -450,6 +551,7 @@ public class ItemImport
         {
             System.out.println("***End of Test Run***");
         }
+        System.exit(status);
     }
 
     private void addItems(Context c, Collection[] mycollections,
@@ -635,17 +737,26 @@ public class ItemImport
                 + File.separatorChar);
 
         // and the bitstreams from the contents file
-        // process contents file, add bistreams and bundles
-        processContentsFile(c, myitem, path + File.separatorChar + itemname,
-                "contents");
+        // process contents file, add bistreams and bundles, return any
+        // non-standard permissions
+        Vector options = processContentsFile(c, myitem, path
+                + File.separatorChar + itemname, "contents");
 
         if (useWorkflow)
         {
             // don't process handle file
             // start up a workflow
             if (!isTest)
+            {
+                // Should we send a workflow alert email or not?
+                if (useWorkflowSendEmail)
+                {
+                    WorkflowManager.start(c, wi);
+                }
+                else
                 {
                     WorkflowManager.startWithoutNotify(c, wi);
+                }
 
                 // send ID to the mapfile
                 mapOutput = itemname + " " + myitem.getID();
@@ -667,6 +778,13 @@ public class ItemImport
 
                 mapOutput = itemname + " " + myhandle;
             }
+
+            // set permissions if specified in contents file
+            if (options.size() > 0)
+            {
+                System.out.println("Processing options");
+                processOptions(c, myitem, options);
+            }
         }
 
         // now add to multiple collections if requested
@@ -782,7 +900,7 @@ public class ItemImport
     // Load all metadata schemas into the item.
     private void loadMetadata(Context c, Item myitem, String path)
             throws SQLException, IOException, ParserConfigurationException,
-            SAXException, TransformerException
+            SAXException, TransformerException, AuthorizeException
     {
         // Load the dublin core metadata
         loadDublinCore(c, myitem, path + "dublin_core.xml");
@@ -798,7 +916,7 @@ public class ItemImport
 
     private void loadDublinCore(Context c, Item myitem, String filename)
             throws SQLException, IOException, ParserConfigurationException,
-            SAXException, TransformerException //, AuthorizeException
+            SAXException, TransformerException, AuthorizeException
     {
         Document document = loadXML(filename);
 
@@ -828,11 +946,11 @@ public class ItemImport
         for (int i = 0; i < dcNodes.getLength(); i++)
         {
             Node n = dcNodes.item(i);
-            addDCValue(myitem, schema, n);
+            addDCValue(c, myitem, schema, n);
         }
     }
 
-    private void addDCValue(Item i, String schema, Node n) throws TransformerException
+    private void addDCValue(Context c, Item i, String schema, Node n) throws TransformerException, SQLException, AuthorizeException
     {
         String value = getStringValue(n); //n.getNodeValue();
         // compensate for empty value getting read as "null", which won't display
@@ -869,26 +987,26 @@ public class ItemImport
         {
             i.addMetadata(schema, element, qualifier, language, value);
         }
+        else
+        {
+            // If we're just test the import, let's check that the actual metadata field exists.
+        	MetadataSchema foundSchema = MetadataSchema.find(c,schema);
+        	
+        	if (foundSchema == null)
+        	{
+        		System.out.println("ERROR: schema '"+schema+"' was not found in the registry.");
+        		return;
         	}
         	
-    /**
-     * Return the String value of a Node
-     */
-    public String getStringValue(Node node)
-    {
-        String value = node.getNodeValue();
+        	int schemaID = foundSchema.getSchemaID();
+        	MetadataField foundField = MetadataField.findByElement(c, schemaID, element, qualifier);
         	
-        if (node.hasChildNodes())
+        	if (foundField == null)
         	{
-            Node first = node.getFirstChild();
-
-            if (first.getNodeType() == Node.TEXT_NODE)
-            {
-                return first.getNodeValue();
+        		System.out.println("ERROR: Metadata field: '"+schema+"."+element+"."+qualifier+"' was not found in the registry.");
+        		return;
             }		
         }
-
-        return value;
     }
 
     /**
@@ -929,8 +1047,7 @@ public class ItemImport
                 }
                 catch (IOException e1)
                 {
-                    System.err
-                            .println("Non-critical problem releasing resources.");
+                    System.err.println("Non-critical problem releasing resources.");
                 }
             }
         }
@@ -940,14 +1057,16 @@ public class ItemImport
 
     /**
      * Given a contents file and an item, stuffing it with bitstreams from the
-     * contents file
+     * contents file Returns a Vector of Strings with lines from the contents
+     * file that request non-default bitstream permission
      */
-    private void processContentsFile(Context c, Item i, String path,
+    private Vector processContentsFile(Context c, Item i, String path,
             String filename) throws SQLException, IOException,
             AuthorizeException
     {
         String contentspath = path + File.separatorChar + filename;
         String line = "";
+        Vector options = new Vector();
 
         System.out.println("\tProcessing contents file: " + contentspath);
 
@@ -978,8 +1097,7 @@ public class ItemImport
             	    int iAssetstore = -1;
             	    String sFilePath = null;
                     String sBundle = null;
-                    StringTokenizer tokenizer = 
-                        	new StringTokenizer(sRegistrationLine);
+                    StringTokenizer tokenizer = new StringTokenizer(sRegistrationLine);
                     while (tokenizer.hasMoreTokens())
                     {
                         String sToken = tokenizer.nextToken(); 
@@ -1002,7 +1120,6 @@ public class ItemImport
                         else if (sToken.equals("-f") && tokenizer.hasMoreTokens())
                         {
                             sFilePath = tokenizer.nextToken();
-
                         }
                         else if (sToken.startsWith("bundle:"))
                         {
@@ -1023,33 +1140,114 @@ public class ItemImport
                     registerBitstream(c, i, iAssetstore, sFilePath, sBundle);
                     System.out.println("\tRegistering Bitstream: " + sFilePath
                             + "\tAssetstore: " + iAssetstore
-                            + "\tBundle: " + sBundle);
+                            + "\tBundle: " + sBundle
+                            + "\tDescription: " + sBundle);
                     continue;				// process next line in contents file
             	}
 
-            	// look for a bundle name
-                String bundleMarker = "\tbundle:";
+                int bitstreamEndIndex = line.indexOf("\t");
 
-                int markerIndex = line.indexOf(bundleMarker);
-
-                if (markerIndex == -1)
+                if (bitstreamEndIndex == -1)
                 {
-                    // no bundle found
-                    processContentFileEntry(c, i, path, line, null);
+                    // no extra info
+                    processContentFileEntry(c, i, path, line, null, false);
                     System.out.println("\tBitstream: " + line);
                 }
                 else
                 {
-                    // found bundle
-                    String bundleName = line.substring(markerIndex
-                            + bundleMarker.length());
-                    String bitstreamName = line.substring(0, markerIndex);
-                    bitstreamName = bitstreamName.trim();
 
-                    processContentFileEntry(c, i, path, bitstreamName,
-                            bundleName);
-                    System.out.println("\tBitstream: " + bitstreamName
-                            + "\tBundle: " + bundleName);
+                    String bitstreamName = line.substring(0, bitstreamEndIndex);
+
+                    boolean bundleExists = false;
+                    boolean permissionsExist = false;
+                    boolean descriptionExists = false;
+
+                    // look for a bundle name
+                    String bundleMarker = "\tbundle:";
+                    int bMarkerIndex = line.indexOf(bundleMarker);
+                    int bEndIndex = 0;
+                    if (bMarkerIndex > 0)
+                    {
+                        bEndIndex = line.indexOf("\t", bMarkerIndex + 1);
+                        if (bEndIndex == -1)
+                        {
+                            bEndIndex = line.length();
+                        }
+                        bundleExists = true;
+                    }
+
+                    // look for permissions
+                    String permissionsMarker = "\tpermissions:";
+                    int pMarkerIndex = line.indexOf(permissionsMarker);
+                    int pEndIndex = 0;
+                    if (pMarkerIndex > 0)
+                    {
+                        pEndIndex = line.indexOf("\t", pMarkerIndex + 1);
+                        if (pEndIndex == -1)
+                        {
+                            pEndIndex = line.length();
+                        }
+                        permissionsExist = true;
+                    }
+
+                    // look for descriptions
+                    String descriptionMarker = "\tdescription:";
+                    int dMarkerIndex = line.indexOf(descriptionMarker);
+                    int dEndIndex = 0;
+                    if (dMarkerIndex > 0)
+                    {
+                        dEndIndex = line.indexOf("\t", dMarkerIndex + 1);
+                        if (dEndIndex == -1)
+                        {
+                            dEndIndex = line.length();
+                        }
+                        descriptionExists = true;
+                    }
+
+                    // is this the primary bitstream?
+                    String primaryBitstreamMarker = "\tprimary:true";
+                    boolean primary = false;
+                    String primaryStr = "";
+                    if (line.contains(primaryBitstreamMarker))
+                    {
+                        primary = true;
+                        primaryStr = "\t **Setting as primary bitstream**";
+                    }
+
+                    if (bundleExists)
+                    {
+                        String bundleName = line.substring(bMarkerIndex
+                                + bundleMarker.length(), bEndIndex).trim();
+
+                        processContentFileEntry(c, i, path, bitstreamName, bundleName, primary);
+                        System.out.println("\tBitstream: " + bitstreamName +
+                                           "\tBundle: " + bundleName +
+                                           primaryStr);
+                    }
+                    else
+                    {
+                        processContentFileEntry(c, i, path, bitstreamName, null, primary);
+                        System.out.println("\tBitstream: " + bitstreamName + primaryStr);
+                    }
+
+                    if (permissionsExist || descriptionExists)
+                    {
+                        String extraInfo = bitstreamName;
+
+                        if (permissionsExist)
+                        {
+                            extraInfo = extraInfo
+                                    + line.substring(pMarkerIndex, pEndIndex);
+                        }
+
+                        if (descriptionExists)
+                        {
+                            extraInfo = extraInfo
+                                    + line.substring(dMarkerIndex, dEndIndex);
+                        }
+
+                        options.add(extraInfo);
+                    }
                 }
             }
         }
@@ -1060,11 +1258,22 @@ public class ItemImport
                 is.close();
             }
         }
+        return options;
     }
 
-    // each entry represents a bitstream....
-    public void processContentFileEntry(Context c, Item i, String path,
-            String fileName, String bundleName) throws SQLException,
+    /**
+     * each entry represents a bitstream....
+     * @param c
+     * @param i
+     * @param path
+     * @param fileName
+     * @param bundleName
+     * @throws SQLException
+     * @throws IOException
+     * @throws AuthorizeException
+     */
+    private void processContentFileEntry(Context c, Item i, String path,
+            String fileName, String bundleName, boolean primary) throws SQLException,
             IOException, AuthorizeException
     {
         String fullpath = path + File.separatorChar + fileName;
@@ -1118,6 +1327,13 @@ public class ItemImport
             BitstreamFormat bf = FormatIdentifier.guessFormat(c, bs);
             bs.setFormat(bf);
 
+            // Is this a the primary bitstream?
+            if (primary)
+            {
+                targetBundle.setPrimaryBitstreamID(bs.getID());
+                targetBundle.update();
+            }
+
             bs.update();
         }
     }
@@ -1134,7 +1350,7 @@ public class ItemImport
      * @throws IOException
      * @throws AuthorizeException
      */
-    public void registerBitstream(Context c, Item i, int assetstore, 
+    private void registerBitstream(Context c, Item i, int assetstore, 
             String bitstreamPath, String bundleName )
         	throws SQLException, IOException, AuthorizeException
     {
@@ -1191,72 +1407,261 @@ public class ItemImport
         }
     }
 
-    // XML utility methods
-    public String getAttributeValue(Node n, String myattributename)
+    /**
+     * 
+     * Process the Options to apply to the Item. The options are tab delimited
+     * 
+     * Options:
+     *      48217870-MIT.pdf        permissions: -r 'MIT Users'     description: Full printable version (MIT only)
+     *      permissions:[r|w]-['group name']
+     *      description: 'the description of the file'
+     *      
+     *      where:
+     *          [r|w] (meaning: read|write)
+     *          ['MIT Users'] (the group name)
+     *          
+     * @param c
+     * @param myItem
+     * @param options
+     * @throws SQLException
+     * @throws AuthorizeException
+     */
+    private void processOptions(Context c, Item myItem, Vector options)
+            throws SQLException, AuthorizeException
     {
-        String myvalue = "";
+        for (int i = 0; i < options.size(); i++)
+        {
+            String line = options.elementAt(i).toString();
 
+            System.out.println("\tprocessing " + line);
+
+            boolean permissionsExist = false;
+            boolean descriptionExists = false;
+
+            String permissionsMarker = "\tpermissions:";
+            int pMarkerIndex = line.indexOf(permissionsMarker);
+            int pEndIndex = 0;
+            if (pMarkerIndex > 0)
+            {
+                pEndIndex = line.indexOf("\t", pMarkerIndex + 1);
+                if (pEndIndex == -1)
+                {
+                    pEndIndex = line.length();
+                }
+                permissionsExist = true;
+            }
+
+            String descriptionMarker = "\tdescription:";
+            int dMarkerIndex = line.indexOf(descriptionMarker);
+            int dEndIndex = 0;
+            if (dMarkerIndex > 0)
+            {
+                dEndIndex = line.indexOf("\t", dMarkerIndex + 1);
+                if (dEndIndex == -1)
+                {
+                    dEndIndex = line.length();
+                }
+                descriptionExists = true;
+            }
+
+            int bsEndIndex = line.indexOf("\t");
+            String bitstreamName = line.substring(0, bsEndIndex);
+
+            int actionID = -1;
+            String groupName = "";
+            Group myGroup = null;
+            if (permissionsExist)
+            {
+                String thisPermission = line.substring(pMarkerIndex
+                        + permissionsMarker.length(), pEndIndex);
+
+                // get permission type ("read" or "write")
+                int pTypeIndex = thisPermission.indexOf("-");
+
+                // get permission group (should be in single quotes)
+                int groupIndex = thisPermission.indexOf("'", pTypeIndex);
+                int groupEndIndex = thisPermission.indexOf("'", groupIndex + 1);
+
+                // if not in single quotes, assume everything after type flag is
+                // group name
+                if (groupIndex == -1)
+                {
+                    groupIndex = thisPermission.indexOf(" ", pTypeIndex);
+                    groupEndIndex = thisPermission.length();
+                }
+
+                groupName = thisPermission.substring(groupIndex + 1,
+                        groupEndIndex);
+
+                if (thisPermission.toLowerCase().charAt(pTypeIndex + 1) == 'r')
+                {
+                    actionID = Constants.READ;
+                }
+                else if (thisPermission.toLowerCase().charAt(pTypeIndex + 1) == 'w')
+                {
+                    actionID = Constants.WRITE;
+                }
+
+                try
+                {
+                    myGroup = Group.findByName(c, groupName);
+                }
+                catch (SQLException sqle)
+                {
+                    System.out.println("SQL Exception finding group name: "
+                            + groupName);
+                    // do nothing, will check for null group later
+                }
+            }
+
+            String thisDescription = "";
+            if (descriptionExists)
+            {
+                thisDescription = line.substring(
+                        dMarkerIndex + descriptionMarker.length(), dEndIndex)
+                        .trim();
+            }
+
+            Bitstream bs = null;
+            boolean notfound = true;
+            if (!isTest)
+            {
+                // find bitstream
+                Bitstream[] bitstreams = myItem.getNonInternalBitstreams();
+                for (int j = 0; j < bitstreams.length && notfound; j++)
+                {
+                    if (bitstreams[j].getName().equals(bitstreamName))
+                    {
+                        bs = bitstreams[j];
+                        notfound = false;
+                    }
+                }
+            }
+
+            if (notfound && !isTest)
+            {
+                // this should never happen
+                System.out.println("\tdefault permissions set for "
+                        + bitstreamName);
+            }
+            else if (!isTest)
+            {
+                if (permissionsExist)
+                {
+                    if (myGroup == null)
+                    {
+                        System.out.println("\t" + groupName
+                                + " not found, permissions set to default");
+                    }
+                    else if (actionID == -1)
+                    {
+                        System.out
+                                .println("\tinvalid permissions flag, permissions set to default");
+                    }
+                    else
+                    {
+                        System.out.println("\tSetting special permissions for "
+                                + bitstreamName);
+                        setPermission(c, myGroup, actionID, bs);
+                    }
+                }
+
+                if (descriptionExists)
+                {
+                    System.out.println("\tSetting description for "
+                            + bitstreamName);
+                    bs.setDescription(thisDescription);
+                    bs.update();
+                }
+            }
+        }
+    }
+
+    /**
+     * Set the Permission on a Bitstream.
+     * 
+     * @param c
+     * @param g
+     * @param actionID
+     * @param bs
+     * @throws SQLException
+     * @throws AuthorizeException
+     */
+    private void setPermission(Context c, Group g, int actionID, Bitstream bs)
+            throws SQLException, AuthorizeException
+    {
+        if (!isTest)
+        {
+            // remove the default policy
+            AuthorizeManager.removeAllPolicies(c, bs);
+
+            // add the policy
+            ResourcePolicy rp = ResourcePolicy.create(c);
+
+            rp.setResource(bs);
+            rp.setAction(actionID);
+            rp.setGroup(g);
+
+            rp.update();
+        }
+        else
+        {
+            if (actionID == Constants.READ)
+            {
+                System.out.println("\t\tpermissions: READ for " + g.getName());
+            }
+            else if (actionID == Constants.WRITE)
+            {
+                System.out.println("\t\tpermissions: WRITE for " + g.getName());
+            }
+        }
+
+    }
+
+    // XML utility methods
+    /**
+     * Lookup an attribute from a DOM node.
+     * @param n
+     * @param name
+     * @return
+     */
+    private String getAttributeValue(Node n, String name)
+    {
         NamedNodeMap nm = n.getAttributes();
 
         for (int i = 0; i < nm.getLength(); i++)
         {
             Node node = nm.item(i);
-            String name = node.getNodeName();
-            String value = node.getNodeValue();
 
-            if (myattributename.equals(name))
+            if (name.equals(node.getNodeName()))
             {
-                return value;
+                return node.getNodeValue();
             }
         }
 
-        return myvalue;
+        return "";
     }
 
-    // XML utility methods stolen from administer.
     
     /**
-     * Get the CDATA of a particular element. For example, if the XML document
-     * contains:
-     * <P>
-     * <code>
-     * &lt;foo&gt;&lt;mimetype&gt;application/pdf&lt;/mimetype&gt;&lt;/foo&gt;
-     * </code>
-     * passing this the <code>foo</code> node and <code>mimetype</code> will
-     * return <code>application/pdf</code>.
-     * </P>
-     * Why this isn't a core part of the XML API I do not know...
-     * 
-     * @param parentElement
-     *            the element, whose child element you want the CDATA from
-     * @param childName
-     *            the name of the element you want the CDATA from
-     * 
-     * @return the CDATA as a <code>String</code>
+     * Return the String value of a Node.
+     * @param node
+     * @return
      */
-    private String getElementData(Node parentElement, String childName)
-            throws TransformerException
+    private String getStringValue(Node node)
     {
-        // Grab the child node
-        Node childNode = XPathAPI.selectSingleNode(parentElement, childName);
+        String value = node.getNodeValue();
 
-        if (childNode == null)
+        if (node.hasChildNodes())
         {
-            // No child node, so no values
-            return null;
+            Node first = node.getFirstChild();
+
+            if (first.getNodeType() == Node.TEXT_NODE)
+            {
+                return first.getNodeValue();
             }
-
-        // Get the #text
-        Node dataNode = childNode.getFirstChild();
-
-        if (dataNode == null)
-        {
-            return null;
         }
 
-        // Get the data
-        String value = dataNode.getNodeValue().trim();
-
         return value;
     }
 
@@ -1276,4 +1681,31 @@ public class ItemImport
 
         return builder.parse(new File(filename));
     }
+
+    /**
+     * Delete a directory and its child files and directories
+     * @param path The directory to delete
+     * @return Whether the deletion was successful or not
+     */
+    private static boolean deleteDirectory(File path)
+    {
+        if (path.exists())
+        {
+            File[] files = path.listFiles();
+            for (int i = 0; i < files.length; i++)
+            {
+                if (files[i].isDirectory())
+                {
+                    deleteDirectory(files[i]);
+                }
+                else
+                {
+                    files[i].delete();
+                }
+            }
+        }
+
+        boolean pathDeleted = path.delete();
+        return (pathDeleted);
+    }
 }

dspace-api/src/main/java/org/dspace/app/itemupdate/ActionManager.java

@@ -0,0 +1,110 @@
+/*
+ * ActionManager.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * 	 Container for UpdateActions      
+ *    Order of actions is very import for correct processing.  This implementation
+ *     supports an iterator that returns the actions in the order in which they are
+ *     put in.  Adding the same action a second time has no effect on this order.
+ * 
+ *
+ */
+public class ActionManager implements Iterable<UpdateAction> {
+	
+	private Map<Class<? extends UpdateAction>, UpdateAction> registry 
+                     = new LinkedHashMap<Class<? extends UpdateAction>, UpdateAction>();
+	
+	public UpdateAction getUpdateAction(Class<? extends UpdateAction> actionClass) 
+	throws InstantiationException, IllegalAccessException
+	{
+		UpdateAction action =  registry.get(actionClass);
+		
+		if (action == null)
+		{
+			action = actionClass.newInstance();
+			registry.put(actionClass, action);
+		}
+		
+		return action;		
+	}
+	
+	/**
+	 * 
+	 * @return whether any actions have been registered with this manager
+	 */
+	public boolean hasActions()
+	{
+		return !registry.isEmpty();
+	}
+	
+	/**
+	 * 	 This implementation guarantees the iterator order is the same as the order
+	 *   in which updateActions have been added
+	 * 
+	 * @return iterator for UpdateActions
+	 */
+	public Iterator<UpdateAction> iterator()
+	{
+		return new Iterator<UpdateAction>() 
+		{ 			
+			private Iterator<Class<? extends UpdateAction>> itr = registry.keySet().iterator();
+			
+			public boolean hasNext()
+			{
+				return itr.hasNext();
+			}
+			
+			public UpdateAction next()
+			{
+				return registry.get(itr.next());
+			}
+			
+			//not supported
+			public void remove()
+			{
+				throw new UnsupportedOperationException();
+			}
+		};
+		
+	}
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/AddBitstreamsAction.java

@@ -0,0 +1,232 @@
+/*
+ * AddBitstreamsAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.authorize.ResourcePolicy;
+import org.dspace.content.Bitstream;
+import org.dspace.content.BitstreamFormat;
+import org.dspace.content.Bundle;
+import org.dspace.content.DCDate;
+import org.dspace.content.FormatIdentifier;
+import org.dspace.content.InstallItem;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.dspace.eperson.Group;
+
+/**
+ * 	 Action to add bitstreams listed in item contents file to the item in DSpace	
+ *   
+ *
+ */
+public class AddBitstreamsAction extends UpdateBitstreamsAction {
+
+	public AddBitstreamsAction()
+	{
+		//empty	
+	}
+	
+	/**
+	 * 	Adds bitstreams from the archive as listed in the contents file.
+	 * 
+	 *  @param context
+	 *  @param ItemArchive
+	 *  @param isTest
+	 *  @param suppressUndo
+	 *  @throws IllegalArgumentException
+	 *  @throws ParseException
+	 *  @throws IOException
+	 *  @throws AuthorizeException
+	 *  @throws SQLException
+	 */
+	public void execute(Context context, ItemArchive itarch, boolean isTest, boolean suppressUndo) 
+	throws IllegalArgumentException, ParseException, IOException, AuthorizeException, SQLException 
+	{
+		Item item = itarch.getItem();
+		File dir = itarch.getDirectory();
+		
+		List<ContentsEntry> contents = MetadataUtilities.readContentsFile(new File(dir, ItemUpdate.CONTENTS_FILE));
+		
+		if (contents.isEmpty())
+		{
+			ItemUpdate.pr("Contents is empty - no bitstreams to add");
+			return;
+		}
+		
+		ItemUpdate.pr("Contents bitstream count: " + contents.size());
+		
+		String[] files = dir.list(ItemUpdate.fileFilter);
+		List<String> fileList = new ArrayList<String>();
+		for (String filename : files)
+		{
+			fileList.add(filename);
+			ItemUpdate.pr("file: " + filename);
+		}
+		
+		for (ContentsEntry ce : contents)
+		{
+			//validate match to existing file in archive
+			if (!fileList.contains(ce.filename))
+			{
+				throw new IllegalArgumentException("File listed in contents is missing: " + ce.filename);
+			}
+		}
+						
+		//now okay to add
+		for (ContentsEntry ce : contents)
+		{        				
+			addBitstream(context, itarch, item, dir, ce, suppressUndo, isTest);
+		}
+	}
+		
+	private void addBitstream(Context context, ItemArchive itarch, Item item, File dir, 
+			                  ContentsEntry ce, boolean suppressUndo, boolean isTest)
+	throws IOException, IllegalArgumentException, SQLException, AuthorizeException, ParseException
+	{
+		ItemUpdate.pr("contents entry for bitstream: " + ce.toString());
+    	File f = new File(dir, ce.filename);
+    	
+        // get an input stream
+        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
+
+        Bitstream bs = null;
+        String newBundleName = ce.bundlename;
+
+        if (ce.bundlename == null)  // should be required but default convention established
+        {
+            if (ce.filename.equals("license.txt"))
+            {
+                newBundleName = "LICENSE";
+            }
+            else  
+            {
+                newBundleName = "ORIGINAL";
+            }
+        }
+        ItemUpdate.pr("  Bitstream " + ce.filename + " to be added to bundle: " + newBundleName);
+        
+        if (!isTest)
+        {
+	        // find the bundle
+	        Bundle[] bundles = item.getBundles(newBundleName);
+	        Bundle targetBundle = null;
+	
+	        if (bundles.length < 1)
+	        {
+	            // not found, create a new one
+	            targetBundle = item.createBundle(newBundleName);
+	        }
+	        else
+	        {
+	    		//verify bundle + name are not duplicates
+	        	for (Bundle b : bundles)
+	        	{
+	        		Bitstream[] bitstreams = b.getBitstreams();
+	        		for (Bitstream bsm : bitstreams)
+	        		{
+	        			if (bsm.getName().equals(ce.filename))
+	        			{
+	        				throw new IllegalArgumentException("Duplicate bundle + filename cannot be added: " 
+	        						+ b.getName() + " + " + bsm.getName());
+	        			}
+	        		}
+	        	}
+
+	            // select first bundle
+	            targetBundle = bundles[0];
+	        }
+	
+	        bs = targetBundle.createBitstream(bis);	
+	        bs.setName(ce.filename);
+	
+	        // Identify the format
+	        // FIXME - guessing format guesses license.txt incorrectly as a text file format!
+	        BitstreamFormat fmt = FormatIdentifier.guessFormat(context, bs);
+	    	bs.setFormat(fmt);
+	    	
+	        if (ce.description != null)
+	        {
+	        	bs.setDescription(ce.description);
+	        }
+	        	        
+	        if ((ce.permissionsActionId != -1) && (ce.permissionsGroupName != null))
+	        {
+				Group group = Group.findByName(context, ce.permissionsGroupName);
+				
+				if (group != null)
+				{
+			        AuthorizeManager.removeAllPolicies(context, bs);  // remove the default policy
+			        ResourcePolicy rp = ResourcePolicy.create(context);
+			        rp.setResource(bs);
+			        rp.setAction(ce.permissionsActionId);
+			        rp.setGroup(group);		
+			        rp.update();
+				}
+	        }
+	        
+	        if (alterProvenance && !targetBundle.getName().equals("THUMBMNAIL") 
+	        		&& !targetBundle.getName().equals("TEXT"))
+	        {
+	        	DtoMetadata dtom = DtoMetadata.create("dc.description.provenance", "en", "");
+	        	
+	        	String append = "Bitstream added on " + DCDate.getCurrent() + " : " 
+	        	                + InstallItem.getBitstreamProvenanceMessage(item);
+	        	MetadataUtilities.appendMetadata(item, dtom, false, append);
+	        }
+	        
+	        //update after all changes are applied, even metadata ones
+	        bs.update();
+        
+	        if (!suppressUndo)
+	        {
+	        	itarch.addUndoDeleteContents(bs.getID());
+	        }
+        }
+    }
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/AddMetadataAction.java

@@ -0,0 +1,150 @@
+/*
+ * AddMetadataAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.sql.SQLException;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.DCValue;
+import org.dspace.content.Item;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+
+import org.dspace.core.Context;
+
+/**
+ *   Action to add metadata to item
+ *
+ */
+public class AddMetadataAction extends UpdateMetadataAction {
+	
+	/**
+	 * 	Adds metadata specified in the source archive
+	 * 
+	 *  @param context
+	 *  @param ItemArchive
+	 *  @param isTest
+	 *  @param suppressUndo
+	 *  @throws AuthorizeException
+	 *  @throws SQLException
+	 */
+	public void execute(Context context, ItemArchive itarch, boolean isTest, boolean suppressUndo) 
+	throws AuthorizeException, SQLException
+	{
+		Item item = itarch.getItem();
+		String dirname = itarch.getDirectoryName();
+	    	
+		for (DtoMetadata dtom : itarch.getMetadataFields())
+		{
+			for (String f : targetFields)
+			{
+				if (dtom.matches(f, false))
+				{
+					// match against metadata for this field/value in repository
+					// qualifier must be strictly matched, possibly null					
+					DCValue[] ardcv = null;
+					ardcv = item.getMetadata(dtom.schema, dtom.element, dtom.qualifier, Item.ANY);
+					
+					boolean found = false;
+					for (DCValue dcv : ardcv)
+					{
+						if (dcv.value.equals(dtom.value))
+						{
+							found = true;
+							break;
+						}
+					}
+					
+					if (found)
+					{
+						ItemUpdate.pr("Warning:  No new metadata found to add to item " + dirname 
+								+ " for element " + f);						
+					}
+					else
+					{
+						if (isTest)
+						{
+							ItemUpdate.pr("Metadata to add: " + dtom.toString());
+							   //validity tests that would occur in actual processing
+	        	            // If we're just test the import, let's check that the actual metadata field exists.
+	        	        	MetadataSchema foundSchema = MetadataSchema.find(context, dtom.schema);
+	        	        	
+	        	        	if (foundSchema == null)
+	        	        	{
+	        	        		ItemUpdate.pr("ERROR: schema '" 
+	        	        			+ dtom.schema + "' was not found in the registry; found on item " + dirname);
+	        	        	}
+	        	        	else
+	        	        	{
+		        	        	int schemaID = foundSchema.getSchemaID();
+		        	        	MetadataField foundField = MetadataField.findByElement(context, schemaID, dtom.element, dtom.qualifier);
+		        	        	
+		        	        	if (foundField == null)
+		        	        	{
+		        	        		ItemUpdate.pr("ERROR: Metadata field: '" + dtom.schema + "." + dtom.element + "." 
+		        	        				+ dtom.qualifier + "' not found in registry; found on item " + dirname);
+		        	            }		
+	        				}						
+						}
+						else
+						{
+							item.addMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language, dtom.value);
+							ItemUpdate.pr("Metadata added: " + dtom.toString());
+	
+							if (!suppressUndo)
+							{
+								//itarch.addUndoDtom(dtom);
+								//ItemUpdate.pr("Undo metadata: " + dtom);
+								
+								// add all as a replace record to be preceded by delete
+								for (DCValue dcval : ardcv)
+								{							
+									itarch.addUndoMetadataField(DtoMetadata.create(dcval.schema, dcval.element, 
+											dcval.qualifier, dcval.language, dcval.value));
+								}
+								
+							}
+						}
+					}
+					break;  // don't need to check if this field matches any other target fields
+				}
+			} 				
+		}   
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilter.java

@@ -0,0 +1,80 @@
+/*
+ * BitstreamFilter.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.IOException;
+import java.util.Properties;
+import java.io.InputStream;
+import java.io.FileInputStream;
+import org.dspace.content.Bitstream;
+
+/**
+ *   Filter interface to be used by ItemUpdate 
+ *   to determine which bitstreams in an Item
+ *   acceptable for removal.
+ *
+ */
+public abstract class BitstreamFilter {
+
+	protected Properties props = null; 
+	
+	/**
+	 *  The filter method 
+	 *  
+	 * @param bitstream
+	 * @return whether the bitstream matches the criteria
+	 * @throws BitstreamFilterException
+	 */
+	public abstract boolean accept(Bitstream bitstream) throws BitstreamFilterException;
+	
+	/**
+	 * 
+	 * @param filepath - The complete path for the properties file
+	 * @throws IOException
+	 */
+	public void initProperties(String filepath)
+	throws IOException
+	{
+		props = new Properties();
+		
+		InputStream in = new FileInputStream(filepath);
+		props.load(in);
+		in.close();		
+	}
+	
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterByBundleName.java

@@ -0,0 +1,96 @@
+/*
+ * BitstreamFilterByBundleName.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.sql.SQLException;
+
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+
+/**
+ *   BitstreamFilter implementation to filter by bundle name
+ *
+ */
+public class BitstreamFilterByBundleName extends BitstreamFilter {
+
+	protected String bundleName;
+	
+	public BitstreamFilterByBundleName()
+	{
+		//empty
+	}
+
+	/**
+	 *    Filter bitstream based on bundle name found in properties file
+	 *    
+	 *    @param bitstream
+	 *    @throws BitstreamFilterException
+	 *    @returns whether bitstream is in bundle
+	 *    
+	 */
+	public boolean accept(Bitstream bitstream) 
+	throws BitstreamFilterException
+	{
+		if (bundleName == null)
+		{
+			bundleName = props.getProperty("bundle");
+			if (bundleName == null)
+			{
+				throw new BitstreamFilterException("Property 'bundle' not found.");
+			}			
+		}
+		
+		try
+		{
+			Bundle[] bundles = bitstream.getBundles();
+			for (Bundle b : bundles)
+			{
+				if (b.getName().equals(bundleName))
+				{
+					return true;
+				}
+			}		
+		}
+		catch(SQLException e)
+		{
+			throw new BitstreamFilterException(e);
+		}
+		return false;
+	}
+	
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterByFilename.java

@@ -0,0 +1,80 @@
+/*
+ * BitstreamFilterByFilename.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.util.regex.*;
+
+import org.dspace.content.Bitstream;
+
+/**
+ * BitstreamFilter implementation to filter by filename pattern
+ *
+ */
+public class BitstreamFilterByFilename extends BitstreamFilter {
+	
+	private Pattern pattern;
+	private String filenameRegex;
+	
+	public BitstreamFilterByFilename()
+	{
+		//empty
+	}
+
+	/**
+	 *   Tests bitstream by matching the regular expression in the 
+	 *   properties against the bitstream name
+	 * 
+	 *   @returns whether bitstream name matches the regular expression
+	 */
+	public boolean accept(Bitstream bitstream) throws BitstreamFilterException
+	{		
+		if (filenameRegex == null)
+		{
+			filenameRegex = props.getProperty("filename");
+			if (filenameRegex == null)
+			{
+				throw new BitstreamFilterException("BitstreamFilter property 'filename' not found.");
+			}
+			pattern = Pattern.compile(filenameRegex);
+		}
+		
+		Matcher m = pattern.matcher(bitstream.getName());
+		return m.matches();
+	}	
+ 
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterException.java

@@ -0,0 +1,59 @@
+/*
+ * BitstreamFilterException.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+/**
+ *    Exception class for BitstreamFilters
+ *
+ */
+public class BitstreamFilterException extends Exception 
+{
+	
+	private static final long serialVersionUID = 1L;
+	
+	public BitstreamFilterException() {}
+	public BitstreamFilterException(String msg)
+	{
+		super(msg);
+	}
+	public BitstreamFilterException(Exception e)
+	{
+		super(e);
+	}
+	
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/ContentsEntry.java

@@ -0,0 +1,183 @@
+/*
+ * ContentsEntry.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.text.ParseException;
+import java.util.regex.*;
+
+import org.dspace.core.Constants;
+
+/**
+ *   Holds the elements of a line in the Contents Entry file
+ * 
+ *   Based on private methods in ItemImport
+ *   
+ *   Lacking a spec or full documentation for the file format, 
+ *   it looks from the source code that the ordering or elements is not fixed
+ * 
+ *   e.g.:    
+ *      48217870-MIT.pdf\tbundle: bundlename\tpermissions: -r 'MIT Users'\tdescription: Full printable version (MIT only)
+ *      permissions: -[r|w] ['group name']
+ *      description: <the description of the file>
+ * 
+ *
+ */
+public class ContentsEntry 
+{
+	public static final String HDR_BUNDLE = "bundle:";
+	public static final String HDR_PERMISSIONS = "permissions:";
+	public static final String HDR_DESCRIPTION = "description:";
+		
+	public static final Pattern permissionsPattern = Pattern.compile("-([rw])\\s*'?([^']+)'?");
+	
+	final String filename;
+	final String bundlename;
+	final String permissionsGroupName;
+	final int permissionsActionId;
+	final String description;
+	
+	private ContentsEntry(String filename, 
+			             String bundlename,
+			             int permissionsActionId,
+			             String permissionsGroupName,
+			             String description)
+	{
+		this.filename = filename;
+		this.bundlename = bundlename;
+		this.permissionsActionId = permissionsActionId;
+		this.permissionsGroupName = permissionsGroupName;
+		this.description = description;
+	}
+	
+	/**
+	 *   Factory method parses a line from the Contents Entry file
+	 *   
+	 * @param line
+	 * @return the parsed ContentsEntry object 
+	 * @throws ParseException
+	 */
+	public static ContentsEntry parse(String line)
+	throws ParseException
+	{
+		String[] ar = line.split("\t");
+		ItemUpdate.pr("ce line split: " + ar.length);
+		
+		String[] arp = new String[4];
+		arp[0] = ar[0];   //bitstream name doesn't have header and is always first
+		
+		String groupName = null;
+		int actionId = -1;
+
+		if (ar.length > 1)
+		{
+			for (int i=1; i < ar.length; i++)
+			{
+				ItemUpdate.pr("ce " + i + " : " + ar[i]);
+				if (ar[i].startsWith(HDR_BUNDLE))
+				{
+					arp[1] = ar[i].substring(HDR_BUNDLE.length()).trim();
+					
+				}
+				else if (ar[i].startsWith(HDR_PERMISSIONS))
+				{
+					arp[2] = ar[i].substring(HDR_PERMISSIONS.length()).trim();
+					
+					// parse into actionId and group name
+					
+					Matcher m = permissionsPattern.matcher(arp[2]);
+					if (m.matches())
+					{
+						String action = m.group(1); //
+						if (action.equals("r"))
+						{
+							 actionId = Constants.READ;
+						}
+						else if (action.equals("w"))
+						{
+							 actionId = Constants.WRITE;
+						}
+						
+						groupName = m.group(2).trim();
+					}
+					
+				}
+				else if (ar[i].startsWith(HDR_DESCRIPTION))
+				{
+					arp[3] = ar[i].substring(HDR_DESCRIPTION.length()).trim();
+					
+				}
+				else
+				{
+					throw new ParseException("Unknown text in contents file: " + ar[i], 0);				
+				}			
+			}
+		}
+		return new ContentsEntry(arp[0], arp[1], actionId, groupName, arp[3]);
+	}
+	
+	public String toString()
+	{
+		StringBuilder sb = new StringBuilder(filename);
+		if (bundlename != null)
+		{
+			sb.append(HDR_BUNDLE).append(" ").append(bundlename);
+		}
+		
+		if (permissionsGroupName != null)
+		{
+			sb.append(HDR_PERMISSIONS);
+			if (permissionsActionId == Constants.READ)
+			{
+				sb.append(" -r ");
+			}
+			else if (permissionsActionId == Constants.WRITE)
+			{
+				sb.append(" -w ");
+			}
+			sb.append(permissionsGroupName);
+		}
+		
+		if (description != null)
+		{
+			sb.append(HDR_DESCRIPTION).append(" ").append(description);
+		}		
+		
+		return sb.toString();
+	}
+	
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteBitstreamsAction.java

@@ -0,0 +1,143 @@
+/*
+ * DeleteBitstreamsAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.util.List;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+import org.dspace.content.DCDate;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ * 	  Action to delete bitstreams	
+ * 
+ * 	  Undo not supported for this UpdateAction
+ * 
+ *    Derivatives of the bitstream to be deleted are not also deleted 
+ *
+ */
+public class DeleteBitstreamsAction extends UpdateBitstreamsAction 
+{
+	/**
+	 *   Delete bitstream from item
+	 * 
+	 *  @param context
+	 *  @param ItemArchive
+	 *  @param isTest
+	 *  @param suppressUndo
+	 *  @throws IllegalArgumentException
+	 *  @throws ParseException
+	 *  @throws IOException
+	 *  @throws AuthorizeException
+	 *  @throws SQLException
+	 */
+	public void execute(Context context, ItemArchive itarch, boolean isTest, boolean suppressUndo) 
+	throws IllegalArgumentException, IOException, SQLException, AuthorizeException, ParseException 
+	{
+		File f = new File(itarch.getDirectory(), ItemUpdate.DELETE_CONTENTS_FILE);
+		if (!f.exists())
+		{
+			ItemUpdate.pr("Warning: Delete_contents file for item " + itarch.getDirectoryName() + " not found.");
+		}
+		else
+		{
+			List<Integer> list = MetadataUtilities.readDeleteContentsFile(f);
+			if (list.isEmpty())
+			{
+				ItemUpdate.pr("Warning: empty delete_contents file for item " + itarch.getDirectoryName() );
+			}
+			else
+			{
+				for (int id : list)
+				{
+					try
+					{
+			    		Bitstream bs = Bitstream.find(context, id);
+			    		if (bs == null)
+			    		{
+			    			ItemUpdate.pr("Bitstream not found by id: " + id);
+			    		}
+			    		else
+			    		{
+				    		Bundle[] bundles = bs.getBundles();
+				    		for (Bundle b : bundles)
+				    		{
+				    			if (isTest)
+				    			{
+					    			ItemUpdate.pr("Delete bitstream with id = " + id);
+				    			}
+				    			else
+				    			{
+				    				b.removeBitstream(bs); 
+					    			ItemUpdate.pr("Deleted bitstream with id = " + id);
+					    			
+				    			}
+				    		}	
+			    		
+				            if (alterProvenance)
+				            {
+				            	DtoMetadata dtom = DtoMetadata.create("dc.description.provenance", "en", "");
+				            	
+				            	String append = "Bitstream " + bs.getName() + " deleted on " + DCDate.getCurrent() + "; ";
+				            	Item item = bundles[0].getItems()[0];
+					    		ItemUpdate.pr("Append provenance with: " + append);
+					    		
+					    		if (!isTest)
+					    		{
+					    			MetadataUtilities.appendMetadata(item, dtom, false, append);
+					    		}
+				            }
+			    		}	
+					}
+					catch(SQLException e)
+					{
+						ItemUpdate.pr("Error finding bitstream from id: " + id + " : " + e.toString());
+					}
+				}
+			}
+		}
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteBitstreamsByFilterAction.java

@@ -0,0 +1,159 @@
+/*
+ * DeleteBitstreamsByFilterAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+import org.dspace.content.DCDate;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ * 		Action to delete bitstreams using a specified filter implementing BitstreamFilter
+ *      Derivatives for the target bitstreams are not deleted.
+ * 
+ *      The dc.description.provenance field is amended to reflect the deletions
+ *      
+ *      Note:  Multiple filters are impractical if trying to manage multiple properties files
+ *      in a commandline environment
+ * 
+ *
+ */
+public class DeleteBitstreamsByFilterAction extends UpdateBitstreamsAction {
+
+	private BitstreamFilter filter;
+	
+	/**
+	 *   Set filter
+	 *   
+	 * @param filter
+	 */
+	public void setBitstreamFilter(BitstreamFilter filter)
+	{
+		this.filter = filter;
+	}
+	
+	/**
+	 *   Get filter
+	 * @return filter 
+	 */
+	public BitstreamFilter getBitstreamFilter()
+	{
+		return filter;
+	}
+	
+	/**
+	 * 	 Delete bitstream
+	 * 
+	 *  @param context
+	 *  @param ItemArchive
+	 *  @param isTest
+	 *  @param suppressUndo
+	 *  @throws IllegalArgumentException
+	 *  @throws ParseException
+	 *  @throws IOException
+	 *  @throws AuthorizeException
+	 *  @throws SQLException
+	 */
+	public void execute(Context context, ItemArchive itarch, boolean isTest, boolean suppressUndo) 
+	throws AuthorizeException, BitstreamFilterException, IOException, ParseException, SQLException 
+	{
+		
+		List<String> deleted = new ArrayList<String>();
+		
+		Item item = itarch.getItem();
+		Bundle[] bundles = item.getBundles();
+		
+		for (Bundle b : bundles)    
+		{
+			Bitstream[] bitstreams = b.getBitstreams();
+			String bundleName = b.getName();
+			
+			for (Bitstream bs : bitstreams)
+			{		
+			    if (filter.accept(bs))
+				{
+	    			if (isTest)
+	    			{
+		    			ItemUpdate.pr("Delete from bundle " + bundleName + " bitstream " + bs.getName() 
+		    					+ " with id = " + bs.getID());
+	    			}
+	    			else
+	    			{	    					    				
+	    				//provenance is not maintained for derivative bitstreams
+	    				if (!bundleName.equals("THUMBMNAIL") && !bundleName.equals("TEXT"))
+	    				{
+	    					deleted.add(bs.getName());
+	    				}
+	    				b.removeBitstream(bs); 
+		    			ItemUpdate.pr("Deleted " + bundleName + " bitstream " + bs.getName() 
+		    					+ " with id = " + bs.getID());		    			
+	    			}
+				}
+			}			
+		}
+		
+        if (alterProvenance && !deleted.isEmpty())
+        {     	
+    		StringBuilder sb = new StringBuilder("  Bitstreams deleted on "); 	
+    		sb.append(DCDate.getCurrent()).append(": ");
+    		
+    		for (String s : deleted)
+    		{
+            	sb.append(s).append(", ");
+    		}
+    		        	
+        	DtoMetadata dtom = DtoMetadata.create("dc.description.provenance", "en", "");
+        	
+    		ItemUpdate.pr("Append provenance with: " + sb.toString());
+    		
+    		if (!isTest)
+    		{
+    			MetadataUtilities.appendMetadata(item, dtom, false, sb.toString());
+    		}
+        }
+	}
+	
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteMetadataAction.java

@@ -0,0 +1,94 @@
+/*
+ * DeleteMetadataAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.text.ParseException;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.DCValue;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ *    Action to delete metadata 
+ * 
+ *
+ */
+public class DeleteMetadataAction extends UpdateMetadataAction {
+
+	/**
+	 *   Delete metadata from item
+	 * 
+	 *  @param context
+	 *  @param ItemArchive
+	 *  @param isTest
+	 *  @param suppressUndo
+	 *  @throws ParseException
+	 *  @throws AuthorizeException
+	 */
+	public void execute(Context context, ItemArchive itarch, boolean isTest, boolean suppressUndo) 
+	throws AuthorizeException, ParseException 
+	{
+		Item item = itarch.getItem();
+		for (String f : targetFields)
+		{
+			DtoMetadata dummy = DtoMetadata.create(f, Item.ANY, "");
+			DCValue[] ardcv = item.getMetadata(f);
+
+			ItemUpdate.pr("Metadata to be deleted: ");
+			for (DCValue dcv : ardcv)
+			{
+				ItemUpdate.pr("  " + MetadataUtilities.getDCValueString(dcv));
+			}
+
+			if (!isTest)
+			{
+				if (!suppressUndo)
+				{
+					for (DCValue dcv : ardcv)
+					{
+						itarch.addUndoMetadataField(DtoMetadata.create(dcv.schema, dcv.element, 
+								dcv.qualifier, dcv.language, dcv.value));					
+					}
+				}
+				
+				item.clearMetadata(dummy.schema, dummy.element, dummy.qualifier, Item.ANY);	
+			}
+		}
+	}
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/DerivativeTextBitstreamFilter.java

@@ -0,0 +1,54 @@
+/*
+ * DerivativeTextBitstreamFilter.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.util.Properties;
+
+/**
+ *   Bitstream filter to delete from TEXT bundle
+ *
+ */
+public class DerivativeTextBitstreamFilter extends BitstreamFilterByBundleName {
+	
+	public DerivativeTextBitstreamFilter()
+	{
+		props = new Properties();
+		props.setProperty("bundle", "TEXT");
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/DtoMetadata.java

@@ -0,0 +1,186 @@
+/*
+ * DtoMetadata.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.text.ParseException;
+import org.dspace.content.Item;
+
+/**
+ *   A data transfer object class enhancement of org.dspace.content.DCValue, which is deprecated
+ *   Name intended to not conflict with DSpace API classes for similar concepts but not usable in this context
+ *   
+ *   Adds some utility methods
+ *   
+ *   Really not at all general enough but supports Dublin Core and the compound form notation <schema>.<element>[.<qualifier>]
+ *   
+ *   Does not support wildcard for qualifier
+ * 
+ *
+ */
+class DtoMetadata 
+{
+	final String schema;   
+	final String element;
+	final String qualifier;
+	final String language;
+	final String value;
+	
+	private DtoMetadata(String schema, String element, String qualifier, String language, String value) 
+	{
+		this.schema = schema;
+		this.element = element;
+		this.qualifier = qualifier;
+		this.language = language;
+		this.value = value;
+	}
+	
+	/**
+	 *  Factory method
+	 *  
+	 *  
+	 * @param schema     not null, not empty -  'dc' is the standard case
+	 * @param element    not null, not empty
+	 * @param qualifier  null; don't allow empty string or * indicating 'any'
+	 * @param language   null or empty
+	 * @param value      
+	 * @return DtoMetadata object
+	 */
+	public static DtoMetadata create(String schema,
+			    String element,
+			    String qualifier,
+			    String language,
+			    String value)
+	throws IllegalArgumentException
+    {
+		if ((qualifier != null) &&  (qualifier.equals(Item.ANY) || qualifier.equals("")))
+		{
+			throw new IllegalArgumentException("Invalid qualifier: " + qualifier);
+		}
+		return new DtoMetadata(schema, element, qualifier, language, value);
+    }
+
+	/**
+	 *   Factory method to create metadata object
+	 *   
+	 * 
+	 * @param compoundForm   of the form <schema>.<element>[.<qualifier>]
+	 * @param language   null or empty
+	 * @param value      
+	 */
+	public static DtoMetadata create(String compoundForm, String language, String value)
+	throws ParseException, IllegalArgumentException  
+    {
+		String[] ar = MetadataUtilities.parseCompoundForm(compoundForm);
+		
+		String qual = null;
+		if (ar.length > 2)
+		{
+    		qual = ar[2];
+		}
+		
+		return create(ar[0], ar[1], qual, language, value);
+    }
+
+	/**
+	 *   Determine if this metadata field matches the specified type:
+	 *    schema.element or schema.element.qualifier
+	 *    
+	 * 
+	 * @param compoundForm   of the form <schema>.<element>[.<qualifier>|.*]
+	 * @param wildcard       allow wildcards in compoundForm param
+	 * @return whether matches
+	 */
+	public boolean matches(String compoundForm, boolean wildcard)
+	{
+		String[] ar = compoundForm.split("\\s*\\.\\s*"); //MetadataUtilities.parseCompoundForm(compoundForm);
+		
+		if ((ar.length < 2) || (ar.length > 3))
+		{
+			return false;
+		}
+		
+		if (!this.schema.equals(ar[0]) || !this.element.equals(ar[1]))
+		{
+			return false;
+		}
+		
+		if (ar.length == 2)
+		{
+			if (this.qualifier != null)
+			{
+				return false;
+			}
+		}
+		
+		if (ar.length == 3)	
+		{
+			if (this.qualifier == null)
+			{
+				return false;
+			}
+			if (wildcard && ar[2].equals(Item.ANY))
+			{
+				return true;
+			}
+			if (!this.qualifier.equals(ar[2]))
+			{
+				return false;
+			}
+		}
+		return true;		
+	}
+	
+	public String toString()
+	{
+		String s =  "\tSchema: " + schema + " Element: " + element;
+		if (qualifier != null)
+		{
+			s+= " Qualifier: " + qualifier;
+		}
+		s+= " Language: " + ((language == null) ? "[null]" : language);
+        s += " Value: " + value;
+        
+        return s;
+	}
+	
+	public String getValue()
+	{
+		return value;
+	}
+		
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/ItemArchive.java

@@ -0,0 +1,354 @@
+/*
+ * ItemArchive.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerConfigurationException;
+
+import org.dspace.storage.rdbms.DatabaseManager;
+import org.dspace.content.ItemIterator;
+import org.dspace.storage.rdbms.TableRowIterator;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.Item;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.core.Context;
+import org.dspace.handle.HandleManager;
+
+import org.w3c.dom.Document;
+
+
+/**
+ *   Encapsulates the Item in the context of the DSpace Archive Format
+ *
+ */
+public class ItemArchive {
+
+	static public final String DUBLIN_CORE_XML = "dublin_core.xml"; 
+	
+    private static DocumentBuilder builder = null;
+    private static Transformer transformer = null;
+   
+	private List<DtoMetadata> dtomList = null; 
+	private List<DtoMetadata> undoDtomList = new ArrayList<DtoMetadata>();
+	
+	private List<Integer> undoAddContents = new ArrayList<Integer>(); // for undo of add
+	
+	private Item item;
+	private File dir;  // directory name in source archive for this item
+	private String dirname; //convenience
+	
+//constructors
+	private ItemArchive() 
+	{
+		// nothing
+	}	
+	
+/** factory method
+ * 
+ * 	Minimal requirements for dublin_core.xml for this application
+ *  is the presence of dc.identifier.uri
+ *  which must contain the handle for the item
+ *  
+ *  @param context - The DSpace context
+ *  @param dir     - The directory File in the source archive
+ *  @param itemField - The metadata field in which the Item identifier is located
+ *                     if null, the default is the handle in the dc.identifier.uri field
+ * 
+ */
+	public static ItemArchive create(Context context, File dir, String itemField)
+	throws Exception
+	{
+		ItemArchive itarch = new ItemArchive(); 
+		itarch.dir = dir;
+		itarch.dirname = dir.getName();
+		InputStream is = new FileInputStream(new File(dir, DUBLIN_CORE_XML));
+		itarch.dtomList = MetadataUtilities.loadDublinCore(getDocumentBuilder(), is);  
+		ItemUpdate.pr("Loaded metadata with " + itarch.dtomList.size() + " fields");
+		
+		if (itemField == null)
+		{
+			itarch.item = itarch.itemFromHandleInput(context);  // sets the item instance var and seeds the undo list
+		}
+		else
+		{
+			itarch.item = itarch.itemFromMetadataField(context, itemField);  			
+		}
+		
+		if (itarch.item == null)
+		{
+			throw new Exception("Item not instantiated: " + itarch.dirname);
+		}
+		
+		ItemUpdate.prv("item instantiated: " + itarch.item.getHandle());
+
+		return itarch;
+	}
+		
+	private static DocumentBuilder getDocumentBuilder()
+	throws ParserConfigurationException
+	{
+		if (builder == null)
+		{
+		    builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+		}
+		return builder;
+	}
+	
+	private static Transformer getTransformer()
+	throws TransformerConfigurationException
+	{
+		if (transformer == null)
+		{
+		    transformer = TransformerFactory.newInstance().newTransformer();
+		}
+		return transformer;
+	}
+
+	/**
+	 *   Getter for the DSpace item referenced in the archive
+	 * @return DSpace item 
+	 */
+	public Item getItem()
+	{
+		return item;
+	}
+	
+	/**
+	 *   Getter for directory in archive on disk
+	 * @return directory in archive
+	 */
+	public File getDirectory()
+	{
+		return dir;
+	}
+	
+	/**
+	 *   Getter for directory name in archive
+	 * @return directory name in archive
+	 */
+	public String getDirectoryName()
+	{
+		return dirname;
+	}
+	
+	/**
+	 *   Add metadata field to undo list
+	 * @param dtom
+	 */
+	public void addUndoMetadataField(DtoMetadata dtom)
+	{
+		this.undoDtomList.add(dtom);
+	}
+	
+	/**
+	 *    Getter for list of metadata fields 
+	 * @return list of metadata fields
+	 */
+	public List<DtoMetadata> getMetadataFields()
+	{
+		return dtomList;
+	}
+	
+	/**
+	 *   Add bitstream id to delete contents file
+	 * @param bitstreamId
+	 */
+	public void addUndoDeleteContents(int bitstreamId)
+	{
+		this.undoAddContents.add(bitstreamId);
+	}
+	
+	
+    /**
+	 *   Obtain item from DSpace based on handle
+     *   This is the default implementation
+     *   that uses the dc.identifier.uri metadatafield 
+     *   that contains the item handle as its value  
+     *   
+     */
+    private Item itemFromHandleInput(Context context)
+    throws SQLException, Exception
+    {
+    	DtoMetadata dtom = getMetadataField("dc.identifier.uri");
+    	if (dtom == null)
+    	{
+    		throw new Exception("No dc.identier.uri field found for handle"); 
+    	}
+    	
+    	this.addUndoMetadataField(dtom);  //seed the undo list with the uri
+    	
+		String uri = dtom.value;
+		
+    	if (!uri.startsWith(ItemUpdate.HANDLE_PREFIX))
+    	{
+    		throw new Exception("dc.identifier.uri for item " + uri 
+    				+ " does not begin with prefix: " + ItemUpdate.HANDLE_PREFIX);
+    	}
+    	
+    	String handle = uri.substring(ItemUpdate.HANDLE_PREFIX.length());
+    		
+		DSpaceObject dso = HandleManager.resolveToObject(context, handle);  
+		if (dso instanceof Item)
+		{
+			item =  (Item) dso;
+		}
+		else
+		{
+			ItemUpdate.pr("Warning: item not instantiated");
+			throw new IllegalArgumentException("Item " + handle + " not instantiated.");
+		}	
+		return item;
+    }
+    
+    /**
+     * 	 Find and instantiate Item from the dublin_core.xml based
+     *   on the specified itemField for the item identifier,
+     *   
+     * 
+     * @param context   - the DSpace context
+     * @param itemField - the compound form of the metadata element <schema>.<element>.<qualifier>
+     * @throws SQLException
+     * @throws Exception
+     */
+    private Item itemFromMetadataField(Context context, String itemField)
+    throws SQLException, AuthorizeException, Exception
+    {
+    	DtoMetadata dtom = getMetadataField(itemField);
+    	
+    	Item item = null;
+    	
+    	if (dtom == null)
+    	{
+    		throw new IllegalArgumentException("No field found for item identifier field: " + itemField);
+    	}  
+    	ItemUpdate.prv("Metadata field to match for item: " + dtom.toString());
+
+    	this.addUndoMetadataField(dtom);  //seed the undo list with the identifier field
+    	
+	    ItemIterator itr = Item.findByMetadataField(context, dtom.schema, dtom.element, dtom.qualifier, dtom.value);
+		int count = 0;
+		while (itr.hasNext())
+		{
+			item = itr.next();
+			count++;
+		}
+		
+		itr.close(); 
+		
+		ItemUpdate.prv("items matching = " + count );
+		
+		if (count != 1)
+		{
+			throw new Exception ("" + count + " items matching item identifier: " + dtom.value);
+		}
+        
+    	return item;    	
+    }  
+    
+    private DtoMetadata  getMetadataField(String compoundForm)
+    {
+    	for (DtoMetadata dtom : dtomList)
+    	{
+			if (dtom.matches(compoundForm, false))
+			{
+				return dtom;
+			}
+    	}
+    	return null;
+    }    
+
+    /**
+     * write undo directory and files to Disk in archive format
+     * 
+     * 
+     * @param undoDir - the root directory of the undo archive
+     */
+	public void writeUndo(File undoDir)
+	throws IOException, ParserConfigurationException, TransformerConfigurationException, 
+	       TransformerException, FileNotFoundException
+	{
+		// create directory for item
+		File dir = new File(undoDir, dirname);
+		dir.mkdir();
+		
+		OutputStream out = new FileOutputStream(new File(dir, "dublin_core.xml"));
+        Document doc = MetadataUtilities.writeDublinCore(getDocumentBuilder(), undoDtomList);
+        MetadataUtilities.writeDocument(doc, getTransformer(), out);
+		
+		// if undo has delete bitstream
+        if (undoAddContents.size() > 0)
+        {
+        	PrintWriter pw = null;
+        	try
+        	{
+	        	File f = new File(dir, ItemUpdate.DELETE_CONTENTS_FILE);
+	        	pw = new PrintWriter(new BufferedWriter(new FileWriter(f)));
+	        	for (Integer i : undoAddContents)
+	        	{
+	        		pw.println(i);
+	        	}
+        	}
+        	finally
+        	{
+        		pw.close();
+        	}
+        }        
+	}
+	
+} //end class

dspace-api/src/main/java/org/dspace/app/itemupdate/ItemUpdate.java

@@ -0,0 +1,642 @@
+/*
+ * ItemUpdate.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.PosixParser;
+import org.dspace.content.Item;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+
+/**
+ *   
+ *   Provides some batch editing capabilities for items in DSpace:
+ *   	Metadata fields - Add, Delete
+ *      Bitstreams - Add, Delete
+ * 
+ *   The design has been for compatibility with ItemImporter
+ *      in the use of the DSpace archive format which is used to
+ *      specify changes on a per item basis.  The directory names
+ *      to correspond to each item are arbitrary and will only be
+ *      used for logging purposes.  The reference to the item is
+ *      from a required dc.identifier with the item handle to be 
+ *      included in the dublin_core.xml (or similar metadata) file.
+ *      
+ *   Any combination of these actions is permitted in a single run of this class 
+ *      The order of actions is important when used in combination.  
+ *      It is the responsibility of the calling class (here, ItemUpdate)
+ *      to register UpdateAction classes in the order to which they are
+ *      to be performed.
+ *      
+ * 
+ *   It is unfortunate that so much code needs to be borrowed 
+ *      from ItemImport as it is not reusable in private methods, etc.
+ *      Some of this has been placed into the MetadataUtilities class
+ *      for possible reuse elsewhere. 
+ *   
+ * 
+ * @author W. Hays based on a conceptual design by R. Rodgers
+ *
+ */
+public class ItemUpdate {
+	
+	static public String SUPPRESS_UNDO_FILENAME = "suppress_undo"; 
+
+	static public final String CONTENTS_FILE = "contents"; 	
+	static public final String DELETE_CONTENTS_FILE = "delete_contents"; 
+
+	static public String HANDLE_PREFIX = null;	
+	static public Map<String, String> filterAliases = new HashMap<String, String>();
+	
+	static public boolean verbose = false;
+	
+	static
+	{
+		filterAliases.put("ORIGINAL", "org.dspace.app.itemupdate.OriginalBitstreamFilter");
+		filterAliases.put("ORIGINAL_AND_DERIVATIVES", "org.dspace.app.itemupdate.OriginalWithDerivativesBitstreamFilter");
+		filterAliases.put("TEXT", "org.dspace.app.itemupdate.DerivativeTextBitstreamFilter");		
+		filterAliases.put("THUMBNAIL", "org.dspace.app.itemupdate.ThumbnailBitstreamFilter");		
+	}
+	          	                
+    // File listing filter to check for folders
+    static FilenameFilter directoryFilter = new FilenameFilter()
+    {
+        public boolean accept(File dir, String n)
+        {
+            File f = new File(dir.getAbsolutePath() + File.separatorChar + n);
+            return f.isDirectory();
+        }
+    };
+ 
+    // File listing filter to check for files (not directories)
+    static FilenameFilter fileFilter = new FilenameFilter()
+    {
+        public boolean accept(File dir, String n)
+        {
+            File f = new File(dir.getAbsolutePath() + File.separatorChar + n);
+            return (f.isFile());
+        }
+    };
+
+    // instance variables
+    private ActionManager actionMgr = new ActionManager(); 
+    private List<String> undoActionList = new ArrayList<String>();  
+    private String eperson;
+   
+    /**
+     * 
+     * @param argv
+     */
+    public static void main(String[] argv)
+    {
+        // create an options object and populate it
+        CommandLineParser parser = new PosixParser();
+
+        Options options = new Options();
+
+     //processing basis for detemining items    
+        //item-specific changes with metadata in source directory with dublic_core.xml files  
+        options.addOption("s", "source", true, "root directory of source dspace archive ");
+      
+    //actions  on items     
+        options.addOption("a", "addmetadata", true, "add metadata specified for each item; multiples separated by semicolon ';'");
+        options.addOption("d", "deletemetadata", true, "delete metadata specified for each item");
+        
+        options.addOption("A", "addbitstreams", false, "add bitstreams as specified for each item");
+        
+        // extra work to get optional argument
+        Option delBitstreamOption = new Option("D", "deletebitstreams", true, "delete bitstreams as specified for each item");
+        delBitstreamOption.setOptionalArg(true);
+        delBitstreamOption.setArgName("BitstreamFilter");
+        options.addOption(delBitstreamOption);
+                               
+//other params        
+        options.addOption("e", "eperson", true, "email of eperson doing the update");
+        options.addOption("i", "itemfield", true, "optional metadata field that containing item identifier; default is dc.identifier.uri");
+        options.addOption("F", "filter-properties", true, "filter class name; only for deleting bitstream");  
+        options.addOption("v", "verbose", false, "verbose logging");
+      
+//special run states        
+        options.addOption("t", "test", false, "test run - do not actually import items");
+        options.addOption("P", "provenance", false, "suppress altering provenance field for bitstream changes");
+        options.addOption("h", "help", false, "help");
+        
+        int status = 0;
+        boolean isTest = false;
+        boolean alterProvenance = true;
+        String itemField = null;
+        String metadataIndexName = null;
+        
+        Context context = null;
+        ItemUpdate iu = new ItemUpdate();	
+
+        try
+        {       
+	        CommandLine line = parser.parse(options, argv);
+	
+	        if (line.hasOption('h'))
+	        {
+	            HelpFormatter myhelp = new HelpFormatter();
+	            myhelp.printHelp("ItemUpdate", options);
+	            pr("");
+	            pr("Examples:");
+	            pr("  adding metadata:     ItemUpdate -e jsmith@mit.edu -s sourcedir -a dc.contributor -a dc.subject ");
+	            pr("  deleting metadata:   ItemUpdate -e jsmith@mit.edu -s sourcedir -d dc.description.other");
+	            pr("  adding bitstreams:   ItemUpdate -e jsmith@mit.edu -s sourcedir -A -i dc.identifier");
+	            pr("  deleting bitstreams: ItemUpdate -e jsmith@mit.edu -s sourcedir -D ORIGINAL ");
+	            pr("");
+	
+	            System.exit(0);
+	        }
+	        
+	        if (line.hasOption('v'))
+	        {
+	        	verbose = true;
+	        }
+
+ 
+	        if (line.hasOption('P'))
+	        {
+	        	alterProvenance = false;
+	        	pr("Suppressing changes to Provenance field option");
+	        }
+
+	        iu.eperson = line.getOptionValue('e'); // db ID or email
+	        
+	        if (!line.hasOption('s')) // item specific changes from archive dir
+	        {
+	        	pr("Missing source archive option");
+	        	System.exit(1);
+	        }
+	        String sourcedir = line.getOptionValue('s');
+	        
+        	if (line.hasOption('t'))  //test
+        	{
+        		isTest = true;
+	            pr("**Test Run** - not actually updating items.");
+       		       	
+	        }
+        	
+        	if (line.hasOption('i'))
+        	{
+        		itemField = line.getOptionValue('i');      		
+        	}
+
+	        if (line.hasOption('d'))
+	        {
+	        	String[] targetFields = line.getOptionValues('d'); 
+	        	
+	        	DeleteMetadataAction delMetadataAction = (DeleteMetadataAction) iu.actionMgr.getUpdateAction(DeleteMetadataAction.class);
+	        	delMetadataAction.addTargetFields(targetFields);
+	        	
+	        	//undo is an add 
+	        	for (String field : targetFields)
+	        	{
+	        		iu.undoActionList.add(" -a " + field + " ");
+	        	}
+	        	
+	        	pr("Delete metadata for fields: ");
+	        	for (String s : targetFields)
+	        	{
+	        		pr("    " + s);
+	        	}
+	        }
+	        
+    		if (line.hasOption('a'))
+    		{
+    			String[] targetFields = line.getOptionValues('a'); 
+        	
+    			AddMetadataAction addMetadataAction = (AddMetadataAction) iu.actionMgr.getUpdateAction(AddMetadataAction.class); 
+    			addMetadataAction.addTargetFields(targetFields);
+        		
+        		//undo is a delete followed by an add of a replace record for target fields
+	        	for (String field : targetFields)
+	        	{
+	        		iu.undoActionList.add(" -d " + field + " ");
+	        	}
+    			
+	        	for (String field : targetFields)
+	        	{
+	        		iu.undoActionList.add(" -a " + field + " ");
+	        	}
+    			
+	        	pr("Add metadata for fields: ");
+	        	for (String s : targetFields)
+	        	{
+	        		pr("    " + s);
+	        	}
+        	}
+    		
+	        if (line.hasOption('D'))  // undo not supported 
+	        {
+	        	pr("Delete bitstreams ");
+	        	
+	        	String[] filterNames = line.getOptionValues('D');
+	        	if ((filterNames != null) && (filterNames.length > 1))
+	        	{
+	        		pr("Error: Only one filter can be a used at a time.");
+	        		System.exit(1);
+	        	}
+	        	
+	        	String filterName = line.getOptionValue('D');
+	        	pr("Filter argument: " + filterName);
+	        	
+	        	if (filterName == null)  // indicates using delete_contents files
+	        	{
+	        		DeleteBitstreamsAction delAction = (DeleteBitstreamsAction) iu.actionMgr.getUpdateAction(DeleteBitstreamsAction.class);
+		        	delAction.setAlterProvenance(alterProvenance);
+	        	}
+	        	else
+	        	{
+	        	    // check if param is on ALIAS list
+	        		String filterClassname = filterAliases.get(filterName);
+	        		
+	        		if (filterClassname == null)
+	        		{
+	        			filterClassname = filterName;
+	        		}
+	        			        		
+	        	    BitstreamFilter filter = null; 
+
+	        	    try
+	        	    {
+		    			Class<?> cfilter = Class.forName(filterClassname);
+		    			pr("BitstreamFilter class to instantiate: " + cfilter.toString());
+		    			
+		    			filter =  (BitstreamFilter) cfilter.newInstance();  //unfortunate cast, an erasure consequence
+	        	    }
+	        	    catch(Exception e)
+	        	    {
+	        	    	pr("Error:  Failure instantiating bitstream filter class: " + filterClassname);
+	        	    	System.exit(1);
+	        	    }
+	        	    
+	        	    String filterPropertiesName = line.getOptionValue('F');
+	        	    if (filterPropertiesName != null)  //not always required
+	        	    {
+	        	    	try
+	        	    	{
+	        	    		// TODO try multiple relative locations, e.g. source dir
+	        	    		if (!filterPropertiesName.startsWith("/"))
+	        	    		{
+	        	    			filterPropertiesName = sourcedir + File.separator + filterPropertiesName;
+	        	    		}
+	        	    		
+	        	    		filter.initProperties(filterPropertiesName);
+	        	    	}
+	        	    	catch(Exception e)
+	        	    	{
+		        	    	pr("Error:  Failure finding properties file for bitstream filter class: " + filterPropertiesName);
+		        	    	System.exit(1);
+	        	    	}
+	        	    }
+	        	    
+	        		DeleteBitstreamsByFilterAction delAction = 
+	        			(DeleteBitstreamsByFilterAction) iu.actionMgr.getUpdateAction(DeleteBitstreamsByFilterAction.class);
+		        	delAction.setAlterProvenance(alterProvenance);
+		        	delAction.setBitstreamFilter(filter);
+	        	    //undo not supported
+	        	}        	
+	        }
+
+	        if (line.hasOption('A'))
+	        {
+	        	pr("Add bitstreams ");    	        	
+        		AddBitstreamsAction addAction = (AddBitstreamsAction) iu.actionMgr.getUpdateAction(AddBitstreamsAction.class);
+	        	addAction.setAlterProvenance(alterProvenance);
+	        	
+	        	iu.undoActionList.add(" -D ");  // delete_contents file will be written, no arg required	        	
+	        }    	        
+	        	        
+	        if (!iu.actionMgr.hasActions())
+	        {
+                pr("Error - an action must be specified");
+                System.exit(1);
+	        }
+	        else  
+	        {
+	        	pr("Actions to be performed: ");
+	        	
+	        	for (UpdateAction ua : iu.actionMgr)
+	        	{
+	        		pr("    " + ua.getClass().getName());
+	        	}
+	        }
+	        
+	        pr("ItemUpdate - initializing run on " + (new Date()).toString());
+	               	
+	        context = new Context();  
+	        iu.setEPerson(context, iu.eperson);	
+	        context.setIgnoreAuthorization(true);
+	        
+	    	HANDLE_PREFIX = ConfigurationManager.getProperty("handle.canonical.prefix");
+	    	if (HANDLE_PREFIX == null || HANDLE_PREFIX.length() == 0)
+	    	{
+	    		HANDLE_PREFIX = "http://hdl.handle.net/";
+	    	}
+	    		        
+        	iu.processArchive(context, sourcedir, itemField, metadataIndexName, alterProvenance, isTest);		        	            
+
+	        context.complete();  // complete all transactions
+	        context.setIgnoreAuthorization(false);
+        }
+        catch (Exception e)
+        {
+            if (context != null && context.isValid())
+            {
+                context.abort();
+            	context.setIgnoreAuthorization(false);
+            }
+            e.printStackTrace();
+            pr(e.toString());
+            status = 1;
+        }
+
+        if (isTest)
+        {
+            pr("***End of Test Run***");
+        }
+        else
+        {
+        	pr("End.");
+        	
+        }
+        System.exit(status);
+    }
+    
+    private void processArchive(Context context, String sourceDirPath, String itemField,
+    		String metadataIndexName, boolean alterProvenance, boolean isTest)
+    throws Exception
+    {
+        // open and process the source directory
+        File sourceDir = new File(sourceDirPath);
+
+        if ((sourceDir == null) || !sourceDir.exists() || !sourceDir.isDirectory())
+        {
+            pr("Error, cannot open archive source directory " + sourceDirPath);
+            throw new Exception("error with archive source directory " + sourceDirPath);
+        }
+
+        String[] dircontents = sourceDir.list(directoryFilter);  //just the names, not the path
+        Arrays.sort(dircontents);
+       
+        //Undo is suppressed to prevent undo of undo
+        boolean suppressUndo = false;
+        File fSuppressUndo = new File(sourceDir, SUPPRESS_UNDO_FILENAME);
+        if (fSuppressUndo.exists())
+        {
+        	suppressUndo = true;
+        }
+
+        File undoDir = null;  //sibling directory of source archive
+        
+    	if (!suppressUndo && !isTest) 
+    	{
+    		undoDir = initUndoArchive(sourceDir);	
+    	}
+        
+    	int itemCount = 0;
+    	int successItemCount = 0;
+    	
+        for (String dirname : dircontents)
+        {
+        	itemCount++;
+    		pr("");
+    		pr("processing item " + dirname);
+    		
+    		try
+    		{
+	    		ItemArchive itarch = ItemArchive.create(context, new File(sourceDir, dirname), itemField);
+	    		
+	    		for (UpdateAction action : actionMgr)
+	    		{
+	    			pr("action: " + action.getClass().getName());
+	    			action.execute(context, itarch, isTest, suppressUndo);
+	    			if (!isTest)
+	    			{
+		    			if (!suppressUndo)
+		    	        {
+		    				itarch.writeUndo(undoDir);
+		    	        }
+	    			}
+	    		}
+	    		if (!isTest)
+	    		{
+    				Item item = itarch.getItem();
+    				item.update();  //need to update before commit
+    				context.commit();  
+	    			item.decache();
+	    		}
+    			ItemUpdate.pr("Item " + dirname + " completed");
+    			successItemCount++;
+    		}
+    		catch(Exception e)
+    		{
+    			pr("Exception processing item " + dirname + ": " + e.toString());
+    		}
+        }  
+        
+        if (!suppressUndo && !isTest)
+        {        	     	
+        	StringBuilder sb = new StringBuilder("dsrun org.dspace.app.itemupdate.ItemUpdate ");
+        	sb.append(" -e ").append(this.eperson);
+        	sb.append(" -s ").append(undoDir);
+        	
+        	if (itemField != null)
+        	{
+        		sb.append(" -i ").append(itemField);
+        	}
+        	
+         	if (!alterProvenance)
+        	{
+        		sb.append(" -P ");
+        	}
+        	if (isTest)
+        	{
+        		sb.append(" -t ");
+        	}
+        	
+        	for (String actionOption : undoActionList)
+        	{
+        		sb.append(actionOption);
+        	}   
+        	
+        	PrintWriter pw = null;
+        	try
+        	{
+               	File cmdFile = new File (undoDir.getParent(), undoDir.getName() + "_command.sh");
+	        	pw = new PrintWriter(new BufferedWriter(new FileWriter(cmdFile)));
+	        	pw.println(sb.toString());
+        	}
+        	finally
+        	{
+        		pw.close();
+        	}
+        }
+        
+        pr("");
+        pr("Done processing.  Successful items: " + successItemCount + " of " + itemCount + " items in source archive");
+        pr("");
+    }
+           
+    
+    /**
+     * 
+     * to avoid overwriting the undo source tree on repeated processing
+     * sequence numbers are added and checked 
+     * 
+     * @param sourceDir - the original source directory
+     * @return the directory of the undo archive
+     * @throws FileNotFoundException
+     * @throws IOException
+     */
+	private File initUndoArchive(File sourceDir)
+	throws FileNotFoundException, IOException
+	{				
+		File parentDir = sourceDir.getAbsoluteFile().getParentFile(); 
+		if (parentDir == null)
+		{
+			throw new FileNotFoundException("Parent directory of archive directory not found; unable to write UndoArchive; no processing performed");    			
+		}
+		
+		String sourceDirName = sourceDir.getName();
+		int seqNo = 1;
+		
+		File undoDir = new File(parentDir, "undo_" + sourceDirName + "_" + seqNo);
+		while (undoDir.exists())
+		{
+    		undoDir = new File(parentDir, "undo_" + sourceDirName+ "_" + ++seqNo); //increment
+		}
+		
+		// create root directory
+		if (!undoDir.mkdir())
+		{
+        	pr("ERROR creating  Undo Archive directory ");
+        	throw new IOException("ERROR creating  Undo Archive directory ");
+		}
+		
+        //Undo is suppressed to prevent undo of undo
+        File fSuppressUndo = new File(undoDir, ItemUpdate.SUPPRESS_UNDO_FILENAME);
+        try
+        {
+        	fSuppressUndo.createNewFile();
+        }
+        catch(IOException e)
+        {
+        	pr("ERROR creating Suppress Undo File " + e.toString());
+        	throw e;
+        }
+        return undoDir;		
+	}
+	
+	//private void write
+
+    private void setEPerson(Context context, String eperson)
+    throws Exception
+    {
+        if (eperson == null)
+        {
+            pr("Error - an eperson to do the importing must be specified");
+            pr(" (run with -h flag for details)");
+            throw new Exception("EPerson not specified.");        }
+
+        EPerson myEPerson = null;
+
+        if (eperson.indexOf('@') != -1)
+        {
+            // @ sign, must be an email
+            myEPerson = EPerson.findByEmail(context, eperson);
+        }
+        else
+        {
+            myEPerson = EPerson.find(context, Integer.parseInt(eperson));
+        }
+
+        if (myEPerson == null)
+        {
+            pr("Error, eperson cannot be found: " + eperson);
+            throw new Exception("Invalid EPerson");
+        }
+
+        context.setCurrentUser(myEPerson);
+    }
+    
+    /**
+     *   poor man's logging
+	 *   As with ItemImport, API logging goes through log4j to the DSpace.log files
+	 *   whereas the batch logging goes to the console to be captured there.
+     * @param s
+     */
+    static void pr(String s)
+    {
+    	System.out.println(s);
+    }
+    
+    /**
+     *  print if verbose flag is set
+     * @param s
+     */
+    static void prv(String s)
+    {
+    	if (verbose) 
+    	{
+        	System.out.println(s);
+    	}
+    }
+    
+} //end of class
+

dspace-api/src/main/java/org/dspace/app/itemupdate/MetadataUtilities.java

@@ -0,0 +1,561 @@
+/*
+ * MetadataUtilities.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.apache.xpath.XPathAPI;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.DCValue;
+import org.dspace.content.Item;
+import org.dspace.content.MetadataSchema;
+import org.dspace.core.ConfigurationManager;
+
+
+/**
+ * 		Miscellaneous methods for metadata handling that build on the API
+ *      which might have general utility outside of the specific use
+ *      in context in ItemUpdate.
+ *      
+ *      The XML methods were based on those in ItemImport
+ * 
+ *
+ */
+public class MetadataUtilities {
+	
+    /**      
+     * 
+     *  Working around Item API to delete a value-specific DCValue
+     *  For a given element/qualifier/lang:
+     *      get all DCValues
+     *      clear (i.e. delete) all of these DCValues
+     *      add them back, minus the one to actually delete
+     *  
+     * 
+     * @param item
+     * @param dtom
+     * @param isLanguageStrict - 
+     * 
+     * @return true if metadata field is found with matching value and was deleted
+     */
+    public static boolean deleteMetadataByValue(Item item, DtoMetadata dtom, boolean isLanguageStrict)
+    {   	
+    	DCValue[] ar = null;
+    	
+    	if (isLanguageStrict)
+    	{   // get all for given type
+    		ar = item.getMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language);  
+    	}
+    	else
+    	{
+    		ar = item.getMetadata(dtom.schema, dtom.element, dtom.qualifier, Item.ANY);  
+    	}
+    	
+    	boolean found = false;
+    	
+    	//build new set minus the one to delete
+    	List<String> vals = new ArrayList<String>();
+    	for (DCValue dcv : ar)
+    	{
+    		if (dcv.value.equals(dtom.value))
+    		{
+    			found = true;
+    		}
+    		else
+    		{
+    			vals.add(dcv.value);
+    		}
+    	}
+    	
+    	if (found)  //remove all for given type  ??synchronize this block??
+    	{   
+        	if (isLanguageStrict)
+        	{           		
+        		item.clearMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language);
+        	}
+        	else
+        	{
+        		item.clearMetadata(dtom.schema, dtom.element, dtom.qualifier, Item.ANY);
+        	}
+    	
+    		item.addMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language, vals.toArray(new String[0]));   	
+    	}
+		return found;
+    }
+
+    /**
+     *   Append text to value metadata field to item
+     *   
+     * @param item
+     * @param dtom
+     * @param isLanguageStrict
+     * @param textToAppend
+     * @throws IllegalArgumentException  - When target metadata field is not found
+     */
+    public static void appendMetadata(Item item, DtoMetadata dtom, boolean isLanguageStrict, 
+    		String textToAppend)
+    throws IllegalArgumentException
+    {   	
+    	DCValue[] ar = null;
+    	
+    	// get all values for given element/qualifier
+    	if (isLanguageStrict)  // get all for given element/qualifier
+    	{   
+    		ar = item.getMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language);  
+    	}
+    	else
+    	{
+    		ar = item.getMetadata(dtom.schema, dtom.element, dtom.qualifier, Item.ANY);  
+    	}
+    	
+    	if (ar.length == 0)
+    	{
+    		throw new IllegalArgumentException("Metadata to append to not found");
+    	}
+    	
+    	int idx = 0;  //index of field to change
+    	if (ar.length > 1)  //need to pick one, can't be sure it's the last one
+    	{
+    		// TODO maybe get highest id ?
+    	}
+    	
+    	//build new set minus the one to delete
+    	List<String> vals = new ArrayList<String>();
+    	for (int i=0; i < ar.length; i++) 
+    	{
+    		if (i == idx)
+    		{
+    			vals.add(ar[i].value + textToAppend);
+    		}
+    		else
+    		{
+    			vals.add(ar[i].value);
+    		}
+    	}
+
+    	if (isLanguageStrict)
+    	{           		
+    		item.clearMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language);
+    	}
+    	else
+    	{
+    		item.clearMetadata(dtom.schema, dtom.element, dtom.qualifier, Item.ANY);
+    	}
+	
+		item.addMetadata(dtom.schema, dtom.element, dtom.qualifier, dtom.language, vals.toArray(new String[0]));   	
+    }
+ 
+    /**
+     *  Modification of method from ItemImporter.loadDublinCore 
+     *  as a Factory method
+     * 
+     * @param docBuilder  - 
+     * @param is - InputStream of dublin_core.xml
+     * @return list of DtoMetadata representing the metadata fields relating to an Item
+     * @throws SQLException
+     * @throws IOException
+     * @throws ParserConfigurationException
+     * @throws SAXException
+     * @throws TransformerException
+     * @throws AuthorizeException
+     */
+    public static List<DtoMetadata> loadDublinCore(DocumentBuilder docBuilder, InputStream is)
+    throws SQLException, IOException, ParserConfigurationException,
+           SAXException, TransformerException, AuthorizeException
+	{    	
+		Document document = docBuilder.parse(is);
+		
+		List<DtoMetadata> dtomList = new ArrayList<DtoMetadata>();
+		
+		// Get the schema, for backward compatibility we will default to the
+		// dublin core schema if the schema name is not available in the import file		
+		String schema = null;
+		NodeList metadata = XPathAPI.selectNodeList(document, "/dublin_core");		
+		Node schemaAttr = metadata.item(0).getAttributes().getNamedItem("schema");
+		if (schemaAttr == null)
+		{
+		    schema = MetadataSchema.DC_SCHEMA;
+		}
+		else
+		{
+		    schema = schemaAttr.getNodeValue();
+		}
+
+		// Get the nodes corresponding to formats
+		NodeList dcNodes = XPathAPI.selectNodeList(document, "/dublin_core/dcvalue");
+		
+		for (int i = 0; i < dcNodes.getLength(); i++)
+		{
+		    Node n = dcNodes.item(i);		    
+	        String value = getStringValue(n).trim(); 
+	        // compensate for empty value getting read as "null", which won't display
+	        if (value == null)
+	        {
+	            value = "";
+	        }
+	        String element = getAttributeValue(n, "element");
+	        if (element != null)
+	        {
+	        	element = element.trim();
+	        }
+	        String qualifier = getAttributeValue(n, "qualifier"); 
+	        if (qualifier != null)
+	        {
+	        	qualifier = qualifier.trim();
+	        }
+	        String language = getAttributeValue(n, "language");
+	        if (language != null)
+	        {
+	        	language = language.trim();
+	        }
+
+	        if (qualifier.equals("none") || "".equals(qualifier))
+	        {
+	            qualifier = null;
+	        }
+	        
+	        // a goofy default, but consistent with DSpace treatment elsewhere  
+	        if (language == null)
+	        {
+	            language = "en";
+	        }
+	        else if (language.equals(""))
+	        {
+	            language = ConfigurationManager.getProperty("default.language");
+	        }
+	        
+		    DtoMetadata dtom = DtoMetadata.create(schema, element, qualifier, language, value);
+		    ItemUpdate.pr(dtom.toString());
+		    dtomList.add(dtom);
+		}
+		return dtomList;
+	}
+
+    /**
+     *    Write dublin_core.xml 
+     * 
+     * @param docBuilder
+     * @param dtomList
+     * @return xml document
+     * @throws ParserConfigurationException
+     * @throws TransformerConfigurationException
+     * @throws TransformerException
+     */
+	public static Document writeDublinCore(DocumentBuilder docBuilder, List<DtoMetadata> dtomList)
+	throws ParserConfigurationException, TransformerConfigurationException, TransformerException
+	{		
+        Document doc = docBuilder.newDocument();
+        Element root = doc.createElement("dublin_core");
+        doc.appendChild(root);
+    
+        for (DtoMetadata dtom : dtomList)
+        {
+        	Element mel = doc.createElement("dcvalue");
+        	mel.setAttribute("element", dtom.element);
+        	if (dtom.qualifier == null)
+        	{
+        		mel.setAttribute("qualifier", "none");
+        	}
+        	else
+        	{
+        		mel.setAttribute("qualifier", dtom.qualifier);
+        	}
+ 
+        	if ((dtom.language == null) || (dtom.language.equals("")))
+        	{
+        		mel.setAttribute("language", "en");
+        	}
+        	else
+        	{
+        		mel.setAttribute("language", dtom.language);
+        	}
+        	mel.setTextContent(dtom.value);
+        	root.appendChild(mel);
+        }
+        
+        return doc;       
+	}
+	
+    /**
+     *   write xml document to output stream
+     * @param doc
+     * @param transformer
+     * @param out
+     * @throws IOException
+     * @throws TransformerException
+     */
+	public static void writeDocument(Document doc, Transformer transformer, OutputStream out)
+	throws IOException, TransformerException
+	{
+        Source src = new DOMSource(doc); 
+        Result dest = new StreamResult(out); 
+        transformer.transform(src, dest); 
+	}
+    
+    
+    
+    // XML utility methods
+    /**
+     * Lookup an attribute from a DOM node.
+     * @param n
+     * @param name
+     * @return
+     */
+    private static String getAttributeValue(Node n, String name)
+    {
+        NamedNodeMap nm = n.getAttributes();
+
+        for (int i = 0; i < nm.getLength(); i++)
+        {
+            Node node = nm.item(i);
+
+            if (name.equals(node.getNodeName()))
+            {
+                return node.getNodeValue();
+            }
+        }
+
+        return "";
+    }
+    
+    /**
+     * Return the String value of a Node.
+     * @param node
+     * @return
+     */
+    private static String getStringValue(Node node)
+    {
+        String value = node.getNodeValue();
+
+        if (node.hasChildNodes())
+        {
+            Node first = node.getFirstChild();
+
+            if (first.getNodeType() == Node.TEXT_NODE)
+            {
+                return first.getNodeValue();
+            }
+        }
+
+        return value;
+    }
+    
+    /**
+     * 		rewrite of ItemImport's functionality
+     *      but just the parsing of the file, not the processing of its elements
+     *      
+     *      
+     * @validate  flag to verify matching files in tree
+     * @return
+     */
+    public static List<ContentsEntry> readContentsFile(File f)
+    throws FileNotFoundException, IOException, ParseException
+    {
+    	List<ContentsEntry> list = new ArrayList<ContentsEntry>();
+    	
+    	BufferedReader in = null;
+    	
+    	try
+    	{
+	    	in = new BufferedReader(new FileReader(f));
+	    	String line = null;
+	    	
+	    	while ((line = in.readLine()) != null)
+	    	{
+	    		line = line.trim();
+	            if ("".equals(line))
+	            {
+	                continue;
+	            }
+	            ItemUpdate.pr("Contents entry: " + line);	            
+	    		list.add(ContentsEntry.parse(line));	 
+	    	}
+    	}
+    	finally
+    	{
+    		try
+    		{
+    			in.close();
+    		}
+    		catch(IOException e)
+    		{
+    			//skip
+    		}
+    	}
+    	
+    	return list;
+    }
+
+    /**
+     * 
+     * @param f
+     * @return
+     * @throws FileNotFoundException
+     * @throws IOException
+     */
+    public static List<Integer> readDeleteContentsFile(File f)
+    throws FileNotFoundException, IOException
+    {
+    	List<Integer> list = new ArrayList<Integer>();
+    	
+    	BufferedReader in = null;
+    	
+    	try
+    	{
+	    	in = new BufferedReader(new FileReader(f));
+	    	String line = null;
+	    	
+	    	while ((line = in.readLine()) != null)
+	    	{
+	    		line = line.trim();
+	            if ("".equals(line))
+	            {
+	                continue;
+	            }
+	            
+	            int n = 0;
+	            try
+	            {
+	            	n = Integer.parseInt(line);
+		    		list.add(n);	    		
+	            }
+	            catch(NumberFormatException e)
+	            {
+	            	ItemUpdate.pr("Error reading delete contents line:" + e.toString());
+	            }            	
+	    	}
+    	}
+    	finally
+    	{
+    		try
+    		{
+    			in.close();
+    		}
+    		catch(IOException e)
+    		{
+    			//skip
+    		}
+    	}
+    	
+    	return list;
+    }
+
+    /**
+     *    Get display of DCValue    
+	 *
+     * @param dcv
+     * @return string displaying elements of the DCValue
+     */
+    public static String getDCValueString(DCValue dcv)
+    {
+    	return "schema: " + dcv.schema + "; element: " + dcv.element + "; qualifier: " + dcv.qualifier +
+    	       "; language: " + dcv.language + "; value: " + dcv.value;
+    }
+
+	/**
+	 * 
+	 * @return a String representation of the two- or three-part form of a metadata element
+	 *         e.g. dc.identifier.uri
+	 */
+	public static  String getCompoundForm(String schema, String element, String qualifier)
+	{
+		StringBuilder sb = new StringBuilder();
+		sb.append(schema).append(".").append(element);
+		
+		if (qualifier != null)
+		{
+			sb.append(".").append(qualifier);
+		}
+		return sb.toString();
+	}
+	
+	/**
+	 *    Parses metadata field given in the form <schema>.<element>[.<qualifier>|.*]
+	 *    checks for correct number of elements (2 or 3) and for empty strings
+	 *    
+	 *    @return String Array
+	 *    @throws ParseException if validity checks fail
+	 *    
+	 */
+	public static String[] parseCompoundForm(String compoundForm)
+	throws ParseException
+	{
+		String[] ar = compoundForm.split("\\s*\\.\\s*");  //trim ends
+				
+		if (ar[0].equals(""))
+		{
+			throw new ParseException("schema is empty string: " + compoundForm, 0);
+		}
+		
+		if ((ar.length < 2) || (ar.length > 3) || ar[1].equals(""))
+		{
+			throw new ParseException("element is malformed or empty string: " + compoundForm, 0);
+		}
+		
+		return ar;
+	}
+	
+} 

dspace-api/src/main/java/org/dspace/app/itemupdate/OriginalBitstreamFilter.java

@@ -0,0 +1,85 @@
+/*
+ * OriginalBitstreamFilter.java
+ * 
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.sql.SQLException;
+
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+
+/** 
+ * 		Filter all bitstreams in the ORIGINAL bundle
+ *      Also delete all derivative bitstreams, i.e.
+ *      all bitstreams in the TEXT and THUMBNAIL bundles
+ */
+public class OriginalBitstreamFilter extends BitstreamFilterByBundleName 
+{	
+	public OriginalBitstreamFilter()
+	{
+		//empty
+	}
+	
+	/**
+	 *   Tests bitstreams for containment in an ORIGINAL bundle
+	 *  
+	 *  @returns true if the bitstream is in the ORIGINAL bundle
+	 *  
+	 *  @throws BitstreamFilterException
+	 */
+	public boolean accept(Bitstream bitstream) 
+	throws BitstreamFilterException
+	{		
+		try
+		{
+			Bundle[] bundles = bitstream.getBundles();
+			for (Bundle b : bundles)
+			{
+				if (b.getName().equals("ORIGINAL"))
+				{
+					return true;
+				}
+			}		
+		}
+		catch(SQLException e)
+		{
+			throw new BitstreamFilterException(e);
+		}
+		return false;
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/OriginalWithDerivativesBitstreamFilter.java

@@ -0,0 +1,89 @@
+/*
+ * OriginalWithDerivativesBitstreamFilter.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.sql.SQLException;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+
+/** 
+ * 		Filter all bitstreams in the ORIGINAL bundle
+ *      Also delete all derivative bitstreams, i.e.
+ *      all bitstreams in the TEXT and THUMBNAIL bundles
+ */
+public class OriginalWithDerivativesBitstreamFilter extends BitstreamFilter 
+{
+	private String[] bundlesToEmpty = { "ORIGINAL", "TEXT", "THUMBNAIL" };	
+	
+	public OriginalWithDerivativesBitstreamFilter()
+	{
+		//empty
+	}
+	
+	/**
+	 * 	Tests bitstream for membership in specified bundles (ORIGINAL, TEXT, THUMBNAIL)
+	 * 
+	 * @param bitstream
+	 * @throws BitstreamFilterException
+	 * @returns true if bitstream is in specified bundles
+	 */
+	public boolean accept(Bitstream bitstream) 
+	throws BitstreamFilterException
+	{		
+		try
+		{
+			Bundle[] bundles = bitstream.getBundles();
+			for (Bundle b : bundles)
+			{
+				for (String bn : bundlesToEmpty)
+				{
+					if (b.getName().equals(bn))
+					{
+						return true;
+					}
+				}
+			}		
+		}
+		catch(SQLException e)
+		{
+			throw new BitstreamFilterException(e);
+		}
+		return false;
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/ThumbnailBitstreamFilter.java

@@ -0,0 +1,54 @@
+/*
+ * ThumbnailBitstreamFilter.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.util.Properties;
+
+/**
+ *    Bitstream filter targetting the THUMBNAIL bundle
+ *
+ */
+public class ThumbnailBitstreamFilter extends BitstreamFilterByBundleName {
+	
+	public ThumbnailBitstreamFilter()
+	{
+		props = new Properties();
+		props.setProperty("bundle", "THUMBNAIL");
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateAction.java

@@ -0,0 +1,60 @@
+/*
+ * UpdateAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import org.dspace.core.Context;
+
+/**
+ *    Interface for actions to update an item
+ *
+ */
+public interface UpdateAction 
+{
+	/**
+	 *   Action to update item
+	 * 
+	 * @param context
+	 * @param itarch
+	 * @param isTest
+	 * @param suppressUndo
+	 * @throws Exception
+	 */
+	public void execute(Context context, ItemArchive itarch, boolean isTest, boolean suppressUndo) 
+	throws Exception;
+	
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateBitstreamsAction.java

@@ -0,0 +1,69 @@
+/*
+ * UpdateBitstreamsAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+/**
+ * 	  Base class for Bitstream actions
+ * 
+ *
+ */
+public abstract class UpdateBitstreamsAction implements UpdateAction {
+
+	protected boolean alterProvenance = true;
+
+	/**
+	 *        Set variable to indicate that the dc.description.provenance field may 
+	 *        be changed as a result of Bitstream changes by ItemUpdate
+	 * @param alterProvenance
+	 */
+	public void setAlterProvenance(boolean alterProvenance)
+	{
+		this.alterProvenance = alterProvenance;
+	}
+	
+	/**
+	 * 
+	 * @return boolean value to indicate whether the dc.description.provenance field may 
+	 *        be changed as a result of Bitstream changes by ItemUpdate
+	 */
+	public boolean getAlterProvenance()
+	{
+		return alterProvenance;
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateMetadataAction.java

@@ -0,0 +1,100 @@
+/*
+ * UpdateMetadataAction.java
+ *
+ * Version: $Revision: 3984 $
+ *
+ * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.itemupdate;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ *   This abstract subclass for metadata actions
+ *   maintains a collection for the target metadata fields
+ *   expressed as a string in the compound notation ( <schema>.<element>.<qualifier> )
+ *   on which to apply the action when the method execute is called.
+ * 
+ *   Implemented as a Set to avoid problems with duplicates
+ * 
+ *
+ */
+public abstract class UpdateMetadataAction implements UpdateAction {
+
+	protected Set<String> targetFields = new HashSet<String>();
+	
+    /**
+     *   Get target fields
+     *   
+     * @return set of fields to update
+     */
+	public Set<String> getTargetFields() {
+		return targetFields;
+	}
+
+	/**
+	 *   Set target fields
+	 *   
+	 * @param targetFields
+	 */
+	public void addTargetFields(Set<String> targetFields) {
+		for (String tf : targetFields)
+		{
+			this.targetFields.add(tf);
+		}
+		
+	}
+
+	/**
+	 *    Add array of target fields to update
+	 * @param targetFields
+	 */
+	public void addTargetFields(String[] targetFields) {
+		for (String tf : targetFields)
+		{
+			this.targetFields.add(tf);
+		}
+		
+	}
+
+	/**
+	 *   Add single field to update
+	 * 
+	 * @param targetField
+	 */
+	public void addTargetField(String targetField) {
+			this.targetFields.add(targetField);
+	}
+
+}

dspace-api/src/main/java/org/dspace/app/launcher/ScriptLauncher.java

@@ -0,0 +1,285 @@
+/*
+ * ScriptLauncher.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, Duraspace.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Duraspace nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.launcher;
+
+import org.dspace.core.ConfigurationManager;
+import org.dspace.servicemanager.DSpaceKernelImpl;
+import org.dspace.servicemanager.DSpaceKernelInit;
+import org.dspace.services.RequestService;
+import org.jdom.Document;
+import org.jdom.Element;
+import org.jdom.input.SAXBuilder;
+import java.util.List;
+import java.lang.reflect.Method;
+
+/**
+ * A DSpace script launcher.
+ *
+ * @author Stuart Lewis
+ * @author Mark Diggory
+ */
+public class ScriptLauncher
+{
+    /** The service manager kernel */
+    private static transient DSpaceKernelImpl kernelImpl;
+
+    /**
+     * Execute the DSpace script launcher
+     *
+     * @param args Any parameters required to be passed to the scripts it executes
+     * @throws Exception
+     */
+    public static void main(String[] args)
+    {
+        // Check that there is at least one argument
+        if (args.length < 1)
+        {
+            System.err.println("You must provide at least one command argument");
+            display();
+            System.exit(1);
+        }
+
+        // Initalise the service manager kernel
+        try {
+            kernelImpl = DSpaceKernelInit.getKernel(null);
+            if (!kernelImpl.isRunning())
+            {
+                kernelImpl.start(ConfigurationManager.getProperty("dspace.dir"));
+            }
+        } catch (Exception e)
+        {
+            // Failed to start so destroy it and log and throw an exception
+            try
+            {
+                kernelImpl.destroy();
+            }
+            catch (Exception e1)
+            {
+                // Nothing to do
+            }
+            String message = "Failure during filter init: " + e.getMessage();
+            System.err.println(message + ":" + e);
+            throw new RuntimeException(message, e);
+        }
+
+        // Parse the configuration file looking for the command entered
+        Document doc = getConfig();
+        String request = args[0];
+        Element root = doc.getRootElement();
+        List<Element> commands = root.getChildren("command");
+        for (Element command : commands)
+        {
+            if (request.equalsIgnoreCase(command.getChild("name").getValue()))
+            {
+                // Run each step
+                List<Element> steps = command.getChildren("step");
+                for (Element step : steps)
+                {
+                    // Instantiate the class
+                    Class target = null;
+                    String className = step.getChild("class").getValue();
+                    try
+                    {
+                        target = Class.forName(className,
+                                               true,
+                                               Thread.currentThread().getContextClassLoader());
+                    }
+                    catch (ClassNotFoundException e)
+                    {
+                        System.err.println("Error in launcher.xml: Invalid class name: " + className);
+                        System.exit(1);
+                    }
+
+                    // Strip the leading argument from the args, and add the arguments
+                    // Set <passargs>false</passargs> if the arguments should not be passed on
+                    String[] useargs = args.clone();
+                    Class[] argTypes = {useargs.getClass()};
+                    boolean passargs = true;
+                    if ((step.getAttribute("passuserargs") != null) &&
+                        ("false".equalsIgnoreCase(step.getAttribute("passuserargs").getValue())))
+                    {
+                        passargs = false;
+                    }
+                    if ((args.length == 1) || (!passargs))
+                    {
+                        useargs = new String[0];
+                    }
+                    else
+                    {
+                        String[] argsnew = new String[useargs.length - 1];
+                        for (int i = 1; i < useargs.length; i++)
+                        {
+                            argsnew[i - 1] = useargs[i];
+                        }
+                        useargs = argsnew;
+                    }
+
+                    // Add any extra properties
+                    List<Element> bits = step.getChildren("argument");
+                    if (step.getChild("argument") != null)
+                    {
+                        String[] argsnew = new String[useargs.length + bits.size()];
+                        int i = 0;
+                        for (Element arg : bits)
+                        {
+                            argsnew[i++] = arg.getValue();
+                        }
+                        for (; i < bits.size() + useargs.length; i++)
+                        {
+                            argsnew[i] = useargs[i - bits.size()];
+                        }
+                        useargs = argsnew;
+                    }
+
+                    // Establish the request service startup
+                    RequestService requestService = kernelImpl.getServiceManager().getServiceByName(RequestService.class.getName(), RequestService.class);
+                    if (requestService == null) {
+                        throw new IllegalStateException("Could not get the DSpace RequestService to start the request transaction");
+                    }
+
+                    // Establish a request related to the current session
+                    // that will trigger the various request listeners
+                    requestService.startRequest();
+                    
+                    // Run the main() method
+                    try
+                    {
+                        Object[] arguments = {useargs};
+
+                        // Useful for debugging, so left in the code...
+                        /**System.out.print("About to execute: " + className);
+                        for (String param : useargs)
+                        {
+                            System.out.print(" " + param);
+                        }
+                        System.out.println("");**/
+                        
+                        Method main = target.getMethod("main", argTypes);
+                        Object output = main.invoke(null, arguments);
+
+                        // ensure we close out the request (happy request)
+                        requestService.endRequest(null);
+                       
+                        
+                    }
+                    catch (Exception e)
+                    {
+                        // Failure occurred in the request so we destroy it
+                        requestService.endRequest(e);
+                        
+                    	if (kernelImpl != null)
+                        {
+                            kernelImpl.destroy();
+                            kernelImpl = null;
+                        }
+                    	
+                        // Exceptions from the script are reported as a 'cause'
+                        Throwable cause = e.getCause();
+                        System.err.println("Exception: " + cause.getMessage());
+                        cause.printStackTrace();
+                        System.exit(1);
+                    }
+                    
+                }
+
+                // Destroy the service kernel
+                if (kernelImpl != null)
+                {
+                    kernelImpl.destroy();
+                    kernelImpl = null;
+                }
+                
+                System.exit(0);
+            }
+        }
+
+        // Destroy the service kernel if it is still alive
+        if (kernelImpl != null)
+        {
+            kernelImpl.destroy();
+            kernelImpl = null;
+        }
+        
+        // The command wasn't found
+        System.err.println("Command not found: " + args[0]);
+        display();
+        System.exit(1);
+    }
+
+    /**
+     * Load the launcher configuration file
+     *
+     * @return The XML configuration file Document
+     */
+    private static Document getConfig()
+    {
+        // Load the launcher configuration file
+        String config = ConfigurationManager.getProperty("dspace.dir") +
+                        System.getProperty("file.separator") + "config" +
+                        System.getProperty("file.separator") + "launcher.xml";
+        SAXBuilder saxBuilder = new SAXBuilder();
+        Document doc = null;
+        try
+        {
+            doc = saxBuilder.build(config);
+        }
+        catch (Exception e)
+        {
+            System.err.println("Unable to load the launcher configuration file: [dspace]/config/launcher.xml");
+            System.err.println(e.getMessage());
+            System.exit(1);
+        }
+        return doc;
+    }
+
+    /**
+     * Display the commands that the current launcher config file knows about
+     */
+    private static void display()
+    {
+        Document doc = getConfig();
+        List<Element> commands = doc.getRootElement().getChildren("command");
+        System.out.println("Usage: dspace [command-name] {parameters}");
+        for (Element command : commands)
+        {
+            System.out.println(" - " + command.getChild("name").getValue() +
+                               ": " + command.getChild("description").getValue());
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/mediafilter/Brand.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2006, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/mediafilter/BrandText.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2006, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/mediafilter/BrandedPreviewJPEGFilter.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -182,7 +180,7 @@ public class BrandedPreviewJPEGFilter extends MediaFilter
         Brand brand = new Brand((int) xsize, brandHeight, new Font(brandFont, Font.PLAIN, brandFontPoint), 5);
 		BufferedImage brandImage = brand.create(ConfigurationManager.getProperty("webui.preview.brand"),
 												ConfigurationManager.getProperty("webui.preview.brand.abbrev"),
-												item == null ? "" : "hdl:" + item.getHandle());
+												MediaFilterManager.getCurrentItem() == null ? "" : "hdl:" + MediaFilterManager.getCurrentItem().getHandle());
 		
 		g2d.drawImage(brandImage, (int)0, (int)ysize, (int) xsize, (int) 20, null);
 

dspace-api/src/main/java/org/dspace/app/mediafilter/FormatFilter.java

@@ -0,0 +1,133 @@
+/*
+ * FormatFilter.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.InputStream;
+
+import org.dspace.content.Bitstream;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ * Public interface for any class which transforms or converts content/bitstreams 
+ * from one format to another.  This interface should be implemented by any class
+ * which defines a "filter" to be run by the MediaFilterManager.
+ */
+public interface FormatFilter
+{
+    /**
+     * Get a filename for a newly created filtered bitstream
+     * 
+     * @param sourceName
+     *            name of source bitstream
+     * @return filename generated by the filter - for example, document.pdf
+     *         becomes document.pdf.txt
+     */
+    public String getFilteredName(String sourceName);
+
+    /**
+     * @return name of the bundle this filter will stick its generated
+     *         Bitstreams
+     */
+    public String getBundleName();
+
+    /**
+     * @return name of the bitstream format (say "HTML" or "Microsoft Word")
+     *         returned by this filter look in the bitstream format registry or
+     *         mediafilter.cfg for valid format strings.
+     */
+    public String getFormatString();
+
+    /**
+     * @return string to describe the newly-generated Bitstream's - how it was
+     *         produced is a good idea
+     */
+    public String getDescription();
+
+    /**
+     * @param source
+     *            input stream
+     * 
+     * @return result of filter's transformation, written out to a bitstream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception;
+
+    /**
+     * Perform any pre-processing of the source bitstream *before* the actual 
+     * filtering takes place in MediaFilterManager.processBitstream().
+     * <p>
+     * Return true if pre-processing is successful (or no pre-processing
+     * is necessary).  Return false if bitstream should be skipped
+     * for any reason.
+     * 
+     * 
+     * @param c
+     *            context
+     * @param item
+     *            item containing bitstream to process
+     * @param source
+     *            source bitstream to be processed
+     * 
+     * @return true if bitstream processing should continue, 
+     * 			false if this bitstream should be skipped
+     */
+    public boolean preProcessBitstream(Context c, Item item, Bitstream source)
+            throws Exception;
+        
+    /**
+     * Perform any post-processing of the generated bitstream *after* this
+     * filter has already been run.
+     * <p>
+     * Return true if pre-processing is successful (or no pre-processing
+     * is necessary).  Return false if bitstream should be skipped
+     * for some reason.
+     * 
+     * 
+     * @param c
+     *            context
+     * @param item
+     *            item containing bitstream to process
+     * @param generatedBitstream
+     *            the bitstream which was generated by
+     *            this filter.
+     */
+    public void postProcessBitstream(Context c, Item item, Bitstream generatedBitstream)
+            throws Exception;
+}
+

dspace-api/src/main/java/org/dspace/app/mediafilter/HTMLFilter.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/mediafilter/JPEGFilter.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/mediafilter/MediaFilter.java

@@ -0,0 +1,100 @@
+/*
+ * MediaFilter.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.mediafilter;
+
+import org.dspace.content.Bitstream;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+
+/**
+ * Abstract class which defines the default settings for a *simple* Media or Format Filter. 
+ * This class may be extended by any class which wishes to define a simple filter to be run 
+ * by the MediaFilterManager.  More complex filters should likely implement the FormatFilter
+ * interface directly, so that they can define their own pre/postProcessing methods.
+ */
+public abstract class MediaFilter implements FormatFilter
+{
+	/**
+     * Perform any pre-processing of the source bitstream *before* the actual 
+     * filtering takes place in MediaFilterManager.processBitstream().
+     * <p>
+     * Return true if pre-processing is successful (or no pre-processing
+     * is necessary).  Return false if bitstream should be skipped
+     * for any reason.
+     * 
+     * 
+     * @param c
+     *            context
+     * @param item
+     *            item containing bitstream to process
+     * @param source
+     *            source bitstream to be processed
+     * 
+     * @return true if bitstream processing should continue, 
+     *          false if this bitstream should be skipped
+     */
+    public boolean preProcessBitstream(Context c, Item item, Bitstream source)
+            throws Exception
+    {
+        return true;  //default to no pre-processing
+    }
+     
+    /**
+     * Perform any post-processing of the generated bitstream *after* this
+     * filter has already been run.
+     * <p>
+     * Return true if pre-processing is successful (or no pre-processing
+     * is necessary).  Return false if bitstream should be skipped
+     * for some reason.
+     * 
+     * 
+     * @param c
+     *            context
+     * @param item
+     *            item containing bitstream to process
+     * @param generatedBitstream
+     *            the bitstream which was generated by
+     *            this filter.
+     */
+    public void postProcessBitstream(Context c, Item item, Bitstream generatedBitstream)
+            throws Exception
+    {
+        //default to no post-processing necessary
+    }
+}

dspace-api/src/main/java/org/dspace/app/mediafilter/MediaFilterManager.java

@@ -0,0 +1,767 @@
+/*
+ * MediaFilterManager.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.mediafilter;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.MissingArgumentException;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.OptionBuilder;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.PosixParser;
+
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.content.Bitstream;
+import org.dspace.content.BitstreamFormat;
+import org.dspace.content.Bundle;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.content.DCDate;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.Item;
+import org.dspace.content.ItemIterator;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.core.PluginManager;
+import org.dspace.core.SelfNamedPlugin;
+import org.dspace.handle.HandleManager;
+import org.dspace.search.DSIndexer;
+
+/**
+ * MediaFilterManager is the class that invokes the media/format filters over the
+ * repository's content. a few command line flags affect the operation of the
+ * MFM: -v verbose outputs all extracted text to STDOUT; -f force forces all
+ * bitstreams to be processed, even if they have been before; -n noindex does not
+ * recreate index after processing bitstreams; -i [identifier] limits processing 
+ * scope to a community, collection or item; and -m [max] limits processing to a
+ * maximum number of items.
+ */
+public class MediaFilterManager
+{
+	//key (in dspace.cfg) which lists all enabled filters by name
+    public static String MEDIA_FILTER_PLUGINS_KEY = "filter.plugins";
+	
+    //prefix (in dspace.cfg) for all filter properties
+    public static String FILTER_PREFIX = "filter";
+    
+    //suffix (in dspace.cfg) for input formats supported by each filter
+    public static String INPUT_FORMATS_SUFFIX = "inputFormats";
+    
+    public static boolean updateIndex = true; // default to updating index
+
+    public static boolean isVerbose = false; // default to not verbose
+
+    public static boolean isQuiet = false; // default is noisy
+
+    public static boolean isForce = false; // default to not forced
+    
+    public static String identifier = null; // object scope limiter
+    
+    public static int max2Process = Integer.MAX_VALUE;  // maximum number items to process
+    
+    public static int processed = 0;   // number items processed
+    
+    private static Item currentItem = null;   // current item being processed
+    
+    private static FormatFilter[] filterClasses = null;
+    
+    private static Map filterFormats = new HashMap();
+    
+    private static List skipList = null; //list of identifiers to skip during processing
+    
+    //separator in filterFormats Map between a filter class name and a plugin name,
+    //for MediaFilters which extend SelfNamedPlugin (\034 is "file separator" char)
+    public static String FILTER_PLUGIN_SEPARATOR = "\034";
+    
+    public static void main(String[] argv) throws Exception
+    {
+        // set headless for non-gui workstations
+        System.setProperty("java.awt.headless", "true");
+
+        // create an options object and populate it
+        CommandLineParser parser = new PosixParser();
+
+        int status = 0;
+
+        Options options = new Options();
+        
+        options.addOption("v", "verbose", false,
+                "print all extracted text and other details to STDOUT");
+        options.addOption("q", "quiet", false,
+                "do not print anything except in the event of errors.");
+        options.addOption("f", "force", false,
+                "force all bitstreams to be processed");
+        options.addOption("n", "noindex", false,
+                "do NOT update the search index after filtering bitstreams");
+        options.addOption("i", "identifier", true,
+        		"ONLY process bitstreams belonging to identifier");
+        options.addOption("m", "maximum", true,
+				"process no more than maximum items");
+        options.addOption("h", "help", false, "help");
+
+        //create a "plugin" option (to specify specific MediaFilter plugins to run)
+        OptionBuilder.withLongOpt("plugins");
+        OptionBuilder.withValueSeparator(',');
+        OptionBuilder.withDescription(
+                       "ONLY run the specified Media Filter plugin(s)\n" +
+                       "listed from '" + MEDIA_FILTER_PLUGINS_KEY + "' in dspace.cfg.\n" + 
+                       "Separate multiple with a comma (,)\n" +
+                       "(e.g. MediaFilterManager -p \n\"Word Text Extractor\",\"PDF Text Extractor\")");                
+        Option pluginOption = OptionBuilder.create('p');
+        pluginOption.setArgs(Option.UNLIMITED_VALUES); //unlimited number of args
+        options.addOption(pluginOption);	
+        
+         //create a "skip" option (to specify communities/collections/items to skip)
+        OptionBuilder.withLongOpt("skip");
+        OptionBuilder.withValueSeparator(',');
+        OptionBuilder.withDescription(
+                "SKIP the bitstreams belonging to identifier\n" + 
+                "Separate multiple identifiers with a comma (,)\n" +
+                "(e.g. MediaFilterManager -s \n 123456789/34,123456789/323)");                
+        Option skipOption = OptionBuilder.create('s');
+        skipOption.setArgs(Option.UNLIMITED_VALUES); //unlimited number of args
+        options.addOption(skipOption);    
+        
+        CommandLine line = null;
+        try
+        {
+            line = parser.parse(options, argv);
+        }
+        catch(MissingArgumentException e)
+        {
+            System.out.println("ERROR: " + e.getMessage());
+            HelpFormatter myhelp = new HelpFormatter();
+            myhelp.printHelp("MediaFilterManager\n", options);
+            System.exit(1);
+        }          
+
+        if (line.hasOption('h'))
+        {
+            HelpFormatter myhelp = new HelpFormatter();
+            myhelp.printHelp("MediaFilterManager\n", options);
+
+            System.exit(0);
+        }
+
+        if (line.hasOption('v'))
+        {
+            isVerbose = true;
+        }
+
+        isQuiet = line.hasOption('q');
+
+        if (line.hasOption('n'))
+        {
+            updateIndex = false;
+        }
+
+        if (line.hasOption('f'))
+        {
+            isForce = true;
+        }
+        
+        if (line.hasOption('i'))
+        {
+        	identifier = line.getOptionValue('i');
+        }
+        
+        if (line.hasOption('m'))
+        {
+        	max2Process = Integer.parseInt(line.getOptionValue('m'));
+        	if (max2Process <= 1)
+        	{
+        		System.out.println("Invalid maximum value '" + 
+        				     		line.getOptionValue('m') + "' - ignoring");
+        		max2Process = Integer.MAX_VALUE;
+        	}
+        }
+
+        String filterNames[] = null;
+        if(line.hasOption('p'))
+        {
+            //specified which media filter plugins we are using
+            filterNames = line.getOptionValues('p');
+        
+            if(filterNames==null || filterNames.length==0)
+            {   //display error, since no plugins specified
+                System.err.println("\nERROR: -p (-plugin) option requires at least one plugin to be specified.\n" +
+                                          "(e.g. MediaFilterManager -p \"Word Text Extractor\",\"PDF Text Extractor\")\n");
+                HelpFormatter myhelp = new HelpFormatter();
+                myhelp.printHelp("MediaFilterManager\n", options);
+                System.exit(1);
+             }
+        }
+        else
+        { 
+            //retrieve list of all enabled media filter plugins!
+            String enabledPlugins = ConfigurationManager.getProperty(MEDIA_FILTER_PLUGINS_KEY);
+            filterNames = enabledPlugins.split(",\\s*");
+        }
+                
+        //initialize an array of our enabled filters
+        List filterList = new ArrayList();
+                
+        //set up each filter
+        for(int i=0; i< filterNames.length; i++)
+        {
+            //get filter of this name & add to list of filters
+            FormatFilter filter = (FormatFilter) PluginManager.getNamedPlugin(FormatFilter.class, filterNames[i]);
+            if(filter==null)
+            {   
+                System.err.println("\nERROR: Unknown MediaFilter specified (either from command-line or in dspace.cfg): '" + filterNames[i] + "'");
+                System.exit(1);
+            }
+            else
+            {   
+                filterList.add(filter);
+                       
+                String filterClassName = filter.getClass().getName();
+                           
+                String pluginName = null;
+                           
+                //If this filter is a SelfNamedPlugin,
+                //then the input formats it accepts may differ for
+                //each "named" plugin that it defines.
+                //So, we have to look for every key that fits the
+                //following format: filter.<class-name>.<plugin-name>.inputFormats
+                if( SelfNamedPlugin.class.isAssignableFrom(filter.getClass()) )
+                {
+                    //Get the plugin instance name for this class
+                    pluginName = ((SelfNamedPlugin) filter).getPluginInstanceName();
+                }
+            
+                
+                //Retrieve our list of supported formats from dspace.cfg
+                //For SelfNamedPlugins, format of key is:  
+                //  filter.<class-name>.<plugin-name>.inputFormats
+                //For other MediaFilters, format of key is: 
+                //  filter.<class-name>.inputFormats
+                String formats = ConfigurationManager.getProperty(
+                    FILTER_PREFIX + "." + filterClassName + 
+                    (pluginName!=null ? "." + pluginName : "") +
+                    "." + INPUT_FORMATS_SUFFIX);
+            
+                //add to internal map of filters to supported formats	
+                if (formats != null)
+                {
+                    //For SelfNamedPlugins, map key is:  
+                    //  <class-name><separator><plugin-name>
+                    //For other MediaFilters, map key is just:
+                    //  <class-name>
+                    filterFormats.put(filterClassName + 
+        	            (pluginName!=null ? FILTER_PLUGIN_SEPARATOR + pluginName : ""),
+        	            Arrays.asList(formats.split(",[\\s]*")));
+                }
+            }//end if filter!=null
+        }//end for
+        
+        //If verbose, print out loaded mediafilter info
+        if(isVerbose)
+        {   
+            System.out.println("The following MediaFilters are enabled: ");
+            java.util.Iterator i = filterFormats.keySet().iterator();
+            while(i.hasNext())
+            {
+                String filterName = (String) i.next();
+                System.out.println("Full Filter Name: " + filterName);
+                String pluginName = null;
+                if(filterName.contains(FILTER_PLUGIN_SEPARATOR))
+                {
+                    String[] fields = filterName.split(FILTER_PLUGIN_SEPARATOR);
+                    filterName=fields[0];
+                    pluginName=fields[1];
+                }
+                 
+                System.out.println(filterName +
+                        (pluginName!=null? " (Plugin: " + pluginName + ")": ""));
+             }
+        }
+              
+        //store our filter list into an internal array
+        filterClasses = (FormatFilter[]) filterList.toArray(new FormatFilter[filterList.size()]);
+        
+        
+        //Retrieve list of identifiers to skip (if any)
+        String skipIds[] = null;
+        if(line.hasOption('s'))
+        {
+            //specified which identifiers to skip when processing
+            skipIds = line.getOptionValues('s');
+            
+            if(skipIds==null || skipIds.length==0)
+            {   //display error, since no identifiers specified to skip
+                System.err.println("\nERROR: -s (-skip) option requires at least one identifier to SKIP.\n" +
+                                    "Make sure to separate multiple identifiers with a comma!\n" +
+                                    "(e.g. MediaFilterManager -s 123456789/34,123456789/323)\n");
+                HelpFormatter myhelp = new HelpFormatter();
+                myhelp.printHelp("MediaFilterManager\n", options);
+                System.exit(0);
+            }
+            
+            //save to a global skip list
+            skipList = Arrays.asList(skipIds);
+        }
+        
+        Context c = null;
+
+        try
+        {
+            c = new Context();
+
+            // have to be super-user to do the filtering
+            c.setIgnoreAuthorization(true);
+
+            // now apply the filters
+            if (identifier == null)
+            {
+            	applyFiltersAllItems(c);
+            }
+            else  // restrict application scope to identifier
+            {
+            	DSpaceObject dso = HandleManager.resolveToObject(c, identifier);
+            	if (dso == null)
+            	{
+            		throw new IllegalArgumentException("Cannot resolve "
+                                + identifier + " to a DSpace object");
+            	}
+            	
+            	switch (dso.getType())
+            	{
+            		case Constants.COMMUNITY:
+            						applyFiltersCommunity(c, (Community)dso);
+            						break;					
+            		case Constants.COLLECTION:
+            						applyFiltersCollection(c, (Collection)dso);
+            						break;						
+            		case Constants.ITEM:
+            						applyFiltersItem(c, (Item)dso);
+            						break;
+            	}
+            }
+          
+            // update search index?
+            if (updateIndex)
+            {
+                if (!isQuiet)
+                System.out.println("Updating search index:");
+                DSIndexer.updateIndex(c);
+            }
+
+            c.complete();
+            c = null;
+        }
+        catch (Exception e)
+        {
+            status = 1;
+        }
+        finally
+        {
+            if (c != null)
+            {
+                c.abort();
+            }
+        }
+        System.exit(status);
+    }
+
+    public static void applyFiltersAllItems(Context c) throws Exception
+    {
+        if(skipList!=null)
+        {    
+            //if a skip-list exists, we need to filter community-by-community
+            //so we can respect what is in the skip-list
+            Community[] topLevelCommunities = Community.findAllTop(c);
+          
+            for(int i=0; i<topLevelCommunities.length; i++)
+                applyFiltersCommunity(c, topLevelCommunities[i]);
+        }
+        else 
+        {
+            //otherwise, just find every item and process
+            ItemIterator i = Item.findAll(c);
+            try
+            {
+                while (i.hasNext() && processed < max2Process)
+                {
+                    applyFiltersItem(c, i.next());
+                }
+            }
+            finally
+            {
+                if (i != null)
+                    i.close();
+            }
+        }
+    }
+    
+    public static void applyFiltersCommunity(Context c, Community community)
+                                             throws Exception
+    {   //only apply filters if community not in skip-list
+        if(!inSkipList(community.getHandle()))
+        {    
+           	Community[] subcommunities = community.getSubcommunities();
+           	for (int i = 0; i < subcommunities.length; i++)
+           	{
+           		applyFiltersCommunity(c, subcommunities[i]);
+           	}
+           	
+           	Collection[] collections = community.getCollections();
+           	for (int j = 0; j < collections.length; j++)
+           	{
+           		applyFiltersCollection(c, collections[j]);
+           	}
+        }
+    }
+        
+    public static void applyFiltersCollection(Context c, Collection collection)
+                                              throws Exception
+    {
+        //only apply filters if collection not in skip-list
+        if(!inSkipList(collection.getHandle()))
+        {
+            ItemIterator i = collection.getItems();
+            try
+            {
+                while (i.hasNext() && processed < max2Process)
+                {
+                    applyFiltersItem(c, i.next());
+                }
+            }
+            finally
+            {
+                if (i != null)
+                    i.close();
+            }
+        }
+    }
+       
+    public static void applyFiltersItem(Context c, Item item) throws Exception
+    {
+        //only apply filters if item not in skip-list
+        if(!inSkipList(item.getHandle()))
+        {
+    	  //cache this item in MediaFilterManager
+    	  //so it can be accessed by MediaFilters as necessary
+    	  currentItem = item;
+    	
+          if (filterItem(c, item))
+          {
+        	  // commit changes after each filtered item
+        	  c.commit();
+              // increment processed count
+              ++processed;
+          }
+          // clear item objects from context cache and internal cache
+          item.decache();
+          currentItem = null;
+        }  
+    }
+
+    /**
+     * iterate through the item's bitstreams in the ORIGINAL bundle, applying
+     * filters if possible
+     * 
+     * @return true if any bitstreams processed, 
+     *         false if none
+     */
+    public static boolean filterItem(Context c, Item myItem) throws Exception
+    {
+        // get 'original' bundles
+        Bundle[] myBundles = myItem.getBundles("ORIGINAL");
+        boolean done = false;
+        for (int i = 0; i < myBundles.length; i++)
+        {
+        	// now look at all of the bitstreams
+            Bitstream[] myBitstreams = myBundles[i].getBitstreams();
+            
+            for (int k = 0; k < myBitstreams.length; k++)
+            {
+            	done |= filterBitstream(c, myItem, myBitstreams[k]);
+            }
+        }
+        return done;
+    }
+
+    /**
+     * Attempt to filter a bitstream
+     * 
+     * An exception will be thrown if the media filter class cannot be
+     * instantiated, exceptions from filtering will be logged to STDOUT and
+     * swallowed.
+     * 
+     * @return true if bitstream processed, 
+     *         false if no applicable filter or already processed
+     */
+    public static boolean filterBitstream(Context c, Item myItem,
+            Bitstream myBitstream) throws Exception
+    {
+    	boolean filtered = false;
+    	
+    	// iterate through filter classes. A single format may be actioned
+    	// by more than one filter
+    	for (int i = 0; i < filterClasses.length; i++)
+    	{
+    		//List fmts = (List)filterFormats.get(filterClasses[i].getClass().getName());
+    	    String pluginName = null;
+    	               
+    	    //if this filter class is a SelfNamedPlugin,
+    	    //its list of supported formats is different for
+    	    //differently named "plugin"
+    	    if( SelfNamedPlugin.class.isAssignableFrom(filterClasses[i].getClass()) )
+    	    {
+    	        //get plugin instance name for this media filter
+    	        pluginName = ((SelfNamedPlugin)filterClasses[i]).getPluginInstanceName();
+    	    }
+    	               
+    	    //Get list of supported formats for the filter (and possibly named plugin)
+    	    //For SelfNamedPlugins, map key is:  
+    	    //  <class-name><separator><plugin-name>
+    	    //For other MediaFilters, map key is just:
+    	    //  <class-name>
+    	    List fmts = (List)filterFormats.get(filterClasses[i].getClass().getName() + 
+    	                       (pluginName!=null ? FILTER_PLUGIN_SEPARATOR + pluginName : ""));
+    	   
+    	    if (fmts.contains(myBitstream.getFormat().getShortDescription()))
+    		{
+            	try
+            	{
+		            // only update item if bitstream not skipped
+		            if (processBitstream(c, myItem, myBitstream, filterClasses[i]))
+            	    {
+		           		myItem.update(); // Make sure new bitstream has a sequence
+		                                 	// number
+		           		filtered = true;
+		            }
+            	}
+                catch (Exception e)
+                {
+                	String handle = myItem.getHandle();
+                	Bundle[] bundles = myBitstream.getBundles();
+                	String name = myBitstream.getName();
+                	long size = myBitstream.getSize();
+                	String checksum = myBitstream.getChecksum() + " ("+myBitstream.getChecksumAlgorithm()+")";
+                	int assetstore = myBitstream.getStoreNumber();
+   
+                	// Printout helpfull information to find the errored bistream.
+                	System.out.println("ERROR filtering, skipping bitstream:\n");
+                	System.out.println("\tItem Handle: "+ handle);
+                	for (Bundle bundle : bundles)
+                	{
+                		System.out.println("\tBundle Name: " + bundle.getName());
+                	}
+                	System.out.println("\tFile Size: " + size);
+                	System.out.println("\tChecksum: " + checksum);
+                	System.out.println("\tAsset Store: " + assetstore);
+                	System.out.println(e);
+                    e.printStackTrace();
+                }
+    		}
+    	}
+        return filtered;
+    }
+    
+    /**
+     * processBitstream is a utility class that calls the virtual methods
+     * from the current MediaFilter class.
+     * It scans the bitstreams in an item, and decides if a bitstream has 
+     * already been filtered, and if not or if overWrite is set, invokes the 
+     * filter.
+     * 
+     * @param c
+     *            context
+     * @param item
+     *            item containing bitstream to process
+     * @param source
+     *            source bitstream to process
+     * @param formatFilter
+     *            FormatFilter to perform filtering
+     * 
+     * @return true if new rendition is created, false if rendition already
+     *         exists and overWrite is not set
+     */
+    public static boolean processBitstream(Context c, Item item, Bitstream source, FormatFilter formatFilter)
+            throws Exception
+    {
+        //do pre-processing of this bitstream, and if it fails, skip this bitstream!
+    	if(!formatFilter.preProcessBitstream(c, item, source))
+        	return false;
+        	
+    	boolean overWrite = MediaFilterManager.isForce;
+        
+        // get bitstream filename, calculate destination filename
+        String newName = formatFilter.getFilteredName(source.getName());
+
+        Bitstream existingBitstream = null; // is there an existing rendition?
+        Bundle targetBundle = null; // bundle we're modifying
+
+        Bundle[] bundles = item.getBundles(formatFilter.getBundleName());
+
+        // check if destination bitstream exists
+        if (bundles.length > 0)
+        {
+            // only finds the last match (FIXME?)
+            for (int i = 0; i < bundles.length; i++)
+            {
+                Bitstream[] bitstreams = bundles[i].getBitstreams();
+
+                for (int j = 0; j < bitstreams.length; j++)
+                {
+                    if (bitstreams[j].getName().equals(newName))
+                    {
+                        targetBundle = bundles[i];
+                        existingBitstream = bitstreams[j];
+                    }
+                }
+            }
+        }
+
+        // if exists and overwrite = false, exit
+        if (!overWrite && (existingBitstream != null))
+        {
+            if (!isQuiet)
+            System.out.println("SKIPPED: bitstream " + source.getID()
+                    + " (item: " + item.getHandle() + ") because '" + newName + "' already exists");
+
+            return false;
+        }
+        
+        InputStream destStream = formatFilter.getDestinationStream(source.retrieve());
+        if (destStream == null)
+        {
+            if (!isQuiet)
+            System.out.println("SKIPPED: bitstream " + source.getID()
+                    + " (item: " + item.getHandle() + ") because filtering was unsuccessful");
+
+            return false;
+        }
+
+        // create new bundle if needed
+        if (bundles.length < 1)
+        {
+            targetBundle = item.createBundle(formatFilter.getBundleName());
+        }
+        else
+        {
+            // take the first match
+            targetBundle = bundles[0];
+        }
+
+        Bitstream b = targetBundle.createBitstream(destStream);
+
+        // Now set the format and name of the bitstream
+        b.setName(newName);
+        b.setSource("Written by FormatFilter " + formatFilter.getClass().getName() +
+        			" on " + DCDate.getCurrent() + " (GMT)."); 
+        b.setDescription(formatFilter.getDescription());
+
+        // Find the proper format
+        BitstreamFormat bf = BitstreamFormat.findByShortDescription(c,
+                formatFilter.getFormatString());
+        b.setFormat(bf);
+        b.update();
+        
+        //Inherit policies from the source bitstream
+        //(first remove any existing policies)
+        AuthorizeManager.removeAllPolicies(c, b);
+        AuthorizeManager.inheritPolicies(c, source, b);
+
+        // fixme - set date?
+        // we are overwriting, so remove old bitstream
+        if (existingBitstream != null)
+        {
+            targetBundle.removeBitstream(existingBitstream);
+        }
+
+        if (!isQuiet)
+        System.out.println("FILTERED: bitstream " + source.getID()
+                + " (item: " + item.getHandle() + ") and created '" + newName + "'");
+
+        //do post-processing of the generated bitstream
+        formatFilter.postProcessBitstream(c, item, b);
+        
+        return true;
+    }
+    
+    /**
+     * Return the item that is currently being processed/filtered
+     * by the MediaFilterManager
+     * <p>
+     * This allows FormatFilters to retrieve the Item object
+     * in case they need access to item-level information for their format
+     * transformations/conversions.
+     * 
+     * @return current Item being processed by MediaFilterManager
+     */
+    public static Item getCurrentItem()
+    {
+        return currentItem;
+    }
+    
+    /**
+     * Check whether or not to skip processing the given identifier
+     * 
+     * @param identifier
+     *            identifier (handle) of a community, collection or item
+     *            
+     * @return true if this community, collection or item should be skipped
+     *          during processing.  Otherwise, return false.
+     */
+    public static boolean inSkipList(String identifier)
+    {
+        if(skipList!=null && skipList.contains(identifier))
+        {
+            if (!isQuiet)
+            System.out.println("SKIP-LIST: skipped bitstreams within identifier " + identifier);
+            return true;
+        }    
+        else
+            return false;
+    }
+    
+}

dspace-api/src/main/java/org/dspace/app/mediafilter/PDFFilter.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -41,11 +39,25 @@ package org.dspace.app.mediafilter;
 
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
+import java.io.Writer;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.FileInputStream;
+import java.io.BufferedWriter;
+import java.io.OutputStreamWriter;
+import java.io.FileOutputStream;
+import java.io.CharArrayWriter;
+import java.io.ByteArrayOutputStream;
+import java.util.List;
+import java.util.Iterator;
 
 import org.apache.log4j.Logger;
 import org.pdfbox.pdfparser.PDFParser;
 import org.pdfbox.pdmodel.PDDocument;
+import org.pdfbox.pdmodel.PDPage;
+import org.pdfbox.pdmodel.common.PDStream;
 import org.pdfbox.util.PDFTextStripper;
+import org.dspace.core.ConfigurationManager;
 
 /*
  *
@@ -97,44 +109,76 @@ public class PDFFilter extends MediaFilter
     public InputStream getDestinationStream(InputStream source)
             throws Exception
     {
+        try
+        {
+            boolean useTemporaryFile = ConfigurationManager.getBooleanProperty("pdffilter.largepdfs", false);
+
             // get input stream from bitstream
             // pass to filter, get string back
             PDFTextStripper pts = new PDFTextStripper();
-        PDFParser parser = null;
-        String extractedText = null;
+            PDDocument pdfDoc = null;
+            Writer writer = null;
+            File tempTextFile = null;
+            ByteArrayOutputStream byteStream = null;
+
+            if (useTemporaryFile)
+            {
+                tempTextFile = File.createTempFile("dspacepdfextract" + source.hashCode(), ".txt");
+                tempTextFile.deleteOnExit();
+                writer = new OutputStreamWriter(new FileOutputStream(tempTextFile));
+            }
+            else
+            {
+                byteStream = new ByteArrayOutputStream();
+                writer = new OutputStreamWriter(byteStream);
+            }
             
             try
             {
-            parser = new PDFParser(source);
-            parser.parse();
-            extractedText = pts.getText(new PDDocument(parser.getDocument()));
+                pdfDoc = PDDocument.load(source);
+                pts.writeText(pdfDoc, writer);
             }
             finally
             {
                 try
                 {
-                parser.getDocument().close();
+                    if (pdfDoc != null)
+                        pdfDoc.close();
                 }
                 catch(Exception e)
                 {
-               log.error("Error closing temporary PDF file: " + e.getMessage(), e);
-            }
+                   log.error("Error closing PDF file: " + e.getMessage(), e);
                 }
 
-        // if verbose flag is set, print out extracted text
-        // to STDOUT
-        if (MediaFilterManager.isVerbose)
+                try
                 {
-            System.out.println(extractedText);
+                    writer.close();
                 }
-
-
-        // generate an input stream with the extracted text
-        byte[] textBytes = extractedText.getBytes();
-        ByteArrayInputStream bais = new ByteArrayInputStream(textBytes);
-
-        return bais; // will this work? or will the byte array be out of scope?
-
-
+                catch(Exception e)
+                {
+                   log.error("Error closing temporary extract file: " + e.getMessage(), e);
+                }
+            }
+
+            if (useTemporaryFile)
+            {
+                return new FileInputStream(tempTextFile);
+            }
+            else
+            {
+                byte[] bytes = byteStream.toByteArray();
+                return new ByteArrayInputStream(bytes);
+            }
+        }
+        catch (OutOfMemoryError oome)
+        {
+            log.error("Error parsing PDF document " + oome.getMessage(), oome);
+            if (!ConfigurationManager.getBooleanProperty("pdffilter.skiponmemoryexception", false))
+            {
+                throw oome;
+            }
+        }
+
+        return null;
     }
 }

dspace-api/src/main/java/org/dspace/app/mediafilter/WordFilter.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/mediafilter/XPDF2Text.java

@@ -0,0 +1,178 @@
+package org.dspace.app.mediafilter;
+
+/*
+ * $HeadURL: $
+ *
+ * Version: $Revision: $
+ *
+ * Date: $Date: $
+ *
+  * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+import org.apache.log4j.Logger;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Utils;
+
+/**
+ * Text MediaFilter for PDF sources
+ *
+ * This filter produces extracted text suitable for building an index,
+ * but not for display to end users.
+ * It forks a process running the "pdftotext" program from the
+ * XPdf suite -- see http://www.foolabs.com/xpdf/
+ * This is a suite of open-source PDF tools that has been widely ported
+ * to Unix platforms and the ones we use (pdftoppm, pdftotext) even
+ * run on Win32.
+ *
+ * This was written for the FACADE project but it is not directly connected
+ * to any of the other FACADE-specific software.  The FACADE UI expects
+ * to find thumbnail images for 3D PDFs generated by this filter.
+ *
+ * Requires DSpace config properties keys:
+ *
+ *  xpdf.path.pdftotext -- path to "pdftotext" executable (required!)
+ *
+ * @author Larry Stone
+ * @see org.dspace.app.mediafilter.MediaFilter
+ */
+public class XPDF2Text extends MediaFilter
+{
+    private static Logger log = Logger.getLogger(XPDF2Text.class);
+
+    // Command to get text from pdf; @infile@, @COMMAND@ are placeholders
+    private static final String XPDF_PDFTOTEXT_COMMAND[] =
+    {
+        "@COMMAND@", "-q", "-enc", "UTF-8", "@infile@", "-"
+    };
+
+
+    // executable path that comes from DSpace config at runtime.
+    private String pdftotextPath = null;
+
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".txt";
+    }
+
+    public String getBundleName()
+    {
+        return "TEXT";
+    }
+
+    public String getFormatString()
+    {
+        return "Text";
+    }
+
+    public String getDescription()
+    {
+        return "Extracted Text";
+    }
+
+    public InputStream getDestinationStream(InputStream sourceStream)
+            throws Exception
+    {
+        // get configured value for path to XPDF command:
+        if (pdftotextPath == null)
+        {
+            pdftotextPath = ConfigurationManager.getProperty("xpdf.path.pdftotext");
+            if (pdftotextPath == null)
+                throw new IllegalStateException("No value for key \"xpdf.path.pdftotext\" in DSpace configuration!  Should be path to XPDF pdftotext executable.");
+        }
+
+        File sourceTmp = File.createTempFile("DSfilt",".pdf");
+        sourceTmp.deleteOnExit();  // extra insurance, we'll delete it here.
+        int status = -1;
+        try
+        {
+            // make local temp copy of source PDF since PDF tools
+            // require a file for random access.
+            // XXX fixme could optimize if we ever get an interface to grab asset *files*
+            OutputStream sto = new FileOutputStream(sourceTmp);
+            Utils.copy(sourceStream, sto);
+            sto.close();
+            sourceStream.close();
+
+            String pdfCmd[] = XPDF_PDFTOTEXT_COMMAND.clone();
+            pdfCmd[0] = pdftotextPath;
+            pdfCmd[4] = sourceTmp.toString();
+
+            log.debug("Running command: "+Arrays.deepToString(pdfCmd));
+            Process pdfProc = Runtime.getRuntime().exec(pdfCmd);
+            InputStream stdout = pdfProc.getInputStream();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            Utils.copy(new BufferedInputStream(stdout), baos);
+            stdout.close();
+            baos.close();
+
+            status = pdfProc.waitFor();
+            String msg = null;
+            if (status == 1)
+                msg = "pdftotext failed opening input: file="+sourceTmp.toString();
+            else if (status == 3)
+                msg = "pdftotext permission failure (perhaps copying of text from this document is not allowed - check PDF file's internal permissions): file="+sourceTmp.toString();
+            else if (status != 0)
+                msg = "pdftotext failed, maybe corrupt PDF? status="+String.valueOf(status);
+
+            if (msg != null)
+            {
+                log.error(msg);
+                throw new IOException(msg);
+            }
+
+            return new ByteArrayInputStream(baos.toByteArray());
+        }
+        catch (InterruptedException e)
+        {
+            log.error("Failed in pdftotext subprocess: ",e);
+            throw e;
+        }
+        finally
+        {
+            sourceTmp.delete();
+            if (status != 0)
+                log.error("PDF conversion proc failed, returns="+status+", file="+sourceTmp);
+        }
+    }
+}
+
+ 	  	 

dspace-api/src/main/java/org/dspace/app/mediafilter/XPDF2Thumbnail.java

@@ -0,0 +1,310 @@
+package org.dspace.app.mediafilter;
+
+/*
+ * $HeadURL: $
+ *
+ * Version: $Revision: $
+ *
+ * Date: $Date: $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.imageio.ImageIO;
+
+import org.apache.log4j.Logger;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Utils;
+
+/**
+ * Thumbnail MediaFilter for PDF sources
+ *
+ * This filter generates thumbnail images for PDF documents, _including_
+ * 3D PDF documents with 2D "poster" images.  Since the PDFBox library
+ * does not understand these, and fails to render a lot of other PDFs,
+ * this filter forks a process running the "pdftoppm" program from the
+ * XPdf suite -- see http://www.foolabs.com/xpdf/
+ * This is a suite of open-source PDF tools that has been widely ported
+ * to Unix platforms and the ones we use (pdftoppm, pdfinfo) even
+ * run on Win32.
+ *
+ * This was written for the FACADE project but it is not directly connected
+ * to any of the other FACADE-specific software.  The FACADE UI expects
+ * to find thumbnail images for 3D PDFs generated by this filter.
+ *
+ * Requires DSpace config properties keys:
+ *
+ *  xpdf.path.pdftoppm -- absolute path to "pdftoppm" executable (required!)
+ *  xpdf.path.pdfinfo -- absolute path to "pdfinfo" executable (required!)
+ *  thumbnail.maxwidth  -- borrowed from thumbnails, max dim of generated image
+ *
+ * @author Larry Stone
+ * @see org.dspace.app.mediafilter.MediaFilter
+ */
+public class XPDF2Thumbnail extends MediaFilter
+{
+    private static Logger log = Logger.getLogger(XPDF2Thumbnail.class);
+
+    // maximum size of either preview image dimension
+    private static final int MAX_PX = 800;
+
+    // maxium DPI - use common screen res, 100dpi.
+    private static final int MAX_DPI = 100;
+
+    // command to get image from PDF; @FILE@, @OUTPUT@ are placeholders
+    private static final String XPDF_PDFTOPPM_COMMAND[] =
+    {
+        "@COMMAND@", "-q", "-f", "1", "-l", "1",
+        "-r", "@DPI@", "@FILE@", "@OUTPUTFILE@"
+    };
+
+    // command to get image from PDF; @FILE@, @OUTPUT@ are placeholders
+    private static final String XPDF_PDFINFO_COMMAND[] =
+    {
+        "@COMMAND@", "-f", "1", "-l", "1", "-box", "@FILE@"
+    };
+
+    // executable path for "pdftoppm", comes from DSpace config at runtime.
+    private String pdftoppmPath = null;
+
+    // executable path for "pdfinfo", comes from DSpace config at runtime.
+    private String pdfinfoPath = null;
+
+    // match line in pdfinfo output that describes file's MediaBox
+    private static final Pattern MEDIABOX_PATT = Pattern.compile(
+        "^Page\\s+\\d+\\s+MediaBox:\\s+([\\.\\d-]+)\\s+([\\.\\d-]+)\\s+([\\.\\d-]+)\\s+([\\.\\d-]+)");
+
+    // also from thumbnail.maxwidth in config
+    private int maxwidth = 0;
+
+    // backup default for size, on the large side.
+    final private int DEFAULT_MAXWIDTH = 500;
+
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".jpg";
+    }
+
+    public String getBundleName()
+    {
+        return "THUMBNAIL";
+    }
+
+    public String getFormatString()
+    {
+        return "JPEG";
+    }
+
+    public String getDescription()
+    {
+        return "Generated Thumbnail";
+    }
+
+    // canonical MediaFilter method to generate the thumbnail as stream.
+    public InputStream getDestinationStream(InputStream sourceStream)
+            throws Exception
+    {
+        // sanity check: xpdf paths are required. can cache since it won't change
+        if (pdftoppmPath == null || pdfinfoPath == null)
+        {
+            pdftoppmPath = ConfigurationManager.getProperty("xpdf.path.pdftoppm");
+            pdfinfoPath = ConfigurationManager.getProperty("xpdf.path.pdfinfo");
+            if (pdftoppmPath == null)
+                throw new IllegalStateException("No value for key \"xpdf.path.pdftoppm\" in DSpace configuration!  Should be path to XPDF pdftoppm executable.");
+            if (pdfinfoPath == null)
+                throw new IllegalStateException("No value for key \"xpdf.path.pdfinfo\" in DSpace configuration!  Should be path to XPDF pdfinfo executable.");
+            maxwidth = ConfigurationManager.getIntProperty("thumbnail.maxwidth");
+            if (maxwidth == 0)
+                maxwidth = DEFAULT_MAXWIDTH;
+        }
+
+        // make local file copy of source PDF since the PDF tools
+        // require a file for random access.
+        // XXX fixme would be nice to optimize this if we ever get
+        // XXX  a DSpace method to access (optionally!) the _file_ of
+        //     a Bitstream in the asset store, only when there is one of course.
+        File sourceTmp = File.createTempFile("DSfilt",".pdf");
+        sourceTmp.deleteOnExit();
+        int status = 0;
+        BufferedImage source = null;
+        try
+        {
+            OutputStream sto = new FileOutputStream(sourceTmp);
+            Utils.copy(sourceStream, sto);
+            sto.close();
+            sourceStream.close();
+
+            // First get max physical dim of bounding box of first page
+            // to compute the DPI to ask for..  otherwise some AutoCAD
+            // drawings can produce enormous files even at 75dpi, for
+            // 48" drawings..
+
+            // run pdfinfo, look for MediaBox description in the output, e.g.
+            // "Page    1 MediaBox:     0.00     0.00   612.00   792.00"
+            //
+            int dpi = 0;
+            String pdfinfoCmd[] = XPDF_PDFINFO_COMMAND.clone();
+            pdfinfoCmd[0] = pdfinfoPath;
+            pdfinfoCmd[pdfinfoCmd.length-1] = sourceTmp.toString();
+            try
+            {
+                MatchResult mediaBox = null;
+                Process pdfProc = Runtime.getRuntime().exec(pdfinfoCmd);
+                BufferedReader lr = new BufferedReader(new InputStreamReader(pdfProc.getInputStream()));
+                String line;
+                for (line = lr.readLine(); line != null; line = lr.readLine())
+                {
+                    // if (line.matches(MEDIABOX_PATT))
+                    Matcher mm = MEDIABOX_PATT.matcher(line);
+                    if (mm.matches())
+                        mediaBox = mm.toMatchResult();
+                }
+                int istatus = pdfProc.waitFor();
+                if (istatus != 0)
+                    log.error("XPDF pdfinfo proc failed, exit status="+istatus+", file="+sourceTmp);
+                if (mediaBox == null)
+                {
+                    log.error("Sanity check: Did not find \"MediaBox\" line in output of XPDF pdfinfo, file="+sourceTmp);
+                    throw new IllegalArgumentException("Failed to get MediaBox of PDF with pdfinfo, cannot compute thumbnail.");
+                }
+                else
+                {
+                    float x0 = Float.parseFloat(mediaBox.group(1));
+                    float y0 = Float.parseFloat(mediaBox.group(2));
+                    float x1 = Float.parseFloat(mediaBox.group(3));
+                    float y1 = Float.parseFloat(mediaBox.group(4));
+                    int maxdim = (int)Math.max(Math.abs(x1 - x0), Math.abs(y1 - y0));
+                    dpi = Math.min(MAX_DPI, (MAX_PX * 72 / maxdim));
+                    log.debug("DPI: pdfinfo method got dpi="+dpi+" for max dim="+maxdim+" (points, 1/72\")");
+                }
+            }
+            catch (InterruptedException e)
+            {
+                log.error("Failed transforming file for preview: ",e);
+                throw new IllegalArgumentException("Failed transforming file for thumbnail: ",e);
+            }
+            catch (NumberFormatException e)
+            {
+                log.error("Failed interpreting pdfinfo results, check regexp: ",e);
+                throw new IllegalArgumentException("Failed transforming file for thumbnail: ",e);
+            }
+
+            // Render page 1 using xpdf's pdftoppm
+            // Requires Sun JAI imageio additions to read ppm directly.
+            // this will get "-000001.ppm" appended to it by pdftoppm
+            File outPrefixF = File.createTempFile("prevu","out");
+            String outPrefix = outPrefixF.toString();
+            outPrefixF.delete();
+            String pdfCmd[] = XPDF_PDFTOPPM_COMMAND.clone();
+            pdfCmd[0] = pdftoppmPath;
+            pdfCmd[pdfCmd.length-3] = String.valueOf(dpi);
+            pdfCmd[pdfCmd.length-2] = sourceTmp.toString();
+            pdfCmd[pdfCmd.length-1] = outPrefix;
+            File outf = new File(outPrefix+"-000001.ppm");
+            log.debug("Running xpdf command: "+Arrays.deepToString(pdfCmd));
+            try
+            {
+                Process pdfProc = Runtime.getRuntime().exec(pdfCmd);
+                status = pdfProc.waitFor();
+                log.debug("PDFTOPPM output is: "+outf+", exists="+outf.exists());
+                source = ImageIO.read(outf);
+            }
+            catch (InterruptedException e)
+            {
+                log.error("Failed transforming file for preview: ",e);
+                throw new IllegalArgumentException("Failed transforming file for preview: ",e);
+            }
+            finally
+            {
+                outf.delete();
+            }
+        }
+        finally
+        {
+            sourceTmp.delete();
+            if (status != 0)
+                log.error("PDF conversion proc failed, exit status="+status+", file="+sourceTmp);
+        }
+
+        if (source == null)
+            throw new IOException("Unknown failure while transforming file to preview: no image produced.");
+
+        // Scale image and return in-memory stream
+        BufferedImage toenail = scaleImage(source, maxwidth*3/4, maxwidth);
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ImageIO.write(toenail, "jpeg", baos);
+        return new ByteArrayInputStream(baos.toByteArray());
+    }
+
+    // scale the image, preserving aspect ratio, if at least one
+    // dimension is not between min and max.
+    private static BufferedImage scaleImage(BufferedImage source,
+                                            int min, int max)
+    {
+        int xsize = source.getWidth(null);
+        int ysize = source.getHeight(null);
+        int msize = Math.max(xsize, ysize);
+        BufferedImage result = null;
+
+        // scale the image if it's outside of requested range.
+        // ALSO pass through if min and max are both 0
+        if ((min == 0 && max == 0) ||
+            (msize >= min && Math.min(xsize, ysize) <= max))
+            return source;
+        else
+        {
+            int xnew = xsize * max / msize;
+            int ynew = ysize * max / msize;
+            result = new BufferedImage(xnew, ynew, BufferedImage.TYPE_INT_RGB);
+            Graphics2D g2d = result.createGraphics();
+            g2d.drawImage(source, 0, 0, xnew, ynew, null);
+            return result;
+        }
+    }
+}
+
+ 	  	 

dspace-api/src/main/java/org/dspace/app/mets/METSExport.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -70,7 +68,7 @@ import org.dspace.core.Constants;
 import org.dspace.core.Context;
 import org.dspace.core.Utils;
 import org.dspace.handle.HandleManager;
-import org.dspace.app.webui.util.UIUtil;
+import org.dspace.app.util.Util;
 
 import edu.harvard.hul.ois.mets.Agent;
 import edu.harvard.hul.ois.mets.AmdSec;
@@ -178,7 +176,8 @@ public class METSExport
         }
 
         ItemIterator items = null;
-
+        try
+        {
             if (line.hasOption('c'))
             {
                 String handle = getHandleArg(line.getOptionValue('c'));
@@ -213,8 +212,15 @@ public class METSExport
             {
                 writeAIP(context, items.next(), dest);
             }
+        }
+        finally
+        {
+            if (items != null)
+                items.close();
+        }
         
         context.abort();
+        System.exit(0);
     }
 
     /**
@@ -241,10 +247,19 @@ public class METSExport
                 + File.separator + "config" + File.separator + "dc2mods.cfg";
 
         // Read it in
-        InputStream is = new FileInputStream(configFile);
+        InputStream is = null;
+        try
+        {
+            is = new FileInputStream(configFile);
             dcToMODS = new Properties();
             dcToMODS.load(is);
         }
+        finally
+        {
+            if (is != null)
+                try { is.close(); } catch (IOException ioe) { }
+        }
+    }
 
     /**
      * Write out the AIP for the given item to the given directory. A new
@@ -409,6 +424,12 @@ public class METSExport
             {
                 Bitstream[] bitstreams = bundles[i].getBitstreams();
 
+                // Unusual condition, but if no bitstreams, skip this bundle
+                if (bitstreams.length == 0)
+                {
+                    continue;
+                }
+                        
                 // First: we skip the license bundle, since it's included
                 // elsewhere
                 if (bitstreams[0].getFormat().getID() == licenseFormat)
@@ -436,7 +457,7 @@ public class METSExport
                             + "/"
                             + bitstreams[bits].getSequenceID()
                             + "/"
-                            + UIUtil.encodeBitstreamName(bitstreams[bits].getName(),
+                            + Util.encodeBitstreamName(bitstreams[bits].getName(),
                                     "UTF-8");
 
                     edu.harvard.hul.ois.mets.File file = new edu.harvard.hul.ois.mets.File();
@@ -562,12 +583,15 @@ public class METSExport
             // Assume license will be in its own bundle
             Bitstream[] bitstreams = bundles[i].getBitstreams();
 
+            if (bitstreams.length > 0)
+            {
                 if (bitstreams[0].getFormat().getID() == licenseFormat)
                 {
                     // Read the license into a string
                     return bitstreams[0].retrieve();
                 }
             }
+        }
 
         // Oops! No license!
         return null;
@@ -645,13 +669,30 @@ public class METSExport
                 System.err.println("WARNING: No MODS mapping for " + propName);
             }
             else
+            {
+                String value = dc[i].value;
+
+                // Replace all $'s with \$ so it doesn't trip up the replaceAll!
+                if (value != null && value.length() > 0)
+                {
+                    // RegExp note: Yes, there really does need to be this many backslashes!
+                    // To have \$ inserted in the replacement, both the backslash and the dollar
+                    // have to be escaped (backslash) - so the replacemenet string has to be
+                    // passed as \\\$. All of those backslashes then have to escaped in the literal
+                    // for them to be in string used!!!
+                    value = dc[i].value.replaceAll("\\$", "\\\\\\$");
+                }
+
+                if (!(("description.provenance".equals(propName)) &&
+                    ((ConfigurationManager.getBooleanProperty("oai.mets.hide-provenance", false)))))
                 {
                     // Replace '%s' with DC value (with entities encoded)
                     modsXML.append(modsMapping.replaceAll("%s", Utils
-                        .addEntities(dc[i].value)));
+                            .addEntities(value)));
                     modsXML.append("\n"); // For readability
                 }
             }
+        }
 
         PreformedXML pXML = new PreformedXML(modsXML.toString());
         xmlData.getContent().add(pXML);

dspace-api/src/main/java/org/dspace/app/packager/Packager.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/sitemap/AbstractGenerator.java

@@ -0,0 +1,281 @@
+/*
+ * AbstractMETSDisseminator.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.sitemap;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.Date;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * Base class for creating sitemaps of various kinds. A sitemap consists of one
+ * or more files which list significant URLs on a site for search engines to
+ * efficiently crawl. Dates of modification may also be included. A sitemap
+ * index file that links to each of the sitemap files is also generated. It is
+ * this index file that search engines should be directed towards.
+ * <P>
+ * Provides most of the required functionality, subclasses need just implement a
+ * few methods that specify the "boilerplate" and text for including URLs.
+ * <P>
+ * Typical usage:
+ * <pre>
+ *   AbstractGenerator g = new FooGenerator(...);
+ *   while (...) {
+ *     g.addURL(url, date);
+ *   }
+ *   g.finish();
+ * </pre>
+ * 
+ * @author Robert Tansley
+ */
+public abstract class AbstractGenerator
+{
+    /** Number of files written so far */
+    protected int fileCount;
+
+    /** Number of bytes written to current file */
+    protected int bytesWritten;
+
+    /** Number of URLs written to current file */
+    protected int urlsWritten;
+
+    /** Directory files are written to */
+    protected File outputDir;
+
+    /** Current output */
+    protected PrintStream currentOutput;
+
+    /** Size in bytes of trailing boilerplate */
+    private int trailingByteCount;
+
+    /**
+     * Initialize this generator to write to the given directory. This must be
+     * called by any subclass constructor.
+     * 
+     * @param outputDirIn
+     *            directory to write sitemap files to
+     */
+    public AbstractGenerator(File outputDirIn)
+    {
+        fileCount = 0;
+        outputDir = outputDirIn;
+        trailingByteCount = getTrailingBoilerPlate().length();
+        currentOutput = null;
+    }
+
+    /**
+     * Start writing a new sitemap file.
+     * 
+     * @throws IOException
+     *             if an error occurs creating the file
+     */
+    protected void startNewFile() throws IOException
+    {
+        String lbp = getLeadingBoilerPlate();
+
+        OutputStream fo = new FileOutputStream(new File(outputDir,
+                getFilename(fileCount)));
+
+        if (useCompression())
+        {
+            fo = new GZIPOutputStream(fo);
+        }
+
+        currentOutput = new PrintStream(fo);
+        currentOutput.print(lbp);
+        bytesWritten = lbp.length();
+        urlsWritten = 0;
+    }
+
+    /**
+     * Add the given URL to the sitemap.
+     * 
+     * @param url
+     *            Full URL to add
+     * @param lastMod
+     *            Date URL was last modified, or {@code null}
+     * @throws IOException
+     *             if an error occurs writing
+     */
+    public void addURL(String url, Date lastMod) throws IOException
+    {
+        // Kick things off if this is the first call
+        if (currentOutput == null)
+        {
+            startNewFile();
+        }
+
+        String newURLText = getURLText(url, lastMod);
+
+        if (bytesWritten + newURLText.length() + trailingByteCount > getMaxSize()
+                || urlsWritten + 1 > getMaxURLs())
+        {
+            closeCurrentFile();
+            startNewFile();
+        }
+
+        currentOutput.print(newURLText);
+        bytesWritten += newURLText.length();
+        urlsWritten++;
+    }
+
+    /**
+     * Finish with the current sitemap file.
+     * 
+     * @throws IOException
+     *             if an error occurs writing
+     */
+    protected void closeCurrentFile() throws IOException
+    {
+        currentOutput.print(getTrailingBoilerPlate());
+        currentOutput.close();
+        fileCount++;
+    }
+
+    /**
+     * Complete writing sitemap files and write the index files. This is invoked
+     * when all calls to {@link AbstractGenerator#addURL(String, Date)} have
+     * been completed, and invalidates the generator.
+     * 
+     * @return number of sitemap files written.
+     * 
+     * @throws IOException
+     *             if an error occurs writing
+     */
+    public int finish() throws IOException
+    {
+        closeCurrentFile();
+
+        OutputStream fo = new FileOutputStream(new File(outputDir,
+                getIndexFilename()));
+
+        if (useCompression())
+        {
+            fo = new GZIPOutputStream(fo);
+        }
+
+        PrintStream out = new PrintStream(fo);
+        writeIndex(out, fileCount);
+        out.close();
+        
+        return fileCount;
+    }
+
+    /**
+     * Return marked-up text to be included in a sitemap about a given URL.
+     * 
+     * @param url
+     *            URL to add information about
+     * @param lastMod
+     *            date URL was last modified, or {@code null} if unknown or not
+     *            applicable
+     * @return the mark-up to include
+     */
+    public abstract String getURLText(String url, Date lastMod);
+
+    /**
+     * Return the boilerplate at the top of a sitemap file.
+     * 
+     * @return The boilerplate markup.
+     */
+    public abstract String getLeadingBoilerPlate();
+
+    /**
+     * Return the boilerplate at the end of a sitemap file.
+     * 
+     * @return The boilerplate markup.
+     */
+    public abstract String getTrailingBoilerPlate();
+
+    /**
+     * Return the maximum size in bytes that an individual sitemap file should
+     * be.
+     * 
+     * @return the size in bytes.
+     */
+    public abstract int getMaxSize();
+
+    /**
+     * Return the maximum number of URLs that an individual sitemap file should
+     * contain.
+     * 
+     * @return the maximum number of URLs.
+     */
+    public abstract int getMaxURLs();
+
+    /**
+     * Return whether the written sitemap files and index should be
+     * GZIP-compressed.
+     * 
+     * @return {@code true} if GZIP compression should be used, {@code false}
+     *         otherwise.
+     */
+    public abstract boolean useCompression();
+
+    /**
+     * Return the filename a sitemap at the given index should be stored at.
+     * 
+     * @param number
+     *            index of the sitemap file (zero is first).
+     * @return the filename to write the sitemap to.
+     */
+    public abstract String getFilename(int number);
+
+    /**
+     * Get the filename the index should be written to.
+     * 
+     * @return the filename of the index.
+     */
+    public abstract String getIndexFilename();
+
+    /**
+     * Write the index file.
+     * 
+     * @param output
+     *            stream to write the index to
+     * @param sitemapCount
+     *            number of sitemaps that were generated
+     * @throws IOException
+     *             if an IO error occurs
+     */
+    public abstract void writeIndex(PrintStream output, int sitemapCount)
+            throws IOException;
+}

dspace-api/src/main/java/org/dspace/app/sitemap/GenerateSitemaps.java

@@ -0,0 +1,381 @@
+/*
+ * GenerateSitemaps.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.sitemap;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.sql.SQLException;
+import java.util.Date;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.PosixParser;
+import org.apache.log4j.Logger;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.content.Item;
+import org.dspace.content.ItemIterator;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+
+/**
+ * Command-line utility for generating HTML and Sitemaps.org protocol Sitemaps.
+ * 
+ * @author Robert Tansley
+ * @author Stuart Lewis
+ */
+public class GenerateSitemaps
+{
+    /** Logger */
+    private static Logger log = Logger.getLogger(GenerateSitemaps.class);
+
+    public static void main(String[] args) throws Exception
+    {
+        final String usage = GenerateSitemaps.class.getCanonicalName();
+
+        CommandLineParser parser = new PosixParser();
+        HelpFormatter hf = new HelpFormatter();
+
+        Options options = new Options();
+
+        options.addOption("h", "help", false, "help");
+        options.addOption("s", "no_sitemaps", false,
+                "do not generate sitemaps.org protocol sitemap");
+        options.addOption("b", "no_htmlmap", false,
+                "do not generate a basic HTML sitemap");
+        options.addOption("a", "ping_all", false,
+                "ping configured search engines");
+        options
+                .addOption("p", "ping", true,
+                        "ping specified search engine URL");
+
+        CommandLine line = null;
+
+        try
+        {
+            line = parser.parse(options, args);
+        }
+        catch (ParseException pe)
+        {
+            hf.printHelp(usage, options);
+            System.exit(1);
+        }
+
+        if (line.hasOption('h'))
+        {
+            hf.printHelp(usage, options);
+            System.exit(0);
+        }
+
+        if (line.getArgs().length != 0)
+        {
+            hf.printHelp(usage, options);
+            System.exit(1);
+        }
+
+        /*
+         * Sanity check -- if no sitemap generation or pinging to do, print
+         * usage
+         */
+        if (line.getArgs().length != 0 || line.hasOption('b')
+                && line.hasOption('s') && !line.hasOption('g')
+                && !line.hasOption('m') && !line.hasOption('y')
+                && !line.hasOption('p'))
+        {
+            System.err
+                    .println("Nothing to do (no sitemap to generate, no search engines to ping)");
+            hf.printHelp(usage, options);
+            System.exit(1);
+        }
+
+        // Note the negation (CLI options indicate NOT to generate a sitemap)
+        if (!line.hasOption('b') || !line.hasOption('s'))
+        {
+            generateSitemaps(!line.hasOption('b'), !line.hasOption('s'));
+        }
+
+        if (line.hasOption('a'))
+        {
+            pingConfiguredSearchEngines();
+        }
+
+        if (line.hasOption('p'))
+        {
+            try
+            {
+                pingSearchEngine(line.getOptionValue('p'));
+            }
+            catch (MalformedURLException me)
+            {
+                System.err
+                        .println("Bad search engine URL (include all except sitemap URL)");
+                System.exit(1);
+            }
+        }
+
+        System.exit(0);
+    }
+
+    /**
+     * Generate sitemap.org protocol and/or basic HTML sitemaps.
+     * 
+     * @param makeHTMLMap
+     *            if {@code true}, generate an HTML sitemap.
+     * @param makeSitemapOrg
+     *            if {@code true}, generate an sitemap.org sitemap.
+     * @throws SQLException
+     *             if a database error occurs.
+     * @throws IOException
+     *             if IO error occurs.
+     */
+    public static void generateSitemaps(boolean makeHTMLMap,
+            boolean makeSitemapOrg) throws SQLException, IOException
+    {
+        String sitemapStem = ConfigurationManager.getProperty("dspace.url")
+                + "/sitemap";
+        String htmlMapStem = ConfigurationManager.getProperty("dspace.url")
+                + "/htmlmap";
+        String handleURLStem = ConfigurationManager.getProperty("dspace.url")
+                + "/handle/";
+
+        File outputDir = new File(ConfigurationManager.getProperty("sitemap.dir"));
+        if (!outputDir.exists()) {
+        	outputDir.mkdir();
+        }
+        
+        AbstractGenerator html = null;
+        AbstractGenerator sitemapsOrg = null;
+
+        if (makeHTMLMap)
+        {
+            html = new HTMLSitemapGenerator(outputDir, htmlMapStem + "?map=",
+                    null);
+        }
+
+        if (makeSitemapOrg)
+        {
+            sitemapsOrg = new SitemapsOrgGenerator(outputDir, sitemapStem
+                    + "?map=", null);
+        }
+
+        Context c = new Context();
+
+        Community[] comms = Community.findAll(c);
+
+        for (int i = 0; i < comms.length; i++)
+        {
+            String url = handleURLStem + comms[i].getHandle();
+
+            if (makeHTMLMap)
+                html.addURL(url, null);
+            if (makeSitemapOrg)
+                sitemapsOrg.addURL(url, null);
+        }
+
+        Collection[] colls = Collection.findAll(c);
+
+        for (int i = 0; i < colls.length; i++)
+        {
+            String url = handleURLStem + colls[i].getHandle();
+
+            if (makeHTMLMap)
+                html.addURL(url, null);
+            if (makeSitemapOrg)
+                sitemapsOrg.addURL(url, null);
+        }
+
+        ItemIterator allItems = Item.findAll(c);
+        try
+        {
+            int itemCount = 0;
+
+            while (allItems.hasNext())
+            {
+                Item i = allItems.next();
+                String url = handleURLStem + i.getHandle();
+                Date lastMod = i.getLastModified();
+
+                if (makeHTMLMap)
+                    html.addURL(url, lastMod);
+                if (makeSitemapOrg)
+                    sitemapsOrg.addURL(url, lastMod);
+                i.decache();
+
+                itemCount++;
+            }
+
+            if (makeHTMLMap)
+            {
+                int files = html.finish();
+                log.info(LogManager.getHeader(c, "write_sitemap",
+                        "type=html,num_files=" + files + ",communities="
+                                + comms.length + ",collections=" + colls.length
+                                + ",items=" + itemCount));
+            }
+
+            if (makeSitemapOrg)
+            {
+                int files = sitemapsOrg.finish();
+                log.info(LogManager.getHeader(c, "write_sitemap",
+                        "type=html,num_files=" + files + ",communities="
+                                + comms.length + ",collections=" + colls.length
+                                + ",items=" + itemCount));
+            }
+        }
+        finally
+        {
+            if (allItems != null)
+                allItems.close();
+        }
+        
+        c.abort();
+    }
+
+    /**
+     * Ping all search engines configured in {@code dspace.cfg}.
+     * 
+     * @throws UnsupportedEncodingException
+     *             theoretically should never happen
+     */
+    public static void pingConfiguredSearchEngines()
+            throws UnsupportedEncodingException
+    {
+        String engineURLProp = ConfigurationManager
+                .getProperty("sitemap.engineurls");
+        String engineURLs[] = null;
+
+        if (engineURLProp != null)
+        {
+            engineURLs = engineURLProp.trim().split("\\s*,\\s*");
+        }
+
+        if (engineURLProp == null || engineURLs == null
+                || engineURLs.length == 0 || engineURLs[0].trim().equals(""))
+        {
+            log.warn("No search engine URLs configured to ping");
+            return;
+        }
+
+        for (int i = 0; i < engineURLs.length; i++)
+        {
+            try
+            {
+                pingSearchEngine(engineURLs[i]);
+            }
+            catch (MalformedURLException me)
+            {
+                log.warn("Bad search engine URL in configuration: "
+                        + engineURLs[i]);
+            }
+        }
+    }
+
+    /**
+     * Ping the given search engine.
+     * 
+     * @param engineURL
+     *            Search engine URL minus protocol etc, e.g.
+     *            {@code www.google.com}
+     * @return {@code true} if the operation was successful
+     * @throws MalformedURLException
+     *             if the passed in URL is malformed
+     * @throws UnsupportedEncodingException
+     *             theoretically should never happen
+     */
+    public static void pingSearchEngine(String engineURL)
+            throws MalformedURLException, UnsupportedEncodingException
+    {
+        // Set up HTTP proxy
+        if ((ConfigurationManager.getProperty("http.proxy.host") != null)
+                && (ConfigurationManager.getProperty("http.proxy.port") != null))
+        {
+            System.setProperty("proxySet", "true");
+            System.setProperty("proxyHost", ConfigurationManager
+                    .getProperty("http.proxy.host"));
+            System.getProperty("proxyPort", ConfigurationManager
+                    .getProperty("http.proxy.port"));
+        }
+
+        String sitemapURL = ConfigurationManager.getProperty("dspace.url")
+                + "/sitemap";
+
+        URL url = new URL(engineURL + URLEncoder.encode(sitemapURL, "UTF-8"));
+
+        try
+        {
+            HttpURLConnection connection = (HttpURLConnection) url
+                    .openConnection();
+
+            BufferedReader in = new BufferedReader(new InputStreamReader(
+                    connection.getInputStream()));
+
+            String inputLine;
+            StringBuffer resp = new StringBuffer();
+            while ((inputLine = in.readLine()) != null)
+            {
+                resp.append(inputLine).append("\n");
+            }
+            in.close();
+
+            if (connection.getResponseCode() == 200)
+            {
+                log.info("Pinged " + url.toString() + " successfully");
+            }
+            else
+            {
+                log.warn("Error response pinging " + url.toString() + ":\n"
+                        + resp);
+            }
+        }
+        catch (IOException e)
+        {
+            log.warn("Error pinging " + url.toString(), e);
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/sitemap/HTMLSitemapGenerator.java

@@ -0,0 +1,144 @@
+/*
+ * HTMLSitemapGenerator.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.sitemap;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.Date;
+
+/**
+ * Class for generating HTML "sitemaps" which contain links to various pages in
+ * a DSpace site. This should improve search engine coverage of the DSpace site
+ * and limit the server load caused by crawlers.
+ * 
+ * @author Robert Tansley
+ * @author Stuart Lewis
+ */
+public class HTMLSitemapGenerator extends AbstractGenerator
+{
+    /** Stem of URLs sitemaps will eventually appear at */
+    private String indexURLStem;
+
+    /** Tail of URLs sitemaps will eventually appear at */
+    private String indexURLTail;
+
+    /**
+     * Construct an HTML sitemap generator, writing files to the given
+     * directory, and with the sitemaps eventually exposed at starting with the
+     * given URL stem and tail.
+     * 
+     * @param outputDirIn
+     *            Directory to write sitemap files to
+     * @param urlStem
+     *            start of URL that sitemap files will appear at, e.g.
+     *            {@code http://dspace.myu.edu/sitemap?sitemap=}
+     * @param urlTail
+     *            end of URL that sitemap files will appear at, e.g.
+     *            {@code .html} or {@code null}
+     */
+    public HTMLSitemapGenerator(File outputDirIn, String urlStem, String urlTail)
+    {
+        super(outputDirIn);
+
+        indexURLStem = urlStem;
+        indexURLTail = (urlTail == null ? "" : urlTail);
+    }
+
+    public String getFilename(int number)
+    {
+        return "sitemap" + number + ".html";
+    }
+
+    public String getLeadingBoilerPlate()
+    {
+        return "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n"
+                + "<html><head><title>URL List</title></head><body><ul>";
+    }
+
+    public int getMaxSize()
+    {
+        // 50k
+        return 51200;
+    }
+
+    public int getMaxURLs()
+    {
+        return 1000;
+    }
+
+    public String getTrailingBoilerPlate()
+    {
+        return "</ul></body></html>\n";
+    }
+
+    public String getURLText(String url, Date lastMod)
+    {
+        StringBuffer urlText = new StringBuffer();
+
+        urlText.append("<li><a href=\"").append(url).append("\">").append(url)
+                .append("</a></li>\n");
+
+        return urlText.toString();
+    }
+
+    public boolean useCompression()
+    {
+        return false;
+    }
+
+    public String getIndexFilename()
+    {
+        return "sitemap_index.html";
+    }
+
+    public void writeIndex(PrintStream output, int sitemapCount)
+            throws IOException
+    {
+        output.println(getLeadingBoilerPlate());
+
+        for (int i = 0; i < sitemapCount; i++)
+        {
+            output.print("<li><a href=\"" + indexURLStem + i + indexURLTail
+                    + "\">sitemap " + i);
+            output.print("</a></li>\n");
+        }
+
+        output.println(getTrailingBoilerPlate());
+    }
+}

dspace-api/src/main/java/org/dspace/app/sitemap/SitemapsOrgGenerator.java

@@ -0,0 +1,159 @@
+/*
+ * SitemapsOrgGenerator.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.sitemap;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * Class for generating <a href="http://sitemaps.org/">Sitemaps</a> to improve
+ * search engine coverage of the DSpace site and limit the server load caused by
+ * crawlers.
+ * 
+ * @author Robert Tansley
+ * @author Stuart Lewis
+ */
+public class SitemapsOrgGenerator extends AbstractGenerator
+{
+    /** Stem of URLs sitemaps will eventually appear at */
+    private String indexURLStem;
+
+    /** Tail of URLs sitemaps will eventually appear at */
+    private String indexURLTail;
+
+    /** The correct date format */
+    private DateFormat w3dtfFormat = new SimpleDateFormat(
+            "yyyy-MM-dd'T'HH:mm:ss'Z'");
+
+    /**
+     * Construct a sitemaps.org protocol sitemap generator, writing files to the
+     * given directory, and with the sitemaps eventually exposed at starting
+     * with the given URL stem and tail.
+     * 
+     * @param outputDirIn
+     *            Directory to write sitemap files to
+     * @param urlStem
+     *            start of URL that sitemap files will appear at, e.g.
+     *            {@code http://dspace.myu.edu/sitemap?sitemap=}
+     * @param urlTail
+     *            end of URL that sitemap files will appear at, e.g.
+     *            {@code .html} or {@code null}
+     */
+    public SitemapsOrgGenerator(File outputDirIn, String urlStem, String urlTail)
+    {
+        super(outputDirIn);
+
+        indexURLStem = urlStem;
+        indexURLTail = (urlTail == null ? "" : urlTail);
+    }
+
+    public String getFilename(int number)
+    {
+        return "sitemap" + number + ".xml.gz";
+    }
+
+    public String getLeadingBoilerPlate()
+    {
+        return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                + "<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">";
+    }
+
+    public int getMaxSize()
+    {
+        // 10 Mb
+        return 10485760;
+    }
+
+    public int getMaxURLs()
+    {
+        return 50000;
+    }
+
+    public String getTrailingBoilerPlate()
+    {
+        return "</urlset>";
+    }
+
+    public String getURLText(String url, Date lastMod)
+    {
+        StringBuffer urlText = new StringBuffer();
+
+        urlText.append("<url><loc>").append(url).append("</loc>");
+        if (lastMod != null)
+        {
+            urlText.append("<lastmod>").append(w3dtfFormat.format(lastMod))
+                    .append("</lastmod>");
+        }
+        urlText.append("</url>\n");
+
+        return urlText.toString();
+    }
+
+    public boolean useCompression()
+    {
+        return true;
+    }
+
+    public String getIndexFilename()
+    {
+        return "sitemap_index.xml.gz";
+    }
+
+    public void writeIndex(PrintStream output, int sitemapCount)
+            throws IOException
+    {
+        String now = w3dtfFormat.format(new Date());
+
+        output.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+        output
+                .println("<sitemapindex xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">");
+
+        for (int i = 0; i < sitemapCount; i++)
+        {
+            output.print("<sitemap><loc>" + indexURLStem + i + indexURLTail
+                    + "</loc>");
+            output.print("<lastmod>" + now + "</lastmod></sitemap>\n");
+        }
+
+        output.println("</sitemapindex>");
+    }
+}

dspace-api/src/main/java/org/dspace/app/statistics/CreateStatReport.java

@@ -0,0 +1,420 @@
+/*
+ * CreateStatReport.java
+ *
+ * Date: $Date: 2008-01-08 
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.statistics;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Properties;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.PosixParser;
+
+import org.dspace.core.Context;
+import org.dspace.core.ConfigurationManager;
+
+/**
+ * This class allows the running of the DSpace statistic tools
+ * 
+ * Usage: java CreateStatReport -r <statistic to run>
+ * Available: 	<stat-initial> <stat-general> <stat-monthly> <stat-report-initial> 
+ * 				<stat-report-general> <stat-report-monthly>
+ * 
+ * @author Chris Yates
+ *
+ */
+
+public class CreateStatReport {
+
+	/**Current date and time*/
+	private static Calendar calendar = null;
+	
+	/**Reporting start date and time*/
+	private static Calendar reportStartDate = null;
+	
+	/**Path of log directory*/
+	private static String outputLogDirectory = null;
+	
+	/**Path of reporting directory*/
+	private static String outputReportDirectory = null;
+	
+	/**File suffix for log files*/
+	private static String outputSuffix = ".dat";
+	
+	/**User context*/
+	private static Context context;
+
+    /** the config file from which to configure the analyser */
+    private static String configFile = ConfigurationManager.getProperty("dspace.dir") +
+                            File.separator + "config" + File.separator +
+                            "dstat.cfg";
+
+    /*
+	 * Main method to be run from the command line executes individual statistic methods
+	 * 
+	 * Usage: java CreateStatReport -r <statistic to run> 
+	 */
+	public static void main(String[] argv) throws Exception {
+
+        // Open the statistics config file
+        FileInputStream fis = new java.io.FileInputStream(new File(configFile));
+        Properties config = new Properties();
+        config.load(fis);
+        int startMonth = 0;
+        int startYear = 2005;
+        try
+        {
+            startYear = Integer.parseInt(config.getProperty("start.year", "1").trim());
+        } catch (NumberFormatException nfe)
+        {
+            System.err.println("start.year is incorrectly set in dstat.cfg. Must be a number (e.g. 2005).");
+            System.exit(0);
+        }
+        try
+        {
+            startMonth = Integer.parseInt(config.getProperty("start.month", "2005").trim());
+        } catch (NumberFormatException nfe)
+        {
+            System.err.println("start.month is incorrectly set in dstat.cfg. Must be a number between 1 and 12.");
+            System.exit(0);
+        }
+        reportStartDate = new GregorianCalendar(startYear, startMonth - 1, 1);
+        calendar = new GregorianCalendar();
+        
+        // create context as super user
+        context = new Context();
+        context.setIgnoreAuthorization(true);
+        
+        //get paths to directories
+        outputLogDirectory = ConfigurationManager.getProperty("log.dir") + File.separator;
+        outputReportDirectory = ConfigurationManager.getProperty("report.dir") + File.separator;
+        
+        //read in command line variable to determine which statistic to run
+		CommandLineParser parser = new PosixParser();
+		Options options = new Options();
+		options.addOption("r", "report", true, "report");
+		CommandLine line = parser.parse(options, argv);
+		
+		String statAction = null;
+		
+		if(line.hasOption('r')) 
+		{
+			statAction = line.getOptionValue('r');
+		}
+		
+		if (statAction == null) {
+			usage();
+			System.exit(0);
+		}
+
+		//call appropriate statistics method
+		if(statAction.equals("stat-monthly")) {
+			statMonthly();
+		}
+		
+		if(statAction.equals("stat-general")) {
+			statGeneral();
+		}
+		
+		if(statAction.equals("stat-initial")) {
+			statInitial();
+		}
+		
+		if(statAction.equals("stat-report-general")) {
+			statReportGeneral();
+		}
+		
+		if(statAction.equals("stat-report-initial")) {
+			statReportInitial();
+		}
+		
+		if(statAction.equals("stat-report-monthly")) {
+			statReportMonthly();
+		}
+	}
+	
+	/**
+	 * This method generates a report from the first of the current month to the end of the current month.
+	 * 
+	 * @throws Exception
+	 */
+	private static void statMonthly() throws Exception {
+        
+        //Output Prefix
+        String outputPrefix = "dspace-log-monthly-";
+		
+		// set up our command line variables
+        String myLogDir = null;
+        String myFileTemplate = null;
+        String myConfigFile = null;
+        StringBuffer myOutFile = null;
+        Date myStartDate = null;
+        Date myEndDate = null;
+        boolean myLookUp = false;       
+     
+        Calendar start = new GregorianCalendar( calendar.get(Calendar.YEAR),
+        										calendar.get(Calendar.MONTH),
+        										calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
+        myStartDate = start.getTime();
+        
+        Calendar end = new GregorianCalendar( calendar.get(Calendar.YEAR),
+											  calendar.get(Calendar.MONTH),
+											  calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
+        myEndDate = end.getTime();
+        
+        myOutFile = new StringBuffer(outputLogDirectory);
+        myOutFile.append(outputPrefix);
+        myOutFile.append(calendar.get(Calendar.YEAR));
+        myOutFile.append("-");
+        myOutFile.append(calendar.get(Calendar.MONTH)+1);
+        myOutFile.append(outputSuffix);        
+                             
+        LogAnalyser.processLogs(context, myLogDir, myFileTemplate, myConfigFile, myOutFile.toString(), myStartDate, myEndDate, myLookUp);
+	}	
+	
+	/**
+	 * This method generates a full report based on the full log period
+	 * 
+	 * @throws Exception
+	 */
+	private static void statGeneral() throws Exception {
+		
+		//Output Prefix
+        String outputPrefix = "dspace-log-general-";
+		
+        // set up our command line variables
+        String myLogDir = null;
+        String myFileTemplate = null;
+        String myConfigFile = null;
+        StringBuffer myOutFile = null;
+        Date myStartDate = null;
+        Date myEndDate = null;
+        boolean myLookUp = false; 
+        
+        myOutFile = new StringBuffer(outputLogDirectory);
+        myOutFile.append(outputPrefix);
+        myOutFile.append(calendar.get(Calendar.YEAR));
+        myOutFile.append("-");
+        myOutFile.append(calendar.get(Calendar.MONTH)+1);
+        myOutFile.append("-");
+        myOutFile.append(calendar.get(Calendar.DAY_OF_MONTH));
+        myOutFile.append(outputSuffix); 
+		
+        LogAnalyser.processLogs(context, myLogDir, myFileTemplate, myConfigFile, myOutFile.toString(), myStartDate, myEndDate, myLookUp);
+	}
+	
+	/**
+	 * This script starts from the year and month specified below and loops each month until the current month
+	 * generating a monthly aggregation files for the DStat system.
+	 * 
+	 * @throws Exception
+	 */
+	private static void statInitial() throws Exception {
+				
+		//Output Prefix
+        String outputPrefix = "dspace-log-monthly-";
+		
+        // set up our command line variables
+        String myLogDir = null;
+        String myFileTemplate = null;
+        String myConfigFile = null;
+        StringBuffer myOutFile = null;
+        Date myStartDate = null;
+        Date myEndDate = null;
+        boolean myLookUp = false; 
+				
+		Calendar reportEndDate = new GregorianCalendar( calendar.get(Calendar.YEAR),
+				  										calendar.get(Calendar.MONTH),
+				  										calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
+		
+		while(reportStartDate.before(reportEndDate)) {
+									
+			Calendar start = new GregorianCalendar( reportStartDate.get(Calendar.YEAR),
+													reportStartDate.get(Calendar.MONTH),
+													reportStartDate.getActualMinimum(Calendar.DAY_OF_MONTH));
+			myStartDate = start.getTime();
+
+			Calendar end = new GregorianCalendar( reportStartDate.get(Calendar.YEAR),
+												  reportStartDate.get(Calendar.MONTH),
+												  reportStartDate.getActualMaximum(Calendar.DAY_OF_MONTH));
+			myEndDate = end.getTime();
+			
+			myOutFile = new StringBuffer(outputLogDirectory);
+	        myOutFile.append(outputPrefix);
+	        myOutFile.append(reportStartDate.get(Calendar.YEAR));
+	        myOutFile.append("-");
+	        myOutFile.append(reportStartDate.get(Calendar.MONTH)+1);
+	        myOutFile.append(outputSuffix); 
+	        	        
+	        LogAnalyser.processLogs(context, myLogDir, myFileTemplate, myConfigFile, myOutFile.toString(), myStartDate, myEndDate, myLookUp);
+	        
+			reportStartDate.add(Calendar.MONTH, 1);	
+		}
+	}
+	
+	/**
+	 * This method generates a full report based on the full log period
+	 * 
+	 * @throws Exception
+	 */
+	private static void statReportGeneral() throws Exception {
+		
+		//Prefix
+		String inputPrefix = "dspace-log-general-";
+		String outputPrefix = "report-general-";        
+		
+		String myFormat = "html";
+        StringBuffer myInput = null;
+        StringBuffer myOutput = null;
+        String myMap = null;
+		
+        myInput = new StringBuffer(outputLogDirectory);
+        myInput.append(inputPrefix);
+        myInput.append(calendar.get(Calendar.YEAR));
+        myInput.append("-");
+        myInput.append(calendar.get(Calendar.MONTH)+1);
+        myInput.append("-");
+        myInput.append(calendar.get(Calendar.DAY_OF_MONTH));
+        myInput.append(outputSuffix); 
+        
+        myOutput = new StringBuffer(outputReportDirectory);
+        myOutput.append(outputPrefix);
+        myOutput.append(calendar.get(Calendar.YEAR));
+        myOutput.append("-");
+        myOutput.append(calendar.get(Calendar.MONTH)+1);
+        myOutput.append("-");
+        myOutput.append(calendar.get(Calendar.DAY_OF_MONTH));
+        myOutput.append(".");
+        myOutput.append(myFormat);
+		
+		ReportGenerator.processReport(context, myFormat, myInput.toString(), myOutput.toString(), myMap);
+	}
+	
+	/**
+	 * This script starts from the year and month specified below and loops each month until the current month
+	 * generating monthly reports from the DStat aggregation files
+	 * 
+	 * @throws Exception
+	 */
+	private static void statReportInitial() throws Exception {
+		
+		//Prefix
+		String inputPrefix = "dspace-log-monthly-";
+		String outputPrefix = "report-";        
+		
+		String myFormat = "html";
+        StringBuffer myInput = null;
+        StringBuffer myOutput = null;
+        String myMap = null;
+				
+		Calendar reportEndDate = new GregorianCalendar( calendar.get(Calendar.YEAR),
+				  										calendar.get(Calendar.MONTH),
+				  										calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
+		
+		while(reportStartDate.before(reportEndDate)) {
+			
+			myInput = new StringBuffer(outputLogDirectory);
+	        myInput.append(inputPrefix);
+	        myInput.append(reportStartDate.get(Calendar.YEAR));
+	        myInput.append("-");
+	        myInput.append(reportStartDate.get(Calendar.MONTH)+1);
+	        myInput.append(outputSuffix); 
+	        
+	        myOutput = new StringBuffer(outputReportDirectory);
+	        myOutput.append(outputPrefix);
+	        myOutput.append(reportStartDate.get(Calendar.YEAR));
+	        myOutput.append("-");
+	        myOutput.append(reportStartDate.get(Calendar.MONTH)+1);
+	        myOutput.append(".");
+	        myOutput.append(myFormat);			
+			
+			ReportGenerator.processReport(context, myFormat, myInput.toString(), myOutput.toString(), myMap);
+			
+			reportStartDate.add(Calendar.MONTH, 1);
+		}	
+	}
+	
+	/**
+	 * This method generates a report from the aggregation files which have been run for the most recent month
+	 * 
+	 * @throws Exception
+	 */
+	private static void statReportMonthly() throws Exception 
+	{
+		//Prefix
+		String inputPrefix = "dspace-log-monthly-";
+		String outputPrefix = "report-";        
+		
+		String myFormat = "html";
+        StringBuffer myInput = null;
+        StringBuffer myOutput = null;
+        String myMap = null;
+	
+        myInput = new StringBuffer(outputLogDirectory);
+        myInput.append(inputPrefix);
+        myInput.append(calendar.get(Calendar.YEAR));
+        myInput.append("-");
+        myInput.append(calendar.get(Calendar.MONTH)+1);
+        myInput.append(outputSuffix); 
+        
+        myOutput = new StringBuffer(outputReportDirectory);
+        myOutput.append(outputPrefix);
+        myOutput.append(calendar.get(Calendar.YEAR));
+        myOutput.append("-");
+        myOutput.append(calendar.get(Calendar.MONTH)+1);
+        myOutput.append(".");
+        myOutput.append(myFormat);
+		
+        ReportGenerator.processReport(context, myFormat, myInput.toString(), myOutput.toString(), myMap);
+	}
+	
+	/*
+	 * Output the usage information
+	 */
+	private static void usage() throws Exception {
+	
+		System.out.println("Usage: java CreateStatReport -r <statistic to run>");
+		System.out.println("Available: <stat-initial> <stat-general> <stat-monthly> <stat-report-initial> <stat-report-general> <stat-report-monthly>");     
+		return;		
+	}
+}

dspace-api/src/main/java/org/dspace/app/statistics/HTMLReport.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -44,6 +42,7 @@ import org.dspace.app.statistics.Report;
 import org.dspace.app.statistics.Stat;
 import org.dspace.app.statistics.Statistics;
 import org.dspace.app.statistics.ReportTools;
+import org.dspace.core.ConfigurationManager;
 
 import java.text.DateFormat;
 
@@ -54,13 +53,14 @@ import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.io.*;
 
 /**
  * This class provides HTML reports for the ReportGenerator class
  *
  * @author  Richard Jones
  */
-public class HTMLReport extends Report
+public class HTMLReport implements Report
 {
     // FIXME: all of these methods should do some content escaping before
     // outputting anything
@@ -80,6 +80,10 @@ public class HTMLReport extends Report
     /** end date for report */
     private Date end = null;
 
+    /** the output file to which to write aggregation data */
+   private static String output = ConfigurationManager.getProperty("dspace.dir") +
+                            File.separator + "log" + File.separator + "report";
+    
     /**
      * constructor for HTML reporting
      */
@@ -88,6 +92,14 @@ public class HTMLReport extends Report
         // empty constructor
     }
 
+    public void setOutput(String newOutput)
+    {
+        if (newOutput != null)
+        {
+            output = newOutput;
+        }
+    }
+    
     /**
      * return a string containing the report as generated by this class
      *
@@ -120,6 +132,23 @@ public class HTMLReport extends Report
         // output the footer and return
         frag.append(footer());
 
+        // NB: HTMLReport now takes responsibility to write the output file,
+        // so that the Report/ReportGenerator can have more general usage
+        // finally write the string into the output file
+        try
+        {
+        	FileOutputStream fos = new FileOutputStream(output);
+            OutputStreamWriter osr = new OutputStreamWriter(fos, "UTF-8");
+            PrintWriter out = new PrintWriter(osr);
+            out.write(frag.toString());
+            out.close();
+        }
+        catch (IOException e)
+        {
+            System.out.println("Unable to write to output file " + output);
+            System.exit(0);
+        }
+        
         return frag.toString();
     }
     
@@ -398,7 +427,7 @@ public class HTMLReport extends Report
                 frag.append("<a href=\"" + stats[i].getReference() + "\" ");
                 frag.append("target=\"_blank\">");
             }
-            frag.append(stats[i].getKey());
+            frag.append(this.clean(stats[i].getKey()));
             if (stats[i].getReference() != null)
             {
                 frag.append("</a>");
@@ -476,4 +505,18 @@ public class HTMLReport extends Report
         return "";
     }
 
+    /**
+     * Clean Stirngs for display in HTML
+     *
+     * @param s The String to clean
+     * @return The cleaned String
+     */
+    private String clean(String s)
+    {
+        // Clean up the statistics keys
+        s = s.replace("<", "&lt;");
+        s = s.replaceAll(">", "&gt;");
+        return s;
+    }
+    
 }

dspace-api/src/main/java/org/dspace/app/statistics/LogAnalyser.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -44,6 +42,7 @@ import org.dspace.app.statistics.LogLine;
 
 import org.dspace.core.ConfigurationManager;
 import org.dspace.core.Context;
+import org.dspace.core.LogManager;
 import org.dspace.storage.rdbms.DatabaseManager;
 import org.dspace.storage.rdbms.TableRow;
 
@@ -52,9 +51,6 @@ import java.sql.SQLException;
 import java.lang.Long;
 import java.lang.StringBuffer;
 
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 
@@ -100,19 +96,19 @@ public class LogAnalyser
     /////////////////
     
     /** aggregator for all actions performed in the system */
-    private static Map actionAggregator = new HashMap();
+    private static Map actionAggregator;
     
     /** aggregator for all searches performed */
-    private static Map searchAggregator = new HashMap();
+    private static Map searchAggregator;
     
     /** aggregator for user logins */
-    private static Map userAggregator = new HashMap();
+    private static Map userAggregator;
     
     /** aggregator for item views */
-    private static Map itemAggregator = new HashMap();
+    private static Map itemAggregator;
     
     /** aggregator for current archive state statistics */
-    private static Map archiveStats = new HashMap();
+    private static Map archiveStats;
     
     /** warning counter */
     private static int warnCount = 0;
@@ -125,19 +121,19 @@ public class LogAnalyser
     //////////////////
     
     /** list of actions to be included in the general summary */
-    private static List generalSummary = new ArrayList();
+    private static List generalSummary;
     
     /** list of words not to be aggregated */
-    private static List excludeWords = new ArrayList();
+    private static List excludeWords;
     
     /** list of search types to be ignored, such as "author:" */
-    private static List excludeTypes = new ArrayList();
+    private static List excludeTypes;
     
     /** list of characters to be excluded */
-    private static List excludeChars = new ArrayList();
+    private static List excludeChars;
     
     /** list of item types to be reported on in the current state */
-    private static List itemTypes = new ArrayList();
+    private static List itemTypes;
     
     /** bottom limit to output for search word analysis */
     private static int searchFloor;
@@ -224,20 +220,18 @@ public class LogAnalyser
    ////////////////////////
    
    /** the log directory to be analysed */
-   private static String logDir = ConfigurationManager.getProperty("dspace.dir") + 
-                        File.separator + "log";
+   private static String logDir = ConfigurationManager.getProperty("log.dir");  
         
    /** the regex to describe the file name format */
    private static String fileTemplate = "dspace\\.log.*";
         
    /** the config file from which to configure the analyser */
-   private static String configFile = ConfigurationManager.getProperty("dspace.dir") + 
+   public static String configFile = ConfigurationManager.getProperty("dspace.dir") + 
                             File.separator + "config" + File.separator +
                             "dstat.cfg";
    
    /** the output file to which to write aggregation data */
-   private static String outFile = ConfigurationManager.getProperty("dspace.dir") + 
-                            File.separator + "log" + File.separator + "dstat.dat";
+   private static String outFile = ConfigurationManager.getProperty("log.dir") + File.separator + "dstat.dat";
    
    /** the starting date of the report */
    private static Date startDate = null;
@@ -350,10 +344,21 @@ public class LogAnalyser
         // together in a single aggregating object
         
         // if the timer has not yet been started, then start it
-        if (startTime != null)
-        {
         startTime = new GregorianCalendar();
-        }
+                
+        //instantiate aggregators
+        actionAggregator = new HashMap();
+        searchAggregator = new HashMap();
+        userAggregator = new HashMap();
+        itemAggregator = new HashMap();
+        archiveStats = new HashMap();
+        
+        //instantiate lists
+        generalSummary = new ArrayList();
+        excludeWords = new ArrayList();
+        excludeTypes = new ArrayList();
+        excludeChars = new ArrayList();
+        itemTypes = new ArrayList();
               
         // set the parameters for this analysis
         setParameters(myLogDir, myFileTemplate, myConfigFile, myOutFile, myStartDate, myEndDate, myLookUp);
@@ -416,12 +421,12 @@ public class LogAnalyser
                     {
                         // first find out if we are constraining by date and 
                         // if so apply the restrictions
-                        if (logLine.beforeDate(startDate))
+                        if ((startDate != null) && (!logLine.afterDate(startDate)))
                         {
                             continue;
                         }
                         
-                        if (logLine.afterDate(endDate))
+                        if ((endDate !=null) && (!logLine.beforeDate(endDate)))
                         {
                             break;
                         }
@@ -535,15 +540,13 @@ public class LogAnalyser
             archiveStats.put(itemTypes.get(i), getNumItems(context, (String) itemTypes.get(i)));
         }
         
-        // now do the host lookup
-        try 
+        // now do the host name and url lookup
+        hostName = ConfigurationManager.getProperty("dspace.hostname").trim();
+        name = ConfigurationManager.getProperty("dspace.name").trim();
+        url = ConfigurationManager.getProperty("dspace.url").trim();
+        if ((url != null) && (!url.endsWith("/")))
         {
-            InetAddress addr = InetAddress.getLocalHost();
-            hostName = addr.getHostName();
-        } 
-        catch (UnknownHostException e) 
-        {
-            hostName = "unknown host";
+                url = url + "/";
         }
         
         // do the average views analysis
@@ -767,6 +770,7 @@ public class LogAnalyser
         {
             BufferedWriter out = new BufferedWriter(new FileWriter(outFile));
             out.write(summary.toString());
+            out.flush();
             out.close();
         } 
         catch (IOException e) 
@@ -898,6 +902,20 @@ public class LogAnalyser
     public static void readConfig(String configFile)
         throws IOException
     {
+        //instantiate aggregators
+        actionAggregator = new HashMap();
+        searchAggregator = new HashMap();
+        userAggregator = new HashMap();
+        itemAggregator = new HashMap();
+        archiveStats = new HashMap();
+
+        //instantiate lists
+        generalSummary = new ArrayList();
+        excludeWords = new ArrayList();
+        excludeTypes = new ArrayList();
+        excludeChars = new ArrayList();
+        itemTypes = new ArrayList();
+
         // prepare our standard file readers and buffered readers
         FileReader fr = null;
         BufferedReader br = null;
@@ -910,7 +928,7 @@ public class LogAnalyser
         } 
         catch (IOException e) 
         {
-            System.out.println("Failed to read config file");
+            System.out.println("Failed to read config file: " + configFile);
             System.exit(0);
         } 
         
@@ -975,16 +993,6 @@ public class LogAnalyser
                 {
                     userEmail = value;
                 }
-
-                if (key.equals("host.url"))
-                {
-                    url = value;
-                }
-
-                if (key.equals("host.name"))
-                {
-                    name = value;
-                }
             }
         }
 
@@ -1147,10 +1155,10 @@ public class LogAnalyser
         {
             // set up a new log line object
             LogLine logLine = new LogLine(parseDate(match.group(1).trim()),
-                                          match.group(2).trim(),
-                                          match.group(3).trim(),
-                                          match.group(4).trim(),
-                                          match.group(5).trim());
+                                          LogManager.unescapeLogField(match.group(2)).trim(),
+                                          LogManager.unescapeLogField(match.group(3)).trim(),
+                                          LogManager.unescapeLogField(match.group(4)).trim(),
+                                          LogManager.unescapeLogField(match.group(5)).trim());
             
             return logLine;
         }
@@ -1174,6 +1182,12 @@ public class LogAnalyser
     public static Integer getNumItems(Context context, String type)
         throws SQLException
     {
+        boolean oracle = false;
+        if ("oracle".equals(ConfigurationManager.getProperty("db.name")))
+        {
+            oracle = true;
+        }
+
         // FIXME: this method is clearly not optimised
         
         // FIXME: we don't yet collect total statistics, such as number of items
@@ -1197,8 +1211,16 @@ public class LogAnalyser
         
         // start the date constraint query buffer
         StringBuffer dateQuery = new StringBuffer();
-        dateQuery.append("SELECT item_id " +
-                          "FROM metadatavalue " +
+        if (oracle)
+        {
+            dateQuery.append("SELECT /*+ ORDERED_PREDICATES */ item_id ");
+        }
+        else
+        {
+            dateQuery.append("SELECT item_id ");
+        }
+
+        dateQuery.append("FROM metadatavalue " +
                           "WHERE metadata_field_id = (" +
                           " SELECT metadata_field_id " +
                           " FROM metadatafieldregistry " +
@@ -1206,24 +1228,42 @@ public class LogAnalyser
                           " AND qualifier = 'accessioned') ");
       
         if (startDate != null)
+        {
+            if (oracle)
+            {
+                dateQuery.append(" AND TO_TIMESTAMP( TO_CHAR(text_value), "+
+                        "'yyyy-mm-dd\"T\"hh24:mi:ss\"Z\"' ) > TO_DATE('" +
+                        unParseDate(startDate) + "', 'yyyy-MM-dd') ");
+            }
+            else
             {
                 dateQuery.append(" AND text_value::timestamp > '" +
                         unParseDate(startDate) + "'::timestamp ");
             }
+        }
 
         if (endDate != null)
+        {
+            if (oracle)
+            {
+                dateQuery.append(" AND TO_TIMESTAMP( TO_CHAR(text_value), "+
+                        "'yyyy-mm-dd\"T\"hh24:mi:ss\"Z\"' ) < TO_DATE('" +
+                        unParseDate(endDate) + "', 'yyyy-MM-dd') ");
+            }
+            else
             {
                 dateQuery.append(" AND text_value::timestamp < '" +
                         unParseDate(endDate) + "'::timestamp ");
             }
+        }
         
         // build the final query
         StringBuffer query = new StringBuffer();
         
-        query.append("SELECT COUNT(*) AS number " +
+        query.append("SELECT COUNT(*) AS num " +
                   "FROM item " +
-                  "WHERE in_archive = true " + 
-                  "AND withdrawn = false ");
+                  "WHERE in_archive = " + (oracle ? "1 " : "true ") +
+                  "AND withdrawn = " + (oracle ? "0 " : "false "));
         
         if (startDate != null || endDate != null)
         {
@@ -1239,9 +1279,18 @@ public class LogAnalyser
         
         TableRow row = DatabaseManager.querySingle(context, query.toString());
 
+        Integer numItems;
+        if (oracle)
+        {
+            numItems = new Integer(row.getIntColumn("num"));
+        }
+        else
+        {
             // for some reason the number column is of "long" data type!
-        Long count = new Long(row.getLongColumn("number"));
-        return new Integer(count.intValue());
+            Long count = new Long(row.getLongColumn("num"));
+            numItems = new Integer(count.intValue());
+        }
+        return numItems;
     }
     
     

dspace-api/src/main/java/org/dspace/app/statistics/LogLine.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/statistics/Report.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -48,30 +46,18 @@ import java.util.Date;
 import java.util.List;
 
 /**
- * Abstract class to define an interface to a generic report generating
+ * Sn interface to a generic report generating
  * class, and to provide the polymorphism necessary to allow the report
  * generator to generate any number of different formats of report
  *
+ * Note: This used to be an abstract class, but has been made an interface as there wasn't
+ * any logic contained within it. It's also been made public, so that you can create a Report
+ * type without monkeying about in the statistics package.
+ *
  * @author  Richard Jones
  */
-abstract class Report 
+public interface Report
 {
-    
-    /** a list of the statistics blocks being managed by this class */
-    private List blocks = new ArrayList();
-    
-    /** the title for the page */
-    private String pageTitle = null;
-    
-    /** the main title for the page */
-    private String mainTitle = null;
-    
-    /** start date for report */
-    private Date start = null;
-    
-    /** end date for report */
-    private Date end = null;
-    
     /**
      * output any top headers that this page needs
      *

dspace-api/src/main/java/org/dspace/app/statistics/ReportGenerator.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -88,19 +86,19 @@ public class ReportGenerator
     /////////////////
     
     /** aggregator for all actions performed in the system */
-    private static Map actionAggregator = new HashMap();
+    private static Map actionAggregator;
     
     /** aggregator for all searches performed */
-    private static Map searchAggregator = new HashMap();
+    private static Map searchAggregator;
     
     /** aggregator for user logins */
-    private static Map userAggregator = new HashMap();
+    private static Map userAggregator;
     
     /** aggregator for item views */
-    private static Map itemAggregator = new HashMap();
+    private static Map itemAggregator;
     
     /** aggregator for current archive state statistics */
-    private static Map archiveStats = new HashMap();
+    private static Map archiveStats;
     
     
     //////////////////
@@ -147,7 +145,7 @@ public class ReportGenerator
     private static int warnings;
     
     /** the list of results to be displayed in the general summary */
-    private static List generalSummary = new ArrayList();
+    private static List generalSummary;
     
     //////////////////
     // regular expressions
@@ -164,22 +162,15 @@ public class ReportGenerator
    private static Calendar startTime = null;
    
    /** a map from log file action to human readable action */
-   private static Map actionMap = new HashMap();
+   private static Map actionMap = null;
    
     /////////////////
     // report generator config data
     ////////////////
     
-    /** the format of the report to be output */
-    private static String format = null;
-    
     /** the input file to build the report from */
     private static String input = null;
     
-    /** the output file to which to write aggregation data */
-   private static String output = ConfigurationManager.getProperty("dspace.dir") + 
-                            File.separator + "log" + File.separator + "report";
-   
    /** the log file action to human readable action map */
    private static String map = ConfigurationManager.getProperty("dspace.dir") +
                             File.separator + "config" + File.separator + "dstat.map";
@@ -239,6 +230,9 @@ public class ReportGenerator
      * aggregation data and output a file containing the report in the
      * requested format
      *
+     * this method is retained for backwards compatibility, but delegates the actual
+     * wprk to a new method
+     *
      * @param   context     the DSpace context in which this action is performed
      * @param   myFormat    the desired output format (currently on HTML supported)
      * @param   myInput     the aggregation file to be turned into a report
@@ -248,11 +242,48 @@ public class ReportGenerator
                                      String myInput, String myOutput,
                                      String myMap)
         throws Exception, SQLException
+    {
+        // create the relevant report type
+        // FIXME: at the moment we only support HTML report generation
+        Report report = null;
+        if (myFormat.equals("html"))
+        {
+            report = new HTMLReport();
+            ((HTMLReport)report).setOutput(myOutput);
+        }
+
+        if (myMap != null)
+        {
+            map = myMap;
+        }
+
+        ReportGenerator.processReport(context, report, myInput);
+    }
+
+    /**
+     * using the pre-configuration information passed here, read in the
+     * aggregation data and output a file containing the report in the
+     * requested format
+     */
+    public static void processReport(Context context, Report report,
+                                     String myInput)
+        throws Exception, SQLException
     {
         startTime = new GregorianCalendar();
              
+        /** instantiate aggregators */
+        actionAggregator = new HashMap();
+        searchAggregator = new HashMap();
+        userAggregator = new HashMap();
+        itemAggregator = new HashMap();
+        archiveStats = new HashMap();
+        actionMap = new HashMap();
+        
+        /** instantite lists */
+        generalSummary = new ArrayList();
+                
         // set the parameters for this analysis
-        setParameters(myFormat, myInput, myOutput, myMap);
+        setParameters(myInput);
         
         // pre prepare our standard file readers and buffered readers
         FileReader fr = null;
@@ -264,14 +295,6 @@ public class ReportGenerator
         // load the log file action to human readable action map
         readMap(map);
         
-        // create the relevant report type
-        // FIXME: at the moment we only support HTML report generation
-        Report report = null;
-        if (format.equals("html"))
-        {
-            report = new HTMLReport();
-        }
-        
         report.setStartDate(startDate);
         report.setEndDate(endDate);
         report.setMainTitle(name, serverName);
@@ -340,7 +363,8 @@ public class ReportGenerator
         String info = null;
         for (i = 0; i < items.length; i++)
         {
-            if (i < itemLookup)
+            // Allow negative value to say that all items should be looked up
+            if (itemLookup < 0 || i < itemLookup)
             {
                 info = getItemInfo(context, items[i].getKey());
             }
@@ -448,20 +472,7 @@ public class ReportGenerator
         
         report.addBlock(process);
 
-        // finally write the string into the output file
-        try 
-        {
-        	FileOutputStream fos = new FileOutputStream(output);
-            OutputStreamWriter osr = new OutputStreamWriter(fos, "UTF-8");
-            PrintWriter out = new PrintWriter(osr);
-            out.write(report.render());
-            out.close();
-        } 
-        catch (IOException e) 
-        {
-            System.out.println("Unable to write to output file " + output);
-            System.exit(0);
-        }
+        report.render();
         
         return;
     }
@@ -550,6 +561,8 @@ public class ReportGenerator
         FileReader fr = null;
         BufferedReader br = null;
 
+        try
+        {
             // read in the map file, printing a warning if none is found
             String record = null;
             try
@@ -575,6 +588,15 @@ public class ReportGenerator
                 }
             }
         }
+        finally
+        {
+            if (br != null)
+                try { br.close(); } catch (IOException ioe) { }
+
+            if (fr != null)
+                try { fr.close(); } catch (IOException ioe) { }
+        }
+    }
     
     
     /**
@@ -583,34 +605,15 @@ public class ReportGenerator
      * the command line with args or calling the processReport method statically
      * from elsewhere
      *
-     * @param   myFormat    the log file directory to be analysed
      * @param   myInput     regex for log file names
-     * @param   myOutput    config file to use for dstat
-     * @param   myMap       the action map file to use for translations
      */
-    public static void setParameters(String myFormat, String myInput, 
-                                    String myOutput, String myMap)
+    public static void setParameters(String myInput)
     {
-        if (myFormat != null)
-        {
-            format = myFormat;
-        }
-        
         if (myInput != null)
         {
             input = myInput;
         }
         
-        if (myOutput != null)
-        {
-            output = myOutput;
-        }
-        
-        if (myMap != null)
-        {
-            map = myMap;
-        }
-        
         return;
     }
     
@@ -637,10 +640,14 @@ public class ReportGenerator
         } 
         catch (IOException e) 
         {  
-            System.out.println("Failed to read input file");
-            System.exit(0);
+            System.out.println("Failed to read input file: " + input);
+            return;
         } 
         
+        // first initialise a date format object to do our date processing
+        // if necessary
+        SimpleDateFormat sdf = new SimpleDateFormat("dd'/'MM'/'yyyy");
+
         // FIXME: although this works, it is not very elegant
         // loop through the aggregator file and read in the values
         while ((record = br.readLine()) != null) 
@@ -687,64 +694,48 @@ public class ReportGenerator
             }
             
             // if the line is real, then we carry on
-            
-            // first initialise a date format object to do our date processing
-            // if necessary
-            SimpleDateFormat sdf = new SimpleDateFormat("dd'/'MM'/'yyyy");
-            
             // read the analysis contents in
             if (section.equals("archive"))
             {
                 archiveStats.put(key, value);
             }
-            
-            if (section.equals("action"))
+            else if (section.equals("action"))
             {
                 actionAggregator.put(key, value);
             }
-            
-            if (section.equals("user"))
+            else if (section.equals("user"))
             {
                 userAggregator.put(key, value);
             }
-            
-            if (section.equals("search"))
+            else if (section.equals("search"))
             {
                 searchAggregator.put(key, value);
             }
-            
-            if (section.equals("item"))
+            else if (section.equals("item"))
             {
                 itemAggregator.put(key, value);
             }
-            
-            // read the config details used to make this report in
-            if (section.equals("user_email"))
+            else if (section.equals("user_email"))
             {
                 userEmail = value;
             }
-            
-            if (section.equals("item_floor"))
+            else if (section.equals("item_floor"))
             {
                 itemFloor = Integer.parseInt(value);
             }
-            
-            if (section.equals("search_floor"))
+            else if (section.equals("search_floor"))
             {
                 searchFloor = Integer.parseInt(value);
             }
-            
-            if (section.equals("host_url"))
+            else if (section.equals("host_url"))
             {
                 url = value;
             }
-            
-            if (section.equals("item_lookup"))
+            else if (section.equals("item_lookup"))
             {
                 itemLookup = Integer.parseInt(value);
             }
-            
-            if (section.equals("avg_item_views"))
+            else if (section.equals("avg_item_views"))
             {
                 try 
                 {
@@ -755,43 +746,35 @@ public class ReportGenerator
                     avgItemViews = 0;
                 }
             }
-            
-            if (section.equals("server_name"))
+            else if (section.equals("server_name"))
             {
                 serverName = value;
             }
-            
-            if (section.equals("service_name"))
+            else if (section.equals("service_name"))
             {
                 name = value;
             }
-             
-            if (section.equals("start_date"))
+            else if (section.equals("start_date"))
             {
                 startDate = sdf.parse(value);
             }
-            
-            if (section.equals("end_date"))
+            else if (section.equals("end_date"))
             {
                 endDate = sdf.parse(value);
             }
-            
-            if (section.equals("analysis_process_time"))
+            else if (section.equals("analysis_process_time"))
             {
                 processTime = Integer.parseInt(value);
             }
-            
-            if (section.equals("general_summary"))
+            else if (section.equals("general_summary"))
             {
                 generalSummary.add(value);
             }
-            
-            if (section.equals("log_lines"))
+            else if (section.equals("log_lines"))
             {
                 logLines = Integer.parseInt(value);
             }
-            
-            if (section.equals("warnings"))
+            else if (section.equals("warnings"))
             {
                 warnings = Integer.parseInt(value);
             }

dspace-api/src/main/java/org/dspace/app/statistics/ReportTools.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/statistics/Stat.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/statistics/Statistics.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+  * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *

dspace-api/src/main/java/org/dspace/app/statistics/StatisticsLoader.java

@@ -0,0 +1,395 @@
+/*
+ * StatisticsLoader.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.statistics;
+
+import org.apache.commons.lang.time.DateUtils;
+import org.dspace.core.ConfigurationManager;
+
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.text.SimpleDateFormat;
+import java.text.ParseException;
+
+/**
+ * Helper class for loading the analysis / report files from the reports directory
+ */
+public class StatisticsLoader
+{
+    private static Map<String, StatsFile> monthlyAnalysis = null;
+    private static Map<String, StatsFile> monthlyReports = null;
+
+    private static StatsFile generalAnalysis = null;
+    private static StatsFile generalReport = null;
+
+    private static Date lastLoaded = null;
+    private static int fileCount   = 0;
+
+    private static Pattern analysisMonthlyPattern;
+    private static Pattern analysisGeneralPattern;
+    private static Pattern reportMonthlyPattern;
+    private static Pattern reportGeneralPattern;
+
+    private static SimpleDateFormat monthlySDF;
+    private static SimpleDateFormat generalSDF;
+
+    // one time initialisation of the regex patterns and formatters we will use
+    static
+    {
+        analysisMonthlyPattern = Pattern.compile("dspace-log-monthly-([0-9][0-9][0-9][0-9]-[0-9]+)\\.dat");
+        analysisGeneralPattern = Pattern.compile("dspace-log-general-([0-9]+-[0-9]+-[0-9]+)\\.dat");
+        reportMonthlyPattern   = Pattern.compile("report-([0-9][0-9][0-9][0-9]-[0-9]+)\\.html");
+        reportGeneralPattern   = Pattern.compile("report-general-([0-9]+-[0-9]+-[0-9]+)\\.html");
+
+        monthlySDF = new SimpleDateFormat("yyyy'-'M");
+        generalSDF = new SimpleDateFormat("yyyy'-'M'-'dd");
+    }
+
+    /**
+     * Get an array of the dates of the report files
+     * @return
+     */
+    public static Date[] getMonthlyReportDates()
+    {
+        return sortDatesDescending(getDatesFromMap(monthlyReports));
+    }
+
+    /**
+     * Get an array of the dates of the analysis files 
+     * @return
+     */
+    public static Date[] getMonthlyAnalysisDates()
+    {
+        return sortDatesDescending(getDatesFromMap(monthlyAnalysis));
+    }
+
+    /**
+     * Convert the formatted dates that are the keys of the map into a date array
+     * @param monthlyMap
+     * @return
+     */
+    protected static Date[] getDatesFromMap(Map<String, StatsFile> monthlyMap)
+    {
+        Set<String> keys = monthlyMap.keySet();
+        Date[] dates = new Date[keys.size()];
+        int i = 0;
+        for (String date : keys)
+        {
+            try
+            {
+                dates[i] = monthlySDF.parse(date);
+            }
+            catch (ParseException pe)
+            {
+            }
+
+            i++;
+        }
+
+        return dates;
+    }
+
+    /**
+     * Sort the date array in descending (reverse chronological) order
+     * @param dates
+     * @return
+     */
+    protected static Date[] sortDatesDescending(Date[] dates)
+    {
+        Arrays.sort(dates, new Comparator<Date>() {
+            SimpleDateFormat sdf = monthlySDF;
+            public int compare(Date d1, Date d2)
+            {
+                if (d1 == null && d2 == null)
+                    return 0;
+                else if (d1 == null)
+                    return -1;
+                else if (d2 == null)
+                    return 1;
+                else if (d1.before(d2))
+                    return 1;
+                else if (d2.before(d1))
+                    return -1;
+
+                return 0;
+            }
+        });
+        return dates;
+    }
+
+    /**
+     * Get the analysis file for a given date
+     * @param date
+     * @return
+     */
+    public static File getAnalysisFor(String date)
+    {
+        StatisticsLoader.syncFileList();
+        StatsFile sf = (monthlyAnalysis == null ? null : monthlyAnalysis.get(date));
+        return sf == null ? null : sf.file;
+    }
+
+    /**
+     * Get the report file for a given date
+     * @param date
+     * @return
+     */
+    public static File getReportFor(String date)
+    {
+        StatisticsLoader.syncFileList();
+        StatsFile sf = (monthlyReports == null ? null : monthlyReports.get(date));
+        return sf == null ? null : sf.file;
+    }
+
+    /**
+     * Get the current general analysis file
+     * @return
+     */
+    public static File getGeneralAnalysis()
+    {
+        StatisticsLoader.syncFileList();
+        return generalAnalysis == null ? null : generalAnalysis.file;
+    }
+
+    /**
+     * Get the current general report file
+     * @return
+     */
+    public static File getGeneralReport()
+    {
+        StatisticsLoader.syncFileList();
+        return generalReport == null ? null : generalReport.file;
+    }
+
+    /**
+     * Syncronize the cached list of analysis / report files with the reports directory
+     *
+     * We synchronize if:
+     *
+     * 1) The number of files is different (ie. files have been added or removed)
+     * 2) We haven't cached anything yet
+     * 3) The cache was last generate over an hour ago
+     */
+    private static void syncFileList()
+    {
+        // Get an array of all the analysis and report files present
+        File[] fileList = StatisticsLoader.getAnalysisAndReportFileList();
+
+        if (fileList != null && fileList.length != fileCount)
+            StatisticsLoader.loadFileList(fileList);
+        else if (lastLoaded == null)
+            StatisticsLoader.loadFileList(fileList);
+        else if (DateUtils.addHours(lastLoaded, 1).before(new Date()))
+            StatisticsLoader.loadFileList(fileList);
+    }
+
+    /**
+     * Generate the cached file list from the array of files
+     * @param fileList
+     */
+    private static synchronized void loadFileList(File[] fileList)
+    {
+        // If we haven't been passed an array of files, get one now
+        if (fileList == null || fileList.length == 0)
+        {
+            fileList = StatisticsLoader.getAnalysisAndReportFileList();
+        }
+
+        // Create new maps for the monthly analyis / reports
+        Map<String, StatsFile> newMonthlyAnalysis = new HashMap<String, StatsFile>();
+        Map<String, StatsFile> newMonthlyReports  = new HashMap<String, StatsFile>();
+
+        StatsFile newGeneralAnalysis = null;
+        StatsFile newGeneralReport = null;
+
+        if (fileList != null)
+        {
+            for (File thisFile : fileList)
+            {
+                StatsFile statsFile = null;
+
+                // If we haven't identified this file yet
+                if (statsFile == null)
+                {
+                    // See if it is a monthly analysis file
+                    statsFile = makeStatsFile(thisFile, analysisMonthlyPattern, monthlySDF);
+                    if (statsFile != null)
+                    {
+                        // If it is, add it to the map
+                        newMonthlyAnalysis.put(statsFile.dateStr, statsFile);
+                    }
+                }
+
+                // If we haven't identified this file yet
+                if (statsFile == null)
+                {
+                    // See if it is a monthly report file
+                    statsFile = makeStatsFile(thisFile, reportMonthlyPattern, monthlySDF);
+                    if (statsFile != null)
+                    {
+                        // If it is, add it to the map
+                        newMonthlyReports.put(statsFile.dateStr, statsFile);
+                    }
+                }
+
+                // If we haven't identified this file yet
+                if (statsFile == null)
+                {
+                    // See if it is a general analysis file
+                    statsFile = makeStatsFile(thisFile, analysisGeneralPattern, generalSDF);
+                    if (statsFile != null)
+                    {
+                        // If it is, ensure that we are pointing to the most recent file
+                        if (newGeneralAnalysis == null || statsFile.date.after(newGeneralAnalysis.date))
+                        {
+                            newGeneralAnalysis = statsFile;
+                        }
+                    }
+                }
+
+                // If we haven't identified this file yet
+                if (statsFile == null)
+                {
+                    // See if it is a general report file
+                    statsFile = makeStatsFile(thisFile, reportGeneralPattern, generalSDF);
+                    if (statsFile != null)
+                    {
+                        // If it is, ensure that we are pointing to the most recent file
+                        if (newGeneralReport == null || statsFile.date.after(newGeneralReport.date))
+                        {
+                            newGeneralReport = statsFile;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Store the newly discovered values in the member cache
+        monthlyAnalysis = newMonthlyAnalysis;
+        monthlyReports  = newMonthlyReports;
+        generalAnalysis = newGeneralAnalysis;
+        generalReport   = newGeneralReport;
+        lastLoaded = new Date();
+    }
+
+    /**
+     * Generate a StatsFile entry for this file. The pattern and date formatters are used to
+     * identify the file as a particular type, and extract the relevant information.
+     * If the file is not identified by the formatter provided, then we return null
+     * @param thisFile
+     * @param thisPattern
+     * @param sdf
+     * @return
+     */
+    private static StatsFile makeStatsFile(File thisFile, Pattern thisPattern, SimpleDateFormat sdf)
+    {
+        Matcher matcher = thisPattern.matcher(thisFile.getName());
+        if (matcher.matches())
+        {
+            StatsFile sf = new StatsFile();
+            sf.file = thisFile;
+            sf.path = thisFile.getPath();
+            sf.dateStr = matcher.group(1).trim();
+
+            try
+            {
+                sf.date = sdf.parse(sf.dateStr);
+            }
+            catch (ParseException e)
+            {
+
+            }
+
+            return sf;
+        }
+        
+        return null;
+    }
+
+    /**
+     * Get an array of all the analysis and report files
+     * @return
+     */
+    private static File[] getAnalysisAndReportFileList()
+    {
+        File reportDir = new File(ConfigurationManager.getProperty("log.dir"));
+        if (reportDir != null)
+        {
+            return reportDir.listFiles(new AnalysisAndReportFilter());
+        }
+
+        return null;
+    }
+
+    /**
+     * Simple class for holding information about an analysis/report file
+     */
+    private static class StatsFile
+    {
+        File file;
+        String path;
+        Date date;
+        String dateStr;
+    }
+
+    /**
+     * Filter used to restrict files in the reports directory to just analysis or report types
+     */
+    private static class AnalysisAndReportFilter implements FilenameFilter
+    {
+        public boolean accept(File dir, String name)
+        {
+            if (analysisMonthlyPattern.matcher(name).matches())
+                return true;
+
+            if (analysisGeneralPattern.matcher(name).matches())
+                return true;
+
+            if (reportMonthlyPattern.matcher(name).matches())
+                return true;
+            
+            if (reportGeneralPattern.matcher(name).matches())
+                return true;
+
+            return false;
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/statistics/package.html

@@ -0,0 +1,72 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<html>
+<head>
+<title>org.dspace.app.statistics package</title>
+<!--
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+-->
+</head>
+
+<body>
+<p>
+Defines usage event instrumentation points and provides implementations for
+testing.
+</p>
+
+<p>
+This package makes usage instrumentation (for statistics, or whatever else
+you may fancy) pluggable, while avoiding any unnecessary assumptions about how
+usage events may be transmitted, persisted, or processed.
+</p>
+
+<p>
+At appropriate points in the processing of user actions, events may be
+assembled and "fired".  What happens when an event is fired is configurable
+via the PluginManager.  One must configure a plugin for the AbstractUsageEvent
+class, defined in this package, to select an event processing implementation.
+</p>
+
+<p>
+Three "stock" implementations are provided.
+</p>
+<dl>
+	<dt>{@link org.dspace.app.statistics.PassiveUsageEvent PassiveUsageEvent}</dt>
+	<dd>absorbs events without taking action, resulting in behavior identical
+		to that of DSpace before this package was added.  This is the default
+		if no plugin is configured.</dd>
+	<dt>{@link org.dspace.app.statistics.UsageEventTabFileLogger UsageEventTabFileLogger}</dt>
+	<dd>writes event records to a file in Tab Separated Values format.</dd>
+	<dt>{@link org.dspace.app.statistics.UsageEventXMLLogger UsageEventXMLLogger}</dt>
+	<dd>writes event records to a file in an XML format.  Suitable mainly for
+		testing.</dd>
+</dl>
+</body>
+</html>

dspace-api/src/main/java/org/dspace/app/util/AuthorizeUtil.java

@@ -0,0 +1,652 @@
+/*
+ * AuthorizeUtil.java
+ *
+ * Version: $Revision: 3980 $
+ *
+ * Date: $Date: 2009-06-26 19:07:25 +0200 (ven, 26 giu 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+import java.sql.SQLException;
+
+import org.dspace.authorize.AuthorizeConfiguration;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.authorize.ResourcePolicy;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.content.Item;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+
+/**
+ * This class is an addition to the AuthorizeManager that perform authorization
+ * check on not crud (ADD, WRITE, etc.) actions.
+ * 
+ * @author bollini
+ * 
+ */
+public class AuthorizeUtil
+{
+
+    /**
+     * Is allowed manage (create, remove, edit) bitstream's policies in the
+     * current context?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param bitstream
+     *            the bitstream that the policy refer to
+     * @throws AuthorizeException
+     *             if the current context (current user) is not allowed to
+     *             manage the bitstream's policies
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageBitstreamPolicy(Context context,
+            Bitstream bitstream) throws AuthorizeException, SQLException
+    {
+        Bundle bundle = bitstream.getBundles()[0];
+        authorizeManageBundlePolicy(context, bundle);
+    }
+
+    /**
+     * Is allowed manage (create, remove, edit) bundle's policies in the
+     * current context?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param bundle
+     *            the bundle that the policy refer to
+     * @throws AuthorizeException
+     *             if the current context (current user) is not allowed to
+     *             manage the bundle's policies
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageBundlePolicy(Context context,
+            Bundle bundle) throws AuthorizeException, SQLException
+    {
+        Item item = bundle.getItems()[0];
+        authorizeManageItemPolicy(context, item);
+    }
+
+    /**
+     * Is allowed manage (create, remove, edit) item's policies in the
+     * current context?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param item
+     *            the item that the policy refer to
+     * @throws AuthorizeException
+     *             if the current context (current user) is not allowed to
+     *             manage the item's policies
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageItemPolicy(Context context, Item item)
+            throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canItemAdminManagePolicies())
+        {
+            AuthorizeManager.authorizeAction(context, item, Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration.canCollectionAdminManageItemPolicies())
+        {
+            AuthorizeManager.authorizeAction(context, item
+                    .getOwningCollection(), Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration.canCommunityAdminManageItemPolicies())
+        {
+            AuthorizeManager
+                    .authorizeAction(context, item.getOwningCollection()
+                            .getCommunities()[0], Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage item policies");
+        }
+    }
+
+    /**
+     * Is allowed manage (create, remove, edit) collection's policies in the
+     * current context?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param collection
+     *            the collection that the policy refer to
+     * @throws AuthorizeException
+     *             if the current context (current user) is not allowed to
+     *             manage the collection's policies
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageCollectionPolicy(Context context,
+            Collection collection) throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canCollectionAdminManagePolicies())
+        {
+            AuthorizeManager.authorizeAction(context, collection,
+                    Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration
+                .canCommunityAdminManageCollectionPolicies())
+        {
+            AuthorizeManager.authorizeAction(context, collection
+                    .getCommunities()[0], Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage collection policies");
+        }
+    }
+
+    /**
+     * Is allowed manage (create, remove, edit) community's policies in the
+     * current context?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param community
+     *            the community that the policy refer to
+     * @throws AuthorizeException
+     *             if the current context (current user) is not allowed to
+     *             manage the community's policies
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageCommunityPolicy(Context context,
+            Community community) throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canCommunityAdminManagePolicies())
+        {
+            AuthorizeManager.authorizeAction(context, community,
+                    Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage community policies");
+        }
+    }
+
+    /**
+     * Throw an AuthorizeException if the current user is not a System Admin
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @throws AuthorizeException
+     *             if the current user is not a System Admin
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void requireAdminRole(Context context)
+            throws AuthorizeException, SQLException
+    {
+        if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to perform this action");
+        }
+    }
+
+    /**
+     * Is the current user allowed to manage (add, remove, replace) the item's
+     * CC License
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param item
+     *            the item that the CC License refer to
+     * @throws AuthorizeException
+     *             if the current user is not allowed to
+     *             manage the item's CC License
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageCCLicense(Context context, Item item)
+            throws AuthorizeException, SQLException
+    {
+        try
+        {
+            AuthorizeManager.authorizeAction(context, item, Constants.ADD);
+            AuthorizeManager.authorizeAction(context, item, Constants.REMOVE);
+        }
+        catch (AuthorizeException authex)
+        {
+            if (AuthorizeConfiguration.canItemAdminManageCCLicense())
+            {
+                AuthorizeManager
+                        .authorizeAction(context, item, Constants.ADMIN);
+            }
+            else if (AuthorizeConfiguration.canCollectionAdminManageCCLicense())
+            {
+                AuthorizeManager.authorizeAction(context, item
+                        .getParentObject(), Constants.ADMIN);
+            }
+            else if (AuthorizeConfiguration.canCommunityAdminManageCCLicense())
+            {
+                AuthorizeManager.authorizeAction(context, item
+                        .getParentObject().getParentObject(), Constants.ADMIN);
+            }
+            else
+            {
+                requireAdminRole(context);
+            }
+        }
+    }
+
+    /**
+     * Is the current user allowed to manage (create, remove, edit) the
+     * collection's template item?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param collection
+     *            the collection
+     * @throws AuthorizeException
+     *             if the current user is not allowed to manage the collection's
+     *             template item
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageTemplateItem(Context context,
+            Collection collection) throws AuthorizeException, SQLException
+    {
+        boolean isAuthorized = collection.canEditBoolean(false);
+
+        if (!isAuthorized
+                && AuthorizeConfiguration
+                        .canCollectionAdminManageTemplateItem())
+        {
+            AuthorizeManager.authorizeAction(context, collection,
+                    Constants.ADMIN);
+        }
+        else if (!isAuthorized
+                && AuthorizeConfiguration
+                        .canCommunityAdminManageCollectionTemplateItem())
+        {
+            Community[] communities = collection.getCommunities();
+            Community parent = communities != null && communities.length > 0 ? communities[0]
+                    : null;
+            AuthorizeManager.authorizeAction(context, parent, Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "You are not authorized to create a template item for the collection");
+        }
+    }
+
+    /**
+     * Can the current user manage (create, remove, edit) the submitters group of
+     * the collection?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param collection
+     *            the collection
+     * @throws AuthorizeException
+     *             if the current user is not allowed to manage the collection's
+     *             submitters group
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageSubmittersGroup(Context context,
+            Collection collection) throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canCollectionAdminManageSubmitters())
+        {
+            AuthorizeManager.authorizeAction(context, collection,
+                    Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration
+                .canCommunityAdminManageCollectionSubmitters())
+        {
+            AuthorizeManager.authorizeAction(context, collection
+                    .getCommunities()[0], Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage collection submitters");
+        }
+    }
+
+    /**
+     * Can the current user manage (create, remove, edit) the workflow groups of
+     * the collection?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param collection
+     *            the collection
+     * @throws AuthorizeException
+     *             if the current user is not allowed to manage the collection's
+     *             workflow groups
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageWorkflowsGroup(Context context,
+            Collection collection) throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canCollectionAdminManageWorkflows())
+        {
+            AuthorizeManager.authorizeAction(context, collection,
+                    Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration
+                .canCommunityAdminManageCollectionWorkflows())
+        {
+            AuthorizeManager.authorizeAction(context, collection
+                    .getCommunities()[0], Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage collection workflow");
+        }
+    }
+
+    /**
+     * Can the current user create/edit the admins group of the collection?
+     * please note that the remove action need a separate check
+     * 
+     * @see #authorizeRemoveAdminGroup(Context, Collection)
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param collection
+     *            the collection
+     * @throws AuthorizeException
+     *             if the current user is not allowed to create/edit the
+     *             collection's admins group
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageAdminGroup(Context context,
+            Collection collection) throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canCollectionAdminManageAdminGroup())
+        {
+            AuthorizeManager.authorizeAction(context, collection,
+                    Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration
+                .canCommunityAdminManageCollectionAdminGroup())
+        {
+            AuthorizeManager.authorizeAction(context, collection
+                    .getCommunities()[0], Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage collection admin");
+        }
+    }
+
+    /**
+     * Can the current user remove the admins group of the collection?
+     * please note that the create/edit actions need separate check
+     * 
+     * @see #authorizeManageAdminGroup(Context, Collection)
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param collection
+     *            the collection
+     * @throws AuthorizeException
+     *             if the current user is not allowed to remove the
+     *             collection's admins group
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeRemoveAdminGroup(Context context,
+            Collection collection) throws AuthorizeException, SQLException
+    {
+        Community[] parentCommunities = collection.getCommunities();
+        if (AuthorizeConfiguration
+                .canCommunityAdminManageCollectionAdminGroup()
+                && parentCommunities != null && parentCommunities.length > 0)
+        {
+            AuthorizeManager.authorizeAction(context, collection
+                    .getCommunities()[0], Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin can remove the admin group of a collection");
+        }
+    }
+
+    /**
+     * Can the current user create/edit the admins group of the community?
+     * please note that the remove action need a separate check
+     * 
+     * @see #authorizeRemoveAdminGroup(Context, Collection)
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param community
+     *            the community
+     * @throws AuthorizeException
+     *             if the current user is not allowed to create/edit the
+     *             community's admins group
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManageAdminGroup(Context context,
+            Community community) throws AuthorizeException, SQLException
+    {
+        if (AuthorizeConfiguration.canCommunityAdminManageAdminGroup())
+        {
+            AuthorizeManager.authorizeAction(context, community,
+                    Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin are allowed to manage community admin");
+        }
+    }
+
+    /**
+     * Can the current user remove the admins group of the community?
+     * please note that the create/edit actions need separate check
+     * 
+     * @see #authorizeManageAdminGroup(Context, Community)
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param community
+     *            the community
+     * @throws AuthorizeException
+     *             if the current user is not allowed to remove the
+     *             collection's admins group
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeRemoveAdminGroup(Context context,
+            Community community) throws SQLException, AuthorizeException
+    {
+        Community parentCommunity = community.getParentCommunity();
+        if (AuthorizeConfiguration.canCommunityAdminManageAdminGroup()
+                && parentCommunity != null)
+        {
+            AuthorizeManager.authorizeAction(context, parentCommunity,
+                    Constants.ADMIN);
+        }
+        else if (!AuthorizeManager.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only system admin can remove the admin group of the community");
+        }
+    }
+
+    /**
+     * Can the current user remove or edit the supplied policy?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param rp
+     *            a resource policy
+     * @throws AuthorizeException
+     *             if the current context (current user) is not allowed to
+     *             remove/edit the policy
+     * @throws SQLException
+     *             if a db error occur
+     */
+    public static void authorizeManagePolicy(Context c, ResourcePolicy rp)
+            throws SQLException, AuthorizeException
+    {
+        switch (rp.getResourceType())
+        {
+        case Constants.BITSTREAM:
+            authorizeManageBitstreamPolicy(c, Bitstream.find(c, rp
+                    .getResourceID()));
+            break;
+        case Constants.BUNDLE:
+            authorizeManageBundlePolicy(c, Bundle.find(c, rp.getResourceID()));
+            break;
+
+        case Constants.ITEM:
+            authorizeManageItemPolicy(c, Item.find(c, rp.getResourceID()));
+            break;
+        case Constants.COLLECTION:
+            authorizeManageCollectionPolicy(c, Collection.find(c, rp
+                    .getResourceID()));
+            break;
+        case Constants.COMMUNITY:
+            authorizeManageCommunityPolicy(c, Community.find(c, rp
+                    .getResourceID()));
+            break;
+
+        default:
+            requireAdminRole(c);
+            break;
+        }
+    }
+
+    /**
+     * Can the current user withdraw the item?
+     * 
+     * @param context
+     *            the DSpace Context Object
+     * @param item
+     *            the item
+     * @throws SQLException
+     *             if a db error occur
+     * @throws AuthorizeException
+     *             if the current user is not allowed to perform the item
+     *             withdraw
+     */
+    public static void authorizeWithdrawItem(Context context, Item item)
+            throws SQLException, AuthorizeException
+    {
+        boolean authorized = false;
+        if (AuthorizeConfiguration.canCollectionAdminPerformItemWithdrawn())
+        {
+            authorized = AuthorizeManager.authorizeActionBoolean(context, item
+                    .getOwningCollection(), Constants.ADMIN);
+        }
+        else if (AuthorizeConfiguration.canCommunityAdminPerformItemWithdrawn())
+        {
+            authorized = AuthorizeManager
+                    .authorizeActionBoolean(context, item.getOwningCollection()
+                            .getCommunities()[0], Constants.ADMIN);
+        }
+
+        if (!authorized)
+        {
+            authorized = AuthorizeManager.authorizeActionBoolean(context, item
+                    .getOwningCollection(), Constants.REMOVE, false);
+        }
+
+        // authorized
+        if (!authorized)
+        {
+            throw new AuthorizeException(
+                    "To withdraw item must be COLLECTION_ADMIN or have REMOVE authorization on owning Collection");
+        }
+    }
+
+    /**
+    * Can the current user reistate the item?
+    * 
+    * @param context
+    *            the DSpace Context Object
+    * @param item
+    *            the item
+    * @throws SQLException
+    *             if a db error occur
+    * @throws AuthorizeException
+    *             if the current user is not allowed to perform the item
+    *             reistate
+    */
+    public static void authorizeReinstateItem(Context context, Item item)
+            throws SQLException, AuthorizeException
+    {
+        Collection[] colls = item.getCollections();
+
+        for (int i = 0; i < colls.length; i++)
+        {
+            if (!AuthorizeConfiguration
+                    .canCollectionAdminPerformItemReinstatiate())
+            {
+                if (AuthorizeConfiguration
+                        .canCommunityAdminPerformItemReinstatiate()
+                        && AuthorizeManager.authorizeActionBoolean(context,
+                                colls[i].getCommunities()[0], Constants.ADMIN))
+                {
+                    // authorized
+                }
+                else
+                {
+                    AuthorizeManager.authorizeAction(context, colls[i],
+                            Constants.ADD, false);
+                }
+            }
+            else
+            {
+                AuthorizeManager.authorizeAction(context, colls[i],
+                        Constants.ADD);
+            }
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/DCInput.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -38,7 +36,7 @@
  * DAMAGE.
  */
 
-package org.dspace.app.webui.util;
+package org.dspace.app.util;
 
 import java.util.List;
 import java.util.Map;
@@ -89,9 +87,27 @@ public class DCInput
     /** if non-null, visibility scope restriction */
     private String visibility = null;
     
+    /** if non-null, readonly out of the visibility scope */
+    private String readOnly = null;
+
     /** the name of the controlled vocabulary to use */
     private String vocabulary = null;
 
+    /** is the entry closed to vocabulary terms? */
+    private boolean closedVocabulary = false;
+
+    /** 
+     * The scope of the input sets, this restricts hidden metadata fields from 
+     * view during workflow processing. 
+     */
+    public static String WORKFLOW_SCOPE = "workflow";
+
+    /** 
+     * The scope of the input sets, this restricts hidden metadata fields from 
+     * view by the end user during submission. 
+     */
+    public static String SUBMISSION_SCOPE = "submit";
+    
     /**
      * Class constructor for creating a DCInput object based on the contents of
      * a HashMap
@@ -117,7 +133,8 @@ public class DCInput
         label = (String) fieldMap.get("label");
         inputType = (String) fieldMap.get("input-type");
         // these types are list-controlled
-        if ("dropdown".equals(inputType) || "qualdrop_value".equals(inputType))
+        if ("dropdown".equals(inputType) || "qualdrop_value".equals(inputType)
+                || "list".equals(inputType))
         {
             valueListName = (String) fieldMap.get("value-pairs-name");
             valueList = (List) listMap.get(valueListName);
@@ -126,7 +143,11 @@ public class DCInput
         warning = (String) fieldMap.get("required");
         required = (warning != null && warning.length() > 0);
         visibility = (String) fieldMap.get("visibility");
+        readOnly = (String) fieldMap.get("readonly");
         vocabulary = (String) fieldMap.get("vocabulary");
+        String closedVocabularyStr = (String) fieldMap.get("closedVocabulary");
+        closedVocabulary = "true".equalsIgnoreCase(closedVocabularyStr)
+                            || "yes".equalsIgnoreCase(closedVocabularyStr);
     }
 
     /**
@@ -145,6 +166,31 @@ public class DCInput
         return (visibility == null || visibility.equals(scope));
     }
     
+    /**
+     * Is this DCInput for display in readonly mode in the given scope? 
+     * If the scope differ from which in visibility field then we use the out attribute
+     * of the visibility element. Possible values are: hidden (default) and readonly.
+     * If the DCInput is visible in the scope then this methods must return false
+     * 
+     * @param scope
+     *            String identifying the scope that this input's readonly visibility
+     *            should be tested for
+     * 
+     * @return whether the input should be displayed in a readonly way or fully hidden
+     */
+    public boolean isReadOnly(String scope)
+    {
+        if (isVisible(scope))
+        {
+            return false;
+        }
+        else
+        {
+            return readOnly != null && readOnly.equalsIgnoreCase("readonly");
+        }
+    }
+
+
     /**
      * Get the repeatable flag for this row
      * 
@@ -203,8 +249,7 @@ public class DCInput
      */
     public String getWarning()
     {
-        return "<tr><td colspan=\"4\" class=\"submitFormWarn\">" + warning
-                + "</td></tr>";
+        return warning;
     }
 
     /**
@@ -234,8 +279,7 @@ public class DCInput
      */
     public String getHints()
     {
-        return "<tr><td colspan=\"4\" class=\"submitFormHelp\">" + hint
-                + "</td></tr>";
+        return hint;
     }
 
     /**
@@ -349,4 +393,21 @@ public class DCInput
         return null;
     }
 
+	/**
+	 * The closed attribute of the vocabulary tag for this field as set in 
+	 * input-forms.xml
+	 * 
+	 * <code> 
+	 * <field>
+	 *     .....
+	 *     <vocabulary closed="true">nsrc</vocabulary>
+	 * </field>
+	 * </code>
+	 * @return the closedVocabulary flags: true if the entry should be restricted 
+	 *         only to vocabulary terms, false otherwise
+	 */
+	public boolean isClosedVocabulary() {
+		return closedVocabulary;
+	}
+
 }

dspace-api/src/main/java/org/dspace/app/util/DCInputSet.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -38,7 +36,7 @@
  * DAMAGE.
  */
 
-package org.dspace.app.webui.util;
+package org.dspace.app.util;
 
 import java.util.ArrayList;
 import java.util.List;

dspace-api/src/main/java/org/dspace/app/util/DCInputsReader.java

@@ -0,0 +1,743 @@
+/*
+ * DCInputsReader.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
+ * Institute of Technology.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Hewlett-Packard Company nor the name of the
+ * Massachusetts Institute of Technology nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.util;
+
+import java.io.File;
+import java.util.List;
+import java.util.Vector;
+import java.util.HashMap;
+import java.util.Iterator;
+import org.xml.sax.SAXException;
+import org.w3c.dom.*;
+import javax.xml.parsers.*;
+
+import org.apache.log4j.Logger;
+
+import org.dspace.content.MetadataSchema;
+import org.dspace.core.ConfigurationManager;
+
+/**
+ * Submission form generator for DSpace. Reads and parses the installation
+ * form definitions file, input-forms.xml, from the configuration directory.
+ * A forms definition details the page and field layout of the metadata
+ * collection pages used by the submission process. Each forms definition
+ * starts with a unique name that gets associated with that form set.
+ *
+ * The file also specifies which collections use which form sets. At a
+ * minimum, the definitions file must define a default mapping from the
+ * placeholder collection #0 to the distinguished form 'default'. Any
+ * collections that use a custom form set are listed paired with the name
+ * of the form set they use.
+ *
+ * The definitions file also may contain sets of value pairs. Each value pair
+ * will contain one string that the user reads, and a paired string that will
+ * supply the value stored in the database if its sibling display value gets
+ * selected from a choice list.
+ *
+ * @author  Brian S. Hughes
+ * @version $Revision$
+ */
+
+public class DCInputsReader
+{
+    /**
+     * The ID of the default collection. Will never be the ID of a named
+     * collection
+     */
+    public static final String DEFAULT_COLLECTION = "default";
+
+    /** Name of the form definition XML file  */
+    static final String FORM_DEF_FILE = "input-forms.xml";
+
+    /** Keyname for storing dropdown value-pair set name */
+    static final String PAIR_TYPE_NAME = "value-pairs-name";
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(DCInputsReader.class);
+
+    /** The fully qualified pathname of the form definition XML file */
+    private String defsFile = ConfigurationManager.getProperty("dspace.dir")
+            + File.separator + "config" + File.separator + FORM_DEF_FILE;
+
+    /**
+     * Reference to the collections to forms map, computed from the forms
+     * definition file
+     */
+    private HashMap whichForms = null;
+
+    /**
+     * Reference to the forms definitions map, computed from the forms
+     * definition file
+     */
+    private HashMap formDefns  = null;
+
+    /**
+     * Reference to the forms which allow, disallow or mandate files to be
+     * uploaded.
+     */
+    private HashMap formFileUploadDefns = null;
+
+    /**
+     * Reference to the value-pairs map, computed from the forms defition file
+     */
+    private HashMap valuePairs = null;    // Holds display/storage pairs
+    
+    /**
+     * Mini-cache of last DCInputSet requested. If submissions are not typically
+     * form-interleaved, there will be a modest win.
+     */
+    private DCInputSet lastInputSet = null;
+
+    /**
+     * Parse an XML encoded submission forms template file, and create a hashmap
+     * containing all the form information. This hashmap will contain three top
+     * level structures: a map between collections and forms, the definition for
+     * each page of each form, and lists of pairs of values that populate
+     * selection boxes.
+     */
+
+    public DCInputsReader()
+         throws DCInputsReaderException
+    {
+        buildInputs(defsFile);
+    }
+
+
+    public DCInputsReader(String fileName)
+         throws DCInputsReaderException
+    {
+        buildInputs(fileName);
+    }
+
+
+    private void buildInputs(String fileName)
+         throws DCInputsReaderException
+    {
+        whichForms = new HashMap();
+        formDefns  = new HashMap();
+        valuePairs = new HashMap();
+
+        String uri = "file:" + new File(fileName).getAbsolutePath();
+
+        try
+        {
+                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+                factory.setValidating(false);
+                factory.setIgnoringComments(true);
+                factory.setIgnoringElementContentWhitespace(true);
+                
+                DocumentBuilder db = factory.newDocumentBuilder();
+                Document doc = db.parse(uri);
+                doNodes(doc);
+                checkValues();
+        }
+        catch (FactoryConfigurationError fe)
+        {
+                throw new DCInputsReaderException("Cannot create Submission form parser",fe);
+        }
+        catch (Exception e)
+        {
+                throw new DCInputsReaderException("Error creating submission forms: "+e);
+        }
+    }
+   
+    public Iterator getPairsNameIterator()
+    {
+        return valuePairs.keySet().iterator();
+    }
+
+    public List getPairs(String name)
+    {
+        return (Vector)valuePairs.get(name);
+    }
+
+    /**
+     * Returns the set of DC inputs used for a particular collection, or the
+     * default set if no inputs defined for the collection
+     *
+     * @param collectionHandle
+     *            collection's unique Handle
+     * @return DC input set
+     * @throws DCInputsReaderException
+     *             if no default set defined
+     */
+    public DCInputSet getInputs(String collectionHandle)
+                throws DCInputsReaderException
+    {
+        String formName = (String)whichForms.get(collectionHandle);
+        if (formName == null)
+        {
+                formName = (String)whichForms.get(DEFAULT_COLLECTION);
+        }
+        if (formName == null)
+        {
+                throw new DCInputsReaderException("No form designated as default");
+        }
+        // check mini-cache, and return if match
+        if ( lastInputSet != null && lastInputSet.getFormName().equals( formName ) )
+        {
+                return lastInputSet;
+        }
+        // cache miss - construct new DCInputSet
+        Vector pages = (Vector)formDefns.get(formName);
+        if ( pages == null )
+        {
+                throw new DCInputsReaderException("Missing the " + formName  + " form");
+        }
+        lastInputSet = new DCInputSet(formName, pages, valuePairs);
+        return lastInputSet;
+    }
+    
+    /**
+     * Return the number of pages the inputs span for a desginated collection
+     * @param  collectionHandle   collection's unique Handle
+     * @return number of pages of input
+     * @throws DCInputsReaderException if no default set defined
+     */
+    public int getNumberInputPages(String collectionHandle)
+        throws DCInputsReaderException
+    {
+        return getInputs(collectionHandle).getNumberPages();
+    }
+    
+    /**
+     * Process the top level child nodes in the passed top-level node. These
+     * should correspond to the collection-form maps, the form definitions, and
+     * the display/storage word pairs.
+     */
+    private void doNodes(Node n)
+                throws SAXException, DCInputsReaderException
+    {
+        if (n == null)
+        {
+                return;
+        }
+        Node e = getElement(n);
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        boolean foundMap  = false;
+        boolean foundDefs = false;
+        for (int i = 0; i < len; i++)
+        {
+                Node nd = nl.item(i);
+                if ((nd == null) || isEmptyTextNode(nd))
+                {
+                        continue;
+                }
+                String tagName = nd.getNodeName();
+                if (tagName.equals("form-map"))
+                {
+                        processMap(nd);
+                        foundMap = true;
+                }
+                else if (tagName.equals("form-definitions"))
+                {
+                        processDefinition(nd);
+                        foundDefs = true;
+                }
+                else if (tagName.equals("form-value-pairs"))
+                {
+                        processValuePairs(nd);
+                }
+                // Ignore unknown nodes
+        }
+        if (!foundMap)
+        {
+                throw new DCInputsReaderException("No collection to form map found");
+        }
+        if (!foundDefs)
+        {
+                throw new DCInputsReaderException("No form definition found");
+        }
+    }
+
+    /**
+     * Process the form-map section of the XML file.
+     * Each element looks like:
+     *   <name-map collection-handle="hdl" form-name="name" />
+     * Extract the collection handle and form name, put name in hashmap keyed
+     * by the collection handle.
+     */
+    private void processMap(Node e)
+        throws SAXException
+    {
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+                Node nd = nl.item(i);
+                if (nd.getNodeName().equals("name-map"))
+                {
+                        String id = getAttribute(nd, "collection-handle");
+                        String value = getAttribute(nd, "form-name");
+                        String content = getValue(nd);
+                        if (id == null)
+                        {
+                                throw new SAXException("name-map element is missing collection-handle attribute");
+                        }
+                        if (value == null)
+                        {
+                                throw new SAXException("name-map element is missing form-name attribute");
+                        }
+                        if (content != null && content.length() > 0)
+                        {
+                                throw new SAXException("name-map element has content, it should be empty.");
+                        }
+                        whichForms.put(id, value);
+                }  // ignore any child node that isn't a "name-map"
+        }
+    }
+
+    /**
+     * Process the form-definitions section of the XML file. Each element is
+     * formed thusly: <form name="formname">...pages...</form> Each pages
+     * subsection is formed: <page number="#"> ...fields... </page> Each field
+     * is formed from: dc-element, dc-qualifier, label, hint, input-type name,
+     * required text, and repeatable flag.
+     */
+    private void processDefinition(Node e)
+        throws SAXException, DCInputsReaderException
+    {
+        int numForms = 0;
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+                Node nd = nl.item(i);
+                // process each form definition
+                if (nd.getNodeName().equals("form"))
+                {
+                        numForms++;
+                        String formName = getAttribute(nd, "name");
+                        if (formName == null)
+                        {
+                                throw new SAXException("form element has no name attribute");
+                        }
+                        Vector pages = new Vector(); // the form contains pages
+                        formDefns.put(formName, pages);
+                        NodeList pl = nd.getChildNodes();
+                        int lenpg = pl.getLength();
+                        for (int j = 0; j < lenpg; j++)
+                        {
+                                Node npg = pl.item(j);
+                                // process each page definition
+                                if (npg.getNodeName().equals("page"))
+                                {
+                                        String pgNum = getAttribute(npg, "number");
+                                        if (pgNum == null)
+                                        {
+                                                throw new SAXException("Form " + formName + " has no identified pages");
+                                        }
+                                        Vector page = new Vector();
+                                        pages.add(page);
+                                        NodeList flds = npg.getChildNodes();
+                                        int lenflds = flds.getLength();
+                                        for (int k = 0; k < lenflds; k++)
+                                        {
+                                                Node nfld = flds.item(k);
+                                                if ( nfld.getNodeName().equals("field") )
+                                                {
+                                                        // process each field definition
+                                                        HashMap field = new HashMap();
+                                                        page.add(field);
+                                                        processPageParts(formName, pgNum, nfld, field);
+                                                        String error = checkForDups(formName, field, pages);
+                                                        if (error != null)
+                                                        {
+                                                                throw new SAXException(error);
+                                                        }
+                                                }
+                                        }
+                                } // ignore any child that is not a 'page'
+                        }
+                        // sanity check number of pages
+                        if (pages.size() < 1)
+                        {
+                                throw new DCInputsReaderException("Form " + formName + " has no pages");
+                        }
+                }
+        }
+        if (numForms == 0)
+        {
+                throw new DCInputsReaderException("No form definition found");
+        }
+    }
+
+    /**
+     * Process parts of a field
+     * At the end, make sure that input-types 'qualdrop_value' and
+     * 'twobox' are marked repeatable. Complain if dc-element, label,
+     * or input-type are missing.
+     */
+    private void processPageParts(String formName, String page, Node n, HashMap field)
+        throws SAXException
+    {
+        NodeList nl = n.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+                Node nd = nl.item(i);
+                if ( ! isEmptyTextNode(nd) )
+                {
+                        String tagName = nd.getNodeName();
+                        String value   = getValue(nd);
+                        field.put(tagName, value);
+                        if (tagName.equals("input-type"))
+                        {
+                    if (value.equals("dropdown")
+                            || value.equals("qualdrop_value")
+                            || value.equals("list"))
+                                {
+                                        String pairTypeName = getAttribute(nd, PAIR_TYPE_NAME);
+                                        if (pairTypeName == null)
+                                        {
+                                                throw new SAXException("Form " + formName + ", field " +
+                                                                                                field.get("dc-element") +
+                                                                                                        "." + field.get("dc-qualifier") +
+                                                                                                " has no name attribute");
+                                        }
+                                        else
+                                        {
+                                                field.put(PAIR_TYPE_NAME, pairTypeName);
+                                        }
+                                }
+                        }
+                        else if (tagName.equals("vocabulary"))
+                        {
+                                String closedVocabularyString = getAttribute(nd, "closed");
+                            field.put("closedVocabulary", closedVocabularyString);
+                        }
+                }
+        }
+        String missing = null;
+        if (field.get("dc-element") == null)
+        {
+                missing = "dc-element";
+        }
+        if (field.get("label") == null)
+        {
+                missing = "label";
+        }
+        if (field.get("input-type") == null)
+        {
+                missing = "input-type";
+        }
+        if ( missing != null )
+        {
+                String msg = "Required field " + missing + " missing on page " + page + " of form " + formName;
+                throw new SAXException(msg);
+        }
+        String type = (String)field.get("input-type");
+        if (type.equals("twobox") || type.equals("qualdrop_value"))
+        {
+                String rpt = (String)field.get("repeatable");
+                if ((rpt == null) ||
+                                ((!rpt.equalsIgnoreCase("yes")) &&
+                                                (!rpt.equalsIgnoreCase("true"))))
+                {
+                        String msg = "The field \'"+field.get("label")+"\' must be repeatable";
+                        throw new SAXException(msg);
+                }
+        }
+    }
+
+    /**
+     * Check that this is the only field with the name dc-element.dc-qualifier
+     * If there is a duplicate, return an error message, else return null;
+     */
+    private String checkForDups(String formName, HashMap field, Vector pages)
+    {
+        int matches = 0;
+        String err = null;
+        String schema = (String)field.get("dc-schema");
+        String elem = (String)field.get("dc-element");
+        String qual = (String)field.get("dc-qualifier");
+        if ((schema == null) || (schema.equals("")))
+        {
+            schema = MetadataSchema.DC_SCHEMA;
+        }
+        String schemaTest;
+        
+        for (int i = 0; i < pages.size(); i++)
+        {
+            Vector pg = (Vector)pages.get(i);
+            for (int j = 0; j < pg.size(); j++)
+            {
+                HashMap fld = (HashMap)pg.get(j);
+                if ((fld.get("dc-schema") == null) ||
+                    (((String)fld.get("dc-schema")).equals("")))
+                {
+                    schemaTest = MetadataSchema.DC_SCHEMA;
+                }
+                else
+                {
+                    schemaTest = (String)fld.get("dc-schema");
+                }
+                
+                // Are the schema and element the same? If so, check the qualifier
+                if ((((String)fld.get("dc-element")).equals(elem)) &&
+                    (schemaTest.equals(schema)))
+                {
+                    String ql = (String)fld.get("dc-qualifier");
+                    if (qual != null)
+                    {
+                        if ((ql != null) && ql.equals(qual))
+                        {
+                            matches++;
+                        }
+                    }
+                    else if (ql == null)
+                    {
+                        matches++;
+                    }
+                }
+            }
+        }
+        if (matches > 1)
+        {
+            err = "Duplicate field " + schema + "." + elem + "." + qual + " detected in form " + formName;
+        }
+        
+        return err;
+    }
+
+
+    /**
+     * Process the form-value-pairs section of the XML file.
+     *  Each element is formed thusly:
+     *      <value-pairs name="..." dc-term="...">
+     *          <pair>
+     *            <display>displayed name-</display>
+     *            <storage>stored name</storage>
+     *          </pair>
+     * For each value-pairs element, create a new vector, and extract all
+     * the pairs contained within it. Put the display and storage values,
+     * respectively, in the next slots in the vector. Store the vector
+     * in the passed in hashmap.
+     */
+    private void processValuePairs(Node e)
+                throws SAXException
+    {
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+                Node nd = nl.item(i);
+                    String tagName = nd.getNodeName();
+
+                    // process each value-pairs set
+                    if (tagName.equals("value-pairs"))
+                    {
+                        String pairsName = getAttribute(nd, PAIR_TYPE_NAME);
+                        String dcTerm = getAttribute(nd, "dc-term");
+                        if (pairsName == null)
+                        {
+                                String errString =
+                                        "Missing name attribute for value-pairs for DC term " + dcTerm;
+                                throw new SAXException(errString);
+
+                        }
+                        Vector pairs = new Vector();
+                        valuePairs.put(pairsName, pairs);
+                        NodeList cl = nd.getChildNodes();
+                        int lench = cl.getLength();
+                        for (int j = 0; j < lench; j++)
+                        {
+                                Node nch = cl.item(j);
+                                String display = null;
+                                String storage = null;
+
+                                if (nch.getNodeName().equals("pair"))
+                                {
+                                        NodeList pl = nch.getChildNodes();
+                                        int plen = pl.getLength();
+                                        for (int k = 0; k < plen; k++)
+                                        {
+                                                Node vn= pl.item(k);
+                                                String vName = vn.getNodeName();
+                                                if (vName.equals("displayed-value"))
+                                                {
+                                                        display = getValue(vn);
+                                                }
+                                                else if (vName.equals("stored-value"))
+                                                {
+                                                        storage = getValue(vn);
+                                                        if (storage == null)
+                                                        {
+                                                                storage = "";
+                                                        }
+                                                } // ignore any children that aren't 'display' or 'storage'
+                                        }
+                                        pairs.add(display);
+                                        pairs.add(storage);
+                                } // ignore any children that aren't a 'pair'
+                        }
+                    } // ignore any children that aren't a 'value-pair'
+        }
+    }
+
+
+    /**
+     * Check that all referenced value-pairs are present
+     * and field is consistent
+     *
+     * Throws DCInputsReaderException if detects a missing value-pair.
+     */
+
+    private void checkValues()
+                throws DCInputsReaderException
+    {
+        // Step through every field of every page of every form
+        Iterator ki = formDefns.keySet().iterator();
+        while (ki.hasNext())
+        {
+                String idName = (String)ki.next();
+                Vector pages = (Vector)formDefns.get(idName);
+                for (int i = 0; i < pages.size(); i++)
+                {
+                        Vector page = (Vector)pages.get(i);
+                        for (int j = 0; j < page.size(); j++)
+                        {
+                                HashMap fld = (HashMap)page.get(j);
+                                // verify reference in certain input types
+                                String type = (String)fld.get("input-type");
+                    if (type.equals("dropdown")
+                            || type.equals("qualdrop_value")
+                            || type.equals("list"))
+                                {
+                                        String pairsName = (String)fld.get(PAIR_TYPE_NAME);
+                                        Vector v = (Vector)valuePairs.get(pairsName);
+                                        if (v == null)
+                                        {
+                                                String errString = "Cannot find value pairs for " + pairsName;
+                                                throw new DCInputsReaderException(errString);
+                                        }
+                                }
+                                // if visibility restricted, make sure field is not required
+                                String visibility = (String)fld.get("visibility");
+                                if (visibility != null && visibility.length() > 0 )
+                                {
+                                        String required = (String)fld.get("required");
+                                        if (required != null && required.length() > 0)
+                                        {
+                                                String errString = "Field '" + (String)fld.get("label") +
+                                                                        "' is required but invisible";
+                                                throw new DCInputsReaderException(errString);
+                                        }
+                                }
+                        }
+                }
+        }
+    }
+    
+    private Node getElement(Node nd)
+    {
+        NodeList nl = nd.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+            Node n = nl.item(i);
+            if (n.getNodeType() == Node.ELEMENT_NODE)
+            {
+                return n;
+            }
+        }
+        return null;
+     }
+
+    private boolean isEmptyTextNode(Node nd)
+    {
+        boolean isEmpty = false;
+        if (nd.getNodeType() == Node.TEXT_NODE)
+        {
+                String text = nd.getNodeValue().trim();
+                if (text.length() == 0)
+                {
+                        isEmpty = true;
+                }
+        }
+        return isEmpty;
+    }
+
+    /**
+     * Returns the value of the node's attribute named <name>
+     */
+    private String getAttribute(Node e, String name)
+    {
+        NamedNodeMap attrs = e.getAttributes();
+        int len = attrs.getLength();
+        if (len > 0)
+        {
+                int i;
+                for (i = 0; i < len; i++)
+                {
+                        Node attr = attrs.item(i);
+                        if (name.equals(attr.getNodeName()))
+                        {
+                                return attr.getNodeValue().trim();
+                        }
+                }
+        }
+        //no such attribute
+        return null;
+    }
+
+    /**
+     * Returns the value found in the Text node (if any) in the
+     * node list that's passed in.
+     */
+    private String getValue(Node nd)
+    {
+        NodeList nl = nd.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+                Node n = nl.item(i);
+                short type = n.getNodeType();
+                if (type == Node.TEXT_NODE)
+                {
+                        return n.getNodeValue().trim();
+                }
+        }
+        // Didn't find a text node
+        return null;
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/DCInputsReaderException.java

@@ -0,0 +1,87 @@
+/*
+ * DCInputsReaderException.java
+ *
+ * Version: $Revision: 3761 $
+ *
+ * Date: $Date: 2009-05-07 00:18:02 -0400 (Thu, 07 May 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.util;
+
+/**
+ * This is a superclass for exceptions representing a failure when
+ * importing or exporting a package.  E.g., unacceptable package format
+ * or contents.  Implementations should throw one of the more specific
+ * exceptions. This class is intended for declarations and catch clauses.
+ *
+ * @author Larry Stone
+ * @version $Revision: 3761 $
+ */
+public class DCInputsReaderException extends Exception
+{
+    /**
+     * No-args constructor.
+     */
+    public DCInputsReaderException()
+    {
+        super();
+    }
+
+    /**
+     * Constructor for a given message.
+     * @param message diagnostic message.
+     */
+    public DCInputsReaderException(String message)
+    {
+        super(message);
+    }
+
+    /**
+     * Constructor for a given cause.
+     * @param cause throwable that caused this exception
+     */
+    public DCInputsReaderException(Throwable cause)
+    {
+        super(cause);
+    }
+
+    /**
+     * Constructor to create a new exception wrapping it around another exception.
+     * @param message diagnostic message.
+     * @param cause throwable that caused this exception
+     */
+    public DCInputsReaderException(String message, Throwable cause)
+    {
+        super(message, cause);
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/DSpaceContextListener.java

@@ -0,0 +1,172 @@
+/*
+ * DSpaceContextListener.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.util;
+
+import org.dspace.core.ConfigurationManager;
+import org.dspace.storage.rdbms.DatabaseManager;
+import org.apache.log4j.Logger;
+
+import javax.servlet.ServletContextListener;
+import javax.servlet.ServletContextEvent;
+
+import java.beans.Introspector;
+import java.net.URL;
+import java.net.URLConnection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.util.Enumeration;
+
+/**
+ * Class to initialize / cleanup resources used by DSpace when the web application
+ * is started or stopped
+ */
+public class DSpaceContextListener implements ServletContextListener
+{
+    private static Logger log = Logger.getLogger(DSpaceContextListener.class);
+
+    /**
+     * The DSpace config parameter, this is where the path to the DSpace
+     * configuration file can be obtained
+     */
+    public static final String DSPACE_CONFIG_PARAMETER = "dspace-config";
+    
+    /**
+     * Initialize any resources required by the application
+     * @param event
+     */
+    public void contextInitialized(ServletContextEvent event)
+    {
+
+        // On Windows, URL caches can cause problems, particularly with undeployment
+        // So, here we attempt to disable them if we detect that we are running on Windows
+        try
+        {
+            String osName = System.getProperty("os.name");
+
+            if (osName != null && osName.toLowerCase().contains("windows"))
+            {
+                URL url = new URL("http://localhost/");
+                URLConnection urlConn = url.openConnection();
+                urlConn.setDefaultUseCaches(false);
+            }
+        }
+        catch (Throwable t)
+        {
+            log.error(t.getMessage(), t);
+            // Any errors thrown in disabling the caches aren't significant to
+            // the normal execution of the application, so we ignore them
+        }
+
+        // Paths to the various config files
+        String dspaceConfig = null;
+        
+        /**
+         * Stage 1
+         * 
+         * Locate the dspace config
+         */
+        
+        // first check the local per webapp parameter, then check the global parameter.
+        dspaceConfig = event.getServletContext().getInitParameter(DSPACE_CONFIG_PARAMETER);
+        
+        // Finaly, if no config parameter found throw an error
+        if (dspaceConfig == null || "".equals(dspaceConfig))
+        {
+            throw new RuntimeException(
+                    "\n\nDSpace has failed to initialize. This has occurred because it was unable to determine \n" +
+                    "where the dspace.cfg file is located. The path to the configuration file should be stored \n" +
+                    "in a context variable, '"+DSPACE_CONFIG_PARAMETER+"', in the global context. \n" +
+                    "No context variable was found in either location.\n\n");
+        }
+            
+        /**
+         * Stage 2
+         * 
+         * Load the dspace config. Also may load log4j configuration.
+         * (Please rely on ConfigurationManager or Log4j to configure logging)
+         * 
+         */
+        try 
+        {
+            ConfigurationManager.loadConfig(dspaceConfig);
+        }
+        catch (Throwable t)
+        {
+            throw new RuntimeException(
+                    "\n\nDSpace has failed to initialize, during stage 2. Error while attempting to read the \n" +
+                    "DSpace configuration file (Path: '"+dspaceConfig+"'). \n" +
+                    "This has likely occurred because either the file does not exist, or it's permissions \n" +
+                    "are set incorrectly, or the path to the configuration file is incorrect. The path to \n" +
+                    "the DSpace configuration file is stored in a context variable, 'dspace-config', in \n" +
+                    "either the local servlet or global context.\n\n",t);
+        }
+
+    }
+
+    /**
+     * Clean up resources used by the application when stopped
+     * 
+     * @param event
+     */
+    public void contextDestroyed(ServletContextEvent event)
+    {
+        try
+        {
+            // Remove the database pool
+            DatabaseManager.shutdown();
+
+            // Clean out the introspector
+            Introspector.flushCaches();
+
+            // Remove any drivers registered by this classloader
+            for (Enumeration e = DriverManager.getDrivers(); e.hasMoreElements();)
+            {
+                Driver driver = (Driver) e.nextElement();
+                if (driver.getClass().getClassLoader() == getClass().getClassLoader())
+                {
+                    DriverManager.deregisterDriver(driver);
+                }
+            }
+        }
+        catch (Throwable e)
+        {
+            log.error("Failed to cleanup ClassLoader for webapp", e);
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/DailyFileAppender.java

@@ -0,0 +1,369 @@
+/*
+ * DailyFileApender.java
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+
+import java.io.File;
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.apache.commons.lang.time.DateUtils;
+import org.apache.log4j.FileAppender;
+import org.apache.log4j.Logger;
+import org.apache.log4j.helpers.LogLog;
+import org.apache.log4j.spi.LoggingEvent;
+
+/**
+ * Special log appender for log4j. Adds the current date (ie. year-mon) to
+ * the end of the file name, so that rolling on to the next log is simply
+ * a case of starting a new one - no renaming of old logs.
+ *
+ * This is advisable if you are using Windows, and have multiple applications
+ * (ie. dspace, dspace-oai, dspace-sword) that all want to write to the same log file,
+ * as each would otherwise try to rename the old files during rollover.
+ *
+ * An example log4j.properties (one log per month, retains three months of logs)
+ *
+ * log4j.rootCategory=INFO, A1
+ * log4j.appender.A1=org.dspace.app.util.DailyFileAppender
+ * log4j.appender.A1.File=@@log.dir@@/dspace.log
+ * log4j.appender.A1.DatePattern=yyyy-MM
+ * log4j.appender.A1.MaxLogs=3
+ * log4j.appender.A1.layout=org.apache.log4j.PatternLayout
+ * log4j.appender.A1.layout.ConversionPattern=%d %-5p %c @ %m%n
+ *
+ */
+public class DailyFileAppender extends FileAppender
+{
+	private static Logger log = Logger.getLogger(DailyFileAppender.class);
+    /**
+     * The fixed date pattern to be used if one is not specified.
+     */
+    private static String DATE_PATTERN = "yyyy-MM-dd";
+
+    /**
+     * The folder under which daily folders are created. This can be a absolute path
+     * or relative path also.
+     * e.g. JavaLogs/CPRILog or F:/LogFiles/CPRILog
+     */
+    private String mstrFileName;
+
+    /**
+     * Used internally and contains the name of the date derived from current system date.
+     */
+    private Date   mstrDate = new Date(System.currentTimeMillis());
+
+    /**
+     * Holds the user specified DatePattern,
+     */
+    private String mstrDatePattern = DATE_PATTERN;
+
+    private boolean mMonthOnly = false;
+
+    /**
+     * The date formatter object used for parsing the user specified DatePattern.
+     */
+    private SimpleDateFormat mobjSDF;
+
+    private boolean mWithHostName = false;
+
+    private int mMaxLogs = 0;
+
+    /**
+     * Default constructor. This is required as the appender class is dynamically
+     * loaded.
+     */
+    public DailyFileAppender()
+    {
+        super();
+    }
+
+    /* (non-Javadoc)
+     * @see org.apache.log4j.FileAppender#activateOptions()
+     */
+    public void activateOptions()
+    {
+        setFileName();
+        cleanupOldFiles();
+        super.activateOptions();
+    }
+
+/*------------------------------------------------------------------------------
+ * Getters
+ *----------------------------------------------------------------------------*/
+    public String getDatePattern()
+    {
+        return this.mstrDatePattern;
+    }
+
+    public String getFile()
+    {
+        return this.mstrFileName;
+    }
+
+    public boolean getWithHost()
+    {
+        return mWithHostName;
+    }
+
+    public int getMaxLogs()
+    {
+    	return mMaxLogs;
+    }
+
+/*------------------------------------------------------------------------------
+ * Setters
+ *----------------------------------------------------------------------------*/
+    public void setDatePattern(String pstrPattern)
+    {
+        this.mstrDatePattern = checkPattern(pstrPattern);
+        if (mstrDatePattern.contains("dd") || mstrDatePattern.contains("DD"))
+            mMonthOnly = false;
+        else
+            mMonthOnly = true;
+    }
+
+    public void setFile(String file)
+    {
+        // Trim spaces from both ends. The users probably does not want
+        // trailing spaces in file names.
+        String val = file.trim();
+        mstrFileName = val;
+     }
+
+    public void setWithHost(boolean wh)
+    {
+        mWithHostName = wh;
+    }
+
+    public void setMaxLogs(int ml)
+    {
+    	mMaxLogs = ml;
+    }
+
+/*------------------------------------------------------------------------------
+ * Methods
+ *----------------------------------------------------------------------------*/
+    /* (non-Javadoc)
+     * @see org.apache.log4j.WriterAppender#subAppend(org.apache.log4j.spi.LoggingEvent)
+     */
+    protected void subAppend(LoggingEvent pobjEvent)
+    {
+        Date   dtNow = new Date(System.currentTimeMillis());
+
+        boolean rollover = false;
+
+        if (mMonthOnly)
+        {
+            Calendar now = Calendar.getInstance();
+            Calendar cur = Calendar.getInstance();
+            now.setTime(dtNow);
+            cur.setTime(mstrDate);
+            rollover = !(now.get(Calendar.YEAR) == cur.get(Calendar.YEAR) && now.get(Calendar.MONTH) == cur.get(Calendar.MONTH));
+        }
+        else
+        {
+            rollover = !(DateUtils.isSameDay(dtNow, mstrDate));
+        }
+
+        if (rollover)
+        {
+            try
+            {
+                rollOver(dtNow);
+            }
+            catch (IOException IOEx)
+            {
+                LogLog.error("rollOver() failed!", IOEx);
+            }
+        }
+
+        super.subAppend(pobjEvent);
+    }
+
+/*------------------------------------------------------------------------------
+ * Helpers
+ *----------------------------------------------------------------------------*/
+    /**
+     * The helper function to vaildate the DatePattern.
+     * @param pstrPattern The DatePattern to be validated.
+     * @return The validated date pattern or defautlt DATE_PATTERN
+     */
+    private String checkPattern(String pstrPattern)
+    {
+        String strRet = null;
+        SimpleDateFormat objFmt = new SimpleDateFormat(DATE_PATTERN);
+
+        try
+        {
+            this.mobjSDF = new SimpleDateFormat(pstrPattern);
+            strRet = pstrPattern;
+        }
+        catch (NullPointerException NPExIgnore)
+        {
+            LogLog.error("Invalid DatePattern " + pstrPattern, NPExIgnore);
+            this.mobjSDF = objFmt;
+            strRet = DATE_PATTERN;
+        }
+        catch (IllegalArgumentException IlArgExIgnore)
+        {
+            LogLog.error("Invalid DatePattern " + pstrPattern, IlArgExIgnore);
+            this.mobjSDF = objFmt;
+            strRet = DATE_PATTERN;
+        }
+        finally
+        {
+            objFmt = null;
+        }
+        return strRet;
+    }
+
+    /**
+     * This function is responsible for performing the actual file rollover.
+     * @param pstrName The name of the new folder based on current system date.
+     * @throws IOException
+     */
+    static private boolean deletingFiles = false;
+    private void cleanupOldFiles()
+    {
+        // If we need to delete log files
+        if (mMaxLogs > 0 && !deletingFiles)
+        {
+			deletingFiles = true;
+
+			// Determine the final file extension with the hostname
+    		String hostFileExt = null;
+            try
+            {
+                hostFileExt = "." + java.net.InetAddress.getLocalHost().getHostName();
+            }
+            catch (UnknownHostException e)
+            {
+                LogLog.error("Unable to retrieve host name");
+            }
+
+			try
+			{
+				// Array to hold the logs we are going to keep
+				File[] logsToKeep = new File[mMaxLogs];
+
+				// Get a 'master' file handle, and the parent directory from it
+		        File logMaster = new File(mstrFileName);
+		        File logDir = logMaster.getParentFile();
+		        if (logDir.isDirectory())
+		        {
+		        	// Iterate all the files in that directory
+		        	File[] logArr = logDir.listFiles();
+		        	for (File curLog : logArr)
+		        	{
+        				log.info("Comparing '" + curLog.getAbsolutePath() + "' to '" + mstrFileName + "'");
+		        		String name = curLog.getAbsolutePath();
+
+		        		// First, see if we are not using hostname, or the log file ends with this host
+		                if (!mWithHostName || (hostFileExt != null && name.endsWith(hostFileExt)))
+		                {
+		                	// Check that the file is indeed one we want (contains the master file name)
+			        		if (name.contains(mstrFileName))
+			        		{
+			        			// Iterate through the array of logs we are keeping
+			        			for (int i = 0; curLog != null && i < logsToKeep.length; i++)
+			        			{
+			        				// Have we exhausted the 'to keep' array?
+			        				if (logsToKeep[i] == null)
+			        				{
+				        				// Empty space, retain this log file
+			        					logsToKeep[i] = curLog;
+			        					curLog = null;
+			        				}
+			        				// If the 'kept' file is older than the current one
+			        				else if (logsToKeep[i].getName().compareTo(curLog.getName()) < 0)
+			        				{
+			        					// Replace tested entry with current file
+			        					File temp = logsToKeep[i];
+			        					logsToKeep[i] = curLog;
+			        					curLog = temp;
+			        				}
+			        			}
+
+			        			// If we have a 'current' entry at this point, it's a log we don't want
+			        			if (curLog != null)
+			        			{
+			        				log.info("Deleting log " + curLog.getName());
+		        					curLog.delete();
+			        			}
+			        		}
+		                }
+		        	}
+		        }
+			}
+			catch (Exception e)
+			{
+				// Don't worry about exceptions
+			}
+			finally
+			{
+				deletingFiles = false;
+			}
+        }
+    }
+
+    private void rollOver(Date dtNow) throws IOException
+    {
+        mstrDate = dtNow;
+        setFileName();
+        this.setFile(fileName, true, bufferedIO, bufferSize);
+
+        cleanupOldFiles();
+    }
+
+    private void setFileName()
+    {
+        fileName = mstrFileName + "." + mobjSDF.format(mstrDate);
+
+        if (mWithHostName)
+        {
+            try
+            {
+                fileName += "." + java.net.InetAddress.getLocalHost().getHostName();
+            }
+            catch (UnknownHostException e)
+            {
+                LogLog.error("Unable to retrieve host name");
+            }
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/MetadataExposure.java

@@ -0,0 +1,176 @@
+/*
+ * MetadataExposure.java
+ *
+ * Version: $Revision: 3734 $
+ *
+ * Date: $Date: 2009-04-24 00:00:19 -0400 (Fri, 24 Apr 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Enumeration;
+import java.sql.SQLException;
+
+import org.apache.log4j.Logger;
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.core.Constants;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+
+/**
+ * Static utility class to manage configuration for exposure (hiding) of
+ * certain Item metadata fields.
+ *
+ * This class answers the question, "is the user allowed to see this
+ * metadata field?"  Any external interface (UI, OAI-PMH, etc) that
+ * disseminates metadata should consult it before disseminating the value
+ * of a metadata field.
+ *
+ * Since the MetadataExposure.isHidden() method gets called in a lot of inner
+ * loops, it is important to implement it efficiently, in both time and
+ * memory utilization.  It computes an answer without consuming ANY memory
+ * (e.g. it does not build any temporary Strings) and in close to constant
+ * time by use of hash tables.  Although most sites will only hide a few
+ * fields, we can't predict what the usage will be so it's better to make it
+ * scalable.
+ *
+ * Algorithm is as follows:
+ *  1. If a Context is provided and it has a user who is Administrator,
+ *     always grant access (return false).
+ *  2. Return true if field is on the hidden list, false otherwise.
+ *
+ * The internal maps are populated from DSpace Configuration at the first
+ * call, in case the properties are not available in the static context.
+ *
+ * Configuration Properties:
+ *  ## hide a single metadata field
+ *  #metadata.hide.SCHEMA.ELEMENT[.QUALIFIER] = true
+ *  # example: dc.type
+ *  metadata.hide.dc.type = true
+ *  # example: dc.description.provenance
+ *  metadata.hide.dc.description.provenance = true
+ *
+ * @author Larry Stone
+ * @version $Revision: 3734 $
+ */
+public class MetadataExposure
+{
+    private static Logger log = Logger.getLogger(MetadataExposure.class);
+
+    private static Map<String,Set<String>> hiddenElementSets = null;
+    private static Map<String,Map<String,Set<String>>> hiddenElementMaps = null;
+
+    private static final String CONFIG_PREFIX = "metadata.hide.";
+
+    public static boolean isHidden(Context context, String schema, String element, String qualifier)
+        throws SQLException
+    {
+        // the administrator's override
+        if (context != null && AuthorizeManager.isAdmin(context))
+            return false;
+
+        // for schema.element, just check schema->elementSet
+        init();
+        if (qualifier == null)
+        {
+            Set<String> elts = hiddenElementSets.get(schema);
+            return elts == null ? false : elts.contains(element);
+        }
+
+        // for schema.element.qualifier, just schema->eltMap->qualSet
+        else
+        {
+            Map<String,Set<String>> elts = hiddenElementMaps.get(schema);
+            if (elts == null)
+                return false;
+            Set<String> quals = elts.get(element);
+            return quals == null ? false : quals.contains(qualifier);
+        }
+    }
+
+    // load maps from configuration unless it's already done.
+    private static void init()
+    {
+        if (hiddenElementSets == null)
+        {
+            hiddenElementSets = new HashMap<String,Set<String>>();
+            hiddenElementMaps = new HashMap<String,Map<String,Set<String>>>();
+
+            Enumeration pne = ConfigurationManager.propertyNames();
+            while (pne.hasMoreElements())
+            {
+                String key = (String)pne.nextElement();
+                if (key.startsWith(CONFIG_PREFIX))
+                {
+                    String mdField = key.substring(CONFIG_PREFIX.length());
+                    String segment[] = mdField.split("\\.", 3);
+
+                    // got schema.element.qualifier
+                    if (segment.length == 3)
+                    {
+                        Map<String,Set<String>> eltMap = hiddenElementMaps.get(segment[0]);
+                        if (eltMap == null)
+                        {
+                            eltMap = new HashMap<String,Set<String>>();
+                            hiddenElementMaps.put(segment[0], eltMap);
+                        }
+                        if (!eltMap.containsKey(segment[1]))
+                        {
+                            eltMap.put(segment[1], new HashSet<String>());
+                        }
+                        eltMap.get(segment[1]).add(segment[2]);
+                    }
+
+                    // got schema.element
+                    else if (segment.length == 2)
+                    {
+                        if (!hiddenElementSets.containsKey(segment[0]))
+                        {
+                            hiddenElementSets.put(segment[0], new HashSet<String>());
+                        }
+                        hiddenElementSets.get(segment[0]).add(segment[1]);
+                    }
+
+                    // oops..
+                    else
+                    {
+                        log.warn("Bad format in hidden metadata directive, field=\""+mdField+"\", config property="+key);
+                    }
+                }
+            }
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/OpenSearch.java

@@ -0,0 +1,381 @@
+/*
+ * OpenSearch.java
+ *
+ * Version: $Revision: 1.20 $
+ *
+ * Date: $Date: 2005/08/25 17:20:27 $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.UUID;
+import java.net.URLEncoder;
+import java.io.UnsupportedEncodingException;
+
+import org.w3c.dom.Document;
+
+import org.jdom.DocType;
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.jdom.Namespace;
+import org.jdom.output.DOMOutputter;
+import org.jdom.output.XMLOutputter;
+
+import org.apache.log4j.Logger;
+
+import org.dspace.content.Bitstream;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.content.DCDate;
+import org.dspace.content.DCValue;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.Item;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Constants;
+import org.dspace.handle.HandleManager;
+import org.dspace.search.QueryResults;
+
+import com.sun.syndication.feed.WireFeed;
+import com.sun.syndication.feed.atom.Category;
+import com.sun.syndication.feed.atom.Content;
+import com.sun.syndication.feed.atom.Feed;
+import com.sun.syndication.feed.atom.Entry;
+import com.sun.syndication.feed.atom.Link;
+import com.sun.syndication.feed.atom.Person;
+import com.sun.syndication.feed.rss.Channel;
+import com.sun.syndication.feed.rss.Description;
+import com.sun.syndication.feed.rss.Image;
+import com.sun.syndication.io.WireFeedOutput;
+import com.sun.syndication.feed.module.opensearch.OpenSearchModule;
+import com.sun.syndication.feed.module.opensearch.entity.OSQuery;
+import com.sun.syndication.feed.module.opensearch.impl.OpenSearchModuleImpl;
+import com.sun.syndication.io.FeedException;
+
+/**
+ * Utility Class with static methods for producing OpenSearch-compliant search results,
+ * and the OpenSearch description document.
+ * <p>
+ * OpenSearch is a specification for describing and advertising search-engines
+ * and their result formats. Commonly, RSS and Atom formats are used, which
+ * the current implementation supports, as is HTML (used directly in browsers).
+ * NB: this is baseline OpenSearch, no extensions currently supported.
+ * </p>
+ * <p>
+ * The value of the "scope" parameter should either be absent (which means no
+ * scope restriction), or the handle of a community or collection.
+ * </p>
+ * 
+ * @author Richard Rodgers
+ *
+ */
+public class OpenSearch
+{
+    private static final Logger log = Logger.getLogger(OpenSearch.class);
+
+    // are open search queries enabled?
+    private static boolean enabled = false;
+    // supported results formats
+    private static List<String> formats = null;
+    // Namespaces used
+    private static final String osNs = "http://a9.com/-/spec/opensearch/1.1/";
+
+    // base search UI URL
+    private static String uiUrl = null;
+    // base search service URL
+    private static String svcUrl = null;
+    
+    static
+    {
+    	enabled = ConfigurationManager.getBooleanProperty("websvc.opensearch.enable");
+        svcUrl = ConfigurationManager.getProperty("dspace.url") + "/" +
+                 ConfigurationManager.getProperty("websvc.opensearch.svccontext");
+        uiUrl = ConfigurationManager.getProperty("dspace.url") + "/" +
+                ConfigurationManager.getProperty("websvc.opensearch.uicontext");
+
+    	// read rest of config info if enabled
+    	formats = new ArrayList<String>();
+    	if (enabled)
+    	{
+    		String fmtsStr = ConfigurationManager.getProperty("websvc.opensearch.formats");
+    		if ( fmtsStr != null )
+    		{
+    			for (String fmt : fmtsStr.split(","))
+    			{
+    				formats.add(fmt);
+    			}
+    		}
+    	}
+        }
+    
+    /**
+     * Returns list of supported formats
+     * 
+     * @return list of format names - 'rss', 'atom' or 'html'
+     */
+    public static List<String> getFormats()
+    {
+    	return formats;
+    }
+    
+    /**
+     * Returns a mime-type associated with passed format
+     * 
+     * @param format the results document format (rss, atom, html)
+     * @return content-type mime-type
+     */
+    public static String getContentType(String format)
+    {
+    	return "html".equals(format) ? "text/html" : 
+    									"application/" + format + "+xml; charset=UTF-8";
+    }
+    
+    /**
+     * Returns the OpenSearch service document appropriate for given scope
+     * 
+     * @param scope - null for entire repository, or handle or community or collection
+     * @return document the service document
+     * @throws IOException
+     */
+    public static Document getDescriptionDoc(String scope) throws IOException
+    {
+    	return jDomToW3(getServiceDocument(scope));
+    }
+    
+    /**
+     * Returns OpenSearch Servic Document as a string
+     * 
+     * @param scope - null for entire repository, or handle or community or collection
+     * @return service document as a string
+     */
+    public static String getDescription(String scope)
+    {
+    	return new XMLOutputter().outputString(getServiceDocument(scope));
+    }
+    
+    /**
+     * Returns a formatted set of search results as a string
+     * 
+     * @param format results format - html, rss or atom
+     * @param query - the search query
+     * @param qResults - the query results to be formatted
+     * @param scope - search scope, null or community/collection handle
+     * @param results the retreived DSpace objects satisfying search
+     * @param labels labels to apply - format specific
+     * @return formatted search results
+     * @throws IOException
+     */
+    public static String getResultsString(String format, String query, QueryResults qResults,
+    		                          	  DSpaceObject scope, DSpaceObject[] results,
+    		                          	  Map<String, String> labels) throws IOException
+    {
+            try
+            {
+            return getResults(format, query, qResults, scope, results, labels).outputString();
+            }
+        catch (FeedException e)
+            {
+            log.error(e.toString(), e);
+            	throw new IOException("Unable to generate feed");
+            }
+        }
+    
+    /**
+     * Returns a formatted set of search results as a document
+     * 
+     * @param format results format - html, rss or atom
+     * @param query - the search query
+     * @param qResults - the query results to be formatted
+     * @param scope - search scope, null or community/collection handle
+     * @param results the retreived DSpace objects satisfying search
+     * @param labels labels to apply - format specific
+     * @return formatted search results
+     * @throws IOException
+     */
+    public static Document getResultsDoc(String format, String query, QueryResults qResults,
+    		                          DSpaceObject scope, DSpaceObject[] results, Map<String, String> labels)
+                                      throws IOException
+    {
+        	try
+        	{
+            return getResults(format, query, qResults, scope, results, labels).outputW3CDom();
+        	}
+        catch (FeedException e)
+        	{
+            log.error(e.toString(), e);
+            throw new IOException("Unable to generate feed");
+        	}
+    
+        }
+    
+    private static SyndicationFeed getResults(String format, String query, QueryResults qResults,
+                                          DSpaceObject scope, DSpaceObject[] results, Map<String, String> labels)
+    {
+        // Encode results in requested format
+        if ("rss".equals(format))
+            format = "rss_2.0";
+        else if ("atom".equals(format))
+            format = "atom_1.0";
+    	
+        SyndicationFeed feed = new SyndicationFeed(labels.get(SyndicationFeed.MSG_UITYPE));
+        feed.populate(null, scope, results, labels);
+        feed.setType(format);
+        feed.addModule(openSearchMarkup(query, qResults));
+    	return feed;
+	}
+    
+    /*
+     * Generates the OpenSearch elements which are added to the RSS or Atom feeds as foreign markup
+     * wrapped in a module
+     * 
+     * @param query the search query
+     * @param qRes the search results
+     * @return module
+     */
+    private static OpenSearchModule openSearchMarkup(String query, QueryResults qRes)
+    { 
+    	OpenSearchModule osMod = new OpenSearchModuleImpl();
+    	osMod.setTotalResults(qRes.getHitCount());
+    	osMod.setStartIndex(qRes.getStart());
+    	osMod.setItemsPerPage(qRes.getPageSize());
+    	OSQuery osq = new OSQuery();
+    	osq.setRole("request");
+        try
+        {
+            osq.setSearchTerms(URLEncoder.encode(query, "UTF-8"));
+        	}
+        catch(UnsupportedEncodingException e)
+        	{
+            log.error(e);
+        	}
+        osq.setStartPage(1 + (qRes.getStart() / qRes.getPageSize()));
+        osMod.addQuery(osq);
+        return osMod;
+        	}
+    
+    /**
+     * Returns as a document the OpenSearch service document
+     * 
+     * @param scope - null for the entire repository, or a collection/community handle
+     * @return Service Document
+     */
+    private static org.jdom.Document getServiceDocument(String scope)
+    {
+    	Namespace ns = Namespace.getNamespace(osNs);
+        Element root = new Element("OpenSearchDescription", ns);
+        root.addContent(new Element("ShortName", ns).setText(ConfigurationManager.getProperty("websvc.opensearch.shortname")));
+        root.addContent(new Element("LongName", ns).setText(ConfigurationManager.getProperty("websvc.opensearch.longname")));
+        root.addContent(new Element("Description", ns).setText(ConfigurationManager.getProperty("websvc.opensearch.description")));
+        root.addContent(new Element("InputEncoding", ns).setText("UTF-8"));
+        root.addContent(new Element("OutputEncoding", ns).setText("UTF-8"));
+        // optional elements
+        String sample = ConfigurationManager.getProperty("websvc.opensearch.samplequery");
+        if (sample != null && sample.length() > 0)
+        {
+        	Element sq = new Element("Query", ns).setAttribute("role", "example");
+        	root.addContent(sq.setAttribute("searchTerms", sample));
+        }
+        String tags = ConfigurationManager.getProperty("websvc.opensearch.tags");
+        if (tags != null && tags.length() > 0)
+        {
+        	root.addContent(new Element("Tags", ns).setText(tags));
+        }
+        String contact = ConfigurationManager.getProperty("mail.admin");
+        if (contact != null && contact.length() > 0)
+        {
+        	root.addContent(new Element("Contact", ns).setText(contact));
+        }
+        String faviconUrl = ConfigurationManager.getProperty("websvc.opensearch.faviconurl");
+        if (faviconUrl != null && faviconUrl.length() > 0)
+        {
+        	String dim = String.valueOf(16);
+        	String type = faviconUrl.endsWith("ico") ? "image/vnd.microsoft.icon" : "image/png";
+        	Element fav = new Element("Image", ns).setAttribute("height", dim).setAttribute("width", dim).
+        	                setAttribute("type", type).setText(faviconUrl);
+        	root.addContent(fav);
+        }
+        // service URLs
+        for (String format : formats)
+        {
+        	Element url = new Element("Url", ns).setAttribute("type", getContentType(format));
+        	StringBuffer template = new StringBuffer();
+        	if ("html".equals(format))
+        	{
+        		template.append(uiUrl);
+        	}
+        	else
+        	{
+        		template.append(svcUrl);
+        	}
+            template.append("?query={searchTerms}");
+        	if(! "html".equals(format))
+        	{
+               	template.append("&start={startIndex?}&rpp={count?}&format=");
+               	template.append(format);
+        	}
+        	if (scope != null)
+        	{
+        		template.append("&scope=");
+        		template.append(scope);
+        	}
+        	url.setAttribute("template", template.toString());
+        	root.addContent(url);
+        }
+        return new org.jdom.Document(root);
+    }
+    
+    /**
+     * Converts a JDOM document to a W3C one
+     * @param jdomDoc
+     * @return W3C Document object
+     * @throws IOException
+     */
+    private static Document jDomToW3(org.jdom.Document jdomDoc) throws IOException
+    {
+        DOMOutputter domOut = new DOMOutputter();
+        try
+        {
+        	return domOut.output(jdomDoc);
+        }
+        catch(JDOMException jde)
+        {
+        	throw new IOException("JDOM output exception");
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/SubmissionConfig.java

@@ -0,0 +1,209 @@
+/*
+ * SubmissionConfig.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.util;
+
+import java.util.Vector;
+import java.util.Map;
+import java.io.Serializable;
+
+import org.apache.log4j.Logger;
+
+/**
+ * Class representing a single Item Submission config definition, organized into
+ * steps. This class represents the structure of a single 'submission-process'
+ * node in the item-submission.xml configuration file.
+ *
+ * Note: Implements Serializable as it will be saved to the current session during submission.
+ * Please ensure that nothing is added to this class that isn't also serializable
+ * 
+ * @see org.dspace.app.util.SubmissionConfigReader
+ * @see org.dspace.app.util.SubmissionStepConfig
+ * 
+ * @author Tim Donohue, based on DCInputSet by Brian S. Hughes
+ * @version $Revision$
+ */
+
+public class SubmissionConfig implements Serializable
+{
+    /** name of the item submission process */
+    private String submissionName = null;
+
+    /** the configuration classes for the steps in this submission process */
+    private SubmissionStepConfig[] submissionSteps = null;
+
+    /** whether or not this submission process is being used in a workflow * */
+    private boolean isWorkflow = false;
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(SubmissionConfig.class);
+
+    /**
+     * Constructs a new Submission Configuration object, based on the XML
+     * configuration file (item-submission.xml)
+     * 
+     * @param submissionName
+     *            the submission process name
+     * @param steps
+     *            the vector listing of step information to build
+     *            SubmissionStepConfig objects for this submission process
+     * @param isWorkflowProcess
+     *            whether this submission process is being used in a workflow or
+     *            not. If it is a workflow process this may limit the steps that
+     *            are available for editing.
+     */
+    public SubmissionConfig(String submissionName, Vector steps,
+            boolean isWorkflowProcess)
+    {
+        this.submissionName = submissionName;
+        this.isWorkflow = isWorkflowProcess;
+
+        // initialize a vector of SubmissionStepConfig objects
+        Vector stepConfigs = new Vector();
+
+        // loop through our steps, and create SubmissionStepConfig objects
+        for (int stepNum = 0; stepNum < steps.size(); stepNum++)
+        {
+            Map stepInfo = (Map) steps.get(stepNum);
+            SubmissionStepConfig step = new SubmissionStepConfig(stepInfo);
+
+            // Only add this step to the process if either:
+            // (a) this is not a workflow process OR
+            // (b) this is a workflow process, and this step is editable in a
+            // workflow
+            if ((!this.isWorkflow)
+                    || ((this.isWorkflow) && step.isWorkflowEditable()))
+            {
+                // set the number of the step (starts at 0) and add it
+                step.setStepNumber(stepConfigs.size());
+                stepConfigs.add(step);
+
+                log.debug("Added step '" + step.getProcessingClassName()
+                        + "' as step #" + step.getStepNumber()
+                        + " of submission process " + submissionName);
+
+            }
+        }
+
+        // get steps as an array of Strings
+        submissionSteps = (SubmissionStepConfig[]) stepConfigs
+                .toArray(new SubmissionStepConfig[0]);
+    }
+
+    /**
+     * Return the name of the item submission process definition
+     * 
+     * @return the name of the submission process
+     */
+    public String getSubmissionName()
+    {
+        return submissionName;
+    }
+
+    /**
+     * Return the number of steps in this submission process
+     * 
+     * @return number of steps
+     */
+    public int getNumberOfSteps()
+    {
+        return submissionSteps.length;
+    }
+
+    /**
+     * Return whether or not this submission process is being used in a
+     * workflow!
+     * 
+     * @return true, if it's a workflow process. false, otherwise.
+     */
+    public boolean isWorkflow()
+    {
+        return isWorkflow;
+    }
+
+    /**
+     * Retrieve a particular Step configuration in this Item Submission Process
+     * configuration. The first step is numbered "0" (although step #0 is the
+     * implied "select collection" step).
+     * <p>
+     * If you want to retrieve the step after the "select collection" step, you
+     * should retrieve step #1.
+     * 
+     * If the specified step isn't found, null is returned.
+     * 
+     * @param stepNum
+     *            desired step to retrieve
+     * 
+     * @return the SubmissionStepConfig object for the step
+     */
+
+    public SubmissionStepConfig getStep(int stepNum)
+    {
+        if ((stepNum > submissionSteps.length - 1) || (stepNum < 0))
+        {
+            return null;
+        }
+        else
+        {
+            return submissionSteps[stepNum];
+        }
+    }
+
+    /**
+     * Returns whether or not there are more steps which follow the specified
+     * "stepNum". For example, if you specify stepNum=4, then this method checks
+     * to see if there is a Step #5. The first step is numbered "0".
+     * 
+     * @param stepNum
+     *            the current step.
+     * 
+     * @return true, if a step at "stepNum+1" exists. false, otherwise.
+     */
+
+    public boolean hasMoreSteps(int stepNum)
+    {
+        if (getStep(stepNum + 1) != null)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/SubmissionConfigReader.java

@@ -0,0 +1,689 @@
+/*
+ * SubmissionConfigReader.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.util;
+
+import java.io.File;
+import java.util.Vector;
+import java.util.HashMap;
+import java.util.Map;
+import java.lang.Exception;
+import javax.servlet.ServletException;
+import org.xml.sax.SAXException;
+import org.w3c.dom.*;
+import javax.xml.parsers.*;
+
+import org.apache.log4j.Logger;
+
+import org.dspace.core.ConfigurationManager;
+
+/**
+ * Item Submission configuration generator for DSpace. Reads and parses the
+ * installed submission process configuration file, item-submission.xml, from
+ * the configuration directory. This submission process definiton details the
+ * ordering of the steps (and number of steps) that occur during the Item
+ * Submission Process. There may be multiple Item Submission processes defined,
+ * where each definition is assigned a unique name.
+ * 
+ * The file also specifies which collections use which Item Submission process.
+ * At a minimum, the definitions file must define a default mapping from the
+ * placeholder collection # to the distinguished submission process 'default'.
+ * Any collections that use a custom submission process are listed paired with
+ * the name of the item submission process they use.
+ * 
+ * @see org.dspace.app.util.SubmissionConfig
+ * @see org.dspace.app.util.SubmissionStepConfig
+ * 
+ * @author Tim Donohue based on DCInputsReader by Brian S. Hughes
+ * @version $Revision$
+ */
+
+public class SubmissionConfigReader
+{
+    /**
+     * The ID of the default collection. Will never be the ID of a named
+     * collection
+     */
+    public static final String DEFAULT_COLLECTION = "default";
+
+    /** Prefix of the item submission definition XML file */
+    static final String SUBMIT_DEF_FILE_PREFIX = "item-submission";
+    
+    /** Suffix of the item submission definition XML file */
+    static final String SUBMIT_DEF_FILE_SUFFIX = ".xml";
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(SubmissionConfigReader.class);
+
+	/** The fully qualified pathname of the directory containing the Item Submission Configuration file */
+    private String configDir = ConfigurationManager.getProperty("dspace.dir")
+            + File.separator + "config" + File.separator;
+            
+    /**
+     * Hashmap which stores which submission process configuration is used by
+     * which collection, computed from the item submission config file
+     * (specifically, the 'submission-map' tag)
+     */
+    private HashMap collectionToSubmissionConfig = null;
+
+    /**
+     * Reference to the global submission step definitions defined in the
+     * "step-definitions" section
+     */
+    private HashMap stepDefns = null;
+
+    /**
+     * Reference to the item submission definitions defined in the
+     * "submission-definitions" section
+     */
+    private HashMap submitDefns = null;
+
+    /**
+     * Mini-cache of last SubmissionConfig object requested (so that we don't
+     * always reload from scratch)
+     */
+    private SubmissionConfig lastSubmissionConfig = null;
+
+    /**
+     * Load Submission Configuration from the
+     * item-submission.xml configuration file 
+     */
+    public SubmissionConfigReader() throws ServletException
+    {
+        buildInputs(configDir + SUBMIT_DEF_FILE_PREFIX + SUBMIT_DEF_FILE_SUFFIX);
+    }
+
+    /**
+     * Parse an XML encoded item submission configuration file.
+     * <P>
+     * Creates two main hashmaps:
+     * <ul>
+     * <li>Hashmap of Collection to Submission definition mappings -
+     * defines which Submission process a particular collection uses
+     * <li>Hashmap of all Submission definitions.  List of all valid
+     * Submision Processes by name.
+     * </ul>
+     */
+    private void buildInputs(String fileName) throws ServletException
+    {
+        collectionToSubmissionConfig = new HashMap();
+        submitDefns = new HashMap();
+
+        String uri = "file:" + new File(fileName).getAbsolutePath();
+
+        try
+        {
+            DocumentBuilderFactory factory = DocumentBuilderFactory
+                    .newInstance();
+            factory.setValidating(false);
+            factory.setIgnoringComments(true);
+            factory.setIgnoringElementContentWhitespace(true);
+
+            DocumentBuilder db = factory.newDocumentBuilder();
+            Document doc = db.parse(uri);
+            doNodes(doc);
+        }
+        catch (FactoryConfigurationError fe)
+        {
+            throw new ServletException(
+                    "Cannot create Item Submission Configuration parser", fe);
+        }
+        catch (Exception e)
+        {
+            throw new ServletException(
+                    "Error creating Item Submission Configuration: " + e);
+        }
+    }
+
+    /**
+     * Returns the Item Submission process config used for a particular
+     * collection, or the default if none is defined for the collection
+     * 
+     * @param collectionHandle
+     *            collection's unique Handle
+     * @param isWorkflow
+     *            whether or not we are loading the submission process for a
+     *            workflow
+     * @return the SubmissionConfig representing the item submission config
+     * 
+     * @throws ServletException
+     *             if no default submission process configuration defined
+     */
+    public SubmissionConfig getSubmissionConfig(String collectionHandle,
+            boolean isWorkflow) throws ServletException
+    {
+        // get the name of the submission process config for this collection
+        String submitName = (String) collectionToSubmissionConfig
+                .get(collectionHandle);
+        if (submitName == null)
+        {
+            submitName = (String) collectionToSubmissionConfig
+                    .get(DEFAULT_COLLECTION);
+        }
+        if (submitName == null)
+        {
+            throw new ServletException(
+                    "No item submission process configuration designated as 'default' in 'submission-map' section of 'item-submission.xml'.");
+        }
+
+        log.debug("Loading submission process config named '" + submitName
+                + "'");
+
+        // check mini-cache, and return if match
+        if (lastSubmissionConfig != null
+                && lastSubmissionConfig.getSubmissionName().equals(submitName)
+                && lastSubmissionConfig.isWorkflow() == isWorkflow)
+        {
+            log.debug("Found submission process config '" + submitName
+                    + "' in cache.");
+
+            return lastSubmissionConfig;
+        }
+
+        // cache miss - construct new SubmissionConfig
+        Vector steps = (Vector) submitDefns.get(submitName);
+
+        if (steps == null)
+        {
+            throw new ServletException(
+                    "Missing the Item Submission process config '" + submitName
+                            + "' (or unable to load) from 'item-submission.xml'.");
+        }
+
+        log.debug("Submission process config '" + submitName
+                + "' not in cache. Reloading from scratch.");
+
+        lastSubmissionConfig = new SubmissionConfig(submitName, steps,
+                isWorkflow);
+
+        log.debug("Submission process config has "
+                + lastSubmissionConfig.getNumberOfSteps() + " steps listed.");
+
+        return lastSubmissionConfig;
+    }
+
+    /**
+     * Returns a particular global step definition based on its ID.
+     * <P>
+     * Global step definitions are those defined in the <step-definitions>
+     * section of the configuration file.
+     * 
+     * @param stepID
+     *            step's identifier
+     * 
+     * @return the SubmissionStepConfig representing the step
+     * 
+     * @throws ServletException
+     *             if no default submission process configuration defined
+     */
+    public SubmissionStepConfig getStepConfig(String stepID)
+            throws ServletException
+    {
+        // We should already have the step definitions loaded
+        if (stepDefns != null)
+        {
+            // retreive step info
+            Map stepInfo = (Map) stepDefns.get(stepID);
+
+            if (stepInfo != null)
+                return new SubmissionStepConfig(stepInfo);
+        }
+
+        return null;
+    }
+
+    /**
+     * Process the top level child nodes in the passed top-level node. These
+     * should correspond to the collection-form maps, the form definitions, and
+     * the display/storage word pairs.
+     */
+    private void doNodes(Node n) throws SAXException, ServletException
+    {
+        if (n == null)
+        {
+            return;
+        }
+        Node e = getElement(n);
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        boolean foundMap = false;
+        boolean foundStepDefs = false;
+        boolean foundSubmitDefs = false;
+        for (int i = 0; i < len; i++)
+        {
+            Node nd = nl.item(i);
+            if ((nd == null) || isEmptyTextNode(nd))
+            {
+                continue;
+            }
+            String tagName = nd.getNodeName();
+            if (tagName.equals("submission-map"))
+            {
+                processMap(nd);
+                foundMap = true;
+            }
+            else if (tagName.equals("step-definitions"))
+            {
+                processStepDefinition(nd);
+                foundStepDefs = true;
+            }
+            else if (tagName.equals("submission-definitions"))
+            {
+                processSubmissionDefinition(nd);
+                foundSubmitDefs = true;
+            }
+            // Ignore unknown nodes
+        }
+        if (!foundMap)
+        {
+            throw new ServletException(
+                    "No collection to item submission map ('submission-map') found in 'item-submission.xml'");
+        }
+        if (!foundStepDefs)
+        {
+            throw new ServletException("No 'step-definitions' section found in 'item-submission.xml'");
+        }
+        if (!foundSubmitDefs)
+        {
+            throw new ServletException(
+                    "No 'submission-definitions' section found in 'item-submission.xml'");
+        }
+    }
+
+    /**
+     * Process the submission-map section of the XML file. Each element looks
+     * like: <name-map collection-handle="hdl" submission-name="name" /> Extract
+     * the collection handle and item submission name, put name in hashmap keyed
+     * by the collection handle.
+     */
+    private void processMap(Node e) throws SAXException
+    {
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+            Node nd = nl.item(i);
+            if (nd.getNodeName().equals("name-map"))
+            {
+                String id = getAttribute(nd, "collection-handle");
+                String value = getAttribute(nd, "submission-name");
+                String content = getValue(nd);
+                if (id == null)
+                {
+                    throw new SAXException(
+                            "name-map element is missing collection-handle attribute in 'item-submission.xml'");
+                }
+                if (value == null)
+                {
+                    throw new SAXException(
+                            "name-map element is missing submission-name attribute in 'item-submission.xml'");
+                }
+                if (content != null && content.length() > 0)
+                {
+                    throw new SAXException(
+                            "name-map element has content in 'item-submission.xml', it should be empty.");
+                }
+                collectionToSubmissionConfig.put(id, value);
+            } // ignore any child node that isn't a "name-map"
+        }
+    }
+
+    /**
+     * Process the "step-definition" section of the XML file. Each element is
+     * formed thusly: <step id="unique-id"> ...step_fields... </step> The valid
+     * step_fields are: heading, processing-servlet.
+     * <P>
+     * Extract the step information (from the step_fields) and place in a
+     * HashMap whose key is the step's unique id.
+     */
+    private void processStepDefinition(Node e) throws SAXException,
+            ServletException
+    {
+        int numStepDefns = 0;
+        stepDefns = new HashMap();
+
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+            Node nd = nl.item(i);
+            // process each step definition
+            if (nd.getNodeName().equals("step"))
+            {
+                numStepDefns++;
+                String stepID = getAttribute(nd, "id");
+                if (stepID == null)
+                {
+                    throw new SAXException(
+                            "step element has no 'id' attribute in 'item-submission.xml', which is required in the 'step-definitions' section");
+                }
+                else if (stepDefns.containsKey(stepID))
+                {
+                    throw new SAXException(
+                            "There are two step elements with the id '" + stepID + "' in 'item-submission.xml'");
+                }
+
+                HashMap stepInfo = processStepChildNodes("step-definition", nd);
+
+                stepDefns.put(stepID, stepInfo);
+            } // ignore any child that is not a 'step'
+        }
+
+        // Sanity check number of step definitions
+        if (stepDefns.size() < 1)
+        {
+            throw new ServletException(
+                    "step-definition section has no steps! A step with id='collection' is required in 'item-submission.xml'!");
+        }
+
+        // Sanity check to see that the required "collection" step is defined
+        if (!stepDefns.containsKey(SubmissionStepConfig.SELECT_COLLECTION_STEP))
+        {
+            throw new ServletException(
+                    "The step-definition section is REQUIRED to have a step with id='"
+                            + SubmissionStepConfig.SELECT_COLLECTION_STEP
+                            + "' in 'item-submission.xml'!  This step is used to ensure that a new item submission is assigned to a collection.");
+        }
+
+        // Sanity check to see that the required "complete" step is defined
+        if (!stepDefns.containsKey(SubmissionStepConfig.COMPLETE_STEP))
+        {
+            throw new ServletException(
+                    "The step-definition section is REQUIRED to have a step with id='"
+                            + SubmissionStepConfig.COMPLETE_STEP
+                            + "' in 'item-submission.xml'!  This step is used to perform all processing necessary at the completion of the submission (e.g. starting workflow).");
+        }
+    }
+
+    /**
+     * Process the "submission-definition" section of the XML file. Each element
+     * is formed thusly: <submission-process name="submitName">...steps...</submit-process>
+     * Each step subsection is formed: <step> ...step_fields... </step> (with
+     * optional "id" attribute, to reference a step from the <step-definition>
+     * section). The valid step_fields are: heading, class-name.
+     * <P>
+     * Extract the submission-process name and steps and place in a HashMap
+     * whose key is the submission-process's unique name.
+     */
+    private void processSubmissionDefinition(Node e) throws SAXException,
+            ServletException
+    {
+        int numSubmitProcesses = 0;
+        Vector submitNames = new Vector();
+
+        // find all child nodes of the 'submission-definition' node and loop
+        // through
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+            Node nd = nl.item(i);
+
+            // process each 'submission-process' node
+            if (nd.getNodeName().equals("submission-process"))
+            {
+                numSubmitProcesses++;
+                String submitName = getAttribute(nd, "name");
+                if (submitName == null)
+                {
+                    throw new SAXException(
+                            "'submission-process' element has no 'name' attribute in 'item-submission.xml'");
+                }
+                else if (submitNames.contains(submitName))
+                {
+                    throw new SAXException(
+                            "There are two 'submission-process' elements with the name '"
+                                    + submitName + "' in 'item-submission.xml'.");
+                }
+                submitNames.add(submitName);
+
+                // the 'submission-process' definition contains steps
+                Vector steps = new Vector();
+                submitDefns.put(submitName, steps);
+
+                // loop through all the 'step' nodes of the 'submission-process'
+                int stepNum = 0;
+                NodeList pl = nd.getChildNodes();
+                int lenStep = pl.getLength();
+                for (int j = 0; j < lenStep; j++)
+                {
+                    Node nStep = pl.item(j);
+                    stepNum++;
+
+                    // process each 'step' definition
+                    if (nStep.getNodeName().equals("step"))
+                    {
+                        // check for an 'id' attribute
+                        String stepID = getAttribute(nStep, "id");
+
+                        HashMap stepInfo;
+
+                        // if this step has an id, load its information from the
+                        // step-definition section
+                        if ((stepID != null) && (stepID.length() > 0))
+                        {
+                            if (stepDefns.containsKey(stepID))
+                            {
+                                // load the step information from the
+                                // step-definition
+                                stepInfo = (HashMap) stepDefns.get(stepID);
+                            }
+                            else
+                            {
+                                throw new SAXException(
+                                        "The Submission process config named "
+                                                + submitName
+                                                + " contains a step with id="
+                                                + stepID
+                                                + ".  There is no step with this 'id' defined in the 'step-definition' section of 'item-submission.xml'.");
+                            }
+
+                            // Ignore all children of a step element with an
+                            // "id"
+                        }
+                        else
+                        {
+                            // get information about step from its children
+                            // nodes
+                            stepInfo = processStepChildNodes(
+                                    "submission-process", nStep);
+                        }
+
+                        steps.add(stepInfo);
+
+                    } // ignore any child that is not a 'step'
+                }
+
+                // sanity check number of steps
+                if (steps.size() < 1)
+                {
+                    throw new ServletException(
+                            "Item Submission process config named "
+                                    + submitName + " has no steps defined in 'item-submission.xml'");
+                }
+
+                // ALL Item Submission processes MUST BEGIN with selecting a
+                // Collection. So, automatically insert in the "collection" step
+                // (from the 'step-definition' section)
+                // Note: we already did a sanity check that this "collection"
+                // step exists.
+                steps.add(0, (HashMap) stepDefns
+                        .get(SubmissionStepConfig.SELECT_COLLECTION_STEP));
+
+                // ALL Item Submission processes MUST END with the
+                // "Complete" processing step.
+                // So, automatically append in the "complete" step
+                // (from the 'step-definition' section)
+                // Note: we already did a sanity check that this "complete"
+                // step exists.
+                steps.add((HashMap) stepDefns
+                        .get(SubmissionStepConfig.COMPLETE_STEP));
+
+            }
+        }
+        if (numSubmitProcesses == 0)
+        {
+            throw new ServletException(
+                    "No 'submission-process' elements/definitions found in 'item-submission.xml'");
+        }
+    }
+
+    /**
+     * Process the children of the "step" tag of the XML file. Returns a HashMap
+     * of all the fields under that "step" tag, where the key is the field name,
+     * and the value is the field value.
+     * 
+     */
+    private HashMap processStepChildNodes(String configSection, Node nStep)
+            throws SAXException, ServletException
+    {
+        // initialize the HashMap of step Info
+        HashMap stepInfo = new HashMap();
+
+        NodeList flds = nStep.getChildNodes();
+        int lenflds = flds.getLength();
+        for (int k = 0; k < lenflds; k++)
+        {
+            // process each child node of a <step> tag
+            Node nfld = flds.item(k);
+
+            if (!isEmptyTextNode(nfld))
+            {
+                String tagName = nfld.getNodeName();
+                String value = getValue(nfld);
+                stepInfo.put(tagName, value);
+            }
+        }// end for each field
+
+        // check for ID attribute & save to step info
+        String stepID = getAttribute(nStep, "id");
+        if (stepID != null && stepID.length() > 0)
+        {
+            stepInfo.put("id", stepID);
+        }
+
+        // look for REQUIRED 'step' information
+        String missing = null;
+        if (stepInfo.get("processing-class") == null)
+        {
+            missing = "'processing-class'";
+        }
+        if (missing != null)
+        {
+            String msg = "Required field " + missing
+                    + " missing in a 'step' in the " + configSection
+                    + " of the item submission configuration file ('item-submission.xml')";
+            throw new SAXException(msg);
+        }
+
+        return stepInfo;
+    }
+
+    private Node getElement(Node nd)
+    {
+        NodeList nl = nd.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+            Node n = nl.item(i);
+            if (n.getNodeType() == Node.ELEMENT_NODE)
+            {
+                return n;
+            }
+        }
+        return null;
+    }
+
+    private boolean isEmptyTextNode(Node nd)
+    {
+        boolean isEmpty = false;
+        if (nd.getNodeType() == Node.TEXT_NODE)
+        {
+            String text = nd.getNodeValue().trim();
+            if (text.length() == 0)
+            {
+                isEmpty = true;
+            }
+        }
+        return isEmpty;
+    }
+
+    /**
+     * Returns the value of the node's attribute named <name>
+     */
+    private String getAttribute(Node e, String name)
+    {
+        NamedNodeMap attrs = e.getAttributes();
+        int len = attrs.getLength();
+        if (len > 0)
+        {
+            int i;
+            for (i = 0; i < len; i++)
+            {
+                Node attr = attrs.item(i);
+                if (name.equals(attr.getNodeName()))
+                {
+                    return attr.getNodeValue().trim();
+                }
+            }
+        }
+        // no such attribute
+        return null;
+    }
+
+    /**
+     * Returns the value found in the Text node (if any) in the node list that's
+     * passed in.
+     */
+    private String getValue(Node nd)
+    {
+        NodeList nl = nd.getChildNodes();
+        int len = nl.getLength();
+        for (int i = 0; i < len; i++)
+        {
+            Node n = nl.item(i);
+            short type = n.getNodeType();
+            if (type == Node.TEXT_NODE)
+            {
+                return n.getNodeValue().trim();
+            }
+        }
+        // Didn't find a text node
+        return null;
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/SubmissionInfo.java

@@ -0,0 +1,734 @@
+/*
+ * SubmissionInfo.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+
+import org.apache.log4j.Logger;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+import org.dspace.content.InProgressSubmission;
+
+import org.dspace.submit.AbstractProcessingStep;
+import org.dspace.workflow.WorkflowItem;
+
+/**
+ * Information about an item being editing with the submission UI
+ * 
+ * @author Robert Tansley
+ * @version $Revision$
+ */
+public class SubmissionInfo
+{
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(SubmissionInfo.class);
+    
+    /** The item which is being submitted */
+    private InProgressSubmission submissionItem = null;
+
+    /**
+    * The Submission process config, which holds all info about the submission
+    * process that this item is going through (including all steps, etc)
+    */
+    private SubmissionConfig submissionConfig = null;
+    
+    /**
+    * Handle of the collection where this item is being submitted
+    */
+    private String collectionHandle = null;
+    
+    /***************************************************************************
+    * Holds all information used to build the Progress Bar in a key,value set.
+    * Keys are the number of the step, followed by the number of the page
+    * within the step (e.g. "2.1" = The first page of Step 2) (e.g. "5.2" = The
+    * second page of Step 5) Values are the Headings to display for each step
+    * (e.g. "Describe")
+    **************************************************************************/
+    private HashMap progressBar = null;
+    
+    /** The element or element_qualifier to show more input boxes for */
+    private String moreBoxesFor;
+
+    /** The element or element_qualifier to scroll to initially using anchor */
+    private String jumpToField;
+
+    /** If non-empty, form-relative indices of missing fields */
+    private List missingFields;
+
+    /** Specific bundle we're dealing with */
+    private Bundle bundle;
+
+    /** Specific bitstream we're dealing with */
+    private Bitstream bitstream;
+    
+    /** Reader for submission process configuration file * */
+    private static SubmissionConfigReader submissionConfigReader;
+    
+    /**
+     * Default Constructor - PRIVATE
+     * <p>
+     * Create a SubmissionInfo object
+     * using the load() method!
+     * 
+     */
+    private SubmissionInfo()
+    {
+    }
+
+    /**
+     * Loads all known submission information based on the given in progress
+     * submission and request object.
+     * <P>
+     * If subItem is null, then just loads the default submission information
+     * for a new submission.
+     * 
+     * @param request
+     *            The HTTP Servlet Request object          
+     * @param subItem
+     *            The in-progress submission we are loading information for
+     * 
+     * @return a SubmissionInfo object
+     * 
+     * @throws ServletException
+     *             if an error occurs
+     */
+    public static SubmissionInfo load(HttpServletRequest request, InProgressSubmission subItem) throws ServletException
+    {
+        boolean forceReload = false;
+    	SubmissionInfo subInfo = new SubmissionInfo();
+        
+        // load SubmissionConfigReader only the first time
+        // or if we're using a different UI now.
+        if (submissionConfigReader == null)
+        {
+            submissionConfigReader = new SubmissionConfigReader();
+            forceReload=true;
+        }
+
+        // save the item which is going through the submission process
+        subInfo.setSubmissionItem(subItem);
+
+        // Only if the submission item is created can we set its collection
+        String collectionHandle = SubmissionConfigReader.DEFAULT_COLLECTION;
+        if (subItem != null)
+        {
+            collectionHandle = subItem.getCollection().getHandle();
+        }
+
+        // save this collection handle to this submission info object
+        subInfo.setCollectionHandle(collectionHandle);
+
+        // load Submission Process config for this item's collection
+        // (Note: this also loads the Progress Bar info, since it is
+        // dependent on the Submission config)
+        loadSubmissionConfig(request, subInfo, forceReload);
+
+        return subInfo;
+    }
+
+    /**
+     * Is this submission in the workflow process?
+     * 
+     * @return true if the current submission is in the workflow process
+     */
+    public boolean isInWorkflow()
+    {
+        return ((this.submissionItem != null) && this.submissionItem instanceof WorkflowItem);
+    }
+
+    /**
+     * Return the current in progress submission
+     * 
+     * @return the InProgressSubmission object representing the current
+     *         submission
+     */
+    public InProgressSubmission getSubmissionItem()
+    {
+        return this.submissionItem;
+    }
+
+    /**
+     * Updates the current in progress submission item
+     * 
+     * @param subItem
+     *            the new InProgressSubmission object
+     */
+    public void setSubmissionItem(InProgressSubmission subItem)
+    {
+        this.submissionItem = subItem;
+    }
+
+    /**
+     * Return the current submission process config (which includes all steps
+     * which need to be completed for the submission to be successful)
+     * 
+     * @return the SubmissionConfig object, which contains info on all the steps
+     *         in the current submission process
+     */
+    public SubmissionConfig getSubmissionConfig()
+    {
+        return this.submissionConfig;
+    }
+
+    /**
+     * Causes the SubmissionConfig to be completely reloaded from the XML
+     * configuration file (item-submission.xml).
+     * <P>
+     * Note: This also reloads the progress bar info, since the progress bar
+     * depends entirely on the submission process (and its steps).
+     * 
+     * @param request
+     *            The HTTP Servlet Request object
+     * 
+     * @throws ServletException
+     *             if an error occurs
+     */
+    public void reloadSubmissionConfig(HttpServletRequest request)
+            throws ServletException
+    {
+        // Only if the submission item is created can we set its collection
+        String collectionHandle = SubmissionConfigReader.DEFAULT_COLLECTION;
+        if (this.submissionItem != null)
+        {
+            collectionHandle = submissionItem.getCollection().getHandle();
+        }
+        this.setCollectionHandle(collectionHandle);
+
+        // force a reload of the submission process configuration
+        loadSubmissionConfig(request, this, true);
+    }
+
+    /**
+     * Returns a particular global step definition based on its ID.
+     * <P>
+     * Global step definitions are those defined in the <step-definitions>
+     * section of the configuration file.
+     * 
+     * @param stepID
+     *            step's identifier
+     * 
+     * @return the SubmissionStepConfig representing the step
+     * 
+     * @throws ServletException
+     *             if no default submission process configuration defined
+     */
+    public SubmissionStepConfig getStepConfig(String stepID)
+            throws ServletException
+    {
+        return submissionConfigReader.getStepConfig(stepID);
+    }
+
+    
+    /**
+     * Return text information suitable for logging.
+     * <p>
+     * This method is used by several of the Step classes
+     * to log major events during the submission process (e.g. when
+     * license agreement was accepted, when item was submitted, 
+     * when it was available in DSpace, etc.)
+     * 
+     * @return the type and ID of the submission, bundle and/or bitstream for
+     *         logging
+     */
+    public String getSubmissionLogInfo()
+    {
+        String info = "";
+
+        if (isInWorkflow())
+        {
+            info = info + "workflow_id=" + getSubmissionItem().getID();
+        }
+        else
+        {
+            info = info + "workspace_item_id" + getSubmissionItem().getID();
+        }
+
+        if (getBundle() != null)
+        {
+            info = info + ",bundle_id=" + getBundle().getID();
+        }
+
+        if (getBitstream() != null)
+        {
+            info = info + ",bitstream_id=" + getBitstream().getID();
+        }
+
+        return info;
+    }
+    
+    /**
+     * Gets the handle of the collection to which this item is being submitted
+     * 
+     * @return the collection handle
+     */
+    public String getCollectionHandle()
+    {
+        return this.collectionHandle;
+    }
+
+    /**
+     * Sets the handle of the collection to which this item is being submitted
+     * 
+     * @param handle
+     *            the new collection handle
+     */
+    public void setCollectionHandle(String handle)
+    {
+        this.collectionHandle = handle;
+    }
+
+    /**
+     * Return the information used to build the progress bar (this includes all
+     * the steps in this submission, as well as the ordering and names of the
+     * steps).
+     * <p>
+     * Returns a Hashmap, with the following specifics:
+     * <p>
+     * Keys are the number of the step, followed by the number of the page
+     * within the step
+     * <p>
+     * (e.g. "2.1" = The first page of Step 2)
+     * <p>
+     * (e.g. "5.2" = The second page of Step 5)
+     * <P>
+     * Values are the Headings to display for each step (e.g. "Describe")
+     * 
+     * @return a Hashmap of Progress Bar information.
+     */
+    public Map getProgressBarInfo()
+    {
+        return this.progressBar;
+    }
+
+    /**
+     * Return the current bitstream we're working with (This is used during
+     * upload processes, or user interfaces that are dealing with bitstreams)
+     * 
+     * @return the Bitstream object for the bitstream
+     */
+    public Bitstream getBitstream()
+    {
+        return this.bitstream;
+    }
+
+    /**
+     * Sets the current bitstream we're working with (This is used during upload
+     * processes, or user interfaces that are dealing with bitstreams)
+     * 
+     * @param bits
+     *            the bitstream
+     */
+    public void setBitstream(Bitstream bits)
+    {
+        this.bitstream = bits;
+    }
+
+    /**
+     * Return the current bundle we're working with (This is used during upload
+     * processes, or user interfaces that are dealing with bundles/bitstreams)
+     * 
+     * @return the Bundle object for the bundle
+     */
+    public Bundle getBundle()
+    {
+        return this.bundle;
+    }
+
+    /**
+     * Sets the current bundle we're working with (This is used during upload
+     * processes, or user interfaces that are dealing with bundles/bitstreams)
+     * 
+     * @param bund
+     *            the bundle
+     */
+    public void setBundle(Bundle bund)
+    {
+        this.bundle = bund;
+    }
+
+    /**
+     * Return form related indices of the required fields which were not filled
+     * out by the user.
+     * 
+     * @return a List of empty fields which are required
+     */
+    public List getMissingFields()
+    {
+        return this.missingFields;
+    }
+
+    /**
+     * Sets the form related indices of the required fields which were not
+     * filled out by the user.
+     * 
+     * @param missing
+     *            the List of empty fields which are required
+     */
+    public void setMissingFields(List missing)
+    {
+        this.missingFields = missing;
+    }
+
+    /**
+     * Return metadata field which user has requested more input boxes be
+     * displayed (by pressing "Add More" on one of the "Describe" pages)
+     * 
+     * @return the String name of the field element
+     */
+    public String getMoreBoxesFor()
+    {
+        return this.moreBoxesFor;
+    }
+
+    /**
+     * Sets the metadata field which user has requested more input boxes be
+     * displayed (by pressing "Add More" on one of the "Describe" pages)
+     * 
+     * @param fieldname
+     *            the name of the field element on the page
+     */
+    public void setMoreBoxesFor(String fieldname)
+    {
+        this.moreBoxesFor = fieldname;
+    }
+
+    /**
+     * Return metadata field which JSP should "jump to" (i.e. set focus on) when
+     * the JSP next loads. This is used during the Describe step.
+     * 
+     * @return the String name of the field element
+     */
+    public String getJumpToField()
+    {
+        return this.jumpToField;
+    }
+
+    /**
+     * Sets metadata field which JSP should "jump to" (i.e. set focus on) when
+     * the JSP next loads. This is used during the Describe step.
+     * 
+     * @param fieldname
+     *            the name of the field on the page
+     */
+    public void setJumpToField(String fieldname)
+    {
+        this.jumpToField = fieldname;
+    }
+
+    /**
+     * Load necessary information to build the Progress Bar for the Item
+     * Submission Progress.
+     * 
+     * This information is returned in the form of a HashMap (which is then
+     * stored as a part of the SubmissionInfo). The HashMap takes the following
+     * form:
+     * 
+     * Keys - the number of the step, followed by the number of the page within
+     * the step (e.g. "2.1" = The first page of Step 2) (e.g. "5.2" = The second
+     * page of Step 5)
+     * 
+     * Values - the headings to display for each step (e.g. "Describe",
+     * "Verify")
+     * 
+     * @param request
+     *            The HTTP Servlet Request object
+     * @param subInfo
+     *            the SubmissionInfo object we are loading into
+     * @param forceReload
+     *            If true, this method reloads from stratch (and overwrites
+     *            cached progress bar info)
+     * 
+     */
+    private static void loadProgressBar(HttpServletRequest request,
+            SubmissionInfo subInfo, boolean forceReload)
+    {
+        LinkedHashMap progressBarInfo = null;
+
+        log.debug("Loading Progress Bar Info");
+
+        if (!forceReload)
+        {
+            // first, attempt to load from cache
+            progressBarInfo = (LinkedHashMap) loadProgressBarFromCache(request
+                    .getSession());
+        }
+
+        if (progressBarInfo != null && log.isDebugEnabled())
+        {
+            log.debug("Found Progress Bar Info in cache: "
+                    + progressBarInfo.size()
+                    + " pages to display in progress bar");
+        }
+        // if unable to load from cache, must load from scratch
+        else
+        {
+            progressBarInfo = new LinkedHashMap();
+
+            // loop through all steps
+            for (int i = 0; i < subInfo.submissionConfig.getNumberOfSteps(); i++)
+            {
+                // get the current step info
+                SubmissionStepConfig currentStep = subInfo.submissionConfig
+                        .getStep(i);
+                String stepNumber = Integer.toString(currentStep
+                        .getStepNumber());
+                String stepHeading = currentStep.getHeading();
+
+                // as long as this step is visible, include it in
+                // the Progress Bar
+                if (currentStep.isVisible())
+                {
+                    // default to just one page in this step
+                    int numPages = 1;
+
+                    try
+                    {
+                        // load the processing class for this step
+                        ClassLoader loader = subInfo.getClass()
+                                .getClassLoader();
+                        Class stepClass = loader.loadClass(currentStep
+                                .getProcessingClassName());
+
+                        // call the "getNumberOfPages()" method of the class
+                        // to get it's number of pages
+                        AbstractProcessingStep step = (AbstractProcessingStep) stepClass
+                                .newInstance();
+
+                        // get number of pages from servlet
+                        numPages = step.getNumberOfPages(request, subInfo);
+                    }
+                    catch (Exception e)
+                    {
+                        log.error(
+                                "Error loading progress bar information from Step Class '"
+                                        + currentStep.getProcessingClassName()
+                                        + "' Error:", e);
+                    }
+
+                    // save each of the step's pages to the progress bar
+                    for (int j = 1; j <= numPages; j++)
+                    {
+                        String pageNumber = Integer.toString(j);
+
+                        // store ("stepNumber.pageNumber", Heading) for each
+                        // page in the step
+                        progressBarInfo.put(stepNumber + "." + pageNumber,
+                                stepHeading);
+                    }// end for each page
+                }
+            }// end for each step
+
+            log.debug("Loaded Progress Bar Info from scratch: "
+                    + progressBarInfo.size()
+                    + " pages to display in progress bar");
+
+            // cache this new progress bar
+            saveProgressBarToCache(request.getSession(), progressBarInfo);
+        }// end if null
+
+        // save progressBarInfo to submission Info
+        subInfo.progressBar = progressBarInfo;
+    }
+
+    /**
+     * Saves all progress bar information into session cache. This saves us from
+     * having to reload this same progress bar over and over again.
+     * 
+     * @param session
+     *            The HTTP Session object
+     * @param progressBarInfo
+     *            The progress bar info to cache
+     * 
+     */
+    private static void saveProgressBarToCache(HttpSession session,
+            HashMap progressBarInfo)
+    {
+        // cache progress bar info to Session
+        session.setAttribute("submission.progressbar", progressBarInfo);
+    }
+
+    /**
+     * Attempts to retrieve progress bar information (for a particular
+     * collection) from session cache.
+     * 
+     * If the progress bar info cannot be found, returns null
+     * 
+     * @param session
+     *            The HTTP Session object
+     * 
+     * @return progressBarInfo HashMap (if found), or null (if not)
+     * 
+     */
+    private static HashMap loadProgressBarFromCache(HttpSession session)
+    {
+        return (HashMap) session.getAttribute("submission.progressbar");
+    }
+
+    /**
+     * Loads SubmissionConfig object for the given submission info object. If a
+     * SubmissionConfig object cannot be loaded, a Servlet Error is thrown.
+     * <p>
+     * This method just loads this SubmissionConfig object internally, so that
+     * it is available via a call to "getSubmissionConfig()"
+     * 
+     * @param request
+     *            The HTTP Servlet Request object
+     * @param subInfo
+     *            the SubmissionInfo object we are loading into
+     * @param forceReload
+     *            If true, this method reloads from stratch (and overwrites
+     *            cached SubmissionConfig)
+     * 
+     */
+    private static void loadSubmissionConfig(HttpServletRequest request,
+            SubmissionInfo subInfo, boolean forceReload)
+            throws ServletException
+    {
+
+        log.debug("Loading Submission Config information");
+
+        if (!forceReload)
+        {
+            // first, try to load from cache
+            subInfo.submissionConfig = loadSubmissionConfigFromCache(request
+                    .getSession(), subInfo.getCollectionHandle(), subInfo
+                    .isInWorkflow());
+        }
+
+        if (subInfo.submissionConfig == null || forceReload)
+        {
+            // reload the proper Submission process config
+            // (by reading the XML config file)
+            subInfo.submissionConfig = submissionConfigReader
+                    .getSubmissionConfig(subInfo.getCollectionHandle(), subInfo
+                            .isInWorkflow());
+
+            // cache this new submission process configuration
+            saveSubmissionConfigToCache(request.getSession(),
+                    subInfo.submissionConfig, subInfo.getCollectionHandle(),
+                    subInfo.isInWorkflow());
+
+            // also must force reload Progress Bar info,
+            // since it's based on the Submission config
+            loadProgressBar(request, subInfo, true);
+        }
+        else
+        {
+            log.debug("Found Submission Config in session cache!");
+
+            // try and reload progress bar from cache
+            loadProgressBar(request, subInfo, false);
+        }
+    }
+
+    /**
+     * Saves SubmissionConfig object into session cache. This saves us from
+     * having to reload this object during every "Step".
+     * 
+     * @param session
+     *            The HTTP Session object
+     * @param subConfig
+     *            The SubmissionConfig to cache
+     * @param collectionHandle
+     *            The Collection handle this SubmissionConfig corresponds to
+     * @param isWorkflow
+     *            Whether this SubmissionConfig corresponds to a workflow
+     * 
+     * 
+     */
+    private static void saveSubmissionConfigToCache(HttpSession session,
+            SubmissionConfig subConfig, String collectionHandle,
+            boolean isWorkflow)
+    {
+        // cache the submission process config
+        // and the collection it corresponds to
+        session.setAttribute("submission.config", subConfig);
+        session.setAttribute("submission.config.collection", collectionHandle);
+        session.setAttribute("submission.config.isWorkflow", new Boolean(
+                isWorkflow));
+    }
+
+    /**
+     * Loads SubmissionConfig object from session cache for the given
+     * Collection. If a SubmissionConfig object cannot be found, null is
+     * returned.
+     * 
+     * @param session
+     *            The HTTP Session object
+     * @param collectionHandle
+     *            The Collection handle of the SubmissionConfig to load
+     * @param isWorkflow
+     *            whether or not we loading the Submission process for a
+     *            workflow item
+     * 
+     * @return The cached SubmissionConfig for this collection
+     */
+    private static SubmissionConfig loadSubmissionConfigFromCache(
+            HttpSession session, String collectionHandle, boolean isWorkflow)
+    {
+        // attempt to load submission process config
+        // from cache for the current collection
+        String cachedHandle = (String) session
+                .getAttribute("submission.config.collection");
+
+        Boolean cachedIsWorkflow = (Boolean) session
+                .getAttribute("submission.config.isWorkflow");
+
+        // only load from cache if the collection handle and
+        // workflow item status both match!
+        if (collectionHandle.equals(cachedHandle)
+                && isWorkflow == cachedIsWorkflow.booleanValue())
+
+        {
+            return (SubmissionConfig) session.getAttribute("submission.config");
+        }
+        else
+        {
+            return null;
+        }
+    }
+    
+}
+

dspace-api/src/main/java/org/dspace/app/util/SubmissionStepConfig.java

@@ -0,0 +1,256 @@
+/*
+ * SubmissionStepConfig.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.app.util;
+
+import java.util.Map;
+import java.io.Serializable;
+
+import org.apache.log4j.Logger;
+
+/**
+ * Class representing configuration for a single step within an Item Submission
+ * Process. In other words, this is a single step in the SubmissionConfig class.
+ * This class represents the structure of a single 'step' node in the
+ * item-submission.xml configuration file.
+ *
+ * Note: Implements Serializable as it will be saved to the current session during submission.
+ * Please ensure that nothing is added to this class that isn't also serializable
+ * 
+ * @see org.dspace.app.util.SubmissionConfigReader
+ * @see org.dspace.app.util.SubmissionConfig
+ * 
+ * @author Tim Donohue
+ * @version $Revision$
+ */
+public class SubmissionStepConfig implements Serializable
+{
+    /*
+     * The identifier for the Select Collection step
+     */
+    public static String SELECT_COLLECTION_STEP = "collection";
+
+    /*
+     * The identifier for the Completion step
+     */
+    public static String COMPLETE_STEP = "complete";
+
+    /**
+     * the id for this step ('id' only exists if this step is defined in the
+     * <step-definitions> section)
+     */
+    private String id = null;
+
+    /** the heading for this step */
+    private String heading = null;
+
+    /** the name of the java processing class for this step */
+    private String processingClassName = null;
+   
+    /** whether or not this step is editable during workflow (default=true) */
+    private boolean workflowEditable = true;
+
+    /** 
+     * The full name of the JSP-UI binding class for this step. This field is
+     * ONLY used by the JSP-UI.
+     **/
+    private String jspBindingClassName = null;
+
+    /**
+     * The full name of the Manakin XML-UI Transformer class which will generate
+     * the necessary DRI for displaying this class in Manakin. This field is
+     * ONLY used by the Manakin XML-UI.
+     */
+    private String xmlBindingClassName = null;
+
+    /** The number of this step in the current SubmissionConfig */
+    private int number = -1;
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(SubmissionStepConfig.class);
+
+    /**
+     * Class constructor for creating an empty SubmissionStepConfig object
+     */
+    public SubmissionStepConfig()
+    {
+    }
+
+    /**
+     * Class constructor for creating a SubmissionStepConfig object based on the
+     * contents of a HashMap initialized by the SubmissionConfig object.
+     * 
+     * @param stepMap
+     *            the HashMap containing all required information about this
+     *            step
+     */
+    public SubmissionStepConfig(Map stepMap)
+    {
+        id = (String) stepMap.get("id");
+        heading = (String) stepMap.get("heading");
+        processingClassName = (String) stepMap.get("processing-class");
+        jspBindingClassName = (String) stepMap.get("jspui-binding");
+        xmlBindingClassName = (String) stepMap.get("xmlui-binding");
+
+        String wfEditString = (String) stepMap.get("workflow-editable");
+        if (wfEditString != null && wfEditString.length() > 0)
+        {
+            workflowEditable = new Boolean(wfEditString).booleanValue();
+        }
+    }
+
+    /**
+     * Get the ID for this step. An ID is only defined if the step exists in the
+     * <step-definitions> section. This ID field is used to reference special
+     * steps (like the required step with id="collection")
+     * 
+     * @return the step ID
+     */
+    public String getId()
+    {
+        return id;
+    }
+
+    /**
+     * Get the heading for this step. This can either be a property from
+     * Messages.properties, or the actual heading text. If this "heading"
+     * contains a period(.) it is assumed to reference Messages.properties.
+     * 
+     * @return the heading
+     */
+    public String getHeading()
+    {
+        return heading;
+    }
+
+    /**
+     * Get the class which handles all processing for this step.
+     * <p>
+     * This class must extend the org.dspace.submit.AbstractProcessingStep class,
+     * and provide processing for BOTH the JSP-UI and XML-UI
+     * 
+     * @return the class's full class path (e.g.
+     *         "org.dspace.submit.step.MySampleStep")
+     */
+    public String getProcessingClassName()
+    {
+        return processingClassName;
+    }
+
+    /**
+     * Retrieve the full class name of the Manakin Transformer which will
+     * generate this step's DRI, for display in Manakin XML-UI.
+     * <P>
+     * This class must extend the
+     * org.dspace.app.xmlui.aspect.submission.StepTransformer class.
+     * <P>
+     * This property is only used by the Manakin XML-UI, and therefore is not
+     * relevant if you are using the JSP-UI.
+     * 
+     * @return the full java class name of the Transformer to use for this step
+     */
+    public String getXMLUIClassName()
+    {
+        return xmlBindingClassName;
+    }
+    
+    /**
+     * Retrieve the full class name of the JSP-UI "binding" class which will
+     * initialize and call the necessary JSPs for display in the JSP-UI
+     * <P>
+     * This class must extend the
+     * org.dspace.app.webui.submit.JSPStep class.
+     * <P>
+     * This property is only used by the JSP-UI, and therefore is not
+     * relevant if you are using the XML-UI (aka. Manakin).
+     * 
+     * @return the full java class name of the JSPStep to use for this step
+     */
+    public String getJSPUIClassName()
+    {
+        return jspBindingClassName;
+    }
+
+    /**
+     * Get the number of this step in the current Submission process config.
+     * Step numbers start with #0 (although step #0 is ALWAYS the special
+     * "select collection" step)
+     * 
+     * @return the number of this step in the current SubmissionConfig
+     */
+    public int getStepNumber()
+    {
+        return number;
+    }
+
+    /**
+     * Sets the number of this step in the current Submission process config.
+     * Step numbers start with #0 (although step #0 is ALWAYS the special
+     * "select collection" step)
+     * 
+     * @param stepNum
+     *            the step number.
+     */
+    protected void setStepNumber(int stepNum)
+    {
+        this.number = stepNum;
+    }
+
+    /**
+     * Whether or not this step is editable during workflow processing. If
+     * "true", then this step will appear in the "Edit Metadata" stage of the
+     * workflow process.
+     * 
+     * @return if step is editable in a workflow process
+     */
+    public boolean isWorkflowEditable()
+    {
+        return workflowEditable;
+    }
+
+    /**
+     * Whether or not this step is visible within the Progress Bar. A step is
+     * only visible if it has been assigned a Heading, otherwise it's invisible
+     * 
+     * @return if step is visible within the progress bar
+     */
+    public boolean isVisible()
+    {
+        return ((heading != null) && (heading.length() > 0));
+    }
+}

dspace-api/src/main/java/org/dspace/app/util/SyndicationFeed.java

@@ -0,0 +1,483 @@
+/*
+ * SyndicationFeed.java
+ *
+ * Version: $Revision: 1.1 $
+ *
+ * Date: $Date: 2009/10/19 21:51:54 $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.w3c.dom.Document;
+
+import org.dspace.content.Bitstream;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.content.DCDate;
+import org.dspace.content.DCValue;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.Item;
+import org.dspace.content.MetadataSchema;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Constants;
+import org.dspace.handle.HandleManager;
+
+import com.sun.syndication.feed.synd.SyndFeed;
+import com.sun.syndication.feed.synd.SyndFeedImpl;
+import com.sun.syndication.feed.synd.SyndEntry;
+import com.sun.syndication.feed.synd.SyndEntryImpl;
+import com.sun.syndication.feed.synd.SyndImage;
+import com.sun.syndication.feed.synd.SyndImageImpl;
+import com.sun.syndication.feed.synd.SyndPerson;
+import com.sun.syndication.feed.synd.SyndPersonImpl;
+import com.sun.syndication.feed.synd.SyndContent;
+import com.sun.syndication.feed.synd.SyndContentImpl;
+import com.sun.syndication.feed.module.DCModuleImpl;
+import com.sun.syndication.feed.module.DCModule;
+import com.sun.syndication.feed.module.Module;
+import com.sun.syndication.io.SyndFeedOutput;
+import com.sun.syndication.io.FeedException;
+
+import org.apache.log4j.Logger;
+
+/**
+ * Invoke ROME library to assemble a generic model of a syndication
+ * for the given list of Items and scope.  Consults configuration for the
+ * metadata bindings to feed elements.  Uses ROME's output drivers to
+ * return any of the implemented formats, e.g. RSS 1.0, RSS 2.0, ATOM 1.0.
+ *
+ * The feed generator and OpenSearch call on this class so feed contents are
+ * uniform for both.
+ *
+ * @author Larry Stone
+ */
+public class SyndicationFeed
+{
+    private static final Logger log = Logger.getLogger(SyndicationFeed.class);
+
+
+    /** i18n key values */
+    public static final String MSG_UNTITLED = "notitle";
+    public static final String MSG_LOGO_TITLE = "logo.title";
+    public static final String MSG_FEED_TITLE = "feed.title";
+    public static final String MSG_FEED_DESCRIPTION = "general-feed.description";
+    public static final String MSG_METADATA = "metadata.";
+    public static final String MSG_UITYPE = "ui.type";
+
+    // UI keywords
+    public static final String UITYPE_XMLUI = "xmlui";
+    public static final String UITYPE_JSPUI = "jspui";
+
+    // default DC fields for entry
+    private static String defaultTitleField = "dc.title";
+    private static String defaultAuthorField = "dc.contributor.author";
+    private static String defaultDateField = "dc.date.issued";
+    private static String defaultDescriptionFields = "dc.description.abstract, dc.description, dc.title.alternative, dc.title";
+
+    // metadata field for Item title in entry:
+    private static String titleField =
+        getDefaultedConfiguration("webui.feed.item.title", defaultTitleField);
+
+    // metadata field for Item publication date in entry:
+    private static String dateField =
+        getDefaultedConfiguration("webui.feed.item.date", defaultDateField);
+
+    // metadata field for Item description in entry:
+    private static String descriptionFields[] =
+        getDefaultedConfiguration("webui.feed.item.description", defaultDescriptionFields).split("\\s*,\\s*");
+
+    private static String authorField =
+        getDefaultedConfiguration("webui.feed.item.author", defaultAuthorField);
+
+    // metadata field for Item dc:creator field in entry's DCModule (no default)
+    private static String dcCreatorField = ConfigurationManager.getProperty("webui.feed.item.dc.creator");
+
+    // metadata field for Item dc:date field in entry's DCModule (no default)
+    private static String dcDateField = ConfigurationManager.getProperty("webui.feed.item.dc.date");
+
+    // metadata field for Item dc:author field in entry's DCModule (no default)
+    private static String dcDescriptionField = ConfigurationManager.getProperty("webui.feed.item.dc.description");
+
+
+    // -------- Instance variables:
+
+    // the feed object we are building
+    private SyndFeed feed = null;
+
+    // memory of UI that called us, "xmlui" or "jspui"
+    // affects Bitstream retrieval URL and I18N keys
+    private String uiType = null;
+
+    /**
+     * Constructor.
+     * @param ui either "xmlui" or "jspui"
+     */
+    public SyndicationFeed(String ui)
+    {
+        feed = new SyndFeedImpl();
+        uiType = ui;
+    }
+
+    /**
+     * Returns list of metadata selectors used to compose the description element
+     *
+     * @return selector list - format 'schema.element[.qualifier]'
+     */
+    public static String[] getDescriptionSelectors()
+    {
+        return descriptionFields;
+    }
+
+
+    /**
+     * Fills in the feed and entry-level metadata from DSpace objects.
+     */
+    public void populate(HttpServletRequest request, DSpaceObject dso,
+                         DSpaceObject items[], Map<String, String> labels)
+    {
+        String logoURL = null;
+        String objectURL = null;
+        String defaultTitle = null;
+
+        // dso is null for the whole site, or a search without scope
+        if (dso == null)
+        {
+            defaultTitle = ConfigurationManager.getProperty("dspace.name");
+            feed.setDescription(localize(labels, MSG_FEED_DESCRIPTION));
+            objectURL = resolveURL(request, null);
+            logoURL = ConfigurationManager.getProperty("webui.feed.logo.url");
+        }
+        else
+        {
+            Bitstream logo = null;
+            if (dso.getType() == Constants.COLLECTION)
+            {
+                Collection col = (Collection)dso;
+                defaultTitle = col.getMetadata("name");
+                feed.setDescription(col.getMetadata("short_description"));
+                logo = col.getLogo();
+            }
+            else if (dso.getType() == Constants.COMMUNITY)
+            {
+                Community comm = (Community)dso;
+                defaultTitle = comm.getMetadata("name");
+                feed.setDescription(comm.getMetadata("short_description"));
+                logo = comm.getLogo();
+            }
+            objectURL = resolveURL(request, dso);
+            if (logo != null)
+                logoURL = urlOfBitstream(request, logo);
+        }
+        feed.setTitle(labels.containsKey(MSG_FEED_TITLE) ?
+                            localize(labels, MSG_FEED_TITLE) : defaultTitle);
+        feed.setLink(objectURL);
+        feed.setPublishedDate(new Date());
+        feed.setUri(objectURL);
+
+        // add logo if we found one:
+        if (logoURL != null)
+        {
+            // we use the path to the logo for this, the logo itself cannot
+            // be contained in the rdf. Not all RSS-viewers show this logo.
+            SyndImage image = new SyndImageImpl();
+            image.setLink(objectURL);
+            image.setTitle(localize(labels, MSG_LOGO_TITLE));
+            image.setUrl(logoURL);
+            feed.setImage(image);
+        }
+
+        // add entries for items
+        if (items != null)
+        {
+            List<SyndEntry> entries = new ArrayList<SyndEntry>();
+            for (DSpaceObject itemDSO : items)
+            {
+                if (itemDSO.getType() != Constants.ITEM)
+                    continue;
+                Item item = (Item)itemDSO;
+                boolean hasDate = false;
+                SyndEntry entry = new SyndEntryImpl();
+                entries.add(entry);
+             
+                String entryURL = resolveURL(request, item);
+                entry.setLink(entryURL);
+                entry.setUri(entryURL);
+             
+                String title = getOneDC(item, titleField);
+                entry.setTitle(title == null ? localize(labels, MSG_UNTITLED) : title);
+             
+                // "published" date -- should be dc.date.issued
+                String pubDate = getOneDC(item, dateField);
+                if (pubDate != null)
+                {
+                    entry.setPublishedDate((new DCDate(pubDate)).toDate());
+                    hasDate = true;
+                }
+                // date of last change to Item
+                entry.setUpdatedDate(item.getLastModified());
+             
+                StringBuffer db = new StringBuffer();
+                for (String df : descriptionFields)
+                {
+                    // Special Case: "(date)" in field name means render as date
+                    boolean isDate = df.indexOf("(date)") > 0;
+                    if (isDate)
+                        df = df.replaceAll("\\(date\\)", "");
+             
+                    DCValue dcv[] = item.getMetadata(df);
+                    if (dcv.length > 0)
+                    {
+                        String fieldLabel = labels.get(MSG_METADATA + df);
+                        if (fieldLabel != null && fieldLabel.length()>0)
+                            db.append(fieldLabel + ": ");
+                        boolean first = true;
+                        for (DCValue v : dcv)
+                        {
+                            if (first)
+                                first = false;
+                            else
+                                db.append("; ");
+                            db.append(isDate ? new DCDate(v.value).toString() : v.value);
+                        }
+                        db.append("\n");
+                    }
+                }
+                if (db.length() > 0)
+                {
+                    SyndContent desc = new SyndContentImpl();
+                    desc.setType("text/plain");
+                    desc.setValue(db.toString());
+                    entry.setDescription(desc);
+                }
+
+                // This gets the authors into an ATOM feed
+                DCValue authors[] = item.getMetadata(authorField);
+                if (authors.length > 0)
+                {
+                    List<SyndPerson> creators = new ArrayList<SyndPerson>();
+                    for (DCValue author : authors)
+                    {
+                        SyndPerson sp = new SyndPersonImpl();
+                        sp.setName(author.value);
+                        creators.add(sp);
+                    }
+                    entry.setAuthors(creators);
+                }
+
+                // only add DC module if any DC fields are configured
+                if (dcCreatorField != null || dcDateField != null ||
+                    dcDescriptionField != null)
+                {
+                    DCModule dc = new DCModuleImpl();
+                    if (dcCreatorField != null)
+                    {
+                        DCValue dcAuthors[] = item.getMetadata(dcCreatorField);
+                        if (dcAuthors.length > 0)
+                        {
+                            List<String> creators = new ArrayList<String>();
+                            for (DCValue author : dcAuthors)
+                                creators.add(author.value);
+                            dc.setCreators(creators);
+                        }
+                    }
+                    if (dcDateField != null && !hasDate)
+                    {
+                        DCValue v[] = item.getMetadata(dcDateField);
+                        if (v.length > 0)
+                            dc.setDate((new DCDate(v[0].value)).toDate());
+                    }
+                    if (dcDescriptionField != null)
+                    {
+                        DCValue v[] = item.getMetadata(dcDescriptionField);
+                        if (v.length > 0)
+                        {
+                            StringBuffer descs = new StringBuffer();
+                            for (DCValue d : v)
+                            {
+                                if (descs.length() > 0)
+                                    descs.append("\n\n");
+                                descs.append(d.value);
+                            }
+                            dc.setDescription(descs.toString());
+                        }
+                    }
+                    entry.getModules().add(dc);
+                }
+            }
+            feed.setEntries(entries);
+        }
+    }
+
+    /**
+     * Sets the feed type for XML delivery, e.g. "rss_1.0", "atom_1.0"
+     * Must match one of ROME's configured generators, see rome.properties
+     * (currently rss_1.0, rss_2.0, atom_1.0, atom_0.3)
+     */
+    public void setType(String feedType)
+    {
+        feed.setFeedType(feedType);
+        // XXX FIXME: workaround ROME 1.0 bug, it puts invalid image element in rss1.0
+        if (feedType.equals("rss_1.0"))
+            feed.setImage(null);
+    }
+
+    /**
+     * @return the feed we built as DOM Document
+     */
+    public Document outputW3CDom()
+        throws FeedException
+    {
+        try
+        {
+            SyndFeedOutput feedWriter = new SyndFeedOutput();
+            return feedWriter.outputW3CDom(feed);
+        }
+        catch (FeedException e)
+        {
+            log.error(e);
+            throw e;
+        }
+    }
+
+    /**
+     * @return the feed we built as serialized XML string
+     */
+    public String outputString()
+        throws FeedException
+    {
+        SyndFeedOutput feedWriter = new SyndFeedOutput();
+        return feedWriter.outputString(feed);
+    }
+
+    /**
+     * send the output to designated Writer
+     */
+    public void output(java.io.Writer writer)
+        throws FeedException, IOException
+    {
+        SyndFeedOutput feedWriter = new SyndFeedOutput();
+        feedWriter.output(feed, writer);
+    }
+
+    /**
+     * @add a ROME plugin module (e.g. for OpenSearch) at the feed level
+     */
+    public void addModule(Module m)
+    {
+        feed.getModules().add(m);
+    }
+
+    // utility to get config property with default value when not set.
+    private static String getDefaultedConfiguration(String key, String dfl)
+    {
+        String result = ConfigurationManager.getProperty(key);
+        return (result == null) ? dfl : result;
+    }
+
+    // returns absolute URL to download content of bitstream (which might not belong to any Item)
+    private String urlOfBitstream(HttpServletRequest request, Bitstream logo)
+    {
+        String name = logo.getName();
+        return resolveURL(request,null) +
+                 (uiType.equalsIgnoreCase(UITYPE_XMLUI) ?"/bitstream/id/":"/retrieve/") +
+                 logo.getID()+"/"+(name == null?"":name);
+    }
+
+    /**
+     * Return a url to the DSpace object, either use the official
+     * handle for the item or build a url based upon the current server.
+     *
+     * If the dspaceobject is null then a local url to the repository is generated.
+     *
+     * @param dso The object to refrence, null if to the repository.
+     * @return
+     */
+    private String baseURL = null;  // cache the result for null
+
+    private String resolveURL(HttpServletRequest request, DSpaceObject dso)
+    {
+        // If no object given then just link to the whole repository,
+        // since no offical handle exists so we have to use local resolution.
+        if (dso == null)
+        {
+            if (baseURL == null)
+            {
+                if (request == null)
+                    baseURL = ConfigurationManager.getProperty("dspace.url");
+                else
+                {
+                    baseURL = (request.isSecure()) ? "https://" : "http://";
+                    baseURL += ConfigurationManager.getProperty("dspace.hostname");
+                    baseURL += ":" + request.getServerPort();
+                    baseURL += request.getContextPath();
+                }
+            }
+            return baseURL;
+        }
+
+        // return a link to handle in repository
+        else if (ConfigurationManager.getBooleanProperty("webui.feed.localresolve"))
+        {
+            return resolveURL(request, null) + "/handle/" + dso.getHandle();
+        }
+
+        // link to the Handle server or other persistent URL source
+        else
+        {
+            return HandleManager.getCanonicalForm(dso.getHandle());
+        }
+    }
+
+    // retrieve text for localization key, or mark untranslated
+    private String localize(Map<String, String> labels, String s)
+    {
+        return labels.containsKey(s) ? labels.get(s) : ("Untranslated:"+s);
+    }
+
+    // spoonful of syntactic sugar when we only need first value
+    private String getOneDC(Item item, String field)
+    {
+        DCValue dcv[] = item.getMetadata(field);
+        return (dcv.length > 0) ? dcv[0].value : null;
+    }
+}
+

dspace-api/src/main/java/org/dspace/app/util/Util.java

@@ -0,0 +1,370 @@
+/*
+ * Util.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.util;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.Enumeration;
+import java.util.Locale;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.log4j.Logger;
+import org.dspace.core.Constants;
+
+
+/**
+ * Miscellaneous utility methods
+ *
+ * @author Robert Tansley
+ * @author Mark Diggory
+ * @version $Revision$
+ */
+public class Util {
+        // cache for source version result
+        private static String sourceVersion = null;
+
+        private static Logger log = Logger.getLogger(Util.class);
+        
+        /**
+         * Utility method to convert spaces in a string to HTML non-break space
+         * elements.
+         *
+         * @param s
+         *            string to change spaces in
+         * @return the string passed in with spaces converted to HTML non-break
+         *         spaces
+         */
+        public static String nonBreakSpace(String s) {
+            StringBuffer newString = new StringBuffer();
+        
+            for (int i = 0; i < s.length(); i++)
+            {
+                char ch = s.charAt(i);
+        
+                if (ch == ' ')
+                {
+                    newString.append("&nbsp;");
+                }
+                else
+                {
+                    newString.append(ch);
+                }
+            }
+        
+            return newString.toString();
+        }
+
+        /**
+         * Encode a bitstream name for inclusion in a URL in an HTML document. This
+         * differs from the usual URL-encoding, since we want pathname separators to
+         * be passed through verbatim; this is required so that relative paths in
+         * bitstream names and HTML references work correctly.
+         * <P>
+         * If the link to a bitstream is generated with the pathname separators
+         * escaped (e.g. "%2F" instead of "/") then the Web user agent perceives it
+         * to be one pathname element, and relative URI paths within that document
+         * containing ".." elements will be handled incorrectly.
+         * <P>
+         *
+         * @param stringIn
+         *            input string to encode
+         * @param encoding
+         *            character encoding, e.g. UTF-8
+         * @return the encoded string
+         */
+        public static String encodeBitstreamName(String stringIn, String encoding) throws java.io.UnsupportedEncodingException {
+            // FIXME: This should be moved elsewhere, as it is used outside the UI
+            StringBuffer out = new StringBuffer();
+        
+            final String[] pctEncoding = { "%00", "%01", "%02", "%03", "%04",
+                    "%05", "%06", "%07", "%08", "%09", "%0a", "%0b", "%0c", "%0d",
+                    "%0e", "%0f", "%10", "%11", "%12", "%13", "%14", "%15", "%16",
+                    "%17", "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",
+                    "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27", "%28",
+                    "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f", "%30", "%31",
+                    "%32", "%33", "%34", "%35", "%36", "%37", "%38", "%39", "%3a",
+                    "%3b", "%3c", "%3d", "%3e", "%3f", "%40", "%41", "%42", "%43",
+                    "%44", "%45", "%46", "%47", "%48", "%49", "%4a", "%4b", "%4c",
+                    "%4d", "%4e", "%4f", "%50", "%51", "%52", "%53", "%54", "%55",
+                    "%56", "%57", "%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e",
+                    "%5f", "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",
+                    "%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f", "%70",
+                    "%71", "%72", "%73", "%74", "%75", "%76", "%77", "%78", "%79",
+                    "%7a", "%7b", "%7c", "%7d", "%7e", "%7f", "%80", "%81", "%82",
+                    "%83", "%84", "%85", "%86", "%87", "%88", "%89", "%8a", "%8b",
+                    "%8c", "%8d", "%8e", "%8f", "%90", "%91", "%92", "%93", "%94",
+                    "%95", "%96", "%97", "%98", "%99", "%9a", "%9b", "%9c", "%9d",
+                    "%9e", "%9f", "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6",
+                    "%a7", "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",
+                    "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7", "%b8",
+                    "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf", "%c0", "%c1",
+                    "%c2", "%c3", "%c4", "%c5", "%c6", "%c7", "%c8", "%c9", "%ca",
+                    "%cb", "%cc", "%cd", "%ce", "%cf", "%d0", "%d1", "%d2", "%d3",
+                    "%d4", "%d5", "%d6", "%d7", "%d8", "%d9", "%da", "%db", "%dc",
+                    "%dd", "%de", "%df", "%e0", "%e1", "%e2", "%e3", "%e4", "%e5",
+                    "%e6", "%e7", "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee",
+                    "%ef", "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
+                    "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff" };
+        
+            byte[] bytes = stringIn.getBytes(encoding);
+        
+            for (int i = 0; i < bytes.length; i++)
+            {
+                // Any unreserved char or "/" goes through unencoded
+                if ((bytes[i] >= 'A' && bytes[i] <= 'Z')
+                        || (bytes[i] >= 'a' && bytes[i] <= 'z')
+                        || (bytes[i] >= '0' && bytes[i] <= '9') || bytes[i] == '-'
+                        || bytes[i] == '.' || bytes[i] == '_' || bytes[i] == '~'
+                        || bytes[i] == '/')
+                {
+                    out.append((char) bytes[i]);
+                }
+                else if (bytes[i] >= 0)
+                {
+                    // encode other chars (byte code < 128)
+                    out.append(pctEncoding[bytes[i]]);
+                }
+                else
+                {
+                    // encode other chars (byte code > 127, so it appears as
+                    // negative in Java signed byte data type)
+                    out.append(pctEncoding[256 + bytes[i]]);
+                }
+            }
+            log.debug("encoded \"" + stringIn + "\" to \"" + out.toString() + "\"");
+        
+            return out.toString();
+        }
+
+        /** Version of encodeBitstreamName with one parameter, uses default encoding
+         * <P>
+         * @param stringIn
+         *                input string to encode
+         * @return the encoded string
+         */
+        public static String encodeBitstreamName(String stringIn) throws java.io.UnsupportedEncodingException {
+                return encodeBitstreamName(stringIn, Constants.DEFAULT_ENCODING);
+         }
+
+        /**
+          * Formats the file size. Examples:
+          *
+          *  - 50 = 50B
+          *  - 1024 = 1KB
+          *  - 1,024,000 = 1MB etc
+          *
+          *  The numbers are formatted using java Locales
+          *
+          * @param in The number to covnert
+          * @return the file size as a String
+          */
+        public static String formatFileSize(double in) {
+             // Work out the size of the file, and format appropriatly
+             // FIXME: When full i18n support is available, use the user's Locale
+             // rather than the default Locale.
+             NumberFormat nf = NumberFormat.getNumberInstance(Locale.getDefault());
+             DecimalFormat df = (DecimalFormat)nf;
+             df.applyPattern("###,###.##");
+             if (in < 1024)
+             {
+                 df.applyPattern("0");
+                 return df.format(in) +  " " + "B";
+             }
+             else if (in < 1024000)
+             {
+                 in = in / 1024;
+                 return df.format(in) + " " + "kB";
+             }
+             else if (in < 1024000000)
+             {
+                 in = in / 1024000;
+                 return df.format(in) + " " + "MB";
+             }
+             else
+             {
+                 in = in / 1024000000;
+                 return df.format(in) + " " + "GB";
+             }
+         }
+
+    /**
+     * Obtain a parameter from the given request as an int. <code>-1</code> is
+     * returned if the parameter is garbled or does not exist.
+     *
+     * @param request
+     *            the HTTP request
+     * @param param
+     *            the name of the parameter
+     *
+     * @return the integer value of the parameter, or -1
+     */
+    public static int getIntParameter(HttpServletRequest request, String param)
+    {
+        String val = request.getParameter(param);
+
+        try
+        {
+            return Integer.parseInt(val.trim());
+        }
+        catch (Exception e)
+        {
+            // Problem with parameter
+            return -1;
+        }
+    }
+
+    /**
+     * Obtain an array of int parameters from the given request as an int. null
+     * is returned if parameter doesn't exist. <code>-1</code> is returned in
+     * array locations if that particular value is garbled.
+     *
+     * @param request
+     *            the HTTP request
+     * @param param
+     *            the name of the parameter
+     *
+     * @return array of integers or null
+     */
+    public static int[] getIntParameters(HttpServletRequest request,
+            String param)
+    {
+        String[] request_values = request.getParameterValues(param);
+
+        if (request_values == null)
+        {
+            return null;
+        }
+
+        int[] return_values = new int[request_values.length];
+
+        for (int x = 0; x < return_values.length; x++)
+        {
+            try
+            {
+                return_values[x] = Integer.parseInt(request_values[x]);
+            }
+            catch (Exception e)
+            {
+                // Problem with parameter, stuff -1 in this slot
+                return_values[x] = -1;
+            }
+        }
+
+        return return_values;
+    }
+
+    /**
+     * Obtain a parameter from the given request as a boolean.
+     * <code>false</code> is returned if the parameter is garbled or does not
+     * exist.
+     *
+     * @param request
+     *            the HTTP request
+     * @param param
+     *            the name of the parameter
+     *
+     * @return the integer value of the parameter, or -1
+     */
+    public static boolean getBoolParameter(HttpServletRequest request,
+            String param)
+    {
+        return ((request.getParameter(param) != null) && request.getParameter(
+                param).equals("true"));
+    }
+
+    /**
+     * Get the button the user pressed on a submitted form. All buttons should
+     * start with the text <code>submit</code> for this to work. A default
+     * should be supplied, since often the browser will submit a form with no
+     * submit button pressed if the user presses enter.
+     *
+     * @param request
+     *            the HTTP request
+     * @param def
+     *            the default button
+     *
+     * @return the button pressed
+     */
+    public static String getSubmitButton(HttpServletRequest request, String def)
+    {
+        Enumeration e = request.getParameterNames();
+
+        while (e.hasMoreElements())
+        {
+            String parameterName = (String) e.nextElement();
+
+            if (parameterName.startsWith("submit"))
+            {
+                return parameterName;
+            }
+        }
+
+        return def;
+    }
+
+    /**
+     * Gets Maven version string of the source that built this instance.
+     * @return string containing version, e.g. "1.5.2"; ends in "-SNAPSHOT" for development versions.
+     */
+    public static String getSourceVersion()
+    {
+        if (sourceVersion == null)
+        {
+            Properties constants = new Properties();
+
+            try
+            {
+                InputStream cis = Util.class.getResourceAsStream
+                    ("/META-INF/maven/org.dspace/dspace-api/pom.properties");
+
+                constants.load(cis);
+            }
+            catch(Exception e)
+            {
+                log.error(e.getMessage(),e);
+            }
+
+            sourceVersion = constants.getProperty("version", "none");
+        }
+        return sourceVersion;
+    }
+}

dspace-api/src/main/java/org/dspace/authenticate/AuthenticationManager.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -37,7 +35,7 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */
-package org.dspace.eperson;
+package org.dspace.authenticate;
 
 import java.io.IOException;
 
@@ -58,7 +56,6 @@ import org.dspace.core.Context;
 import org.dspace.core.PluginManager;
 import org.dspace.core.LogManager;
 import org.dspace.eperson.EPerson;
-import org.dspace.eperson.AuthenticationMethod;
 
 /**
  * Access point for the stackable authentication methods.
@@ -299,6 +296,7 @@ public class AuthenticationManager
      */
     public static int[] getSpecialGroups(Context context,
                                          HttpServletRequest request)
+        throws SQLException
     {
         ArrayList gll = new ArrayList();
         int totalLen = 0;

dspace-api/src/main/java/org/dspace/authenticate/AuthenticationMethod.java

@@ -5,8 +5,7 @@
  *
  * Date: $Date$
  *
- * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -19,8 +18,7 @@
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  *
- * - Neither the name of the Hewlett-Packard Company nor the name of the
- * Massachusetts Institute of Technology nor the names of their
+ * - Neither the name of the DSpace Foundation nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -37,7 +35,7 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */
-package org.dspace.eperson;
+package org.dspace.authenticate;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
@@ -162,28 +160,29 @@ public interface AuthenticationMethod {
     public boolean isImplicit();
 
     /**
-     * Get list of extra groups that user implicitly belongs to.
-     * Returns IDs of any EPerson-groups that the user authenticated by
-     * this request is <em>implicitly</em> a member of -- e.g.
-     * a group that depends on the client network-address.
+     * Get list of extra groups that user implicitly belongs to. Note that this
+     * method will be invoked regardless of the authentication status of the
+     * user (logged-in or not) e.g. a group that depends on the client
+     * network-address.
      * <p>
      * It might make sense to implement this method by itself in a separate
-     * authentication method that just adds special groups, if the
-     * code doesn't belong with any existing auth method.
-     * The stackable authentication system was designed expressly to
-     * separate functions into "stacked" methods to keep your
-     * site-specific code  modular and tidy.
+     * authentication method that just adds special groups, if the code doesn't
+     * belong with any existing auth method. The stackable authentication system
+     * was designed expressly to separate functions into "stacked" methods to
+     * keep your site-specific code modular and tidy.
      * 
      * @param context
      *            A valid DSpace context.
      * 
      * @param request
-     *  The request that started this operation, or null if not applicable.
+     *            The request that started this operation, or null if not
+     *            applicable.
      * 
-     * @return array of EPerson-group IDs, possibly 0-length, but
-     * never <code>null</code>.
+     * @return array of EPerson-group IDs, possibly 0-length, but never
+     *         <code>null</code>.
      */
-    public int[] getSpecialGroups(Context context, HttpServletRequest request);
+    public int[] getSpecialGroups(Context context, HttpServletRequest request)
+        throws SQLException;
 
     /**
      * Authenticate the given or implicit credentials.

dspace-api/src/main/java/org/dspace/authenticate/IPAuthentication.java

@@ -0,0 +1,340 @@
+/*
+ * IPAuthentication.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.authenticate;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.log4j.Logger;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+import org.dspace.eperson.EPerson;
+import org.dspace.eperson.Group;
+
+/**
+ * Adds users to special groups based on IP address. Configuration parameter
+ * form is:
+ * <P>
+ * {@code authentication.ip.<GROUPNAME> = <IPRANGE>[, <IPRANGE> ...]}
+ * <P>
+ * e.g. {@code authentication.ip.MIT = 18., 192.25.0.0/255.255.0.0}
+ * <P>
+ * Negative matches can be included by prepending the range with a '-'. For example if you want
+ * to include all of a class B network except for users of a contained class c network, you could use:
+ * <P>
+ * 111.222,-111.222.333.
+ * <p>
+ * For supported IP ranges see {@link org.dspace.authenticate.IPMatcher}.
+ * 
+ * @version $Revision$
+ * @author Robert Tansley
+ */
+public class IPAuthentication implements AuthenticationMethod
+{
+    /** Our logger */
+    private static Logger log = Logger.getLogger(IPAuthentication.class);
+
+    /** All the IP matchers */
+    private List<IPMatcher> ipMatchers;
+
+    /** All the negative IP matchers */
+    private List<IPMatcher> ipNegativeMatchers;
+
+    /**
+     * Maps IPMatchers to group names when we don't know group DB ID yet. When
+     * the DB ID is known, the IPMatcher is moved to ipMatcherGroupIDs and then
+     * points to the DB ID.
+     */
+    private Map<IPMatcher, String> ipMatcherGroupNames;
+
+    /** Maps IPMatchers to group IDs (Integers) where we know the group DB ID */
+    private Map<IPMatcher, Integer> ipMatcherGroupIDs;
+
+    /**
+     * Initialize an IP authenticator, reading in the configuration. Note this
+     * will never fail if the configuration is bad -- a warning will be logged.
+     */
+    public IPAuthentication()
+    {
+        ipMatchers = new ArrayList<IPMatcher>();
+        ipNegativeMatchers = new ArrayList<IPMatcher>();
+        ipMatcherGroupIDs = new HashMap<IPMatcher, Integer>();
+        ipMatcherGroupNames = new HashMap<IPMatcher, String>();
+
+        Enumeration e = ConfigurationManager.propertyNames();
+
+        while (e.hasMoreElements())
+        {
+            String propName = (String) e.nextElement();
+            if (propName.startsWith("authentication.ip."))
+            {
+                String[] nameParts = propName.split("\\.");
+
+                if (nameParts.length == 3)
+                {
+                    addMatchers(nameParts[2], ConfigurationManager
+                            .getProperty(propName));
+                }
+                else
+                {
+                    log.warn("Malformed configuration property name: "
+                            + propName);
+                }
+            }
+        }
+    }
+
+    /**
+     * Add matchers for the given comma-delimited IP ranges and group.
+     * 
+     * @param groupName
+     *            name of group
+     * @param ipRanges
+     *            IP ranges
+     */
+    private void addMatchers(String groupName, String ipRanges)
+    {
+        String[] ranges = ipRanges.split("\\s*,\\s*");
+
+        for (String entry : ranges)
+        {
+            try
+            {
+                IPMatcher ipm;
+                if (entry.startsWith("-"))
+                {
+                    ipm = new IPMatcher(entry.substring(1));
+                    ipNegativeMatchers.add(ipm);
+                }
+                else
+                {
+                    ipm = new IPMatcher(entry);
+                    ipMatchers.add(ipm);
+                }
+                ipMatcherGroupNames.put(ipm, groupName);
+
+                if (log.isDebugEnabled())
+                {
+                    log.debug("Configured " + entry + " for special group "
+                            + groupName);
+                }
+            }
+            catch (IPMatcherException ipme)
+            {
+                log.warn("Malformed IP range specified for group " + groupName,
+                        ipme);
+            }
+        }
+    }
+
+    public boolean canSelfRegister(Context context, HttpServletRequest request,
+            String username) throws SQLException
+    {
+        return false;
+    }
+
+    public void initEPerson(Context context, HttpServletRequest request,
+            EPerson eperson) throws SQLException
+    {
+    }
+
+    public boolean allowSetPassword(Context context,
+            HttpServletRequest request, String username) throws SQLException
+    {
+        return false;
+    }
+
+    public boolean isImplicit()
+    {
+        return true;
+    }
+
+    public int[] getSpecialGroups(Context context, HttpServletRequest request)
+            throws SQLException
+    {
+        if (request == null)
+        {
+            return new int[0];
+        }
+        List<Integer> groupIDs = new ArrayList<Integer>();
+
+        String addr = request.getRemoteAddr();
+
+        for (IPMatcher ipm : ipMatchers)
+        {
+            try
+            {
+                if (ipm.match(addr))
+                {
+                    // Do we know group ID?
+                    Integer g = ipMatcherGroupIDs.get(ipm);
+                    if (g != null)
+                    {
+                        groupIDs.add(g);
+                    }
+                    else
+                    {
+                        // See if we have a group name
+                        String groupName = ipMatcherGroupNames.get(ipm);
+
+                        if (groupName != null)
+                        {
+                            Group group = Group.findByName(context, groupName);
+                            if (group != null)
+                            {
+                                // Add ID so we won't have to do lookup again
+                                ipMatcherGroupIDs.put(ipm, new Integer(group
+                                        .getID()));
+                                ipMatcherGroupNames.remove(ipm);
+
+                                groupIDs.add(new Integer(group.getID()));
+                            }
+                            else
+                            {
+                                log.warn(LogManager.getHeader(context,
+                                        "configuration_error", "unknown_group="
+                                                + groupName));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (IPMatcherException ipme)
+            {
+                log.warn(LogManager.getHeader(context, "configuration_error",
+                        "bad_ip=" + addr), ipme);
+            }
+        }
+
+        // Now remove any negative matches
+        for (IPMatcher ipm : ipNegativeMatchers)
+        {
+            try
+            {
+                if (ipm.match(addr))
+                {
+                    // Do we know group ID?
+                    Integer g = ipMatcherGroupIDs.get(ipm);
+                    if (g != null)
+                    {
+                        groupIDs.remove(g);
+                    }
+                    else
+                    {
+                        // See if we have a group name
+                        String groupName = ipMatcherGroupNames.get(ipm);
+
+                        if (groupName != null)
+                        {
+                            Group group = Group.findByName(context, groupName);
+                            if (group != null)
+                            {
+                                // Add ID so we won't have to do lookup again
+                                ipMatcherGroupIDs.put(ipm, new Integer(group
+                                        .getID()));
+                                ipMatcherGroupNames.remove(ipm);
+
+                                groupIDs.remove(new Integer(group.getID()));
+                            }
+                            else
+                            {
+                                log.warn(LogManager.getHeader(context,
+                                        "configuration_error", "unknown_group="
+                                                + groupName));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (IPMatcherException ipme)
+            {
+                log.warn(LogManager.getHeader(context, "configuration_error",
+                        "bad_ip=" + addr), ipme);
+            }
+        }
+
+
+        int[] results = new int[groupIDs.size()];
+        for (int i = 0; i < groupIDs.size(); i++)
+        {
+            results[i] = (groupIDs.get(i)).intValue();
+        }
+
+        if (log.isDebugEnabled())
+        {
+            StringBuffer gsb = new StringBuffer();
+
+            for (int i = 0; i < results.length; i++)
+            {
+                if (i > 0)
+                    gsb.append(",");
+                    gsb.append(results[i]);
+            }
+
+            log.debug(LogManager.getHeader(context, "authenticated",
+                    "special_groups=" + gsb.toString()));
+        }
+
+        return results;
+    }
+
+    public int authenticate(Context context, String username, String password,
+            String realm, HttpServletRequest request) throws SQLException
+    {
+        return BAD_ARGS;
+    }
+
+    public String loginPageURL(Context context, HttpServletRequest request,
+            HttpServletResponse response)
+    {
+        return null;
+    }
+
+    public String loginPageTitle(Context context)
+    {
+        return null;
+    }
+}

dspace-api/src/main/java/org/dspace/authenticate/IPMatcher.java

@@ -0,0 +1,229 @@
+/*
+ * IPMatcher.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package org.dspace.authenticate;
+
+/**
+ * Quickly tests whether a given IPv4 4-byte address matches an IP range. An
+ * {@code IPMatcher} is initialized with a particular IP range specification.
+ * Calls to {@link IPMatcher#match(String) match} method will then quickly
+ * determine whether a given IP falls within that range.
+ * <p>
+ * Supported range specifications areL
+ * <p>
+ * <ul>
+ * <li>Full IP address, e.g. {@code 12.34.56.78}</li>
+ * <li>Partial IP address, e.g. {@code 12.34} (which matches any IP starting
+ * {@code 12.34})</li>
+ * <li>Network/netmask, e.g. {@code 18.25.0.0/255.255.0.0}</li>
+ * <li>CIDR slash notation, e.g. {@code 18.25.0.0/16}</li>
+ * </ul>
+ * 
+ * @version $Revision$
+ * @author Robert Tansley
+ */
+public class IPMatcher
+{
+    /** Network to match */
+    private byte[] network;
+
+    /** Network mask */
+    private byte[] netmask;
+
+    /**
+     * Construct an IPMatcher that will test for the given IP specification
+     * 
+     * @param ipSpec
+     *            IP specification (full or partial URL, network/netmask,
+     *            network/cidr)
+     * @throws IPMatcherException
+     *             if there is an error parsing the specification (i.e. it is
+     *             somehow malformed)
+     */
+    public IPMatcher(String ipSpec) throws IPMatcherException
+    {
+        // Boil all specs down to network + mask
+        network = new byte[4];
+        netmask = new byte[] { -1, -1, -1, -1 };
+
+        // Allow partial IP
+        boolean mustHave4 = false;
+
+        String ipPart = ipSpec;
+        String[] parts = ipSpec.split("/");
+
+        switch (parts.length)
+        {
+        case 2:
+            // Some kind of slash notation -- we'll need a full network IP
+            ipPart = parts[0];
+            mustHave4 = true;
+
+            String[] maskParts = parts[1].split("\\.");
+            if (maskParts.length == 1)
+            {
+                // CIDR slash notation
+                int x;
+
+                try
+                {
+                    x = Integer.parseInt(maskParts[0]);
+                }
+                catch (NumberFormatException nfe)
+                {
+                    throw new IPMatcherException(
+                            "Malformed IP range specification " + ipSpec, nfe);
+                }
+
+                if (x < 0 || x > 32)
+                {
+                    throw new IPMatcherException();
+                }
+
+                int fullMask = -1 << (32 - x);
+                netmask[0] = (byte) ((fullMask & 0xFF000000) >>> 24);
+                netmask[1] = (byte) ((fullMask & 0x00FF0000) >>> 16);
+                netmask[2] = (byte) ((fullMask & 0x0000FF00) >>> 8);
+                netmask[3] = (byte) (fullMask & 0x000000FF);
+            }
+            else
+            {
+                // full subnet specified
+                ipToBytes(parts[1], netmask, true);
+            }
+
+        case 1:
+            // Get IP
+            int partCount = ipToBytes(ipPart, network, mustHave4);
+
+            // If partial IP, set mask for remaining bytes
+            for (int i = 3; i >= partCount; i--)
+            {
+                netmask[i] = 0;
+            }
+
+            break;
+
+        default:
+            throw new IPMatcherException("Malformed IP range specification "
+                    + ipSpec);
+        }
+    }
+
+    /**
+     * Fill out a given four-byte array with the IP address specified in the
+     * given String
+     * 
+     * @param ip
+     *            IP address as a dot-delimited String
+     * @param bytes
+     *            4-byte array to fill out
+     * @param mustHave4
+     *            if true, will require that the given IP string specify all
+     *            four bytes
+     * @return the number of actual IP bytes found in the given IP address
+     *         String
+     * @throws IPMatcherException
+     *             if there is a problem parsing the IP string -- e.g. number
+     *             outside of range 0-255, too many numbers, less than 4 numbers
+     *             if {@code mustHave4} is true
+     */
+    private int ipToBytes(String ip, byte[] bytes, boolean mustHave4)
+            throws IPMatcherException
+    {
+        String[] parts = ip.split("\\.");
+
+        if (parts.length > 4 || mustHave4 && parts.length != 4)
+        {
+            throw new IPMatcherException("Malformed IP specification " + ip);
+        }
+
+        try
+        {
+
+            for (int i = 0; i < parts.length; i++)
+            {
+                int p = Integer.parseInt(parts[i]);
+                if (p < 0 || p > 255)
+                {
+                    throw new IPMatcherException("Malformed IP specification "
+                            + ip);
+
+                }
+
+                bytes[i] = (byte) (p < 128 ? p : p - 256);
+            }
+        }
+        catch (NumberFormatException nfe)
+        {
+            throw new IPMatcherException("Malformed IP specification " + ip,
+                    nfe);
+        }
+
+        return parts.length;
+    }
+
+    /**
+     * Determine whether the given full IP falls within the range this
+     * {@code IPMatcher} was initialized with.
+     * 
+     * @param ipIn
+     *            IP address as dot-delimited String
+     * @return {@code true} if the IP matches the range of this
+     *         {@code IPMatcher}; {@code false} otherwise
+     * @throws IPMatcherException
+     *             if the IP passed in cannot be parsed correctly (i.e. is
+     *             malformed)
+     */
+    public boolean match(String ipIn) throws IPMatcherException
+    {
+        byte[] bytes = new byte[4];
+
+        ipToBytes(ipIn, bytes, true);
+
+        for (int i = 0; i < 4; i++)
+        {
+            if ((bytes[i] & netmask[i]) != (network[i] & netmask[i]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

dspace-api/src/main/java/org/dspace/authenticate/IPMatcherException.java

@@ -0,0 +1,67 @@
+/*
+ * IPMatcherException.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.authenticate;
+
+/**
+ * Thrown when there is a problem parsing an IP matcher specification.
+ * 
+ * @version $Revision$
+ * @author Robert Tansley
+ */
+public class IPMatcherException extends Exception
+{
+    public IPMatcherException()
+    {
+        super();
+    }
+
+    public IPMatcherException(String message)
+    {
+        super(message);
+    }
+
+    public IPMatcherException(Throwable cause)
+    {
+        super(cause);
+    }
+
+    public IPMatcherException(String message, Throwable cause)
+    {
+        super(message, cause);
+    }
+}