[maven-release-plugin] prepare release dspace-5.0

Merge pull request #840 from helix84/typos
typos
2025-10-07 10:04:21 +00:00 · 2015-01-16 11:04:01 -06:00 · 2015-01-16 10:04:46 -06:00 · 2015-01-16 16:31:46 +01:00 · 2015-01-16 08:52:07 -06:00 · 2015-01-16 13:05:41 +01:00
3601 changed files with 567077 additions and 149276 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,14 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Standard to msysgit
+*.doc  diff=astextplain
+*.DOC  diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF  diff=astextplain
+*.rtf  diff=astextplain
+*.RTF  diff=astextplain
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,31 @@
+## Ignore the MVN compiled output directories from version tracking
+target/
+
+## Ignore project files created by Eclipse
+.settings/
+.project
+.classpath
+
+## Ignore project files created by IntelliJ IDEA
+*.iml
+*.ipr
+*.iws
+.idea/
+overlays/
+
+## Ignore project files created by NetBeans
+nbproject/private/
+build/
+nbbuild/
+dist/
+nbdist/
+nbactions.xml
+nb-configuration.xml
+META-INF/
+
+## Ignore all *.properties file in root folder, EXCEPT build.properties (the default)
+/*.properties
+!/build.properties
+
+##Mac noise
+.DS_Store
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,45 @@
+language: java
+
+env: 
+  # Give Maven 1GB of memory to work with
+  - MAVEN_OPTS=-Xmx1024M
+
+# Install prerequisites for building Mirage2 more rapidly
+before_install:
+  # Install latest Node.js 0.10.x & print version info
+  - nvm install 0.10
+  - node --version
+  # Install Bower
+  - npm install -g bower
+  # Install Grunt & print version info
+  - npm install -g grunt && npm install -g grunt-cli
+  - grunt --version
+  # Print ruby version info (should be installed)
+  - ruby -v
+  # Install Sass & print version info
+  - gem install sass
+  - sass -v
+  # Install Compass & print version info
+  - gem install compass
+  - compass version
+
+# Skip install stage, as we'll do it below
+install: "echo 'Skipping install stage, dependencies will be downloaded during build and test stages.'"
+
+# Two stage Build and Test
+# 1. Install & Unit Test APIs
+# 2. Assemble DSpace
+script:
+  # 1. [Install & Unit Test] Check source code licenses and run source code Unit Tests
+  #    (This explicitly skips building the 'dspace' assembly module, since we only want to do that ONCE.)
+  #        license:check => Validate all source code license headers
+  #        -Dmaven.test.skip=false => Enable DSpace Unit Tests
+  #        -P !dspace => SKIP full DSpace assembly (will do below)
+  #        -B => Maven batch/non-interactive mode (recommended for CI)
+  #        -V => Display Maven version info before build
+  - "mvn clean install license:check -Dmaven.test.skip=false -P !dspace -B -V"
+  # 2. [Assemble DSpace] Ensure assembly process works (from [src]/dspace/), including Mirage 2
+  #        -Dmirage2.on=true => Build Mirage2
+  #        -Dmirage2.deps.included=false => Don't include Mirage2 build dependencies (We installed them in before_install)
+  #        -P !assembly => SKIP the actual building of [src]/dspace/dspace-installer (as it can be memory intensive)
+  - "cd dspace && mvn package -Dmirage2.on=true -Dmirage2.deps.included=false -P !assembly -B -V"
--- a/40
+++ b/40
@@ -0,0 +1,40 @@
+DSpace source code license:
+
+
+Copyright (c) 2002-2013, 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 DuraSpace nor 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.
+
+
+DSpace uses third-party libraries which may be distributed under
+different licenses to the above. Information about these licenses 
+is detailed in the LICENSES_THIRD_PARTY file at the root of the source 
+tree.  You must agree to the terms of these licenses, in addition to 
+the above DSpace source code license, in order to use this software.
--- a/393
+++ b/393
@@ -0,0 +1,393 @@
+
+DSpace uses third-party libraries which may be distributed under different 
+licenses. We have listed all of these third party libraries and their licenses
+below. This file can be regenerated at any time by simply running:
+    
+    mvn clean verify -Dthird.party.licenses=true
+
+You must agree to the terms of these licenses, in addition to the DSpace 
+source code license, in order to use this software.
+
+---------------------------------------------------
+Third party Java libraries listed by License type.
+
+PLEASE NOTE: Some dependencies may be listed under multiple licenses if they
+are dual-licensed. This is especially true of anything listed as 
+"GNU General Public Library" below, as DSpace actually does NOT allow for any 
+dependencies that are solely released under GPL terms. For more info see:
+https://wiki.duraspace.org/display/DSPACE/Code+Contribution+Guidelines
+---------------------------------------------------
+
+    Apache Software License, Version 2.0:
+
+        * Ant-Contrib Tasks (ant-contrib:ant-contrib:1.0b3 - http://ant-contrib.sourceforge.net)
+        * Code Generation Library (cglib:cglib:3.1 - http://cglib.sourceforge.net/)
+        * HPPC Collections (com.carrotsearch:hppc:0.5.2 - http://labs.carrotsearch.com/hppc.html/hppc)
+        * metadata-extractor (com.drewnoakes:metadata-extractor:2.6.2 - http://code.google.com/p/metadata-extractor/)
+        * Jackson-annotations (com.fasterxml.jackson.core:jackson-annotations:2.3.0 - http://wiki.fasterxml.com/JacksonHome)
+        * Jackson-core (com.fasterxml.jackson.core:jackson-core:2.1.3 - http://wiki.fasterxml.com/JacksonHome)
+        * Jackson-core (com.fasterxml.jackson.core:jackson-core:2.3.3 - http://wiki.fasterxml.com/JacksonHome)
+        * jackson-databind (com.fasterxml.jackson.core:jackson-databind:2.3.3 - http://wiki.fasterxml.com/JacksonHome)
+        * Google APIs Client Library for Java (com.google.api-client:google-api-client:1.19.0 - http://code.google.com/p/google-api-java-client/google-api-client/)
+        * Google Analytics API v3-rev103-1.19.0 (com.google.apis:google-api-services-analytics:v3-rev103-1.19.0 - http://nexus.sonatype.org/oss-repository-hosting.html/google-api-services-analytics)
+        * FindBugs-jsr305 (com.google.code.findbugs:jsr305:3.0.0 - http://findbugs.sourceforge.net/)
+        * Gson (com.google.code.gson:gson:2.2.1 - http://code.google.com/p/google-gson/)
+        * Guava: Google Core Libraries for Java (com.google.guava:guava:13.0 - http://code.google.com/p/guava-libraries/guava)
+        * Guava: Google Core Libraries for Java (com.google.guava:guava:14.0.1 - http://code.google.com/p/guava-libraries/guava)
+        * Guava: Google Core Libraries for Java (com.google.guava:guava:18.0 - http://code.google.com/p/guava-libraries/guava)
+        * Guava: Google Core Libraries for Java (com.google.guava:guava-jdk5:13.0 - http://code.google.com/p/guava-libraries/guava-jdk5)
+        * Google HTTP Client Library for Java (com.google.http-client:google-http-client:1.19.0 - http://code.google.com/p/google-http-java-client/google-http-client/)
+        * Jackson 2 extensions to the Google HTTP Client Library for Java. (com.google.http-client:google-http-client-jackson2:1.19.0 - http://code.google.com/p/google-http-java-client/google-http-client-jackson2/)
+        * Google OAuth Client Library for Java (com.google.oauth-client:google-oauth-client:1.19.0 - http://code.google.com/p/google-oauth-java-client/google-oauth-client/)
+        * Java 6 (and higher) extensions to the Google OAuth Client Library for Java. (com.google.oauth-client:google-oauth-client-java6:1.19.0 - http://code.google.com/p/google-oauth-java-client/google-oauth-client-java6/)
+        * Jetty extensions to the Google OAuth Client Library for Java. (com.google.oauth-client:google-oauth-client-jetty:1.19.0 - http://code.google.com/p/google-oauth-java-client/google-oauth-client-jetty/)
+        * ConcurrentLinkedHashMap (com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.2 - http://code.google.com/p/concurrentlinkedhashmap)
+        * FORESITE :: Object Reuse and Exchange library (com.googlecode.foresite-toolkit:foresite:0.9 - http://www.openarchives.org/ore)
+        * ISO Parser (com.googlecode.mp4parser:isoparser:1.0-RC-1 - http://code.google.com/p/mp4parser/)
+        * builder-commons (com.lyncode:builder-commons:1.0.2 - http://nexus.sonatype.org/oss-repository-hosting.html/builder-commons)
+        * Jtwig Core (com.lyncode:jtwig-core:2.0.1 - http://www.lyncode.com/jtwig-core)
+        * Jtwig Core Functions (com.lyncode:jtwig-functions:2.0.1 - http://www.lyncode.com/jtwig-functions)
+        * Jtwig Spring (com.lyncode:jtwig-spring:2.0.1 - http://www.lyncode.com/jtwig-spring)
+        * Test Support (com.lyncode:test-support:1.0.3 - http://nexus.sonatype.org/oss-repository-hosting.html/test-support)
+        * XOAI : OAI-PMH Java Toolkit (com.lyncode:xoai:3.2.9 - http://www.lyncode.com)
+        * Spatial4J (com.spatial4j:spatial4j:0.4.1 - https://github.com/spatial4j/spatial4j)
+        * Commons BeanUtils (commons-beanutils:commons-beanutils:1.8.3 - http://commons.apache.org/beanutils/)
+        * Commons CLI (commons-cli:commons-cli:1.2 - http://commons.apache.org/cli/)
+        * Apache Commons Codec (commons-codec:commons-codec:1.9 - http://commons.apache.org/proper/commons-codec/)
+        * Collections (commons-collections:commons-collections:3.2 - http://jakarta.apache.org/commons/collections/)
+        * Commons Configuration (commons-configuration:commons-configuration:1.6 - http://commons.apache.org/${pom.artifactId.substring(8)}/)
+        * Commons Configuration (commons-configuration:commons-configuration:1.8 - http://commons.apache.org/configuration/)
+        * Commons DBCP (commons-dbcp:commons-dbcp:1.4 - http://commons.apache.org/dbcp/)
+        * Digester (commons-digester:commons-digester:1.8 - http://jakarta.apache.org/commons/digester/)
+        * Commons FileUpload (commons-fileupload:commons-fileupload:1.2.1 - http://commons.apache.org/fileupload/)
+        * HttpClient (commons-httpclient:commons-httpclient:3.1 - http://jakarta.apache.org/httpcomponents/httpclient-3.x/)
+        * Commons IO (commons-io:commons-io:2.3 - http://commons.apache.org/io/)
+        * commons-jexl (commons-jexl:commons-jexl:1.0 - no url defined)
+        * Commons JXPath (commons-jxpath:commons-jxpath:1.3 - http://commons.apache.org/jxpath/)
+        * Commons Lang (commons-lang:commons-lang:2.6 - http://commons.apache.org/lang/)
+        * Commons Logging (commons-logging:commons-logging:1.1.1 - http://commons.apache.org/logging)
+        * Commons Pool (commons-pool:commons-pool:1.4 - http://commons.apache.org/pool/)
+        * Commons Validator (commons-validator:commons-validator:1.4.0 - http://commons.apache.org/validator/)
+        * Boilerpipe -- Boilerplate Removal and Fulltext Extraction from HTML pages (de.l3s.boilerpipe:boilerpipe:1.1.0 - http://code.google.com/p/boilerpipe/)
+        * jakarta-regexp (jakarta-regexp:jakarta-regexp:1.4 - no url defined)
+        * javax.inject (javax.inject:javax.inject:1 - http://code.google.com/p/atinject/)
+        * jdbm (jdbm:jdbm:1.0 - no url defined)
+        * Joda time (joda-time:joda-time:2.2 - http://joda-time.sourceforge.net)
+        * Joda-Time (joda-time:joda-time:2.3 - http://www.joda.org/joda-time/)
+        * Apache Log4j (log4j:log4j:1.2.16 - http://logging.apache.org/log4j/1.2/)
+        * Apache Log4j (log4j:log4j:1.2.17 - http://logging.apache.org/log4j/1.2/)
+        * Ehcache Core (net.sf.ehcache:ehcache-core:1.7.2 - http://ehcache.sf.net/ehcache-core)
+        * opencsv (net.sf.opencsv:opencsv:2.0 - http://opencsv.sf.net)
+        * opencsv (net.sf.opencsv:opencsv:2.3 - http://opencsv.sf.net)
+        * Abdera Client (org.apache.abdera:abdera-client:1.1.1 - http://abdera.apache.org/abdera-client)
+        * Abdera Core (org.apache.abdera:abdera-core:1.1.1 - http://abdera.apache.org/abdera-core)
+        * I18N Libraries (org.apache.abdera:abdera-i18n:1.1.1 - http://abdera.apache.org)
+        * Abdera Parser (org.apache.abdera:abdera-parser:1.1.1 - http://abdera.apache.org/abdera-parser)
+        * org.apache.tools.ant (org.apache.ant:ant:1.7.0 - http://ant.apache.org/ant/)
+        * ant-launcher (org.apache.ant:ant-launcher:1.7.0 - http://ant.apache.org/ant-launcher/)
+        * Avalon Framework API (org.apache.avalon.framework:avalon-framework-api:4.3.1 - http://www.apache.org/excalibur/avalon-framework/avalon-framework-api/)
+        * Avalon Framework Implementation (org.apache.avalon.framework:avalon-framework-impl:4.3.1 - http://www.apache.org/excalibur/avalon-framework/avalon-framework-impl/)
+        * Cocoon Configuration API (org.apache.cocoon:cocoon-configuration-api:1.0.2 - http://cocoon.apache.org/subprojects/configuration/1.0/configuration-api/1.0/)
+        * Cocoon Core (org.apache.cocoon:cocoon-core:2.2.0 - http://cocoon.apache.org/2.2/core-modules/core/2.2/)
+        * Cocoon Expression Language API (org.apache.cocoon:cocoon-expression-language-api:1.0.0 - http://cocoon.apache.org/2.2/core-modules/expression-language-api/1.0/)
+        * Cocoon Expression Language Implementation. (org.apache.cocoon:cocoon-expression-language-impl:1.0.0 - http://cocoon.apache.org/2.2/core-modules/expression-language-impl/1.0/)
+        * Cocoon Flowscript Block Implementation (org.apache.cocoon:cocoon-flowscript-impl:1.0.0 - http://cocoon.apache.org/2.2/blocks/flowscript/1.0/)
+        * Cocoon Linkrewriter Block Implementation (org.apache.cocoon:cocoon-linkrewriter-impl:1.0.0 - http://cocoon.apache.org/2.2/blocks/linkrewriter/1.0/)
+        * Cocoon Pipeline API (org.apache.cocoon:cocoon-pipeline-api:1.0.0 - http://cocoon.apache.org/2.2/core-modules/pipeline-api/1.0/)
+        * Cocoon Pipeline Components (org.apache.cocoon:cocoon-pipeline-components:1.0.0 - http://cocoon.apache.org/2.2/core-modules/pipeline-components/1.0/)
+        * Cocoon Pipeline Implementation (org.apache.cocoon:cocoon-pipeline-impl:1.0.0 - http://cocoon.apache.org/2.2/core-modules/pipeline-impl/1.0/)
+        * Cocoon Servlet Service Components (org.apache.cocoon:cocoon-servlet-service-components:1.0.0 - http://cocoon.apache.org/subprojects/servlet-service/1.0/servlet-service-components/1.0/)
+        * Cocoon Sitemap API (org.apache.cocoon:cocoon-sitemap-api:1.0.0 - http://cocoon.apache.org/2.2/core-modules/sitemap-api/1.0/)
+        * Cocoon Sitemap Components (org.apache.cocoon:cocoon-sitemap-components:1.0.0 - http://cocoon.apache.org/2.2/core-modules/sitemap-components/1.0/)
+        * Cocoon Sitemap Implementation (org.apache.cocoon:cocoon-sitemap-impl:1.0.0 - http://cocoon.apache.org/2.2/core-modules/sitemap-impl/1.0/)
+        * Cocoon Spring Configurator (org.apache.cocoon:cocoon-spring-configurator:1.0.2 - http://cocoon.apache.org/cocoon-spring-configurator)
+        * Cocoon Store Implementation (org.apache.cocoon:cocoon-store-impl:1.0.0 - http://cocoon.apache.org/2.2/core-modules/store-impl/1.0/)
+        * Cocoon Template Framework Block Implementation (org.apache.cocoon:cocoon-template-impl:1.1.0 - http://cocoon.apache.org/2.2/blocks/template/1.0/)
+        * Cocoon Thread API (org.apache.cocoon:cocoon-thread-api:1.0.0 - http://cocoon.apache.org/2.2/core-modules/thread-api/1.0/)
+        * Cocoon Thread Implementation (org.apache.cocoon:cocoon-thread-impl:1.0.0 - http://cocoon.apache.org/2.2/core-modules/thread-impl/1.0/)
+        * Cocoon Util (org.apache.cocoon:cocoon-util:1.0.0 - http://cocoon.apache.org/2.2/core-modules/util/1.0/)
+        * Cocoon XML API (org.apache.cocoon:cocoon-xml-api:1.0.0 - http://cocoon.apache.org/2.2/core-modules/xml-api/1.0/)
+        * Cocoon XML Implementation (org.apache.cocoon:cocoon-xml-impl:1.0.0 - http://cocoon.apache.org/2.2/core-modules/xml-impl/1.0/)
+        * Cocoon XML Resolver (org.apache.cocoon:cocoon-xml-resolver:1.0.0 - http://cocoon.apache.org/2.2/core-modules/xml-resolver/1.0/)
+        * Cocoon XML Utilities (org.apache.cocoon:cocoon-xml-util:1.0.0 - http://cocoon.apache.org/2.2/core-modules/xml-util/1.0/)
+        * Apache Commons Compress (org.apache.commons:commons-compress:1.7 - http://commons.apache.org/proper/commons-compress/)
+        * Commons Lang (org.apache.commons:commons-lang3:3.1 - http://commons.apache.org/lang/)
+        * Excalibur Pool API (org.apache.excalibur.components:excalibur-pool-api:2.2.1 - http://www.apache.org/excalibur/excalibur-components-modules/excalibur-pool-modules/excalibur-pool-api/)
+        * Excalibur Sourceresolve (org.apache.excalibur.components:excalibur-sourceresolve:2.2.3 - http://www.apache.org/excalibur/excalibur-sourceresolve/)
+        * Excalibur Store (org.apache.excalibur.components:excalibur-store:2.2.1 - http://www.apache.org/excalibur/excalibur-components-modules/excalibur-store/)
+        * Excalibur XML Utilities (org.apache.excalibur.components:excalibur-xmlutil:2.2.1 - http://www.apache.org/excalibur/excalibur-components-modules/excalibur-xmlutil/)
+        * Excalibur Instrument API (org.apache.excalibur.containerkit:excalibur-instrument-api:2.2.1 - http://www.apache.org/excalibur/excalibur-containerkit/excalibur-instrument-modules/excalibur-instrument-api/)
+        * Excalibur Logger (org.apache.excalibur.containerkit:excalibur-logger:2.2.1 - http://www.apache.org/excalibur/excalibur-containerkit/excalibur-logger/)
+        * Activation (org.apache.geronimo.specs:geronimo-activation_1.0.2_spec:1.1 - http://geronimo.apache.org/geronimo-activation_1.0.2_spec)
+        * Activation 1.1 (org.apache.geronimo.specs:geronimo-activation_1.1_spec:1.0.2 - http://geronimo.apache.org/specs/geronimo-activation_1.1_spec)
+        * JavaMail 1.4 (org.apache.geronimo.specs:geronimo-javamail_1.4_spec:1.6 - http://geronimo.apache.org/maven/specs/geronimo-javamail_1.4_spec/1.6)
+        * Streaming API for XML (STAX API 1.0) (org.apache.geronimo.specs:geronimo-stax-api_1.0_spec:1.0 - http://geronimo.apache.org/specs/geronimo-stax-api_1.0_spec)
+        * Streaming API for XML (STAX API 1.0) (org.apache.geronimo.specs:geronimo-stax-api_1.0_spec:1.0.1 - http://geronimo.apache.org/specs/geronimo-stax-api_1.0_spec)
+        * Apache Hadoop Annotations (org.apache.hadoop:hadoop-annotations:2.2.0 - no url defined)
+        * Apache Hadoop Auth (org.apache.hadoop:hadoop-auth:2.2.0 - no url defined)
+        * Apache Hadoop Common (org.apache.hadoop:hadoop-common:2.2.0 - no url defined)
+        * Apache Hadoop HDFS (org.apache.hadoop:hadoop-hdfs:2.2.0 - no url defined)
+        * Apache HttpClient (org.apache.httpcomponents:httpclient:4.3.5 - http://hc.apache.org/httpcomponents-client)
+        * Apache HttpClient Cache (org.apache.httpcomponents:httpclient-cache:4.2.6 - http://hc.apache.org/httpcomponents-client)
+        * Apache HttpCore (org.apache.httpcomponents:httpcore:4.3.2 - http://hc.apache.org/httpcomponents-core-ga)
+        * Apache HttpClient Mime (org.apache.httpcomponents:httpmime:4.3.1 - http://hc.apache.org/httpcomponents-client)
+        * Apache JAMES Mime4j (Core) (org.apache.james:apache-mime4j-core:0.7.2 - http://james.apache.org/mime4j/apache-mime4j-core)
+        * Apache JAMES Mime4j (DOM) (org.apache.james:apache-mime4j-dom:0.7.2 - http://james.apache.org/mime4j/apache-mime4j-dom)
+        * Apache Jena - Libraries POM (org.apache.jena:apache-jena-libs:2.12.0 - http://jena.apache.org/apache-jena-libs/)
+        * Apache Jena - ARQ (SPARQL 1.1 Query Engine) (org.apache.jena:jena-arq:2.12.0 - http://jena.apache.org/jena-arq/)
+        * Apache Jena - Core (org.apache.jena:jena-core:2.12.0 - http://jena.apache.org/jena-core/)
+        * Apache Jena - IRI (org.apache.jena:jena-iri:1.1.0 - http://jena.apache.org/jena-iri/)
+        * Apache Jena - TDB (Native Triple Store) (org.apache.jena:jena-tdb:1.1.0 - http://jena.apache.org/jena-tdb/)
+        * Lucene Common Analyzers (org.apache.lucene:lucene-analyzers-common:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-common)
+        * Lucene ICU Analysis Components (org.apache.lucene:lucene-analyzers-icu:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-icu)
+        * Lucene Kuromoji Japanese Morphological Analyzer (org.apache.lucene:lucene-analyzers-kuromoji:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-kuromoji)
+        * Lucene Morfologik Polish Lemmatizer (org.apache.lucene:lucene-analyzers-morfologik:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-morfologik)
+        * Lucene Phonetic Filters (org.apache.lucene:lucene-analyzers-phonetic:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-phonetic)
+        * Lucene Smart Chinese Analyzer (org.apache.lucene:lucene-analyzers-smartcn:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-smartcn)
+        * Lucene Stempel Analyzer (org.apache.lucene:lucene-analyzers-stempel:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-analyzers-stempel)
+        * Lucene codecs (org.apache.lucene:lucene-codecs:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-codecs)
+        * Lucene Core (org.apache.lucene:lucene-core:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-core)
+        * Lucene Expressions (org.apache.lucene:lucene-expressions:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-expressions)
+        * Lucene Grouping (org.apache.lucene:lucene-grouping:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-grouping)
+        * Lucene Highlighter (org.apache.lucene:lucene-highlighter:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-highlighter)
+        * Lucene Join (org.apache.lucene:lucene-join:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-join)
+        * Lucene Memory (org.apache.lucene:lucene-memory:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-memory)
+        * Lucene Miscellaneous (org.apache.lucene:lucene-misc:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-misc)
+        * Lucene Queries (org.apache.lucene:lucene-queries:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-queries)
+        * Lucene QueryParsers (org.apache.lucene:lucene-queryparser:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-queryparser)
+        * Lucene Sandbox (org.apache.lucene:lucene-sandbox:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-sandbox)
+        * Lucene Spatial (org.apache.lucene:lucene-spatial:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-spatial)
+        * Lucene Suggest (org.apache.lucene:lucene-suggest:4.10.2 - http://lucene.apache.org/lucene-parent/lucene-suggest)
+        * Apache FontBox (org.apache.pdfbox:fontbox:1.8.7 - http://pdfbox.apache.org/)
+        * Apache JempBox (org.apache.pdfbox:jempbox:1.8.7 - http://www.apache.org/pdfbox-parent/jempbox/)
+        * Apache PDFBox (org.apache.pdfbox:pdfbox:1.8.7 - http://www.apache.org/pdfbox-parent/pdfbox/)
+        * Apache POI (org.apache.poi:poi:3.6 - http://poi.apache.org/)
+        * Apache POI (org.apache.poi:poi-ooxml:3.6 - http://poi.apache.org/)
+        * Apache POI (org.apache.poi:poi-ooxml-schemas:3.10.1 - http://poi.apache.org/)
+        * Apache POI (org.apache.poi:poi-ooxml-schemas:3.6 - http://poi.apache.org/)
+        * Apache POI (org.apache.poi:poi-scratchpad:3.6 - http://poi.apache.org/)
+        * Apache Solr Search Server (org.apache.solr:solr:4.10.2 - http://lucene.apache.org/solr-parent/solr)
+        * Apache Solr Analysis Extras (org.apache.solr:solr-analysis-extras:4.10.2 - http://lucene.apache.org/solr-parent/solr-analysis-extras)
+        * Apache Solr Content Extraction Library (org.apache.solr:solr-cell:4.10.2 - http://lucene.apache.org/solr-parent/solr-cell)
+        * Apache Solr Core (org.apache.solr:solr-core:4.10.2 - http://lucene.apache.org/solr-parent/solr-core)
+        * Apache Solr Solrj (org.apache.solr:solr-solrj:4.10.2 - http://lucene.apache.org/solr-parent/solr-solrj)
+        * Apache Tika core (org.apache.tika:tika-core:1.5 - http://tika.apache.org/)
+        * Apache Tika parsers (org.apache.tika:tika-parsers:1.5 - http://tika.apache.org/)
+        * Apache Tika XMP (org.apache.tika:tika-xmp:1.5 - http://tika.apache.org/)
+        * Axiom API (org.apache.ws.commons.axiom:axiom-api:1.2.10 - http://ws.apache.org/axiom/axiom-api/)
+        * Axiom Impl (org.apache.ws.commons.axiom:axiom-impl:1.2.10 - http://ws.apache.org/axiom/axiom-impl/)
+        * XmlBeans (org.apache.xmlbeans:xmlbeans:2.3.0 - http://xmlbeans.apache.org)
+        * XmlBeans (org.apache.xmlbeans:xmlbeans:2.6.0 - http://xmlbeans.apache.org)
+        * zookeeper (org.apache.zookeeper:zookeeper:3.4.6 - no url defined)
+        * Evo Inflector (org.atteo:evo-inflector:1.0.1 - http://atteo.org/static/evo-inflector)
+        * TagSoup (org.ccil.cowan.tagsoup:tagsoup:1.2.1 - http://home.ccil.org/~cowan/XML/tagsoup/)
+        * Jackson (org.codehaus.jackson:jackson-core-asl:1.9.13 - http://jackson.codehaus.org)
+        * Jackson (org.codehaus.jackson:jackson-core-asl:1.9.2 - http://jackson.codehaus.org)
+        * JAX-RS provider for JSON content type (org.codehaus.jackson:jackson-jaxrs:1.9.2 - http://jackson.codehaus.org)
+        * Data Mapper for Jackson (org.codehaus.jackson:jackson-mapper-asl:1.9.13 - http://jackson.codehaus.org)
+        * Data Mapper for Jackson (org.codehaus.jackson:jackson-mapper-asl:1.9.2 - http://jackson.codehaus.org)
+        * Xml Compatibility extensions for Jackson (org.codehaus.jackson:jackson-xc:1.9.2 - http://jackson.codehaus.org)
+        * Jettison (org.codehaus.jettison:jettison:1.1 - no url defined)
+        * Woodstox (org.codehaus.woodstox:wstx-asl:3.2.0 - http://woodstox.codehaus.org)
+        * Woodstox (org.codehaus.woodstox:wstx-asl:3.2.7 - http://woodstox.codehaus.org)
+        * databene ContiPerf (org.databene:contiperf:2.2.0 - http://databene.org/contiperf)
+        * elasticsearch (org.elasticsearch:elasticsearch:1.4.0 - http://nexus.sonatype.org/oss-repository-hosting.html/elasticsearch)
+        * flyway-core (org.flywaydb:flyway-core:3.0 - http://flywaydb.org/flyway-core)
+        * Ogg and Vorbis for Java, Core (org.gagravarr:vorbis-java-core:0.1 - https://github.com/Gagravarr/VorbisJava)
+        * Apache Tika plugin for Ogg, Vorbis and FLAC (org.gagravarr:vorbis-java-tika:0.1 - https://github.com/Gagravarr/VorbisJava)
+        * Javassist (org.javassist:javassist:3.16.1-GA - http://www.javassist.org/)
+        * Jetty Server (org.mortbay.jetty:jetty:6.1.14 - http://jetty.mortbay.org/project/modules/jetty)
+        * Jetty Server (org.mortbay.jetty:jetty:6.1.26 - http://www.eclipse.org/jetty/jetty-parent/project/modules/jetty)
+        * Jetty Servlet Tester (org.mortbay.jetty:jetty-servlet-tester:6.1.14 - http://jetty.mortbay.org/project/jetty-servlet-tester)
+        * Jetty Utilities (org.mortbay.jetty:jetty-util:6.1.14 - http://jetty.mortbay.org/project/jetty-util)
+        * Jetty Utilities (org.mortbay.jetty:jetty-util:6.1.26 - http://www.eclipse.org/jetty/jetty-parent/project/jetty-util)
+        * Servlet Specification API (org.mortbay.jetty:servlet-api:2.5-20081211 - http://jetty.mortbay.org/servlet-api)
+        * Noggit (org.noggit:noggit:0.5 - http://noggit.org)
+        * parboiled-core (org.parboiled:parboiled-core:1.1.6 - http://parboiled.org)
+        * parboiled-java (org.parboiled:parboiled-java:1.1.6 - http://parboiled.org)
+        * Restlet Core - API and Engine (org.restlet.jee:org.restlet:2.1.1 - http://www.restlet.org/org.restlet)
+        * Restlet Extension - Servlet (org.restlet.jee:org.restlet.ext.servlet:2.1.1 - http://www.restlet.org/org.restlet.ext.servlet)
+        * rome-modules (org.rometools:rome-modules:1.0 - http://www.rometools.org)
+        * spring-aop (org.springframework:spring-aop:3.1.1.RELEASE - no url defined)
+        * Spring AOP (org.springframework:spring-aop:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-asm (org.springframework:spring-asm:3.1.1.RELEASE - no url defined)
+        * spring-beans (org.springframework:spring-beans:3.1.1.RELEASE - no url defined)
+        * Spring Beans (org.springframework:spring-beans:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-context (org.springframework:spring-context:3.1.1.RELEASE - no url defined)
+        * Spring Context (org.springframework:spring-context:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-context-support (org.springframework:spring-context-support:3.1.1.RELEASE - no url defined)
+        * spring-core (org.springframework:spring-core:3.1.1.RELEASE - no url defined)
+        * Spring Core (org.springframework:spring-core:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-expression (org.springframework:spring-expression:3.1.1.RELEASE - no url defined)
+        * Spring Expression Language (SpEL) (org.springframework:spring-expression:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-jdbc (org.springframework:spring-jdbc:3.1.1.RELEASE - no url defined)
+        * Spring Framework: Mock (org.springframework:spring-mock:2.0.8 - http://www.springframework.org)
+        * Spring TestContext Framework (org.springframework:spring-test:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-tx (org.springframework:spring-tx:3.1.1.RELEASE - no url defined)
+        * spring-web (org.springframework:spring-web:3.1.1.RELEASE - no url defined)
+        * Spring Web (org.springframework:spring-web:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * spring-webmvc (org.springframework:spring-webmvc:3.1.1.RELEASE - no url defined)
+        * Spring Web MVC (org.springframework:spring-webmvc:3.2.5.RELEASE - https://github.com/SpringSource/spring-framework)
+        * SWORD Java API, GUI and CLI (org.swordapp:sword-common:1.1 - http://nexus.sonatype.org/oss-repository-hosting.html/sword-common)
+        * SWORD v2 :: Common Server Library (org.swordapp:sword2-server:1.0 - http://www.swordapp.org/)
+        * xml-matchers (org.xmlmatchers:xml-matchers:0.10 - http://code.google.com/p/xml-matchers/)
+        * oro (oro:oro:2.0.8 - no url defined)
+        * JUnitParams (pl.pragmatists:JUnitParams:1.0.2 - http://junitparams.googlecode.com)
+        * Rome A9 OpenSearch (rome:opensearch:0.1 - http://wiki.java.net/bin/view/Javawsxml/OpenSearch)
+        * ROME, RSS and atOM utilitiEs for Java (rome:rome:1.0 - https://rome.dev.java.net/)
+        * oai4j (se.kb:oai4j:0.6b1 - http://oai4j-client.sourceforge.net/)
+        * StAX API (stax:stax-api:1.0.1 - http://stax.codehaus.org/)
+        * standard (taglibs:standard:1.1.2 - no url defined)
+        * xalan (xalan:xalan:2.7.0 - no url defined)
+        * Xerces2 Java Parser (xerces:xercesImpl:2.8.1 - http://xerces.apache.org/xerces2-j/)
+        * xmlParserAPIs (xerces:xmlParserAPIs:2.6.2 - no url defined)
+        * XML Commons External Components XML APIs (xml-apis:xml-apis:1.0.b2 - http://xml.apache.org/commons/#external)
+        * xml-apis (xml-apis:xml-apis:1.3.02 - http://xml.apache.org/commons/#external)
+        * xmlParserAPIs (xml-apis:xmlParserAPIs:2.0.2 - no url defined)
+        * XML Commons Resolver Component (xml-resolver:xml-resolver:1.2 - http://xml.apache.org/commons/components/resolver/)
+
+    BSD License:
+
+        * ASM Core (asm:asm:3.1 - http://asm.objectweb.org/asm/)
+        * XMP Library for Java (com.adobe.xmp:xmpcore:5.1.2 - http://www.adobe.com/devnet/xmp.html)
+        * coverity-escapers (com.coverity.security:coverity-escapers:1.1.1 - http://coverity.com/security)
+        * JSONLD Java :: Core (com.github.jsonld-java:jsonld-java:0.5.0 - http://github.com/jsonld-java/jsonld-java/jsonld-java/)
+        * Protocol Buffer Java API (com.google.protobuf:protobuf-java:2.5.0 - http://code.google.com/p/protobuf)
+        * Jena IRI (com.hp.hpl.jena:iri:0.8 - http://jena.sf.net/iri)
+        * Jena (com.hp.hpl.jena:jena:2.6.4 - http://www.openjena.org/)
+        * yui compressor (com.yahoo.platform.yui:yuicompressor:2.3.6 - http://developer.yahoo.com/yui/compressor/)
+        * dnsjava (dnsjava:dnsjava:2.1.1 - http://www.dnsjava.org)
+        * dom4j (dom4j:dom4j:1.6.1 - http://dom4j.org)
+        * Biblio Transformation Engine :: Core (gr.ekt.bte:bte-core:0.9.3.5 - http://github.com/EKT/Biblio-Transformation-Engine/bte-core)
+        * Biblio Transformation Engine :: Input/Output (gr.ekt.bte:bte-io:0.9.3.5 - http://github.com/EKT/Biblio-Transformation-Engine/bte-io)
+        * jaxen (jaxen:jaxen:1.1 - http://jaxen.codehaus.org/)
+        * ANTLR 3 Runtime (org.antlr:antlr-runtime:3.5 - http://www.antlr.org)
+        * Morfologik FSA (org.carrot2:morfologik-fsa:1.7.1 - http://morfologik.blogspot.com/morfologik-fsa/)
+        * Morfologik Stemming Dictionary for Polish (org.carrot2:morfologik-polish:1.7.1 - http://morfologik.blogspot.com/morfologik-polish/)
+        * Morfologik Stemming APIs (org.carrot2:morfologik-stemming:1.7.1 - http://morfologik.blogspot.com/morfologik-stemming/)
+        * databene ContiPerf (org.databene:contiperf:2.2.0 - http://databene.org/contiperf)
+        * DSpace Kernel :: API and Implementation (org.dspace:dspace-api:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-api)
+        * DSpace JSP-UI (org.dspace:dspace-jspui:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-jspui)
+        * DSpace OAI-PMH (org.dspace:dspace-oai:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-oai)
+        * DSpace RDF (org.dspace:dspace-rdf:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-rdf)
+        * DSpace REST :: API and Implementation (org.dspace:dspace-rest:5.0-rc4-SNAPSHOT - http://demo.dspace.org)
+        * DSpace Services Framework :: API and Implementation (org.dspace:dspace-services:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-services)
+        * Apache Solr Webapp (org.dspace:dspace-solr:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-solr)
+        * DSpace SWORD (org.dspace:dspace-sword:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-sword)
+        * DSpace SWORD v2 (org.dspace:dspace-swordv2:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-swordv2)
+        * DSpace XML-UI (Manakin) (org.dspace:dspace-xmlui:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/dspace-xmlui)
+        * handle (org.dspace:handle:6.2 - no url defined)
+        * jargon (org.dspace:jargon:1.4.25 - no url defined)
+        * mets (org.dspace:mets:1.5.2 - no url defined)
+        * oclc-harvester2 (org.dspace:oclc-harvester2:0.1.12 - no url defined)
+        * Repackaged Cocoon Servlet Service Implementation (org.dspace.dependencies.cocoon:dspace-cocoon-servlet-service-impl:1.0.3 - http://projects.dspace.org/dspace-pom/dspace-cocoon-servlet-service-impl)
+        * DSpace Kernel :: Additions and Local Customizations (org.dspace.modules:additions:5.0-rc4-SNAPSHOT - https://github.com/dspace/DSpace/modules/additions)
+        * Hamcrest All (org.hamcrest:hamcrest-all:1.3 - https://github.com/hamcrest/JavaHamcrest/hamcrest-all)
+        * Hamcrest Core (org.hamcrest:hamcrest-core:1.3 - https://github.com/hamcrest/JavaHamcrest/hamcrest-core)
+        * JBibTeX (org.jbibtex:jbibtex:1.0.10 - http://www.jbibtex.org)
+        * ASM Core (org.ow2.asm:asm:4.1 - http://asm.objectweb.org/asm/)
+        * ASM Core (org.ow2.asm:asm:4.2 - http://asm.objectweb.org/asm/)
+        * ASM Analysis (org.ow2.asm:asm-analysis:4.1 - http://asm.objectweb.org/asm-analysis/)
+        * ASM Commons (org.ow2.asm:asm-commons:4.1 - http://asm.objectweb.org/asm-commons/)
+        * ASM Tree (org.ow2.asm:asm-tree:4.1 - http://asm.objectweb.org/asm-tree/)
+        * ASM Util (org.ow2.asm:asm-util:4.1 - http://asm.objectweb.org/asm-util/)
+        * PostgreSQL JDBC Driver (postgresql:postgresql:9.1-901-1.jdbc4 - http://jdbc.postgresql.org)
+        * XMLUnit for Java (xmlunit:xmlunit:1.1 - http://xmlunit.sourceforge.net/)
+        * XMLUnit for Java (xmlunit:xmlunit:1.3 - http://xmlunit.sourceforge.net/)
+
+    Common Development and Distribution License (CDDL):
+
+        * jersey-core (com.sun.jersey:jersey-core:1.17.1 - https://jersey.java.net/jersey-core/)
+        * jersey-json (com.sun.jersey:jersey-json:1.17.1 - https://jersey.java.net/jersey-json/)
+        * jersey-server (com.sun.jersey:jersey-server:1.17.1 - https://jersey.java.net/jersey-server/)
+        * jersey-servlet (com.sun.jersey:jersey-servlet:1.17.1 - https://jersey.java.net/jersey-servlet/)
+        * jersey-spring (com.sun.jersey.contribs:jersey-spring:1.8 - http://maven.apache.org)
+        * JAXB RI (com.sun.xml.bind:jaxb-impl:2.2.3-1 - http://jaxb.java.net/)
+        * JAXB Reference Implementation (com.sun.xml.bind:jaxb-impl:2.2.5 - http://jaxb.java.net/)
+        * JHighlight (com.uwyn:jhighlight:1.0 - https://jhighlight.dev.java.net/)
+        * JavaBeans Activation Framework (JAF) (javax.activation:activation:1.1 - http://java.sun.com/products/javabeans/jaf/index.jsp)
+        * JavaMail API (javax.mail:mail:1.4 - https://glassfish.dev.java.net/javaee5/mail/)
+        * Java Servlet API (javax.servlet:javax.servlet-api:3.1.0 - http://servlet-spec.java.net)
+        * jsp-api (javax.servlet:jsp-api:2.0 - no url defined)
+        * jstl (javax.servlet:jstl:1.1.2 - no url defined)
+        * servlet-api (javax.servlet:servlet-api:2.5 - no url defined)
+        * JAXB API bundle for GlassFish V3 (javax.xml.bind:jaxb-api:2.2.2 - https://jaxb.dev.java.net/)
+        * Streaming API for XML (javax.xml.stream:stax-api:1.0-2 - no url defined)
+        * Servlet Specification 2.5 API (org.mortbay.jetty:servlet-api-2.5:6.1.14 - http://jetty.mortbay.org/project/modules/servlet-api-2.5)
+        * Restlet Core - API and Engine (org.restlet.jee:org.restlet:2.1.1 - http://www.restlet.org/org.restlet)
+        * Restlet Extension - Servlet (org.restlet.jee:org.restlet.ext.servlet:2.1.1 - http://www.restlet.org/org.restlet.ext.servlet)
+
+    Eclipse Public License:
+
+        * JUnit (junit:junit:4.11 - http://junit.org)
+        * AspectJ runtime (org.aspectj:aspectjrt:1.6.11 - http://www.aspectj.org)
+        * databene ContiPerf (org.databene:contiperf:2.2.0 - http://databene.org/contiperf)
+        * Jetty Server (org.mortbay.jetty:jetty:6.1.26 - http://www.eclipse.org/jetty/jetty-parent/project/modules/jetty)
+        * Jetty Utilities (org.mortbay.jetty:jetty-util:6.1.26 - http://www.eclipse.org/jetty/jetty-parent/project/jetty-util)
+        * Restlet Core - API and Engine (org.restlet.jee:org.restlet:2.1.1 - http://www.restlet.org/org.restlet)
+        * Restlet Extension - Servlet (org.restlet.jee:org.restlet.ext.servlet:2.1.1 - http://www.restlet.org/org.restlet.ext.servlet)
+
+    GNU General Public Library:
+
+        * Streaming API for XML (javax.xml.stream:stax-api:1.0-2 - no url defined)
+
+    GNU Lesser General Public License (LGPL):
+
+        * Jackson-annotations (com.fasterxml.jackson.core:jackson-annotations:2.3.0 - http://wiki.fasterxml.com/JacksonHome)
+        * Jackson-core (com.fasterxml.jackson.core:jackson-core:2.3.3 - http://wiki.fasterxml.com/JacksonHome)
+        * jackson-databind (com.fasterxml.jackson.core:jackson-databind:2.3.3 - http://wiki.fasterxml.com/JacksonHome)
+        * FindBugs-Annotations (com.google.code.findbugs:annotations:3.0.0 - http://findbugs.sourceforge.net/)
+        * MaxMind GeoIP API (com.maxmind.geoip:geoip-api:1.2.11 - https://github.com/maxmind/geoip-api-java)
+        * JHighlight (com.uwyn:jhighlight:1.0 - https://jhighlight.dev.java.net/)
+        * JAX-RS provider for JSON content type (org.codehaus.jackson:jackson-jaxrs:1.9.2 - http://jackson.codehaus.org)
+        * Xml Compatibility extensions for Jackson (org.codehaus.jackson:jackson-xc:1.9.2 - http://jackson.codehaus.org)
+        * databene ContiPerf (org.databene:contiperf:2.2.0 - http://databene.org/contiperf)
+        * DSpace TM-Extractors Dependency (org.dspace.dependencies:dspace-tm-extractors:1.0.1 - http://projects.dspace.org/dspace-pom/dspace-tm-extractors)
+        * im4java (org.im4java:im4java:1.4.0 - http://sourceforge.net/projects/im4java/)
+        * Javassist (org.javassist:javassist:3.16.1-GA - http://www.javassist.org/)
+        * org.jdesktop - Swing Worker (org.jdesktop:swing-worker:1.1 - no url defined)
+        * Restlet Core - API and Engine (org.restlet.jee:org.restlet:2.1.1 - http://www.restlet.org/org.restlet)
+        * Restlet Extension - Servlet (org.restlet.jee:org.restlet.ext.servlet:2.1.1 - http://www.restlet.org/org.restlet.ext.servlet)
+        * xom (xom:xom:1.1 - http://www.xom.nu)
+
+    ICU License:
+
+        * ICU4J (com.ibm.icu:icu4j:51.1 - http://icu-project.org/)
+
+    JDOM License:
+
+        * jdom (jdom:jdom:1.0 - no url defined)
+
+    MIT License:
+
+        * Bouncy Castle CMS and S/MIME API (org.bouncycastle:bcmail-jdk15:1.44 - http://www.bouncycastle.org/java.html)
+        * Bouncy Castle Provider (org.bouncycastle:bcprov-jdk15:1.44 - http://www.bouncycastle.org/java.html)
+        * Main (org.jmockit:jmockit:1.10 - http://www.jmockit.org)
+        * OpenCloud (org.mcavallo:opencloud:0.3 - http://opencloud.mcavallo.org/)
+        * Mockito (org.mockito:mockito-all:1.9.5 - http://www.mockito.org)
+        * Mockito (org.mockito:mockito-core:1.9.5 - http://www.mockito.org)
+        * Objenesis (org.objenesis:objenesis:1.0 - http://objenesis.googlecode.com/svn/docs/index.html)
+        * JCL 1.1.1 implemented over SLF4J (org.slf4j:jcl-over-slf4j:1.6.1 - http://www.slf4j.org)
+        * JUL to SLF4J bridge (org.slf4j:jul-to-slf4j:1.6.1 - http://www.slf4j.org)
+        * SLF4J API Module (org.slf4j:slf4j-api:1.6.1 - http://www.slf4j.org)
+        * SLF4J JDK14 Binding (org.slf4j:slf4j-jdk14:1.6.1 - http://www.slf4j.org)
+        * SLF4J LOG4J-12 Binding (org.slf4j:slf4j-log4j12:1.6.1 - http://www.slf4j.org)
+
+    Mozilla Public License:
+
+        * juniversalchardet (com.googlecode.juniversalchardet:juniversalchardet:1.0.3 - http://juniversalchardet.googlecode.com/)
+        * H2 Database Engine (com.h2database:h2:1.4.180 - http://www.h2database.com)
+        * Javassist (org.javassist:javassist:3.16.1-GA - http://www.javassist.org/)
+        * Rhino (rhino:js:1.6R7 - http://www.mozilla.org/rhino/)
+
+    Public Domain:
+
+        * AOP alliance (aopalliance:aopalliance:1.0 - http://aopalliance.sourceforge.net)
+        * Dough Lea's util.concurrent package (concurrent:concurrent:1.3.4 - no url defined)
+        * Reflections (org.reflections:reflections:0.9.9-RC1 - http://code.google.com/p/reflections/reflections/)
+        * XZ for Java (org.tukaani:xz:1.4 - http://tukaani.org/xz/java.html)
+
+    Unknown license:
+
+        * DSpace I18N :: Language Packs (org.dspace:dspace-api-lang:5.0.2 - http://nexus.sonatype.org/oss-repository-hosting.html/dspace-api-lang)
+        * DSpace XML-UI (Manakin) I18N :: Language Packs (org.dspace:dspace-xmlui-lang:5.0.2 - http://nexus.sonatype.org/oss-repository-hosting.html/dspace-xmlui-lang)
--- a/5
+++ b/5
@@ -0,0 +1,5 @@
+The contents of this file are subject to the license and copyright
+detailed in the LICENSE and NOTICE files at the root of the source
+tree and available online at
+
+http://www.dspace.org/license/
--- a/15
+++ b/15
@@ -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 possess the copyright, in these instances please note that the copy 
+right has transferred to the DSpace foundation, and subsequently to DuraSpace.
--- a/54
+++ b/54
@@ -0,0 +1,54 @@
+DSpace version information can be viewed online at
+ - https://wiki.duraspace.org/display/DSDOC/
+
+Documentation for the most recent stable release(s) may be downloaded
+or viewed online at
+ - http://www.dspace.org/latest-release/
+ - https://wiki.duraspace.org/display/DSDOC/
+ - http://sourceforge.net/projects/dspace/files/DSpace%20Stable/
+     (select a version and read DSpace-Manual.pdf)
+
+Installation instructions are to be found in that documentation.
+
+In addition, a listing of all known contributors to DSpace software can be
+found online at:
+https://wiki.duraspace.org/display/DSPACE/DSpaceContributors
+
+Installation instructions for other versions may be different, so you
+are encouraged to obtain the appropriate version of the Documentation
+from the links above.
+
+To obtain files from the repository and build, please see:
+
+ - https://github.com/DSpace/DSpace/
+
+or just:
+
+ - git clone git://github.com/DSpace/DSpace.git
+
+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
+
+ - https://jira.duraspace.org/browse/DS
+
+
+To contribute to DSpace, please see:
+
+ - https://wiki.duraspace.org/display/DSPACE/How+to+Contribute+to+DSpace
+
+
+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/
+
+
+DSpace source code licensing information available online at:
+ - http://www.dspace.org/license/
+
+Copyright (c) 2002-2015, DuraSpace.  All rights reserved.
--- a/build.properties
+++ b/build.properties
@@ -0,0 +1,173 @@
+# DSpace build.properties
+# This file should be customised to suit your build environment.
+# Note that not all configuration is handled here, only the most common
+# properties that tend to differ between build environments. 
+# For adjusting global settings or more complex settings, edit the relevant config file.
+#
+# IMPORTANT: Do not remove or comment out settings in build.properties
+# When you edit the "build.properties" file (or a custom *.properties file),
+# take care not to remove or comment out any settings. Doing so, may cause
+# your final "dspace.cfg" file to be misconfigured with regards to that
+# particular setting.  Instead, if you wish to remove/disable a particular
+# setting, just clear out its value.  For example, if you don't want to be
+# notified of new user registrations, ensure the "mail.registration.notify"
+# setting has no value, e.g. "mail.registration.notify="
+#
+
+##########################
+# SERVER CONFIGURATION #
+##########################
+
+# DSpace installation directory. This is the location where you want
+# to install DSpace. NOTE: this value will be copied over to the
+# "dspace.dir" setting in the final "dspace.cfg" file. It can be
+# modified later on in your "dspace.cfg", if needed.
+dspace.install.dir=/dspace
+
+# DSpace host name - should match base URL.  Do not include port number
+dspace.hostname = localhost
+
+# DSpace base host URL.  Include port number etc.
+dspace.baseUrl = http://localhost:8080
+
+# The user interface you will be using for DSpace. Common usage is either xmlui or jspui
+dspace.ui = xmlui
+
+# Full link your end users will use to access DSpace. In most cases, this will be the baseurl followed by
+# the context path to the UI you are using.
+#
+# Alternatively, you can use a url redirect or deploy the web application under the servlet container root.
+# In this case, make sure to remove the /${dspace.ui} from the dspace.url property.
+dspace.url = ${dspace.baseUrl}/${dspace.ui}
+
+# Name of the site
+dspace.name = DSpace at My University
+
+# Solr server
+solr.server=http://localhost:8080/solr
+
+# Default language for metadata values
+default.language = en_US
+
+##########################
+# DATABASE CONFIGURATION #
+##########################
+
+# Uncomment the appropriate block below for your database.
+# postgres
+db.driver=org.postgresql.Driver
+db.url=jdbc:postgresql://localhost:5432/dspace
+db.username=dspace
+db.password=dspace
+
+# oracle
+#db.driver= oracle.jdbc.OracleDriver
+#db.url=jdbc:oracle:thin:@//localhost:1521/xe
+#db.username=dspace
+#db.password=dspace
+
+# Schema name - if your database contains multiple schemas, you can avoid problems with
+# retrieving the definitions of duplicate object names by specifying
+# the schema name here that is used for DSpace by uncommenting the following entry
+
+# NOTE: this configuration option is for PostgreSQL only. For Oracle, schema is equivalent
+# to user name. DSpace depends on the PostgreSQL understanding of schema. If you are using
+# Oracle, just leave this this value blank.
+
+db.schema = 
+
+# Maximum number of DB connections in pool
+db.maxconnections = 30
+
+# Maximum time to wait before giving up if all connections in pool are busy (milliseconds)
+db.maxwait = 5000
+
+# Maximum number of idle connections in pool (-1 = unlimited)
+db.maxidle = -1
+
+# Determine if prepared statement should be cached. (default is true)
+db.statementpool = true
+
+# Specify a name for the connection pool (useful if you have multiple applications sharing Tomcat's dbcp)
+# If not specified, defaults to 'dspacepool'
+db.poolname = dspacepool
+
+#######################
+# EMAIL CONFIGURATION #
+#######################
+
+# SMTP mail server
+mail.server = smtp.example.com
+
+# SMTP mail server authentication username and password (if required)
+# mail.server.username = myusername
+# mail.server.password = mypassword
+mail.server.username=
+mail.server.password=
+
+# SMTP mail server alternate port (defaults to 25)
+mail.server.port = 25
+
+# From address for mail
+mail.from.address = dspace-noreply@myu.edu
+
+# Currently limited to one recipient!
+mail.feedback.recipient = dspace-help@myu.edu
+
+# General site administration (Webmaster) e-mail
+mail.admin = dspace-help@myu.edu
+
+# Recipient for server errors and alerts
+#mail.alert.recipient = email-address-here
+mail.alert.recipient=
+
+# Recipient for new user registration emails
+#mail.registration.notify = email-address-here
+mail.registration.notify=
+
+
+########################
+# HANDLE CONFIGURATION #
+########################
+
+# Canonical Handle URL prefix
+#
+# By default, DSpace is configured to use http://hdl.handle.net/
+# as the canonical URL prefix when generating dc.identifier.uri
+# during submission, and in the 'identifier' displayed in JSPUI
+# item record pages.
+#
+# If you do not subscribe to CNRI's handle service, you can change this
+# to match the persistent URL service you use, or you can force DSpace
+# to use your site's URL, eg.
+#handle.canonical.prefix = ${dspace.url}/handle/
+#
+# Note that this will not alter dc.identifer.uri metadata for existing
+# items (only for subsequent submissions), but it will alter the URL 
+# in JSPUI's 'identifier' message on item record pages for existing items.
+#
+# If omitted, the canonical URL prefix will be http://hdl.handle.net/
+handle.canonical.prefix = http://hdl.handle.net/
+
+# CNRI Handle prefix
+handle.prefix = 123456789
+
+#######################
+# PROXY CONFIGURATION #
+#######################
+# uncomment and specify both properties if proxy server required
+# proxy server for external http requests - use regular hostname without port number
+http.proxy.host =
+
+# port number of proxy server
+http.proxy.port =
+
+#####################
+# LOGLEVEL SETTINGS #
+#####################
+loglevel.other = INFO
+# loglevel.other: Log level for other third-party tools/APIs used by DSpace
+# Possible values (from most to least info): DEBUG, INFO, WARN, ERROR, FATAL
+loglevel.dspace = INFO
+# loglevel.dspace: Log level for all DSpace-specific code (org.dspace.*)
+# Possible values (from most to least info): DEBUG, INFO, WARN, ERROR, FATAL
--- a/dspace-api/pom.xml
+++ b/dspace-api/pom.xml
@@ -0,0 +1,636 @@
+<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>
+
+    <!--
+       A Parent POM that Maven inherits DSpace Defaults
+       POM attributes from.
+    -->
+    <parent>
+        <groupId>org.dspace</groupId>
+        <artifactId>dspace-parent</artifactId>
+        <version>5.0</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <properties>
+        <!-- This is the path to the root [dspace-src] directory. -->
+        <root.basedir>${basedir}/..</root.basedir>
+    </properties>
+
+    <!--
+       Runtime and Compile Time dependencies for DSpace.
+    -->
+    <build>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <includes>
+                    <include>maven.properties</include>
+                    <include>scm.properties</include>
+                </includes>
+                <filtering>true</filtering>
+            </resource>
+            <resource>
+                <directory>src/main/resources</directory>
+                <excludes>
+                    <exclude>maven.properties</exclude>
+                    <exclude>scm.properties</exclude>
+                </excludes>
+                <filtering>false</filtering>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <debug>true</debug>
+                    <showDeprecation>true</showDeprecation>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+                            <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+                        </manifest>
+                    </archive>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>test-jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <!-- Verify OS license headers for all source code files -->
+            <plugin>
+                <groupId>com.mycila</groupId>
+                <artifactId>license-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>**/src/test/resources/**</exclude>
+                        <exclude>**/src/test/data/**</exclude>
+                        <exclude>**/.gitignore</exclude>
+                        <exclude>src/test/data/dspaceFolder/config/spiders/**</exclude>
+                        <exclude>src/main/java/org/apache/solr/handler/extraction/ExtractingParams.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <version>1.9</version>
+                <executions>
+                    <execution>
+                        <phase>validate</phase>
+                        <goals>
+                            <goal>maven-version</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+                <version>1.3</version>
+                <executions>
+                    <execution>
+                        <phase>validate</phase>
+                        <goals>
+                            <goal>create</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+
+    <profiles>
+        <profile>
+            <id>findbugs</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+                <!-- property>
+                    <name>maven.test.skip</name>
+                    <value>false</value>
+                </property -->
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>findbugs-maven-plugin</artifactId>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+        <!-- If Unit Testing is enabled, then setup the Unit Test Environment.
+             See also the 'skiptests' profile in Parent POM. -->
+        <profile>
+            <id>test-environment</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+                <property>
+                    <name>maven.test.skip</name>
+                    <value>false</value>
+                </property>
+            </activation>
+            <build>
+                <plugins>
+                    <!-- Unit/Integration Testing setup: This plugin unzips the
+                         'testEnvironment.zip' file (created by dspace-parent POM), into
+                         the 'target/testing/' folder, to essentially create a test
+                         install of DSpace, against which Tests can be run. -->
+                    <plugin>
+                        <artifactId>maven-dependency-plugin</artifactId>
+                        <version>2.8</version>
+                        <executions>
+                            <execution>
+                                <id>setupTestEnvironment</id>
+                                <phase>generate-test-resources</phase>
+                                <goals>
+                                    <goal>unpack</goal>
+                                </goals>
+                                <configuration>
+                                    <outputDirectory>${project.build.directory}/testing</outputDirectory>
+                                    <artifactItems>
+                                        <artifactItem>
+                                            <groupId>org.dspace</groupId>
+                                            <artifactId>dspace-parent</artifactId>
+                                            <version>${project.version}</version>
+                                            <type>zip</type>
+                                            <classifier>testEnvironment</classifier>
+                                        </artifactItem>
+                                    </artifactItems>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+
+                    <!-- This plugin allows us to run a Groovy script in our Maven POM
+                         (see: http://gmaven.codehaus.org/Executing+Groovy+Code )
+                         We are generating a OS-agnostic version (agnostic.build.dir) of
+                         the ${project.build.directory} property (full path of target dir).
+                         This is needed by the FileWeaver & Surefire plugins (see below)
+                         to initialize the Unit Test environment's dspace.cfg file.
+                         Otherwise, the Unit Test Framework will not work on Windows OS.
+                         This Groovy code was mostly borrowed from:
+                         http://stackoverflow.com/questions/3872355/how-to-convert-file-separator-in-maven
+                    -->
+                    <plugin>
+                        <groupId>org.codehaus.gmaven</groupId>
+                        <artifactId>groovy-maven-plugin</artifactId>
+                        <version>2.0</version>
+                        <executions>
+                            <execution>
+                                <id>setproperty</id>
+                                <phase>generate-test-resources</phase>
+                                <goals>
+                                    <goal>execute</goal>
+                                </goals>
+                                <configuration>
+                                    <source>
+                                    project.properties['agnostic.build.dir']=project.build.directory.replace(File.separator,'/');
+                                    println("Initializing Maven property 'agnostic.build.dir' to: " + project.properties['agnostic.build.dir']);
+                                    </source>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                    
+                    <!-- FileWeaver plugin is in charge of initializing & "weaving" together
+                         the dspace.cfg file to be used by the Unit Testing environment.
+                         It weaves two files, the default 'dspace.cfg' and 'dspace.cfg.more',
+                         both of which are included in the testEnvironment.zip. -->
+                    <plugin>
+                        <groupId>edu.iu.ul.maven.plugins</groupId>
+                        <artifactId>fileweaver</artifactId>
+                        <version>1.0</version>
+                        <configuration>
+                            <outputs>
+                                <output>
+                                    <outputPath>${agnostic.build.dir}/testing</outputPath>
+                                    <name>dspace.cfg.woven</name>
+                                    <parts>
+                                        <part>
+                                            <path>${agnostic.build.dir}/testing/dspace/config/dspace.cfg</path>
+                                        </part>
+                                        <part>
+                                            <path>${agnostic.build.dir}/testing/dspace.cfg.more</path>
+                                        </part>
+                                    </parts>
+                                    <properties>
+                                        <dspace.install.dir>${agnostic.build.dir}/testing/dspace</dspace.install.dir>
+                                    </properties>
+                                </output>
+                            </outputs>
+                        </configuration>
+                        <executions>
+                            <execution>
+                                <id>edit-dspace-cfg</id>
+                                <phase>process-test-resources</phase>
+                                <goals>
+                                    <goal>weave</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                    </plugin>
+
+                    <!-- The ant plugin below ensures that the final "woven" dspace.cfg
+                         ends up in the /target/testing/dspace/ directory. This becomes
+                         our final dspace.cfg for the Unit Testing environment. The dspace
+                         service manager needs this "woven" configuration file when it starts.-->
+                    <plugin>
+                        <artifactId>maven-antrun-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>process-test-resources</phase>
+                                <configuration>
+                                    <target>
+                                        <copy file="${agnostic.build.dir}/testing/dspace.cfg.woven" tofile="${agnostic.build.dir}/testing/dspace/config/dspace.cfg" />
+                                    </target>
+                                </configuration>
+                                <goals>
+                                    <goal>run</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                    </plugin>
+
+                    <!-- Run Unit/Integration Testing! This plugin just kicks off the tests (when enabled). -->
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <!-- Specify the dspace.cfg file to use for test environment -->
+                                <dspace.configuration>${agnostic.build.dir}/testing/dspace/config/dspace.cfg</dspace.configuration>
+                                <!-- Turn off any DSpace logging -->
+                                <dspace.log.init.disable>true</dspace.log.init.disable>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+
+        </profile>
+    </profiles>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>org.dspace</groupId>
+            <artifactId>handle</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.dspace</groupId>
+            <artifactId>jargon</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.dspace</groupId>
+            <artifactId>mets</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.dspace.dependencies</groupId>
+            <artifactId>dspace-tm-extractors</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-analyzers-common</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-queryparser</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.jena</groupId>
+            <artifactId>apache-jena-libs</artifactId>
+            <type>pom</type>
+        </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>commons-validator</groupId>
+            <artifactId>commons-validator</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>org.apache.pdfbox</groupId>
+            <artifactId>pdfbox</artifactId>
+        </dependency>
+        <dependency>
+           <groupId>org.apache.pdfbox</groupId>
+           <artifactId>fontbox</artifactId>
+        </dependency>
+        <dependency>
+           <groupId>org.apache.pdfbox</groupId>
+           <artifactId>jempbox</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk15</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcmail-jdk15</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-scratchpad</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>rome</groupId>
+            <artifactId>rome</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>rome</groupId>
+            <artifactId>opensearch</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</artifactId>
+        </dependency>
+        <dependency> <!-- Keep jmockit before junit -->
+            <groupId>org.jmockit</groupId>
+            <artifactId>jmockit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.databene</groupId>
+            <artifactId>contiperf</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.rometools</groupId>
+            <artifactId>rome-modules</artifactId>
+            <version>1.0</version>
+        </dependency>
+        <dependency>
+            <groupId>gr.ekt.bte</groupId>
+            <artifactId>bte-core</artifactId>
+            <version>0.9.3.5</version>
+        </dependency>
+        <dependency>
+            <groupId>gr.ekt.bte</groupId>
+            <artifactId>bte-io</artifactId>
+            <version>0.9.3.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpcore</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.solr</groupId>
+            <artifactId>solr-solrj</artifactId>
+            <version>${solr.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>jcl-over-slf4j</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-configuration</groupId>
+            <artifactId>commons-configuration</artifactId>
+            <version>1.8</version>
+        </dependency>
+        <dependency>
+            <groupId>com.maxmind.geoip</groupId>
+            <artifactId>geoip-api</artifactId>
+            <version>1.2.11</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.ant</groupId>
+            <artifactId>ant</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>dnsjava</groupId>
+            <artifactId>dnsjava</artifactId>
+            <version>2.1.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.elasticsearch</groupId>
+            <artifactId>elasticsearch</artifactId>
+            <version>1.4.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.coverity.security</groupId>
+            <artifactId>coverity-escapers</artifactId>
+            <version>1.1.1</version>
+        </dependency>
+
+        <!--  Gson: Java to Json conversion -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>18.0</version>
+        </dependency>
+
+
+        <dependency>
+            <groupId>postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+        </dependency>
+		
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>jdbm</groupId>
+            <artifactId>jdbm</artifactId>
+            <version>1.0</version>
+        </dependency>
+
+        <!-- For ImageMagick MediaFilters -->
+        <dependency>
+            <groupId>org.im4java</groupId>
+            <artifactId>im4java</artifactId>
+            <version>1.4.0</version>
+        </dependency>
+        
+        <!-- Flyway DB API (flywaydb.org) is used to manage DB upgrades automatically. -->
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
+            <version>3.0</version>
+        </dependency>
+
+        <!-- Google Analytics -->
+        <dependency>
+            <groupId>com.google.apis</groupId>
+            <artifactId>google-api-services-analytics</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.http-client</groupId>
+            <artifactId>google-http-client-jackson2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.oauth-client</groupId>
+            <artifactId>google-oauth-client-jetty</artifactId>
+        </dependency>
+        <!-- FindBugs -->
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.inject</groupId>
+            <artifactId>javax.inject</artifactId>
+            <version>1</version>
+            <type>jar</type>
+        </dependency>
+    </dependencies>
+
+</project>
--- a/dspace-api/src/main/java/org/apache/solr/handler/extraction/ExtractingParams.java
+++ b/dspace-api/src/main/java/org/apache/solr/handler/extraction/ExtractingParams.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.handler.extraction;
+
+
+/**
+ * The various Solr Parameters names to use when extracting content.
+ *
+ **/
+public interface ExtractingParams {
+
+  /**
+   * Map all generated attribute names to field names with lowercase and underscores.
+   */
+  public static final String LOWERNAMES = "lowernames";
+
+  /**
+   * if true, ignore TikaException (give up to extract text but index meta data)
+   */
+  public static final String IGNORE_TIKA_EXCEPTION = "ignoreTikaException";
+
+
+  /**
+   * The param prefix for mapping Tika metadata to Solr fields.
+   * <p/>
+   * To map a field, add a name like:
+   * <pre>fmap.title=solr.title</pre>
+   *
+   * In this example, the tika "title" metadata value will be added to a Solr field named "solr.title"
+   *
+   *
+   */
+  public static final String MAP_PREFIX = "fmap.";
+
+  /**
+   * The boost value for the name of the field.  The boost can be specified by a name mapping.
+   * <p/>
+   * For example
+   * <pre>
+   * map.title=solr.title
+   * boost.solr.title=2.5
+   * </pre>
+   * will boost the solr.title field for this document by 2.5
+   *
+   */
+  public static final String BOOST_PREFIX = "boost.";
+
+  /**
+   * Pass in literal values to be added to the document, as in
+   * <pre>
+   *  literal.myField=Foo 
+   * </pre>
+   *
+   */
+  public static final String LITERALS_PREFIX = "literal.";
+
+
+  /**
+   * Restrict the extracted parts of a document to be indexed
+   *  by passing in an XPath expression.  All content that satisfies the XPath expr.
+   * will be passed to the {@link SolrContentHandler}.
+   * <p/>
+   * See Tika's docs for what the extracted document looks like.
+   * <p/>
+   * @see #CAPTURE_ELEMENTS
+   */
+  public static final String XPATH_EXPRESSION = "xpath";
+
+
+  /**
+   * Only extract and return the content, do not index it.
+   */
+  public static final String EXTRACT_ONLY = "extractOnly";
+
+  /**
+   * Content output format if extractOnly is true. Default is "xml", alternative is "text".
+   */
+  public static final String EXTRACT_FORMAT = "extractFormat";
+
+  /**
+   * Capture attributes separately according to the name of the element, instead of just adding them to the string buffer
+   */
+  public static final String CAPTURE_ATTRIBUTES = "captureAttr";
+
+  /**
+   * Literal field values will by default override other values such as metadata and content. Set this to false to revert to pre-4.0 behaviour
+   */
+  public static final String LITERALS_OVERRIDE = "literalsOverride";
+
+  /**
+   * Capture the specified fields (and everything included below it that isn't capture by some other capture field) separately from the default.  This is different
+   * then the case of passing in an XPath expression.
+   * <p/>
+   * The Capture field is based on the localName returned to the {@link SolrContentHandler}
+   * by Tika, not to be confused by the mapped field.  The field name can then
+   * be mapped into the index schema.
+   * <p/>
+   * For instance, a Tika document may look like:
+   * <pre>
+   *  &lt;html&gt;
+   *    ...
+   *    &lt;body&gt;
+   *      &lt;p&gt;some text here.  &lt;div&gt;more text&lt;/div&gt;&lt;/p&gt;
+   *      Some more text
+   *    &lt;/body&gt;
+   * </pre>
+   * By passing in the p tag, you could capture all P tags separately from the rest of the t
+   * Thus, in the example, the capture of the P tag would be: "some text here.  more text"
+   *
+   */
+  public static final String CAPTURE_ELEMENTS = "capture";
+
+  /**
+   * The type of the stream.  If not specified, Tika will use mime type detection.
+   */
+  public static final String STREAM_TYPE = "stream.type";
+
+
+  /**
+   * Optional.  The file name. If specified, Tika can take this into account while
+   * guessing the MIME type.
+   */
+  public static final String RESOURCE_NAME = "resource.name";
+
+  /**
+   * Optional. The password for this resource. Will be used instead of the rule based password lookup mechanisms 
+   */
+  public static final String RESOURCE_PASSWORD = "resource.password";
+
+  /**
+   * Optional.  If specified, the prefix will be prepended to all Metadata, such that it would be possible
+   * to setup a dynamic field to automatically capture it
+   */
+  public static final String UNKNOWN_FIELD_PREFIX = "uprefix";
+
+  /**
+   * Optional.  If specified and the name of a potential field cannot be determined, the default Field specified
+   * will be used instead.
+   */
+  public static final String DEFAULT_FIELD = "defaultField";
+
+  /**
+   * Optional. If specified, loads the file as a source for password lookups for Tika encrypted documents.
+   * <p>
+   * File format is Java properties format with one key=value per line.
+   * The key is evaluated as a regex against the file name, and the value is the password
+   * The rules are evaluated top-bottom, i.e. the first match will be used
+   * If you want a fallback password to be always used, supply a .*=&lt;defaultmypassword&gt; at the end  
+   */
+  public static final String PASSWORD_MAP_FILE = "passwordsFile";
+}
--- a/dspace-api/src/main/java/org/dspace/administer/CommunityFiliator.java
+++ b/dspace-api/src/main/java/org/dspace/administer/CommunityFiliator.java
@@ -1,41 +1,9 @@
-/*
- * CommunityFiliator.java
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
 *
- * 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.
+ * http://www.dspace.org/license/
 */
 package org.dspace.administer;

@@ -127,19 +95,17 @@ public class CommunityFiliator
            System.exit(1);
        }

-        if (command.equals("set") || command.equals("remove"))
+        if ("set".equals(command) || "remove".equals(command))
        {
            if (parentID == null)
            {
-                System.out
-                        .println("Error - a parentID must be specified (run with -h flag for details)");
+                System.out.println("Error - a parentID must be specified (run with -h flag for details)");
                System.exit(1);
            }

            if (childID == null)
            {
-                System.out
-                        .println("Error - a childID must be specified (run with -h flag for details)");
+                System.out.println("Error - a childID must be specified (run with -h flag for details)");
                System.exit(1);
            }
        }
@@ -170,7 +136,7 @@ public class CommunityFiliator
                System.exit(1);
            }

-            if (command.equals("set"))
+            if ("set".equals(command))
            {
                filiator.filiate(c, parent, child);
            }
--- a/dspace-api/src/main/java/org/dspace/administer/CreateAdministrator.java
+++ b/dspace-api/src/main/java/org/dspace/administer/CreateAdministrator.java
@@ -0,0 +1,268 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.administer;
+
+import java.io.Console;
+import java.util.Arrays;
+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.apache.commons.lang.StringUtils;
+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 final class CreateAdministrator
+{
+	/** DSpace Context object */
+	private final 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 last 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
+    {
+        Console console = System.console();
+    	
+    	System.out.println("Creating an initial administrator account");
+    	
+    	boolean dataOK = false;
+    	
+    	String email = null;
+    	String firstName = null;
+    	String lastName = null;
+        char[] password1 = null;
+        char[] password2 = null;
+    	String language = I18nUtil.DEFAULTLOCALE.getLanguage();
+    	
+    	while (!dataOK)
+    	{
+    		System.out.print("E-mail address: ");
+    		System.out.flush();
+    		
+    		email = console.readLine();
+            if (!StringUtils.isBlank(email))
+            {
+                email = email.trim();
+            }
+            else
+            {
+                System.out.println("Please provide an email address.");
+                continue;
+            }
+    		
+    		System.out.print("First name: ");
+    		System.out.flush();
+    		
+    		firstName = console.readLine();
+
+            if (firstName != null)
+            {
+                firstName = firstName.trim();
+            }
+    		
+    		System.out.print("Last name: ");
+    		System.out.flush();
+    		
+    		lastName = console.readLine();
+
+            if (lastName != null)
+            {
+                lastName = lastName.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 = console.readLine();
+
+                if (language != null)
+                {
+                    language = language.trim();
+                    language = I18nUtil.getSupportedLocale(new Locale(language)).getLanguage();
+                }
+            }
+            
+    		System.out.println("Password will not display on screen.");
+    		System.out.print("Password: ");
+    		System.out.flush();
+
+    		password1 = console.readPassword();
+    		
+    		System.out.print("Again to confirm: ");
+    		System.out.flush();
+    		
+    		password2 = console.readPassword();
+
+            //TODO real password validation
+            if (password1.length > 1 && Arrays.equals(password1, password2))
+    		{
+    			// password OK
+    			System.out.print("Is the above data correct? (y or n): ");
+    			System.out.flush();
+    			
+    			String s = console.readLine();
+
+                if (s != null)
+                {
+                    s = s.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, String.valueOf(password1));
+
+        //Cleaning arrays that held password
+        Arrays.fill(password1, ' ');
+        Arrays.fill(password2, ' ');
+    }
+    
+    /**
+     * 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 language preferred language
+     * @param pw	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 IllegalStateException("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");
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/administer/DCType.java
+++ b/dspace-api/src/main/java/org/dspace/administer/DCType.java
@@ -1,48 +1,15 @@
-/*
- * DCType.java
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
 *
- * 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.
+ * http://www.dspace.org/license/
 */
 package org.dspace.administer;

 import java.io.IOException;
 import java.sql.SQLException;

-import org.apache.log4j.Logger;
 import org.dspace.authorize.AuthorizeException;
 import org.dspace.content.MetadataField;
 import org.dspace.content.MetadataSchema;
@@ -67,9 +34,6 @@ import org.dspace.core.Context;
 */
 public class DCType
 {
-    /** log4j logger */
-    private static Logger log = Logger.getLogger(DCType.class);
-
    /** Our context */
    private Context ourContext;

--- a/dspace-api/src/main/java/org/dspace/administer/MetadataExporter.java
+++ b/dspace-api/src/main/java/org/dspace/administer/MetadataExporter.java
@@ -0,0 +1,325 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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 definition(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(Integer.valueOf(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(Integer.valueOf(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);
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/administer/MetadataImporter.java
+++ b/dspace-api/src/main/java/org/dspace/administer/MetadataImporter.java
@@ -0,0 +1,276 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.administer;
+
+import java.io.IOException;
+import java.sql.SQLException;
+
+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.authorize.AuthorizeException;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.content.NonUniqueMetadataException;
+import org.dspace.core.Context;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+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
+{
+    /** logging category */
+    private static final Logger log = LoggerFactory.getLogger(MetadataImporter.class);
+
+	/**
+	 * 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
+    {
+        Context context = null;
+
+        try
+        {
+            // create a context
+            context = new Context();
+            context.turnOffAuthorisationSystem();
+
+            // 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.restoreAuthSystemState();
+            context.complete();
+        }
+        finally
+        {
+           // Clean up our context, if it still exists & it was never completed
+            if(context!=null && context.isValid())
+                context.abort();
+        }
+    }
+    
+    /**
+     * 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");
+        }
+
+        // check to see if the schema already exists
+        MetadataSchema s = MetadataSchema.find(context, name);
+        
+        if (s == null)
+        {
+            // Schema does not exist - create
+            log.info("Registering Schema " + name + " (" + namespace + ")");
+            MetadataSchema schema = new MetadataSchema(namespace, name);
+            schema.create(context);
+        }
+        else
+        {
+            // Schema exists - if it's the same namespace, allow the type imports to continue
+            if (s.getNamespace().equals(namespace))
+            {
+                // This schema already exists with this namespace, skipping it
+                return;
+            }
+            
+            // It's a different namespace - have we been told to update?
+            if (updateExisting)
+            {
+                // Update the existing schema namespace and continue to type import
+                log.info("Updating Schema " + name + ": New namespace " + namespace);
+                s.setNamespace(namespace);
+                s.update(context);
+            }
+            else
+            {
+                throw new RegistryImportException("Schema " + name + " already registered with different namespace " + namespace + ". Rerun with 'update' option enabled if you wish to update this schema.");
+            }
+        }
+        
+    }
+    
+    /**
+     * 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;
+        }
+
+        
+        // Find the matching schema object
+        MetadataSchema schemaObj = MetadataSchema.find(context, schema);
+        
+        if (schemaObj == null)
+        {
+            throw new RegistryImportException("Schema '" + schema + "' is not registered and does not exist.");
+        }
+        
+        MetadataField mf = MetadataField.findByElement(context, schemaObj.getSchemaID(), element, qualifier);
+        if (mf != null)
+        {
+            // Metadata field already exists, skipping it
+            return;
+        }
+        
+        // Actually create this metadata field as it doesn't yet exist
+        String fieldName = schema + "." + element + "." + qualifier;
+        if(qualifier==null)
+            fieldName = schema + "." + element;
+        log.info("Registering metadata field " + fieldName);
+        MetadataField field = new MetadataField();
+        field.setSchemaID(schemaObj.getSchemaID());
+        field.setElement(element);
+        field.setQualifier(qualifier);
+        field.setScopeNote(scopeNote);
+        field.create(context);
+    }
+    
+    /**
+     * 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);
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/administer/RegistryExportException.java
+++ b/dspace-api/src/main/java/org/dspace/administer/RegistryExportException.java
@@ -0,0 +1,56 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.administer;
+
+/**
+ * @author Graham Triggs
+ *
+ * An exception to report any problems with registry exports
+ */
+public class RegistryExportException extends Exception
+{
+    /**
+     * 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);
+    }
+    
+}
--- a/dspace-api/src/main/java/org/dspace/administer/RegistryImportException.java
+++ b/dspace-api/src/main/java/org/dspace/administer/RegistryImportException.java
@@ -0,0 +1,56 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.administer;
+
+/**
+ * @author Richard Jones
+ *
+ * An exception to report any problems with registry imports
+ */
+public class RegistryImportException extends Exception
+{
+    /**
+     * 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);
+    }
+    
+}
--- a/dspace-api/src/main/java/org/dspace/administer/RegistryImporter.java
+++ b/dspace-api/src/main/java/org/dspace/administer/RegistryImporter.java
@@ -0,0 +1,141 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.administer;
+
+import java.io.File;
+import java.io.IOException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import org.apache.xpath.XPathAPI;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+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;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/administer/RegistryLoader.java
+++ b/dspace-api/src/main/java/org/dspace/administer/RegistryLoader.java
@@ -0,0 +1,302 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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.log4j.Logger;
+import org.apache.xpath.XPathAPI;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.BitstreamFormat;
+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.xml.sax.SAXException;
+
+/**
+ * Loads the bitstream format and Dublin Core type registries into the database.
+ * Intended for use as a command-line tool.
+ * <P>
+ * Example usage:
+ * <P>
+ * <code>RegistryLoader -bitstream bitstream-formats.xml</code>
+ * <P>
+ * <code>RegistryLoader -dc dc-types.xml</code>
+ * 
+ * @author Robert Tansley
+ * @version $Revision$
+ */
+public class RegistryLoader
+{
+    /** log4j category */
+    private static Logger log = Logger.getLogger(RegistryLoader.class);
+
+    /**
+     * For invoking via the command line
+     * 
+     * @param argv
+     *            command-line arguments
+     */
+    public static void main(String[] argv) throws Exception
+    {
+        String usage = "Usage: " + RegistryLoader.class.getName()
+                + " (-bitstream | -metadata) registry-file.xml";
+
+        Context context = null;
+
+        try
+        {
+            context = new Context();
+
+            // Can't update registries anonymously, so we need to turn off
+            // authorisation
+            context.turnOffAuthorisationSystem();
+
+            // Work out what we're loading
+            if (argv[0].equalsIgnoreCase("-bitstream"))
+            {
+                RegistryLoader.loadBitstreamFormats(context, argv[1]);
+            }
+            else if (argv[0].equalsIgnoreCase("-metadata"))
+            {
+                // Call MetadataImporter, as it handles Metadata schema updates
+                MetadataImporter.loadRegistry(argv[1], true);
+            }
+            else
+            {
+                System.err.println(usage);
+            }
+
+            // Commit changes and close Context
+            context.complete();
+
+            System.exit(0);
+        }
+        catch (ArrayIndexOutOfBoundsException ae)
+        {
+            System.err.println(usage);
+
+            System.exit(1);
+        }
+        catch (Exception e)
+        {
+            log.fatal(LogManager.getHeader(context, "error_loading_registries",
+                    ""), e);
+
+            System.err.println("Error: \n - " + e.getMessage());
+            System.exit(1);
+        }
+        finally
+        {
+            // Clean up our context, if it still exists & it was never completed
+            if(context!=null && context.isValid())
+                context.abort();
+        }
+    }
+
+    /**
+     * Load Bitstream Format metadata
+     * 
+     * @param context
+     *            DSpace context object
+     * @param filename
+     *            the filename of the XML file to load
+     */
+    public static void loadBitstreamFormats(Context context, String filename)
+            throws SQLException, IOException, ParserConfigurationException,
+            SAXException, TransformerException, AuthorizeException
+    {
+        Document document = loadXML(filename);
+
+        // Get the nodes corresponding to formats
+        NodeList typeNodes = XPathAPI.selectNodeList(document,
+                "dspace-bitstream-types/bitstream-type");
+
+        // Add each one as a new format to the registry
+        for (int i = 0; i < typeNodes.getLength(); i++)
+        {
+            Node n = typeNodes.item(i);
+            loadFormat(context, n);
+        }
+
+        log.info(LogManager.getHeader(context, "load_bitstream_formats",
+                "number_loaded=" + typeNodes.getLength()));
+    }
+
+    /**
+     * Process a node in the bitstream format registry XML file. The node must
+     * be a "bitstream-type" node
+     * 
+     * @param context
+     *            DSpace context object
+     * @param node
+     *            the node in the DOM tree
+     */
+    private static void loadFormat(Context context, Node node)
+            throws SQLException, IOException, TransformerException,
+            AuthorizeException
+    {
+        // Get the values
+        String mimeType = getElementData(node, "mimetype");
+        String shortDesc = getElementData(node, "short_description");
+        String desc = getElementData(node, "description");
+
+        String supportLevelString = getElementData(node, "support_level");
+        int supportLevel = Integer.parseInt(supportLevelString);
+
+        String internalString = getElementData(node, "internal");
+        boolean internal = Boolean.valueOf(internalString).booleanValue();
+
+        String[] extensions = getRepeatedElementData(node, "extension");
+
+        // Check if this format already exists in our registry (by mime type)
+        BitstreamFormat exists = BitstreamFormat.findByMIMEType(context, mimeType);
+        
+        // If not found by mimeType, check by short description (since this must also be unique)
+        if(exists==null)
+        {    
+            exists = BitstreamFormat.findByShortDescription(context, shortDesc);
+        }
+            
+        // If it doesn't exist, create it..otherwise skip it.
+        if(exists==null)
+        {
+            // Create the format object
+            BitstreamFormat format = BitstreamFormat.create(context);
+
+            // Fill it out with the values
+            format.setMIMEType(mimeType);
+            format.setShortDescription(shortDesc);
+            format.setDescription(desc);
+            format.setSupportLevel(supportLevel);
+            format.setInternal(internal);
+            format.setExtensions(extensions);
+
+            // Write to database
+            format.update();
+        }
+    }
+
+    // ===================== XML Utility Methods =========================
+
+    /**
+     * Load in the XML from file.
+     * 
+     * @param filename
+     *            the filename to load from
+     * 
+     * @return the DOM representation of the XML file
+     */
+    private static Document loadXML(String filename) throws IOException,
+            ParserConfigurationException, SAXException
+    {
+        DocumentBuilder builder = DocumentBuilderFactory.newInstance()
+                .newDocumentBuilder();
+
+        return builder.parse(new File(filename));
+    }
+
+    /**
+     * 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>
+     */
+    private 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>
+     */
+    private 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;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/administer/StructBuilder.java
+++ b/dspace-api/src/main/java/org/dspace/administer/StructBuilder.java
@@ -0,0 +1,581 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.administer;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+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 Map<String, String> collectionMap = new HashMap<String, String>();
+    
+    /** a hashtable to hold metadata for the community being worked on */
+    private static Map<String, String> communityMap = new HashMap<String, String>();
+    
+    /**
+     * 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("Communities 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 sub-structures
+     * @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);
+            for (Map.Entry<String, String> entry : communityMap.entrySet())
+            {
+                NodeList nl = XPathAPI.selectNodeList(tn, entry.getKey());
+                if (nl.getLength() == 1)
+                {
+                    community.setMetadata(entry.getValue(), getStringValue(nl.item(0)));
+                }
+            }
+            
+            // 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);
+            for (Map.Entry<String, String> entry : collectionMap.entrySet())
+            {
+                NodeList nl = XPathAPI.selectNodeList(tn, entry.getKey());
+                if (nl.getLength() == 1)
+                {
+                    collection.setMetadata(entry.getValue(), getStringValue(nl.item(0)));
+                }
+            }
+            
+            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;
+    }
+    
+}
--- a/dspace-api/src/main/java/org/dspace/administer/package.html
+++ b/dspace-api/src/main/java/org/dspace/administer/package.html
@@ -0,0 +1,23 @@
+<!--
+
+    The contents of this file are subject to the license and copyright
+    detailed in the LICENSE and NOTICE files at the root of the source
+    tree and available online at
+
+    http://www.dspace.org/license/
+
+-->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<html>
+<head>
+<!--
+  Author:   Robert Tansley
+  Version:  $Revision$
+  Date:     $Date$
+-->
+</head>
+<body bgcolor="white">
+Provides classes and methods for administrative functions that fall outside
+the regular use of other subsystems.
+</body>
+</html>
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/BulkEditChange.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/BulkEditChange.java
@@ -0,0 +1,407 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.bulkedit;
+
+import org.dspace.content.Item;
+import org.dspace.content.Metadatum;
+import org.dspace.content.Collection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 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 List of hashtables with the new elements */
+    private List<Metadatum> adds;
+
+    /** The List of hashtables with the removed elements */
+    private List<Metadatum> removes;
+
+    /** The List of hashtables with the unchanged elements */
+    private List<Metadatum> constant;
+
+    /** The List of the complete set of new values (constant + adds) */
+    private List<Metadatum> complete;
+
+    /** The list of old collections the item used to be mapped to */
+    private List<Collection> oldMappedCollections;
+
+    /** The list of new collections the item has been mapped into */
+    private List<Collection> newMappedCollections;
+
+    /** The old owning collection */
+    private Collection oldOwningCollection;
+
+    /** The new owning collection */
+    private Collection newOwningCollection;
+
+    /** Is this a new item */
+    private boolean newItem;
+
+    /** Has this item been deleted? */
+    private boolean deleted;
+
+    /** Has this item been withdrawn? */
+    private boolean withdrawn;
+
+    /** Has this item been reinstated? */
+    private boolean reinstated;
+
+    /** Have any changes actually been made? */
+    private boolean empty;
+
+
+    /**
+     * Initialise a change holder for a new item 
+     */
+    public BulkEditChange()
+    {
+        // Set the item to be null
+        item = null;
+        newItem = true;
+        empty = true;
+        oldOwningCollection = null;
+        newOwningCollection = null;
+
+        // Initialise the arrays
+        adds = new ArrayList<Metadatum>();
+        removes = new ArrayList<Metadatum>();
+        constant = new ArrayList<Metadatum>();
+        complete = new ArrayList<Metadatum>();
+        oldMappedCollections = new ArrayList<Collection>();
+        newMappedCollections = new ArrayList<Collection>();
+    }
+
+    /**
+     * Initialise 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;
+
+        // Initialise the arrays
+        adds = new ArrayList<Metadatum>();
+        removes = new ArrayList<Metadatum>();
+        constant = new ArrayList<Metadatum>();
+        complete = new ArrayList<Metadatum>();
+        oldMappedCollections = new ArrayList<Collection>();
+        newMappedCollections = 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(Metadatum 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(Metadatum 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(Metadatum dcv)
+    {
+        // Add the removed value
+        constant.add(dcv);
+        complete.add(dcv);
+    }
+
+    /**
+     * Add a new mapped Collection
+     *
+     * @param c The new mapped Collection
+     */
+    public void registerNewMappedCollection(Collection c)
+    {
+        // Add the new owning Collection
+        newMappedCollections.add(c);
+        empty = false;
+    }
+
+    /**
+     * Add an old mapped Collection
+     *
+     * @param c The old mapped Collection
+     */
+    public void registerOldMappedCollection(Collection c)
+    {
+        // Add the old owning Collection (if it isn't there already, or is an old collection)
+        boolean found = false;
+
+        if ((this.getOldOwningCollection() != null) &&
+            (this.getOldOwningCollection().getHandle().equals(c.getHandle())))
+        {
+            found = true;
+        }
+
+        for (Collection collection : oldMappedCollections)
+        {
+            if (collection.getHandle().equals(c.getHandle()))
+            {
+                found = true;
+            }
+        }
+
+        if (!found)
+        {
+            oldMappedCollections.add(c);
+            empty = false;
+        }
+    }
+
+    /**
+     * Register a change to the owning collection
+     *
+     * @param oldC The old owning collection
+     * @param newC The new owning collection
+     */
+    public void changeOwningCollection(Collection oldC, Collection newC)
+    {
+        // Store the old owning collection
+        oldOwningCollection = oldC;
+
+        // Store the new owning collection
+        newOwningCollection = newC;
+        empty = false;
+    }
+
+    /**
+     * Set the owning collection of an item
+     *
+     * @param newC The new owning collection
+     */
+    public void setOwningCollection(Collection newC)
+    {
+        // Store the new owning collection
+        newOwningCollection = newC;
+        //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 List<Metadatum> 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 List<Metadatum> getRemoves()
+    {
+        // Return the array
+        return removes;
+    }
+
+    /**
+     * Get the list of unchanged values
+     *
+     * @return the list of unchanged values
+     */
+    public List<Metadatum> getConstant()
+    {
+        // Return the array
+        return constant;
+    }
+
+    /**
+     * Get the list of all values
+     *
+     * @return the list of all values
+     */
+    public List<Metadatum> getComplete()
+    {
+        // Return the array
+        return complete;
+    }
+
+    /**
+     * Get the list of new mapped Collections
+     *
+     * @return the list of new mapped collections
+     */
+    public List<Collection> getNewMappedCollections()
+    {
+        // Return the array
+        return newMappedCollections;
+    }
+
+    /**
+     * Get the list of old mapped Collections
+     *
+     * @return the list of old mapped collections
+     */
+    public List<Collection> getOldMappedCollections()
+    {
+        // Return the array
+        return oldMappedCollections;
+    }
+
+    /**
+     * Get the old owning collection
+     *
+     * @return the old owning collection
+     */
+    public Collection getOldOwningCollection()
+    {
+        // Return the old owning collection
+        return oldOwningCollection;
+    }
+
+    /**
+     * Get the new owning collection
+     *
+     * @return the new owning collection
+     */
+    public Collection getNewOwningCollection()
+    {
+        // Return the new owning collection
+        return newOwningCollection;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Does this change object represent a deleted item?
+     *
+     * @return Whether or not this is for a deleted item
+     */
+    public boolean isDeleted()
+    {
+        // Return the new item status
+        return deleted;
+    }
+
+    /**
+     * Set that this item has been deleted
+     */
+    public void setDeleted() {
+        // Store the setting
+        deleted = true;
+        empty = false;
+    }
+
+    /**
+     * Does this change object represent a withdrawn item?
+     *
+     * @return Whether or not this is for a withdrawn item
+     */
+    public boolean isWithdrawn()
+    {
+        // Return the new item status
+        return withdrawn;
+    }
+
+    /**
+     * Set that this item has been withdrawn
+     */
+    public void setWithdrawn() {
+        // Store the setting
+        withdrawn = true;
+        empty = false;
+    }
+
+    /**
+     * Does this change object represent a reinstated item?
+     *
+     * @return Whether or not this is for a reinstated item
+     */
+    public boolean isReinstated()
+    {
+        // Return the new item status
+        return reinstated;
+    }
+
+    /**
+     * Set that this item has been deleted
+     */
+    public void setReinstated() {
+        // Store the setting
+        reinstated = true;
+        empty = false;
+    }
+
+    /**
+     * Have any changes actually been recorded, or is this empty?
+     *
+     * @return Whether or not changes have been made
+     */
+    public boolean hasChanges()
+    {
+        return !empty;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/DSpaceCSV.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/DSpaceCSV.java
@@ -0,0 +1,703 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.bulkedit;
+
+import org.apache.commons.lang3.StringUtils;
+import org.dspace.authority.AuthorityValue;
+import org.dspace.app.bulkedit.DSpaceCSVLine;
+import org.dspace.app.bulkedit.MetadataImport;
+import org.dspace.app.bulkedit.MetadataImportInvalidHeadingException;
+import org.dspace.content.Collection;
+import org.dspace.content.*;
+import org.dspace.content.Collection;
+import org.dspace.content.authority.Choices;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import java.io.*;
+
+/**
+ * Utility class to read and write CSV files
+ *
+ * **************
+ * Important Note
+ * **************
+ *
+ * This class has been made serializable, as it is stored in a Session.
+ * Is it wise to:
+ *    a) be putting this into a user's session?
+ *    b) holding an entire CSV upload in memory?
+ *
+ * @author Stuart Lewis
+ */
+public class DSpaceCSV implements Serializable
+{
+    /** The headings of the CSV file */
+    private List<String> headings;
+
+    /** An array list of CSV lines */
+    private List<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 regexes */
+    protected static String escapedValueSeparator;
+
+    /** The field separator (defaults to comma) */
+    protected static String fieldSeparator;
+
+    /** The field separator in an escaped form for using in regexes */
+    protected static String escapedFieldSeparator;
+
+    /** The authority separator (defaults to double colon '::') */
+    protected static String authoritySeparator;
+
+    /** The authority separator in an escaped form for using in regexes */
+    protected static String escapedAuthoritySeparator;
+
+
+    /** Whether to export all metadata such as handles and provenance information */
+    private boolean exportAll;
+
+    /** A list of metadata elements to ignore */
+    private Map<String, String> 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)
+    {
+        // Initialise the class
+        init();
+
+        // Store the exportAll setting
+        this.exportAll = exportAll;
+    }
+
+    /**
+     * Create a new instance, reading the lines in from file
+     *
+     * @param f The file to read from
+     * @param c The DSpace Context
+     *
+     * @throws Exception thrown if there is an error reading or processing the file
+     */
+    public DSpaceCSV(File f, Context c) throws Exception
+    {
+        // Initialise the class
+        init();
+
+        // Open the CSV file
+        BufferedReader input = null;
+        try
+        {
+            input = new BufferedReader(new InputStreamReader(new FileInputStream(f),"UTF-8"));
+
+            // Read the heading line
+            String head = input.readLine();
+            String[] headingElements = head.split(escapedFieldSeparator);
+            int columnCounter = 0;
+            for (String element : headingElements)
+            {
+                columnCounter++;
+
+                // Remove surrounding quotes if there are any
+                if ((element.startsWith("\"")) && (element.endsWith("\"")))
+                {
+                    element = element.substring(1, element.length() - 1);
+                }
+
+                // Store the heading
+                if ("collection".equals(element))
+                {
+                    // Store the heading
+                    headings.add(element);
+                }
+                // Store the action
+                else if ("action".equals(element))
+                {
+                    // Store the heading
+                    headings.add(element);
+                }
+                else if (!"id".equals(element))
+                {
+                    String authorityPrefix = "";
+                    AuthorityValue authorityValueType = MetadataImport.getAuthorityValueType(element);
+                    if (authorityValueType != null) {
+                        String authorityType = authorityValueType.getAuthorityType();
+                        authorityPrefix = element.substring(0, authorityType.length() + 1);
+                        element = element.substring(authorityPrefix.length());
+                    }
+
+                    // Verify that the heading is valid in the metadata registry
+                    String[] clean = element.split("\\[");
+                    String[] parts = clean[0].split("\\.");
+
+                    if (parts.length < 2) {
+                        throw new MetadataImportInvalidHeadingException(element,
+                                                                        MetadataImportInvalidHeadingException.ENTRY,
+                                                                        columnCounter);
+                    }
+
+                    String metadataSchema = parts[0];
+                    String metadataElement = parts[1];
+                    String metadataQualifier = null;
+                    if (parts.length > 2) {
+                        metadataQualifier = parts[2];
+                    }
+
+                    // Check that the scheme exists
+                    MetadataSchema foundSchema = MetadataSchema.find(c, metadataSchema);
+                    if (foundSchema == null) {
+                        throw new MetadataImportInvalidHeadingException(clean[0],
+                                                                        MetadataImportInvalidHeadingException.SCHEMA,
+                                                                        columnCounter);
+                    }
+
+                    // Check that the metadata element exists in the schema
+                    int schemaID = foundSchema.getSchemaID();
+                    MetadataField foundField = MetadataField.findByElement(c, schemaID, metadataElement, metadataQualifier);
+                    if (foundField == null) {
+                        throw new MetadataImportInvalidHeadingException(clean[0],
+                                                                        MetadataImportInvalidHeadingException.ELEMENT,
+                                                                        columnCounter);
+                    }
+
+                    // Store the heading
+                    headings.add(authorityPrefix + element);
+                }
+            }
+
+            // Read each subsequent line
+            StringBuilder lineBuilder = new StringBuilder();
+            String lineRead;
+
+            while (StringUtils.isNotBlank(lineRead = input.readLine()))
+            {
+                if (lineBuilder.length() > 0) {
+                    // Already have a previously read value - add this line
+                    lineBuilder.append("\n").append(lineRead);
+
+                    // Count the number of quotes in the buffer
+                    int quoteCount = 0;
+                    for (int pos = 0; pos < lineBuilder.length(); pos++) {
+                        if (lineBuilder.charAt(pos) == '"') {
+                            quoteCount++;
+                        }
+                    }
+
+                    if (quoteCount % 2 == 0) {
+                        // Number of quotes is a multiple of 2, add the item
+                        addItem(lineBuilder.toString());
+                        lineBuilder = new StringBuilder();
+                    }
+                } else if (lineRead.indexOf('"') > -1) {
+                    // Get the number of quotes in the line
+                    int quoteCount = 0;
+                    for (int pos = 0; pos < lineRead.length(); pos++) {
+                        if (lineRead.charAt(pos) == '"') {
+                            quoteCount++;
+                        }
+                    }
+
+                    if (quoteCount % 2 == 0) {
+                        // Number of quotes is a multiple of 2, add the item
+                        addItem(lineRead);
+                    } else {
+                        // Uneven quotes - add to the buffer and leave for later
+                        lineBuilder.append(lineRead);
+                    }
+                } else {
+                    // No previously read line, and no quotes in the line - add item
+                    addItem(lineRead);
+                }
+            }
+        }
+        finally
+        {
+            if (input != null)
+            {
+                input.close();
+            }
+        }
+    }
+
+    /**
+     * Initialise this class with values from dspace.cfg
+     */
+    private void init()
+    {
+        // Set the value separator
+        setValueSeparator();
+
+        // Set the field separator
+        setFieldSeparator();
+
+        // Set the authority separator
+        setAuthoritySeparator();
+
+        // Create the headings
+        headings = new ArrayList<String>();
+
+        // Create the blank list of items
+        lines = new ArrayList<DSpaceCSVLine>();
+
+        // Initialise the counter
+        counter = 0;
+
+        // Set the metadata fields to ignore
+        ignore = new HashMap<String, String>();
+        String toIgnore = ConfigurationManager.getProperty("bulkedit", "ignore-on-export");
+        if ((toIgnore == null) || ("".equals(toIgnore.trim())))
+        {
+            // Set a default value
+            toIgnore = "dc.date.accessioned, dc.date.available, " +
+                       "dc.date.updated, dc.description.provenance";
+        }
+        String[] toIgnoreArray = toIgnore.split(",");
+        for (String toIgnoreString : toIgnoreArray)
+        {
+            if (!"".equals(toIgnoreString.trim()))
+            {
+                ignore.put(toIgnoreString.trim(), toIgnoreString.trim());
+            }
+        }
+    }
+
+    /**
+     * Decide if this CSV file has an 'action' (case-dependent!) header.
+     *
+     * @return Whether or not there is an 'action' header
+     */
+    public boolean hasActions() {
+        // Look for a heading called 'action'
+        for (String header : headings) {
+            if (header.equals("action")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Set the value separator for multiple values stored in one csv value.
+     *
+     * Is set in bulkedit.cfg as 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);
+        escapedValueSeparator = match.replaceAll("\\\\$1");
+    }
+
+    /**
+     * Set the field separator use to separate fields in the csv.
+     *
+     * Is set in bulkedit.cfg as 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");
+    }
+
+     /**
+     * Set the authority separator for value with authority data.
+     *
+     * Is set in dspace.cfg as bulkedit.authorityseparator
+     *
+     * If not set, defaults to double colon '::'
+     */
+    private void setAuthoritySeparator()
+    {
+        // Get the value separator
+        authoritySeparator = ConfigurationManager.getProperty("bulkedit", "authorityseparator");
+        if ((authoritySeparator != null) && (!"".equals(authoritySeparator.trim())))
+        {
+            authoritySeparator = authoritySeparator.trim();
+        }
+        else
+        {
+            authoritySeparator = "::";
+        }
+
+        // Now store the escaped version
+        Pattern spchars = Pattern.compile("([\\\\*+\\[\\](){}\\$.?\\^|])");
+        Matcher match = spchars.matcher(authoritySeparator);
+        escapedAuthoritySeparator = 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 final void addItem(Item i) throws Exception
+    {
+        // If the item does not have an "owningCollection" the the below "getHandle()" call will fail
+        // This should not happen but is here for safety.
+        if (i.getOwningCollection() == null) {
+            return;
+        }
+
+        // Create the CSV line
+        DSpaceCSVLine line = new DSpaceCSVLine(i.getID());
+
+        // Add in owning collection
+        String owningCollectionHandle = i.getOwningCollection().getHandle();
+        line.add("collection", owningCollectionHandle);
+
+        // Add in any mapped collections
+        Collection[] collections = i.getCollections();
+        for (Collection c : collections)
+        {
+            // Only add if it is not the owning collection
+            if (!c.getHandle().equals(owningCollectionHandle))
+            {
+                line.add("collection", c.getHandle());
+            }
+        }
+
+        // Populate it
+        Metadatum md[] = i.getMetadata(Item.ANY, Item.ANY, Item.ANY, Item.ANY);
+        for (Metadatum value : md)
+        {
+            // Get the key (schema.element)
+            String key = value.schema + "." + value.element;
+
+            // Add the qualifier 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))
+            {
+                // Add authority and confidence if authority is not null
+                String mdValue = value.value;
+                if (value.authority != null && !"".equals(value.authority))
+                {
+                    mdValue += authoritySeparator + value.authority + authoritySeparator +  (value.confidence != -1 ? value.confidence : Choices.CF_ACCEPTED);
+                }
+                line.add(key, mdValue);
+                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 final void addItem(String line) throws Exception
+    {
+        // Check to see if the last character is a field separator, which hides the last empty 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 & 1) == 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 information. " +
+                                   "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
+                if (headings.size() < i) {
+                    throw new MetadataImportInvalidHeadingException("",
+                                                                    MetadataImportInvalidHeadingException.MISSING,
+                                                                    i + 1);
+                }
+                csvLine.add(headings.get(i - 1), null);
+                String[] elements = part.split(escapedValueSeparator);
+                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 final List<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 final String[] getCSVLinesAsStringArray()
+    {
+        // Create the headings line
+        String[] csvLines = new String[counter + 1];
+        csvLines[0] = "id" + fieldSeparator + "collection";
+        List<String> headingsCopy = new ArrayList<String>(headings);
+        Collections.sort(headingsCopy);
+        for (String value : headingsCopy)
+        {
+            csvLines[0] = csvLines[0] + fieldSeparator + value;
+        }
+
+        Iterator<DSpaceCSVLine> i = lines.iterator();
+        int c = 1;
+        while (i.hasNext())
+        {
+            csvLines[c++] = i.next().toCSV(headingsCopy);
+        }
+
+        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 final void save(String filename) throws IOException
+    {
+        // Save the file
+        BufferedWriter out = new BufferedWriter(
+                             new OutputStreamWriter(
+                             new FileOutputStream(filename), "UTF-8"));
+        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 ignore-on-export in bulkedit.cfg
+     *
+     * @param md The Metadatum to examine
+     * @return Whether or not it is OK to export this element
+     */
+    private final boolean okToExport(Metadatum md)
+    {
+        // 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;
+    }
+
+    /**
+     * Get the headings used in this CSV file
+     *
+     * @return The headings
+     */
+    public List<String> getHeadings()
+    {
+        return headings;
+    }
+
+    /**
+     * Return the csv file as one long formatted string
+     *
+     * @return The formatted String as a csv
+     */
+    public final 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();
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/DSpaceCSVLine.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/DSpaceCSVLine.java
@@ -0,0 +1,216 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.bulkedit;
+
+import org.dspace.authority.AuthorityValue;
+
+import java.io.Serializable;
+import java.util.*;
+
+/**
+ * Utility class to store a line from a CSV file
+ *
+ * @author Stuart Lewis
+ */
+public class DSpaceCSVLine implements Serializable
+{
+
+    /** 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 Map<String, ArrayList> items;
+
+    /** ensuring that the order-sensible columns of the csv are processed in the correct order */
+    private final Comparator<? super String> headerComparator = new Comparator<String>() {
+        @Override
+        public int compare(String md1, String md2) {
+            // The metadata coming from an external source should be processed after the others
+            AuthorityValue source1 = MetadataImport.getAuthorityValueType(md1);
+            AuthorityValue source2 = MetadataImport.getAuthorityValueType(md2);
+
+            int compare;
+            if (source1 == null && source2 != null) {
+                compare = -1;
+            }
+            else if (source1 != null && source2 == null) {
+                compare = 1;
+            } else {
+                // the order of the rest does not matter
+                compare = md1.compareTo(md2);
+            }
+            return compare;
+        }
+    };
+
+    /**
+     * Create a new CSV line
+     *
+     * @param itemId The item ID of the line
+     */
+    public DSpaceCSVLine(int itemId)
+    {
+        // Store the ID + separator, and initialise the hashtable
+        this.id = itemId;
+        items = new TreeMap<String, ArrayList>(headerComparator);
+//        this.items = new HashMap<String, ArrayList>();
+    }
+
+    /**
+     * Create a new CSV line for a new item
+     */
+    public DSpaceCSVLine()
+    {
+        // Set the ID to be -1, and initialise the hashtable
+        this.id = -1;
+        this.items = new TreeMap<String, ArrayList>(headerComparator);
+//        this.items = new HashMap<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 List<String> get(String key)
+    {
+        // Return any relevant values
+        return items.get(key);
+    }
+
+    /**
+     * Get any action associated with this line
+     *
+     * @return The action (may be blank, 'withdraw', 'reinstate' or 'delete')
+     */
+    public String getAction()
+    {
+        if (items.containsKey("action")) {
+            ArrayList actions = items.get("action");
+            if (actions.size() > 0) {
+                return ((String)actions.get(0)).trim();
+            }
+        }
+        return "";
+    }
+
+    /**
+     * Get all the metadata keys that are represented in this line
+     *
+     * @return An enumeration of all the keys
+     */
+    public Set<String> keys()
+    {
+        // Return the keys
+        return items.keySet();
+    }
+
+    /**
+     * 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(List<String> headings)
+    {
+        StringBuilder bits = new StringBuilder();
+
+        // Add the id
+        bits.append("\"").append(id).append("\"").append(DSpaceCSV.fieldSeparator);
+        bits.append(valueToCSV(items.get("collection")));
+
+        // Add the rest of the elements
+        for (String heading : headings)
+        {
+            bits.append(DSpaceCSV.fieldSeparator);
+            List<String> values = items.get(heading);
+            if (values != null && !"collection".equals(heading))
+            {
+                bits.append(valueToCSV(values));
+            }
+        }
+
+        return bits.toString();
+    }
+
+    /**
+     * 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
+     */
+    protected String valueToCSV(List<String> values)
+    {
+        // Check there is some content
+        if (values == null)
+        {
+            return "";
+        }
+
+        // Get on with the work
+        String s;
+        if (values.size() == 1)
+        {
+            s = values.get(0);
+        }
+        else
+        {
+            // Concatenate any fields together
+            StringBuilder str = new StringBuilder();
+
+            for (String value : values)
+            {
+                if (str.length() > 0)
+                {
+                    str.append(DSpaceCSV.valueSeparator);
+                }
+
+                str.append(value);
+            }
+
+            s = str.toString();
+        }
+
+        // Replace internal quotes with two sets of quotes
+        return "\"" + s.replaceAll("\"", "\"\"") + "\"";
+    }
+}
+
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataExport.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataExport.java
@@ -0,0 +1,269 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.bulkedit;
+
+import org.apache.commons.cli.*;
+
+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;
+import java.util.List;
+
+/**
+ * Metadata exporter to allow the batch export of metadata into a file
+ *
+ * @author Stuart Lewis
+ */
+public class MetadataExport
+{
+    /** The items to export */
+    private ItemIterator toExport;
+
+    /** Whether to export all metadata, or just normally edited metadata */
+    private boolean exportAll;
+
+    /**
+     * 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.toExport = toExport;
+        this.exportAll = exportAll;
+    }
+
+    /**
+     * Method to export a community (and sub-communities 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.toExport = new ItemIterator(c, buildFromCommunity(toExport, new ArrayList<Integer>(), 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 recursion - 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 List<Integer> buildFromCommunity(Community community, List<Integer> 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)
+        {
+            // Something went wrong...
+            System.err.println("Error exporting to CSV:");
+            e.printStackTrace();
+            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 + ")");
+                List<Integer> item = new ArrayList<Integer>();
+                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);        
+
+        // Finish off and tidy up
+        c.restoreAuthSystemState();
+        c.complete();
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImport.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImport.java
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImportException.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImportException.java
@@ -0,0 +1,37 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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);
+    }
+
+    /**
+     * Instantiate a new MetadataImportException
+     *
+     * @param message the error message
+     * @param exception the root cause
+     */
+    public MetadataImportException(String message, Exception exception)
+    {
+       super(message, exception);
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImportInvalidHeadingException.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/MetadataImportInvalidHeadingException.java
@@ -0,0 +1,104 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.bulkedit;
+
+/**
+ * Metadata importer exception
+ *
+ * @author Stuart Lewis
+ */
+public class MetadataImportInvalidHeadingException extends Exception
+{
+    /** The type of error (schema or element) */
+    private int type;
+
+    /** The bad heading */
+    private String badHeading;
+
+    /** The column number */
+    private int column;
+
+    /** Error with the schema */
+    public static final int SCHEMA = 0;
+
+    /** Error with the element */
+    public static final int ELEMENT = 1;
+
+    /** Error with a missing header */
+    public static final int MISSING = 98;
+
+    /** Error with the whole entry */
+    public static final int ENTRY = 99;
+
+
+    /**
+     * Instantiate a new MetadataImportInvalidHeadingException
+     *
+     * @param message the error message
+     * @param theType the type of the error
+     */
+    public MetadataImportInvalidHeadingException(String message, int theType, int theColumn)
+    {
+        super(message);
+        badHeading = message;
+        type = theType;
+        column = theColumn;
+    }
+
+    /**
+     * Get the type of the exception
+     *
+     *  @return the type of the exception
+     */
+    public String getType()
+    {
+        return "" + type;
+    }
+
+    /**
+     * Get the heading that was invalid
+     *
+     * @return the invalid heading
+     */
+    public String getBadHeader()
+    {
+        return badHeading;
+    }
+
+    /**
+     * Get the column number that was invalid
+     *
+     * @return the invalid column number
+     */
+    public int getColumn()
+    {
+        return column;
+    }
+
+    /**
+     * Get the exception message
+     *
+     * @return The exception message
+     */
+    public String getMessage()
+    {
+        if (type == SCHEMA)
+        {
+            return "Unknown metadata schema in row " + column + ": " + badHeading;
+        } else if (type == ELEMENT)
+        {
+            return "Unknown metadata element in row " + column + ": " + badHeading;
+        } else if (type == MISSING)
+        {
+            return "Row with missing header: Row " + column;
+        } else
+        {
+            return "Bad metadata declaration in row " + column + ": " + badHeading;
+        }
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/bulkedit/package-info.java
+++ b/dspace-api/src/main/java/org/dspace/app/bulkedit/package-info.java
@@ -0,0 +1,22 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+
+/**
+ * <p>The DSpace Batch Metadata Editor, which uses a CSV file to export/import
+ * item metadata.</p>
+ * <p>
+ * <ul>
+ *   <li>works on items, communities, collections or the whole site</li>
+ *   <li>can also create new items, delete items and withdraw/restore them</li>
+ *   <li>cannot export/import bitstreams</li>
+ * </ul>
+ */
+
+package org.dspace.app.bulkedit;
+
+
--- a/dspace-api/src/main/java/org/dspace/app/checker/ChecksumChecker.java
+++ b/dspace-api/src/main/java/org/dspace/app/checker/ChecksumChecker.java
@@ -1,39 +1,14 @@
-/*
- * Copyright (c) 2004-2005, Hewlett-Packard Company and Massachusetts
- * Institute of Technology.  All rights reserved.
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
 *
- * 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.
+ * http://www.dspace.org/license/
 */
 package org.dspace.app.checker;

 import java.io.FileNotFoundException;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
@@ -58,6 +33,7 @@ import org.dspace.checker.ListDispatcher;
 import org.dspace.checker.ResultsLogger;
 import org.dspace.checker.ResultsPruner;
 import org.dspace.checker.SimpleDispatcher;
+import org.dspace.core.Context;
 import org.dspace.core.Utils;

 /**
@@ -68,7 +44,7 @@ import org.dspace.core.Utils;
 * @author Grace Carpenter
 * @author Nathan Sarr
 */
-public class ChecksumChecker
+public final class ChecksumChecker
 {
    private static final Logger LOG = Logger.getLogger(ChecksumChecker.class);

@@ -79,7 +55,6 @@ public class ChecksumChecker
     */
    private ChecksumChecker()
    {
-        ;
    }

    /**
@@ -105,8 +80,7 @@ public class ChecksumChecker
     *            <dd>Don't prune results before running checker</dd>
     *            </dl>
     */
-    public static void main(String[] args)
-    {
+    public static void main(String[] args) throws SQLException {
        // set up command line parser
        CommandLineParser parser = new PosixParser();
        CommandLine line = null;
@@ -166,7 +140,7 @@ public class ChecksumChecker
            }
            catch (FileNotFoundException e)
            {
-                e.printStackTrace();
+                LOG.error("File not found", e);
                System.exit(1);
            }
            int count = rp.prune();
@@ -192,13 +166,13 @@ public class ChecksumChecker
        {
            // check only specified bitstream(s)
            String[] ids = line.getOptionValues('b');
-            List idList = new ArrayList(ids.length);
+            List<Integer> idList = new ArrayList<Integer>(ids.length);

            for (int i = 0; i < ids.length; i++)
            {
                try
                {
-                    idList.add(new Integer(ids[i]));
+                    idList.add(Integer.valueOf(ids[i]));
                }
                catch (NumberFormatException nfe)
                {
@@ -234,7 +208,7 @@ public class ChecksumChecker
        }
        else if (line.hasOption('c'))
        {
-        	int count = new Integer(line.getOptionValue('c')).intValue();
+        	int count = Integer.valueOf(line.getOptionValue('c')).intValue();
            
        	// run checker process for specified number of bitstreams
            dispatcher = new LimitedCountDispatcher(new SimpleDispatcher(
@@ -257,7 +231,14 @@ public class ChecksumChecker
        checker.setProcessStartDate(processStart);
        checker.setDispatcher(dispatcher);
        checker.setCollector(logger);
-        checker.process();
+        Context context = new Context();
+        try {
+            checker.process(context);
+        } finally {
+            context.commit();
+            context.complete();
+        }
+        System.exit(0);
    }

    /**
--- a/dspace-api/src/main/java/org/dspace/app/checker/package.html
+++ b/dspace-api/src/main/java/org/dspace/app/checker/package.html
@@ -0,0 +1,19 @@
+<!--
+
+    The contents of this file are subject to the license and copyright
+    detailed in the LICENSE and NOTICE files at the root of the source
+    tree and available online at
+
+    http://www.dspace.org/license/
+
+-->
+<html>
+	<head>
+		<title>org.dspace.app.checker Package Documentation</title>
+	</head>
+  <body>
+      <p>org.dspace.app.checker provides user interfaces to the org.dspace.checker 
+		  package. Command line options are detailed in the ChecksumChecker javadoc.
+		  </p>
+  </body>
+</html>
--- a/dspace-api/src/main/java/org/dspace/app/configuration/APISpringLoader.java
+++ b/dspace-api/src/main/java/org/dspace/app/configuration/APISpringLoader.java
@@ -0,0 +1,40 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.configuration;
+
+import org.dspace.kernel.config.SpringLoader;
+import org.dspace.services.ConfigurationService;
+
+import java.io.File;
+import java.net.MalformedURLException;
+
+/**
+ * @author Kevin Van de Velde (kevin at atmire dot com)
+ */
+public class APISpringLoader implements SpringLoader {
+
+    @Override
+    public String[] getResourcePaths(ConfigurationService configurationService) {
+        StringBuffer filePath = new StringBuffer();
+        filePath.append(configurationService.getProperty("dspace.dir"));
+        filePath.append(File.separator);
+        filePath.append("config");
+        filePath.append(File.separator);
+        filePath.append("spring");
+        filePath.append(File.separator);
+        filePath.append("api");
+        filePath.append(File.separator);
+
+
+        try {
+            return new String[]{new File(filePath.toString()).toURI().toURL().toString() + XML_SUFFIX};
+        } catch (MalformedURLException e) {
+            return new String[0];
+        }
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/harvest/Harvest.java
+++ b/dspace-api/src/main/java/org/dspace/app/harvest/Harvest.java
@@ -0,0 +1,516 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.harvest;
+
+import java.io.IOException;
+import java.sql.SQLException;
+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.Options;
+import org.apache.commons.cli.PosixParser;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.browse.IndexBrowse;
+import org.dspace.content.Collection;
+import org.dspace.content.DSpaceObject;
+import org.dspace.harvest.HarvestedCollection;
+import org.dspace.content.Item;
+import org.dspace.content.ItemIterator;
+import org.dspace.harvest.OAIHarvester;
+import org.dspace.harvest.OAIHarvester.HarvestingException;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+import org.dspace.handle.HandleManager;
+
+/**
+ *  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 standard 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 ("run".equals(command))
+        {
+            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 ("start".equals(command))
+        {
+        	startHarvester();
+        }
+        // reset harvesting status
+        else if ("reset".equals(command))
+        {
+        	resetHarvesting();
+        }
+        // purge all collections that are set up for harvesting (obviously for testing purposes only)
+        else if ("purgeAll".equals(command))
+        {
+        	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 ("purge".equals(command))
+        {
+            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 ("config".equals(command))
+        {
+            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 ("ping".equals(command))
+        {
+            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);
+            }
+
+            pingResponder(oaiSource, oaiSetID, metadataKey);
+        }
+    }
+    
+    /*
+     * 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 != null)
+            {
+                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
+                {
+                    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 {
+            if (context != null)
+            {
+    		    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 resetting 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());
+    		throw new IllegalStateException("Unable to harvest", hex);
+    	} catch (SQLException se) {
+            System.out.print("failed. ");
+            System.out.println(se.getMessage());
+            throw new IllegalStateException("Unable to access database", se);
+		}
+    	    	
+    	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 (SQLException e) {
+            throw new IllegalStateException("Failed to run harvester", e);
+        }
+        catch (AuthorizeException e) {
+            throw new IllegalStateException("Failed to run harvester", e);
+        }
+        catch (IOException e) {
+            throw new IllegalStateException("Failed to run harvester", e);
+        }
+
+        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();
+    	}
+    }
+
+    /**
+     * See if the responder is alive and working.
+     *
+     * @param server address of the responder's host.
+     * @param set name of an item set.
+     * @param metadataFormat local prefix name, or null for "dc".
+     */
+    private static void pingResponder(String server, String set, String metadataFormat)
+    {
+        List<String> errors;
+
+        System.out.print("Testing basic PMH access:  ");
+        errors = OAIHarvester.verifyOAIharvester(server, set,
+                (null != metadataFormat) ? metadataFormat : "dc", false);
+        if (errors.isEmpty())
+            System.out.println("OK");
+        else
+        {
+            for (String error : errors)
+                System.err.println(error);
+        }
+
+        System.out.print("Testing ORE support:  ");
+        errors = OAIHarvester.verifyOAIharvester(server, set,
+                (null != metadataFormat) ? metadataFormat : "dc", true);
+        if (errors.isEmpty())
+            System.out.println("OK");
+        else
+        {
+            for (String error : errors)
+                System.err.println(error);
+        }
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemexport/ItemExport.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemexport/ItemExport.java
--- a/dspace-api/src/main/java/org/dspace/app/itemexport/ItemExportException.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemexport/ItemExportException.java
@@ -0,0 +1,29 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemimport/BTEBatchImportService.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemimport/BTEBatchImportService.java
@@ -0,0 +1,93 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemimport;
+
+import gr.ekt.bte.core.DataLoader;
+import gr.ekt.bte.core.TransformationEngine;
+import gr.ekt.bte.dataloader.FileDataLoader;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+
+
+/**
+ * This class acts as a Service in the procedure ot batch import using the Biblio-Transformation-Engine
+ */
+public class BTEBatchImportService
+{
+
+	TransformationEngine transformationEngine;
+    Map<String, DataLoader> dataLoaders = new HashMap<String, DataLoader>();
+    Map<String, String> outputMap = new HashMap<String,String>();
+    
+    /**
+     * Default constructor
+     */
+    public BTEBatchImportService()
+    {
+        super();
+    }
+
+    /**
+     * Setter method for dataLoaders parameter
+     * @param dataLoaders
+     */
+    public void setDataLoaders(Map<String, DataLoader> dataLoaders)
+    {
+        this.dataLoaders = dataLoaders;
+    }
+
+    /**
+     * 
+     * @return the map of DataLoaders
+     */
+    public Map<String, DataLoader> getDataLoaders()
+    {
+        return dataLoaders;
+    }
+
+    /**
+     * 
+     * @return the outputMapping
+     */
+	public Map<String, String> getOutputMap() {
+		return outputMap;
+	}
+
+	/**
+	 * Setter method for the outputMapping
+	 * @param outputMapping
+	 */
+	public void setOutputMap(Map<String, String> outputMap) {
+		this.outputMap = outputMap;
+	}
+
+	public TransformationEngine getTransformationEngine() {
+		return transformationEngine;
+	}
+
+	public void setTransformationEngine(TransformationEngine transformationEngine) {
+		this.transformationEngine = transformationEngine;
+	}
+	
+	public List<String> getFileDataLoaders(){
+		List<String> result = new ArrayList<String>();
+				
+		for (String key : dataLoaders.keySet()){
+			DataLoader dl = dataLoaders.get(key);
+			if (dl instanceof FileDataLoader){
+				result.add(key);
+			}
+		}
+		return result;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemimport/BatchUpload.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemimport/BatchUpload.java
@@ -0,0 +1,165 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemimport;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.LineNumberReader;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * @author kstamatis
+ *
+ */
+public class BatchUpload {
+
+	private Date date;
+	private File dir;
+	private boolean successful;
+	private int itemsImported;
+	private int totalItems = 0;
+	private List<String> handlesImported = new ArrayList<String>();
+	private String errorMsg = "";
+	private String errorMsgHTML = "";
+	
+	/**
+	 * 
+	 */
+	public BatchUpload(String dirPath) {
+		
+		this.initializeWithFile(new File(dirPath));
+		
+	}
+
+	public BatchUpload(File dir) {
+		
+		this.initializeWithFile(dir);
+		
+	}
+
+
+	private void initializeWithFile(File dir){
+		
+		this.dir = dir;
+		
+		String dirName = dir.getName();
+		long timeMillis = Long.parseLong(dirName);
+		Calendar calendar = new GregorianCalendar();
+		calendar.setTimeInMillis(timeMillis);
+		this.date = calendar.getTime();
+		
+		try {
+			this.itemsImported = countLines(dir + File.separator + "mapfile");
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+		for (File file : dir.listFiles()){
+			if (file.isDirectory()){
+				this.totalItems = file.list().length;
+			}
+		}
+		
+		this.successful = this.totalItems == this.itemsImported;
+		
+		//Parse possible error message
+		
+		File errorFile = new File(dir + File.separator + "error.txt");
+		if (errorFile.exists()){
+			try {
+				readFile(dir + File.separator + "error.txt");
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	private int countLines(String filename) throws IOException {
+	    LineNumberReader reader  = new LineNumberReader(new FileReader(filename));
+	    int cnt = 0;
+	    String lineRead = "";
+	    while ((lineRead = reader.readLine()) != null) {
+	    	String[] parts = lineRead.split(" ");
+	    	if (parts.length > 1)
+	    		handlesImported.add(parts[1].trim());
+	    	else 
+	    		handlesImported.add(lineRead);
+	    }
+
+	    cnt = reader.getLineNumber(); 
+	    reader.close();
+	    return cnt;
+	}
+	
+	private void readFile(String filename) throws IOException {
+	    LineNumberReader reader  = new LineNumberReader(new FileReader(filename));
+	    String lineRead = "";
+	    while ((lineRead = reader.readLine()) != null) {
+	    	this.errorMsg += lineRead + "\n";
+	    	
+	    	if (lineRead.startsWith("\tat ")){
+	    		this.errorMsgHTML += "<span class=\"batchimport-error-tab\">" + lineRead + "</span><br/>";
+	    	}
+	    	else if (lineRead.startsWith("Caused by")){
+	    		this.errorMsgHTML += "<span class=\"batchimport-error-caused\">" + lineRead + "</span><br/>";
+	    	}
+	    	else {
+	    		this.errorMsgHTML += lineRead + "<br/>";
+	    	}
+	    }
+	    reader.close();
+	}
+
+	public Date getDate() {
+		return date;
+	}
+
+	public File getDir() {
+		return dir;
+	}
+
+	public boolean isSuccessful() {
+		return successful;
+	}
+
+	public int getItemsImported() {
+		return itemsImported;
+	}
+
+	public int getTotalItems() {
+		return totalItems;
+	}
+	
+	public String getDateFormatted(){
+		SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy - HH:mm");
+		
+		return df.format(date);
+	}
+
+	public List<String> getHandlesImported() {
+		return handlesImported;
+	}
+
+	public String getErrorMsg() {
+		return errorMsg;
+	}
+
+	public String getErrorMsgHTML() {
+		return errorMsgHTML;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemimport/ItemImport.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemimport/ItemImport.java
--- a/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingAvailabilityBitstreamStrategy.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingAvailabilityBitstreamStrategy.java
@@ -0,0 +1,91 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemmarking;
+
+import java.io.UnsupportedEncodingException;
+import java.sql.SQLException;
+
+import org.dspace.app.util.Util;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+import org.dspace.content.Item;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+
+/**
+ * This is an item marking Strategy class that tries to mark an item availability
+ * based on the existence of bitstreams within the ORIGINAL bundle.
+ * 
+ * @author Kostas Stamatis
+ * 
+ */
+public class ItemMarkingAvailabilityBitstreamStrategy implements ItemMarkingExtractor {
+
+	private String availableImageName;
+	private String nonAvailableImageName;
+	
+	public ItemMarkingAvailabilityBitstreamStrategy() {
+	
+	}
+
+	@Override
+	public ItemMarkingInfo getItemMarkingInfo(Context context, Item item)
+			throws SQLException {
+		
+		Bundle[] bundles = item.getBundles("ORIGINAL");
+		if (bundles.length == 0){
+			ItemMarkingInfo markInfo = new ItemMarkingInfo();
+			markInfo.setImageName(nonAvailableImageName);	
+			
+			return markInfo;
+		}
+		else {
+			Bundle originalBundle = bundles[0];
+			if (originalBundle.getBitstreams().length == 0){
+				ItemMarkingInfo markInfo = new ItemMarkingInfo();
+				markInfo.setImageName(nonAvailableImageName);
+				
+				return markInfo;
+			}
+			else {
+				Bitstream bitstream = originalBundle.getBitstreams()[0];
+				
+				ItemMarkingInfo signInfo = new ItemMarkingInfo();
+				signInfo.setImageName(availableImageName);
+				signInfo.setTooltip(bitstream.getName());
+				
+				
+				
+				String bsLink = "";
+
+                bsLink = bsLink + "bitstream/"
+                            + item.getHandle() + "/"
+                            + bitstream.getSequenceID() + "/";
+                
+                try {
+					bsLink = bsLink + Util.encodeBitstreamName(bitstream.getName(),  Constants.DEFAULT_ENCODING);
+				} catch (UnsupportedEncodingException e) {
+					
+					e.printStackTrace();
+				}
+                
+				signInfo.setLink(bsLink);
+				
+				return signInfo;
+			}
+		}
+	}
+
+	public void setAvailableImageName(String availableImageName) {
+		this.availableImageName = availableImageName;
+	}
+
+	public void setNonAvailableImageName(String nonAvailableImageName) {
+		this.nonAvailableImageName = nonAvailableImageName;
+	}	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingCollectionStrategy.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingCollectionStrategy.java
@@ -0,0 +1,50 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemmarking;
+
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.dspace.content.Collection;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ * This is an item marking Strategy class that tries to mark an item
+ * based on the collection the items belong to
+ * 
+ * @author Kostas Stamatis
+ * 
+ */
+public class ItemMarkingCollectionStrategy implements ItemMarkingExtractor {
+
+	Map<String, ItemMarkingInfo> mapping = new HashMap<String, ItemMarkingInfo>();
+	
+	public ItemMarkingCollectionStrategy() {
+	}
+
+	@Override
+	public ItemMarkingInfo getItemMarkingInfo(Context context, Item item)
+			throws SQLException {
+		
+		if (mapping!=null){
+			for (Collection collection : item.getCollections()){
+				if (mapping.containsKey(collection.getHandle())){
+					return mapping.get(collection.getHandle());
+				}
+			}
+		}
+		
+		return null;
+	}
+
+	public void setMapping(Map<String, ItemMarkingInfo> mapping) {
+		this.mapping = mapping;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingExtractor.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingExtractor.java
@@ -0,0 +1,24 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemmarking;
+
+import java.sql.SQLException;
+
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ * Interface to abstract the strategy for item signing
+ * 
+ * @author Kostas Stamatis
+ * 
+ */
+public interface ItemMarkingExtractor {
+	public ItemMarkingInfo getItemMarkingInfo(Context context, Item item)
+			throws SQLException;
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingInfo.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingInfo.java
@@ -0,0 +1,57 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemmarking;
+
+/**
+ * Simple DTO to transfer data about the marking info for an item
+ * 
+ * @author Kostas Stamatis
+ * 
+ */
+public class ItemMarkingInfo {
+	private String imageName;
+	private String classInfo;
+	private String tooltip;
+	private String link;
+
+	public ItemMarkingInfo() {
+		super();
+	}
+
+	public String getImageName() {
+		return imageName;
+	}
+
+	public void setImageName(String imageName) {
+		this.imageName = imageName;
+	}
+
+	public String getTooltip() {
+		return tooltip;
+	}
+
+	public void setTooltip(String tooltip) {
+		this.tooltip = tooltip;
+	}
+	
+	public String getLink() {
+		return link;
+	}
+
+	public void setLink(String link) {
+		this.link = link;
+	}
+	
+	public String getClassInfo() {
+		return classInfo;
+	}
+
+	public void setClassInfo(String classInfo) {
+		this.classInfo = classInfo;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingMetadataStrategy.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemmarking/ItemMarkingMetadataStrategy.java
@@ -0,0 +1,61 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemmarking;
+
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.dspace.content.Item;
+import org.dspace.content.Metadatum;
+import org.dspace.core.Context;
+
+/**
+ * This is an item marking Strategy class that tries to mark an item
+ * based on the existence of a specific value within the values of a specific
+ * metadata field
+ * 
+ * @author Kostas Stamatis
+ * 
+ */
+public class ItemMarkingMetadataStrategy implements ItemMarkingExtractor {
+
+	private String metadataField;
+	Map<String, ItemMarkingInfo> mapping = new HashMap<String, ItemMarkingInfo>();
+	
+	public ItemMarkingMetadataStrategy() {
+	}
+
+	@Override
+	public ItemMarkingInfo getItemMarkingInfo(Context context, Item item)
+			throws SQLException {
+		
+		if (metadataField != null && mapping!=null)
+		{
+			Metadatum[] vals = item.getMetadataByMetadataString(metadataField);
+			if (vals.length > 0)
+			{
+				for (Metadatum value : vals){
+					String type = value.value;
+					if (mapping.containsKey(type)){
+						return mapping.get(type);
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+	public void setMetadataField(String metadataField) {
+		this.metadataField = metadataField;
+	}
+
+	public void setMapping(Map<String, ItemMarkingInfo> mapping) {
+		this.mapping = mapping;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/ActionManager.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/ActionManager.java
@@ -0,0 +1,80 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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();
+			}
+		};
+		
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/AddBitstreamsAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/AddBitstreamsAction.java
@@ -0,0 +1,212 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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 itarch
+	 *  @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);
+			}
+		}
+		int bitstream_bundles_updated = 0;
+		
+		//now okay to add
+		for (ContentsEntry ce : contents)
+		{        				
+			String targetBundleName = addBitstream(context, itarch, item, dir, ce, suppressUndo, isTest);
+			if (!targetBundleName.equals("")
+			    && !targetBundleName.equals("THUMBNAIL")
+			    && !targetBundleName.equals("TEXT"))
+			{
+				bitstream_bundles_updated++;
+			}
+		}
+
+	        if (alterProvenance && bitstream_bundles_updated > 0)
+	        {
+	        	DtoMetadata dtom = DtoMetadata.create("dc.description.provenance", "en", "");
+	        
+	        	String append = ". Added " + Integer.toString(bitstream_bundles_updated)
+	        	                + " bitstream(s) on " + DCDate.getCurrent() + " : "
+	        	                + InstallItem.getBitstreamProvenanceMessage(item);
+	        	MetadataUtilities.appendMetadata(item, dtom, false, append);
+	        }
+	}
+		
+	private String 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();
+				}
+	        }
+	        
+	        //update after all changes are applied
+	        bs.update();
+        
+	        if (!suppressUndo)
+	        {
+	        	itarch.addUndoDeleteContents(bs.getID());
+	        }
+		return targetBundle.getName();
+        }
+	return "";
+    }
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/AddMetadataAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/AddMetadataAction.java
@@ -0,0 +1,120 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemupdate;
+
+import java.sql.SQLException;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Metadatum;
+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 itarch
+	 *  @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					
+					Metadatum[] ardcv = null;
+					ardcv = item.getMetadata(dtom.schema, dtom.element, dtom.qualifier, Item.ANY);
+					
+					boolean found = false;
+					for (Metadatum 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 (Metadatum 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
+				}
+			} 				
+		}   
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilter.java
@@ -0,0 +1,61 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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 = null;
+
+        try
+        {
+            in = new FileInputStream(filepath);
+            props.load(in);
+        }
+        finally
+        {
+            if (in != null)
+            {
+                in.close();
+            }
+        }
+	}
+	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterByBundleName.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterByBundleName.java
@@ -0,0 +1,66 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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
+	 *    @return 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;
+	}
+	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterByFilename.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterByFilename.java
@@ -0,0 +1,50 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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
+	 * 
+	 *   @return 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();
+	}	
+ 
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterException.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/BitstreamFilterException.java
@@ -0,0 +1,29 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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);
+	}
+	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/ContentsEntry.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/ContentsEntry.java
@@ -0,0 +1,153 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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();
+	}
+	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteBitstreamsAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteBitstreamsAction.java
@@ -0,0 +1,114 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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 itarch
+	 *  @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());
+					}
+				}
+			}
+		}
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteBitstreamsByFilterAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteBitstreamsByFilterAction.java
@@ -0,0 +1,130 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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 itarch
+	 *  @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("THUMBNAIL") && !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());
+    		}
+        }
+	}
+	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteMetadataAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/DeleteMetadataAction.java
@@ -0,0 +1,64 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.itemupdate;
+
+import java.text.ParseException;
+
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Metadatum;
+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 itarch
+	 *  @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, "");
+			Metadatum[] ardcv = item.getMetadataByMetadataString(f);
+
+			ItemUpdate.pr("Metadata to be deleted: ");
+			for (Metadatum dcv : ardcv)
+			{
+				ItemUpdate.pr("  " + MetadataUtilities.getDCValueString(dcv));
+			}
+
+			if (!isTest)
+			{
+				if (!suppressUndo)
+				{
+					for (Metadatum 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);	
+			}
+		}
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/DerivativeTextBitstreamFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/DerivativeTextBitstreamFilter.java
@@ -0,0 +1,24 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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");
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/DtoMetadata.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/DtoMetadata.java
@@ -0,0 +1,156 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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;
+	}
+		
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/ItemArchive.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/ItemArchive.java
@@ -0,0 +1,348 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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.apache.log4j.Logger;
+import org.dspace.content.ItemIterator;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.Item;
+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 {
+    private static final Logger log = Logger.getLogger(ItemArchive.class); 
+
+	public static 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 = null;
+        try
+        {
+            is = new FileInputStream(new File(dir, DUBLIN_CORE_XML));
+            itarch.dtomList = MetadataUtilities.loadDublinCore(getDocumentBuilder(), is);
+        }
+        finally
+        {
+            if (is != null)
+            {
+                is.close();
+            }
+        }
+		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);
+		if (!dir.exists() && !dir.mkdir())
+        {
+            log.error("Unable to create undo directory");
+        }
+		
+		OutputStream out = null;
+
+        try
+        {
+            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();
+                }
+            }
+        }
+        finally
+        {
+            if (out != null)
+            {
+                out.close();
+            }
+        }
+	}
+	
+} //end class
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/ItemUpdate.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/ItemUpdate.java
@@ -0,0 +1,610 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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 {
+	
+	public static final String SUPPRESS_UNDO_FILENAME = "suppress_undo";
+
+	public static final String CONTENTS_FILE = "contents";
+	public static final String DELETE_CONTENTS_FILE = "delete_contents";
+
+	public static String HANDLE_PREFIX = null;
+	public static final Map<String, String> filterAliases = new HashMap<String, String>();
+	
+	public static 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 determining items    
+        //item-specific changes with metadata in source directory with dublin_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 && !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());
+                e.printStackTrace();
+    		}
+        }  
+        
+        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.getCanonicalFile().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 " + undoDir.getCanonicalPath());
+			throw new IOException("ERROR creating  Undo Archive directory " + undoDir.getCanonicalPath());
+		}
+		
+        //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
+
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/MetadataUtilities.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/MetadataUtilities.java
@@ -0,0 +1,529 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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.commons.lang.StringUtils;
+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.Metadatum;
+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 Metadatum
+  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)
+    {   	
+    	Metadatum[] 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 (Metadatum 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[vals.size()]));   	
+    	}
+		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
+    {   	
+    	Metadatum[] 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[vals.size()]));   	
+    }
+ 
+    /**
+     *  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 ("none".equals(qualifier) || "".equals(qualifier))
+	        {
+	            qualifier = null;
+	        }
+	        
+	        // a goofy default, but consistent with DSpace treatment elsewhere  
+	        if (language == null)
+	        {
+	            language = "en";
+	        }
+	        else if ("".equals(language))
+	        {
+	            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 (StringUtils.isEmpty(dtom.language))
+        	{
+        		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
+     */
+    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
+     * @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 Metadatum    
+	 *
+     * @param dcv
+     * @return string displaying elements of the Metadatum
+     */
+    public static String getDCValueString(Metadatum 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 ("".equals(ar[0]))
+		{
+			throw new ParseException("schema is empty string: " + compoundForm, 0);
+		}
+		
+		if ((ar.length < 2) || (ar.length > 3) || "".equals(ar[1]))
+		{
+			throw new ParseException("element is malformed or empty string: " + compoundForm, 0);
+		}
+		
+		return ar;
+	}
+	
+} 
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/OriginalBitstreamFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/OriginalBitstreamFilter.java
@@ -0,0 +1,55 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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
+	 *  
+	 *  @return 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;
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/OriginalWithDerivativesBitstreamFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/OriginalWithDerivativesBitstreamFilter.java
@@ -0,0 +1,59 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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
+	 * @return 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;
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/ThumbnailBitstreamFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/ThumbnailBitstreamFilter.java
@@ -0,0 +1,24 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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");
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateAction.java
@@ -0,0 +1,30 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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;
+	
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateBitstreamsAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateBitstreamsAction.java
@@ -0,0 +1,39 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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;
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateMetadataAction.java
+++ b/dspace-api/src/main/java/org/dspace/app/itemupdate/UpdateMetadataAction.java
@@ -0,0 +1,70 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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);
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/launcher/CommandRunner.java
+++ b/dspace-api/src/main/java/org/dspace/app/launcher/CommandRunner.java
@@ -0,0 +1,107 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.launcher;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.StreamTokenizer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author mwood
+ */
+public class CommandRunner
+{
+    public static void main(String[] args)
+            throws FileNotFoundException, IOException
+    {
+        if (args.length > 0)
+        {
+            runManyCommands(args[0]);
+        }
+        else
+        {
+            runManyCommands("-");
+        }
+        // There is no sensible way to use the status returned by runManyCommands().
+        // If called from the command line then we would want to return it
+        // through System.exit().  But if called (normally) from ScriptLauncher,
+        // there is no way to return it and we don't want to interrupt
+        // ScriptLauncher.
+        //
+        // "'tis a puzzlement." -- the King of Siam
+    }
+
+    /**
+     * Read a file of command lines and execute each in turn.
+     *
+     * @param doc details of recognized commands.
+     * @param script the file of command lines to be executed.
+     * @return
+     * @throws FileNotFoundException
+     * @throws IOException 
+     */
+    static int runManyCommands(String script)
+            throws FileNotFoundException, IOException
+    {
+        Reader input;
+        if ("-".equals(script))
+        {
+            input = new InputStreamReader(System.in);
+        }
+        else
+        {
+            input = new FileReader(script);
+        }
+
+        StreamTokenizer tokenizer = new StreamTokenizer(input);
+
+        tokenizer.eolIsSignificant(true);
+
+        tokenizer.ordinaryChar('-');
+        tokenizer.wordChars('-', '-');
+
+        tokenizer.ordinaryChars('0', '9');
+        tokenizer.wordChars('0', '9');
+
+        tokenizer.ordinaryChar('.');
+        tokenizer.wordChars('.', '.');
+
+        tokenizer.ordinaryChar('@');
+        tokenizer.wordChars('@', '@');
+
+        int status = 0;
+        List<String> tokens = new ArrayList<String>();
+        while (StreamTokenizer.TT_EOF != tokenizer.nextToken())
+        {
+            if (StreamTokenizer.TT_EOL == tokenizer.ttype)
+            {
+                if (tokens.size() > 0)
+                {
+                    status = ScriptLauncher.runOneCommand(tokens.toArray(new String[tokens.size()]));
+                    if (status > 0)
+                    {
+                        break;
+                    }
+                    tokens.clear();
+                }
+            }
+            else
+            {
+                tokens.add(tokenizer.sval);
+            }
+        }
+
+        return status;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/launcher/ScriptLauncher.java
+++ b/dspace-api/src/main/java/org/dspace/app/launcher/ScriptLauncher.java
@@ -0,0 +1,286 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.launcher;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.List;
+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;
+
+/**
+ * A DSpace script launcher.
+ *
+ * @author Stuart Lewis
+ * @author Mark Diggory
+ */
+public class ScriptLauncher
+{
+    /** The service manager kernel */
+    private static transient DSpaceKernelImpl kernelImpl;
+
+    /** Definitions of all commands. */
+    private static final Document commandConfigs = getConfig();
+
+    /**
+     * Execute the DSpace script launcher
+     *
+     * @param args Any parameters required to be passed to the scripts it executes
+     */
+    public static void main(String[] args)
+            throws FileNotFoundException, IOException
+    {
+        // 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);
+        }
+
+        // Initialise 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 IllegalStateException(message, e);
+        }
+
+        // Look up command in the configuration, and execute.
+        int status;
+        status = runOneCommand(args);
+
+        // Destroy the service kernel if it is still alive
+        if (kernelImpl != null)
+        {
+            kernelImpl.destroy();
+            kernelImpl = null;
+        }
+
+        System.exit(status);
+    }
+
+    /**
+     * Recognize and execute a single command.
+     * @param doc
+     * @param args
+     */
+    static int runOneCommand(String[] args)
+    {
+        String request = args[0];
+        Element root = commandConfigs.getRootElement();
+        List<Element> commands = root.getChildren("command");
+        Element command = null;
+        for (Element candidate : commands)
+        {
+            if (request.equalsIgnoreCase(candidate.getChild("name").getValue()))
+            {
+                command = candidate;
+                break;
+            }
+        }
+
+        if (null == command)
+        {
+            // The command wasn't found
+            System.err.println("Command not found: " + args[0]);
+            display();
+            return 1;
+        }
+
+        // Run each step
+        List<Element> steps = command.getChildren("step");
+        for (Element step : steps)
+        {
+            // Instantiate the class
+            Class target = null;
+
+            // Is it the special case 'dsrun' where the user provides the class name?
+            String className;
+            if ("dsrun".equals(request))
+            {
+                if (args.length < 2)
+                {
+                    System.err.println("Error in launcher.xml: Missing class name");
+                    return 1;
+                }
+                className = args[1];
+            }
+            else {
+                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);
+                return 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) || (("dsrun".equals(request)) && (args.length == 2)) || (!passargs))
+            {
+                useargs = new String[0];
+            }
+            else
+            {
+                // The number of arguments to ignore
+                // If dsrun is the command, ignore the next, as it is the class name not an arg
+                int x = 1;
+                if ("dsrun".equals(request))
+                {
+                    x = 2;
+                }
+                String[] argsnew = new String[useargs.length - x];
+                for (int i = x; i < useargs.length; i++)
+                {
+                    argsnew[i - x] = 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);
+                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);
+
+                // Exceptions from the script are reported as a 'cause'
+                Throwable cause = e.getCause();
+                System.err.println("Exception: " + cause.getMessage());
+                cause.printStackTrace();
+                return 1;
+            }
+        }
+
+        // Everything completed OK
+        return 0;
+    }
+
+    /**
+     * 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()
+    {
+        List<Element> commands = commandConfigs.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());
+        }
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/Brand.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/Brand.java
@@ -0,0 +1,162 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.awt.image.BufferedImage;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+
+/**
+ * Class to attach a footer to an image using ImageMagick.
+ * Thanks Ninh Nguyen from the National Library of Australia for providing the source code.
+ * This version of the code is basically Ninh's but reorganised a little. Used with permission.
+ */
+
+public class Brand
+{
+	private int brandWidth;
+	private int brandHeight;
+	private Font font;
+	private int xOffset;
+
+	/**
+	 * Constructor to set up footer image attributes.
+	 *
+	 * @param brandWidth length of the footer in pixels
+	 * @param brandHeight height of the footer in pixels
+	 * @param font font to use for text on the footer
+	 * @param xOffset number of pixels text should be indented from left-hand side of footer
+	 *
+	 */
+	public Brand(int brandWidth,
+		      int brandHeight,
+		      Font font,
+		      int xOffset)
+	{
+		this.brandWidth = brandWidth;
+		this.brandHeight = brandHeight;
+		this.font = font;
+		this.xOffset = xOffset;
+	}
+
+	/**
+	 * Create the brand image
+	 *
+	 * @param brandLeftText text that should appear in the bottom left of the image
+	 * @param shortLeftText abbreviated form of brandLeftText that will be substituted if
+	 *	the image is resized such that brandLeftText will not fit. <code>null</code> if not
+	 *	required
+	 * @param brandRightText text that should appear in the bottom right of the image
+	 *
+	 * @return BufferedImage a BufferedImage object describing the brand image file
+	 */
+	public BufferedImage create(String brandLeftText,
+			   String shortLeftText,
+			   String brandRightText)
+	{
+		BrandText[] allBrandText = null;
+
+		BufferedImage brandImage =
+			new BufferedImage(brandWidth, brandHeight, BufferedImage.TYPE_INT_RGB);
+
+		if (brandWidth >= 350)
+		{
+			allBrandText = new BrandText[]
+			{
+				new BrandText(BrandText.BL, brandLeftText),
+				new BrandText(BrandText.BR, brandRightText)
+			};
+		} 
+		else if (brandWidth >= 190)
+		{
+			allBrandText = new BrandText[]
+			{
+				new BrandText(BrandText.BL, shortLeftText),
+				new BrandText(BrandText.BR, brandRightText)
+			};
+		}
+		else
+		{
+			allBrandText = new BrandText[]
+			{
+				new BrandText(BrandText.BR, brandRightText)
+			};
+		}
+
+		if (allBrandText != null && allBrandText.length > 0)
+		{
+      		for (int i = 0; i < allBrandText.length; ++i)
+			{
+        		drawImage(brandImage, allBrandText[i]);
+      		}
+    	}
+
+		return brandImage;
+	}
+
+
+	/**
+	 * do the text placements and preparatory work for the brand image generation
+	 *
+	 * @param brandImage a BufferedImage object where the image is created
+	 * @param identifier and Identifier object describing what text is to be placed in what
+	 *	position within the brand
+	 */
+	private void drawImage(BufferedImage brandImage,
+			BrandText brandText)
+	{
+		int imgWidth = brandImage.getWidth();
+		int imgHeight = brandImage.getHeight();
+
+		int bx, by, tx, ty, bWidth, bHeight;
+
+		Graphics2D g2 = brandImage.createGraphics();
+		g2.setFont(font);
+		FontMetrics fm = g2.getFontMetrics();
+
+
+		bWidth = fm.stringWidth(brandText.getText()) + xOffset * 2 + 1;
+		bHeight = fm.getHeight();
+
+		bx = 0;
+        by = 0;
+
+		if (brandText.getLocation().equals(BrandText.TL))
+		{
+			bx = 0;
+			by = 0;
+		}
+		else if (brandText.getLocation().equals(BrandText.TR))
+		{
+			bx = imgWidth - bWidth;
+			by = 0;
+		}
+		else if (brandText.getLocation().equals(BrandText.BL))
+		{
+			bx = 0;
+			by = imgHeight - bHeight;
+		}
+		else if (brandText.getLocation().equals(BrandText.BR))
+		{
+			bx = imgWidth - bWidth;
+			by = imgHeight - bHeight;
+		}
+
+		Rectangle box = new Rectangle(bx, by, bWidth, bHeight);
+		tx = bx + xOffset;
+		ty = by + fm.getAscent();
+
+    	g2.setColor(Color.black);
+		g2.fill(box);
+		g2.setColor(Color.white);
+		g2.drawString(brandText.getText(), tx, ty);
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/BrandText.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/BrandText.java
@@ -0,0 +1,85 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+/**
+ * Identifier class, holding a single item of text and its location
+ * within a rectangular areas. Allowable locations are any of the four corners.
+ * This is a copy of Picture Australia's PiObj class re-organised with methods.
+ * Thanks to Ninh Nguyen at the National Library for providing the original source.
+ */
+class BrandText
+{
+	/** Bottom Left */
+	public static final String BL = "bl";
+	/** Bottom Right */
+	public static final String BR = "br";
+	/** Top Left */
+	public static final String TL = "tl";
+	/** Top Right */
+	public static final String TR = "tr";
+
+	private String location;
+	private String text;
+
+	/**
+	 * Constructor for an Identifier object containing a text string and
+	 * its location within a rectangular area.
+	 *
+	 * @param location one of the class location constants e.g. <code>Identifier.BL</code>
+	 * @param the text associated with the location
+	 */
+	public BrandText(String location, String text)
+	{
+		this.location = location;
+		this.text = text;
+	}
+
+	/**
+	 * get the location the text of the Identifier object is associated with
+	 *
+	 * @return String one the class location constants e.g. <code>Identifier.BL</code>
+	 */
+	public String getLocation()
+	{
+		return location;
+	}
+
+
+	/**
+	 * get the text associated with the Identifier object
+	 *
+	 * @return String the text associated with the Identifier object
+	 */
+	public String getText()
+	{
+		return text;
+	}
+
+
+	/**
+	 * set the location associated with the Identifier object
+	 *
+	 * @param location one of the class location constants
+	 */
+	public void setLocation(String location)
+	{
+		this.location = location;
+	}
+
+
+	/**
+	 * set the text associated with the Identifier object
+	 *
+	 * @param text any text string (typically a branding or identifier)
+	 */
+	public void setText(String text)
+	{
+		this.text = text;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/BrandedPreviewJPEGFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/BrandedPreviewJPEGFilter.java
@@ -0,0 +1,296 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.awt.Graphics2D;
+import java.awt.Color;
+import java.awt.image.*;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.Font;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import javax.imageio.ImageIO;
+
+import org.dspace.core.ConfigurationManager;
+
+/**
+ * Filter image bitstreams, scaling the image to be within the bounds of
+ * thumbnail.maxwidth, thumbnail.maxheight, the size we want our thumbnail to be
+ * no bigger than. Creates only JPEGs.
+ *
+ * @author Jason Sherman <jsherman@usao.edu>
+ */
+public class BrandedPreviewJPEGFilter extends MediaFilter
+{
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".preview.jpg";
+    }
+
+    /**
+     * @return String bundle name
+     *  
+     */
+    public String getBundleName()
+    {
+        return "BRANDED_PREVIEW";
+    }
+
+    /**
+     * @return String bitstreamformat
+     */
+    public String getFormatString()
+    {
+        return "JPEG";
+    }
+
+    /**
+     * @return String description
+     */
+    public String getDescription()
+    {
+        return "Generated Branded Preview";
+    }
+
+   
+    /**
+     * @param source
+     *            source input stream
+     * 
+     * @return InputStream the resulting input stream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception
+    {
+        // read in bitstream's image
+        BufferedImage buf = ImageIO.read(source);
+
+        // get config params
+        float xmax = (float) ConfigurationManager
+                .getIntProperty("webui.preview.maxwidth");
+        float ymax = (float) ConfigurationManager
+                .getIntProperty("webui.preview.maxheight");
+        boolean blurring = (boolean) ConfigurationManager
+                .getBooleanProperty("webui.preview.blurring");
+        boolean hqscaling = (boolean) ConfigurationManager
+                .getBooleanProperty("webui.preview.hqscaling");
+        int brandHeight = ConfigurationManager.getIntProperty("webui.preview.brand.height");
+        String brandFont = ConfigurationManager.getProperty("webui.preview.brand.font");
+        int brandFontPoint = ConfigurationManager.getIntProperty("webui.preview.brand.fontpoint");
+        
+        // now get the image dimensions
+        float xsize = (float) buf.getWidth(null);
+        float ysize = (float) buf.getHeight(null);
+
+        // if verbose flag is set, print out dimensions
+        // to STDOUT
+        if (MediaFilterManager.isVerbose)
+        {
+            System.out.println("original size: " + xsize + "," + ysize);
+        }
+
+        // scale by x first if needed
+        if (xsize > xmax)
+        {
+            // calculate scaling factor so that xsize * scale = new size (max)
+            float scaleFactor = xmax / xsize;
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println("x scale factor: " + scaleFactor);
+            }
+
+            // now reduce x size
+            // and y size
+            xsize = xsize * scaleFactor;
+            ysize = ysize * scaleFactor;
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println("new size: " + xsize + "," + ysize);
+            }
+        }
+
+        // scale by y if needed
+        if (ysize > ymax)
+        {
+            float scaleFactor = ymax / ysize;
+
+            // now reduce x size
+            // and y size
+            xsize = xsize * scaleFactor;
+            ysize = ysize * scaleFactor;
+        }
+
+        // if verbose flag is set, print details to STDOUT
+        if (MediaFilterManager.isVerbose)
+        {
+            System.out.println("created thumbnail size: " + xsize + ", "
+                    + ysize);
+        }
+
+        // create an image buffer for the preview with the new xsize, ysize
+        // we add
+        BufferedImage branded = new BufferedImage((int) xsize, (int) ysize + brandHeight,
+                BufferedImage.TYPE_INT_RGB);
+
+        // Use blurring if selected in config.
+        // a little blur before scaling does wonders for keeping moire in check.
+        if (blurring)
+        {
+                // send the buffered image off to get blurred.
+                buf = getBlurredInstance((BufferedImage) buf);
+        }
+
+        // Use high quality scaling method if selected in config.
+        // this has a definite performance penalty.
+        if (hqscaling)
+        {
+                // send the buffered image off to get an HQ downscale.
+                buf = getScaledInstance((BufferedImage) buf, (int) xsize, (int) ysize,
+                        (Object) RenderingHints.VALUE_INTERPOLATION_BICUBIC, (boolean) true);
+        }
+
+        // now render the image into the preview buffer
+        Graphics2D g2d = branded.createGraphics();
+        g2d.drawImage(buf, 0, 0, (int) xsize, (int) ysize, null);
+        
+        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"),
+												MediaFilterManager.getCurrentItem() == null ? "" : "hdl:" + MediaFilterManager.getCurrentItem().getHandle());
+		
+		g2d.drawImage(brandImage, (int)0, (int)ysize, (int) xsize, (int) 20, null);
+
+        // now create an input stream for the thumbnail buffer and return it
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        ImageIO.write(branded, "jpeg", baos);
+
+        // now get the array
+        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+
+        return bais; // hope this gets written out before its garbage collected!
+	}
+
+    public BufferedImage getNormalizedInstance(BufferedImage buf)
+    {
+     int type = (buf.getTransparency() == Transparency.OPAQUE) ?
+            BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB_PRE;
+     int w, h;
+     w = buf.getWidth();
+     h = buf.getHeight();
+     BufferedImage normal = new BufferedImage(w, h, type);
+     Graphics2D g2d = normal.createGraphics();
+     g2d.drawImage(buf, 0, 0, w, h, Color.WHITE, null);
+     g2d.dispose();
+     return normal;
+    }
+
+    public BufferedImage getBlurredInstance(BufferedImage buf)
+    {
+    /**
+     * Convenience method that returns a blurred instance of the
+     * provided {@code BufferedImage}.
+     *
+     */
+
+     buf = getNormalizedInstance(buf);
+
+     // kernel for blur op
+     float[] matrix = {
+        0.111f, 0.111f, 0.111f,
+        0.111f, 0.111f, 0.111f,
+        0.111f, 0.111f, 0.111f,
+      };
+
+     // perform the blur and return the blurred version.
+     BufferedImageOp blur = new ConvolveOp( new Kernel(3, 3, matrix) );
+     BufferedImage blurbuf = blur.filter(buf, null);
+     return blurbuf;
+    }
+
+    /**
+     * Convenience method that returns a scaled instance of the
+     * provided {@code BufferedImage}.
+     *
+     * @param buf the original image to be scaled
+     * @param targetWidth the desired width of the scaled instance,
+     *    in pixels
+     * @param targetHeight the desired height of the scaled instance,
+     *    in pixels
+     * @param hint one of the rendering hints that corresponds to
+     *    {@code RenderingHints.KEY_INTERPOLATION} (e.g.
+     *    {@code RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR},
+     *    {@code RenderingHints.VALUE_INTERPOLATION_BILINEAR},
+     *    {@code RenderingHints.VALUE_INTERPOLATION_BICUBIC})
+     * @param higherQuality if true, this method will use a multi-step
+     *    scaling technique that provides higher quality than the usual
+     *    one-step technique (only useful in downscaling cases, where
+     *    {@code targetWidth} or {@code targetHeight} is
+     *    smaller than the original dimensions, and generally only when
+     *    the {@code BILINEAR} hint is specified)
+     * @return a scaled version of the original {@code BufferedImage}
+     */
+    public BufferedImage getScaledInstance(BufferedImage buf,
+                                           int targetWidth,
+                                           int targetHeight,
+                                           Object hint,
+                                           boolean higherQuality)
+    {
+        int type = (buf.getTransparency() == Transparency.OPAQUE) ?
+            BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+        BufferedImage scalebuf = (BufferedImage)buf;
+        int w, h;
+        if (higherQuality) {
+            // Use multi-step technique: start with original size, then
+            // scale down in multiple passes with drawImage()
+            // until the target size is reached
+            w = buf.getWidth();
+            h = buf.getHeight();
+        } else {
+            // Use one-step technique: scale directly from original
+            // size to target size with a single drawImage() call
+            w = targetWidth;
+            h = targetHeight;
+        }
+
+        do {
+            if (higherQuality && w > targetWidth) {
+                w /= 2;
+                if (w < targetWidth) {
+                    w = targetWidth;
+                }
+            }
+
+            if (higherQuality && h > targetHeight) {
+                h /= 2;
+                if (h < targetHeight) {
+                    h = targetHeight;
+                }
+            }
+
+            BufferedImage tmp = new BufferedImage(w, h, type);
+            Graphics2D g2d = tmp.createGraphics();
+            g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
+            g2d.drawImage(scalebuf, 0, 0, w, h, Color.WHITE, null);
+            g2d.dispose();
+
+            scalebuf = tmp;
+        } while (w != targetWidth || h != targetHeight);
+
+        return scalebuf;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/FormatFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/FormatFilter.java
@@ -0,0 +1,103 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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;
+}
+
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/HTMLFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/HTMLFilter.java
@@ -0,0 +1,81 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import javax.swing.text.Document;
+import javax.swing.text.html.HTMLEditorKit;
+
+/*
+ * 
+ * to do: helpful error messages - can't find mediafilter.cfg - can't
+ * instantiate filter - bitstream format doesn't exist
+ *  
+ */
+public class HTMLFilter extends MediaFilter
+{
+
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".txt";
+    }
+
+    /**
+     * @return String bundle name
+     *  
+     */
+    public String getBundleName()
+    {
+        return "TEXT";
+    }
+
+    /**
+     * @return String bitstreamformat
+     */
+    public String getFormatString()
+    {
+        return "Text";
+    }
+
+    /**
+     * @return String description
+     */
+    public String getDescription()
+    {
+        return "Extracted text";
+    }
+
+    /**
+     * @param source
+     *            source input stream
+     * 
+     * @return InputStream the resulting input stream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception
+    {
+        // try and read the document - set to ignore character set directive,
+        // assuming that the input stream is already set properly (I hope)
+        HTMLEditorKit kit = new HTMLEditorKit();
+        Document doc = kit.createDefaultDocument();
+
+        doc.putProperty("IgnoreCharsetDirective", Boolean.TRUE);
+
+        kit.read(source, doc, 0);
+
+        String extractedText = doc.getText(0, doc.getLength());
+
+        // 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?
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/ImageMagickImageThumbnailFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/ImageMagickImageThumbnailFilter.java
@@ -0,0 +1,38 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+
+
+/**
+ * Filter image bitstreams, scaling the image to be within the bounds of
+ * thumbnail.maxwidth, thumbnail.maxheight, the size we want our thumbnail to be
+ * no bigger than. Creates only JPEGs.
+ */
+public class ImageMagickImageThumbnailFilter extends ImageMagickThumbnailFilter 
+{
+
+    /**
+     * @param source
+     *            source input stream
+     * 
+     * @return InputStream the resulting input stream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception
+    {
+		File f = inputStreamToTempFile(source, "imthumb", ".tmp");
+    	File f2 = getThumbnailFile(f);
+		return new FileInputStream(f2);
+    }
+
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/ImageMagickPdfThumbnailFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/ImageMagickPdfThumbnailFilter.java
@@ -0,0 +1,30 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+
+public class ImageMagickPdfThumbnailFilter extends ImageMagickThumbnailFilter {
+   public InputStream getDestinationStream(InputStream source)
+        throws Exception
+    {
+		File f = inputStreamToTempFile(source, "impdfthumb", ".pdf");
+		File f2 = getImageFile(f, 0);
+    	File f3 = getThumbnailFile(f2);
+    	return new FileInputStream(f3);
+    }
+
+   public static final String[] PDF = {"Adobe PDF"};
+   public String[] getInputMIMETypes()
+  {
+      return PDF;
+  }
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/ImageMagickThumbnailFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/ImageMagickThumbnailFilter.java
@@ -0,0 +1,194 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import javax.imageio.ImageIO;
+
+import org.dspace.app.mediafilter.MediaFilter;
+import org.dspace.app.mediafilter.SelfRegisterInputFormats;
+import org.dspace.content.Bitstream;
+import org.dspace.content.Bundle;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.im4java.core.ConvertCmd;
+import org.im4java.core.IM4JavaException;
+import org.im4java.core.IMOperation;
+import org.im4java.process.ProcessStarter;
+
+import org.dspace.core.ConfigurationManager;
+
+/**
+ * Filter image bitstreams, scaling the image to be within the bounds of
+ * thumbnail.maxwidth, thumbnail.maxheight, the size we want our thumbnail to be
+ * no bigger than. Creates only JPEGs.
+ */
+public abstract class ImageMagickThumbnailFilter extends MediaFilter implements SelfRegisterInputFormats
+{
+	private static int width = 180;
+	private static int height = 120;
+	static String bitstreamDescription = "IM Thumbnail";
+	static final String defaultPattern = "Generated Thumbnail";
+	static Pattern replaceRegex = Pattern.compile(defaultPattern);
+	
+	static {
+		String pre = ImageMagickThumbnailFilter.class.getName();
+		String s = ConfigurationManager.getProperty(pre + ".ProcessStarter");
+		ProcessStarter.setGlobalSearchPath(s);
+		width = ConfigurationManager.getIntProperty("thumbnail.maxwidth", width);
+		height = ConfigurationManager.getIntProperty("thumbnail.maxheight", height);
+		String description = ConfigurationManager.getProperty(pre + ".bitstreamDescription");
+		if (description != null) {
+			bitstreamDescription = description;
+		}
+		try {
+			String patt = ConfigurationManager.getProperty(pre + ".replaceRegex");
+		    replaceRegex = Pattern.compile(patt == null ? defaultPattern : patt);
+		} catch(PatternSyntaxException e) {
+			System.err.println("Invalid thumbnail replacement pattern: "+e.getMessage());
+		}
+		
+	}
+	
+	public ImageMagickThumbnailFilter() {
+	}
+	
+	
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".jpg";
+    }
+
+    /**
+     * @return String bundle name
+     *  
+     */
+    public String getBundleName()
+    {
+        return "THUMBNAIL";
+    }
+
+    /**
+     * @return String bitstreamformat
+     */
+    public String getFormatString()
+    {
+        return "JPEG";
+    }
+
+    /**
+     * @return String bitstreamDescription
+     */
+    public String getDescription()
+    {
+        return bitstreamDescription;
+    }
+
+    public static File inputStreamToTempFile(InputStream source, String prefix, String suffix) throws IOException {
+		File f = File.createTempFile(prefix, suffix);
+		f.deleteOnExit();
+    	FileOutputStream fos = new FileOutputStream(f);
+    	
+    	byte[] buffer = new byte[1024];
+    	int len = source.read(buffer);
+    	while (len != -1) {
+    		fos.write(buffer, 0, len);
+    		len = source.read(buffer);
+    	}
+    	fos.close();
+		return f;
+    }
+    
+    public static File getThumbnailFile(File f) throws IOException, InterruptedException, IM4JavaException {
+    	File f2 = new File(f.getParentFile(), f.getName() + ".jpg");
+    	f2.deleteOnExit();
+    	ConvertCmd cmd = new ConvertCmd();
+		IMOperation op = new IMOperation();
+		op.addImage(f.getAbsolutePath());
+		op.thumbnail(width, height);
+		op.addImage(f2.getAbsolutePath());
+        if (MediaFilterManager.isVerbose) {
+		    System.out.println("IM Thumbnail Param: "+op);
+        }
+		cmd.run(op);
+		return f2;
+    }
+    
+    public static File getImageFile(File f, int page) throws IOException, InterruptedException, IM4JavaException {
+    	File f2 = new File(f.getParentFile(), f.getName() + ".jpg");
+    	f2.deleteOnExit();
+    	ConvertCmd cmd = new ConvertCmd();
+		IMOperation op = new IMOperation();
+		String s = "[" + page + "]";
+		op.addImage(f.getAbsolutePath()+s);
+		op.addImage(f2.getAbsolutePath());
+        if (MediaFilterManager.isVerbose) {
+		    System.out.println("IM Image Param: "+op);
+        }
+		cmd.run(op);
+		return f2;
+    }
+    
+    public boolean preProcessBitstream(Context c, Item item, Bitstream source)
+            throws Exception
+    {
+    	String nsrc = source.getName();
+    	for(Bundle b: item.getBundles("THUMBNAIL")) {
+    		for(Bitstream bit: b.getBitstreams()) {
+    			String n = bit.getName();
+    			if (n != null) {
+    				if (nsrc != null) {
+    					if (!n.startsWith(nsrc)) continue;
+    				}
+    			}
+     	    	String description = bit.getDescription();
+    	    	//If anything other than a generated thumbnail is found, halt processing
+    	    	if (description != null) {
+        	    	if (replaceRegex.matcher(description).matches()) {
+        	            if (MediaFilterManager.isVerbose) {
+        	    		    System.out.println(description + " " + nsrc + " matches pattern and is replacable.");
+        	            }
+        	    		continue;
+        	    	}
+        	    	if (description.equals(bitstreamDescription)) {
+        	            if (MediaFilterManager.isVerbose) {
+        	    		    System.out.println(bitstreamDescription + " " + nsrc + " is replacable.");
+        	            }
+        	    		continue;    	    		
+        	    	}
+    	    	}
+    			System.out.println("Custom Thumbnail exists for " + nsrc + " for item " + item.getHandle() + ".  Thumbnail will not be generated. ");
+    			return false;
+    		}
+    	}
+    	
+    	
+        return true; //assume that the thumbnail is a custom one
+    }
+
+     public String[] getInputMIMETypes()
+    {
+        return ImageIO.getReaderMIMETypes();
+    }
+
+    public String[] getInputDescriptions()
+    {
+        return null;
+    }
+
+    public String[] getInputExtensions()
+    {
+        return ImageIO.getReaderFileSuffixes();
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/JPEGFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/JPEGFilter.java
@@ -0,0 +1,301 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.awt.Graphics2D;
+import java.awt.Color;
+import java.awt.image.*;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import javax.imageio.ImageIO;
+
+import org.dspace.core.ConfigurationManager;
+
+/**
+ * Filter image bitstreams, scaling the image to be within the bounds of
+ * thumbnail.maxwidth, thumbnail.maxheight, the size we want our thumbnail to be
+ * no bigger than. Creates only JPEGs.
+ *
+ * @author Jason Sherman <jsherman@usao.edu>
+ */
+public class JPEGFilter extends MediaFilter implements SelfRegisterInputFormats
+{
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".jpg";
+    }
+
+    /**
+     * @return String bundle name
+     *  
+     */
+    public String getBundleName()
+    {
+        return "THUMBNAIL";
+    }
+
+    /**
+     * @return String bitstreamformat
+     */
+    public String getFormatString()
+    {
+        return "JPEG";
+    }
+
+    /**
+     * @return String description
+     */
+    public String getDescription()
+    {
+        return "Generated Thumbnail";
+    }
+
+    /**
+     * @param source
+     *            source input stream
+     * 
+     * @return InputStream the resulting input stream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception
+    {
+        // read in bitstream's image
+        BufferedImage buf = ImageIO.read(source);
+
+        // get config params
+        float xmax = (float) ConfigurationManager
+                .getIntProperty("thumbnail.maxwidth");
+        float ymax = (float) ConfigurationManager
+                .getIntProperty("thumbnail.maxheight");
+        boolean blurring = (boolean) ConfigurationManager
+                .getBooleanProperty("thumbnail.blurring");
+        boolean hqscaling = (boolean) ConfigurationManager
+                .getBooleanProperty("thumbnail.hqscaling");
+
+        // now get the image dimensions
+        float xsize = (float) buf.getWidth(null);
+        float ysize = (float) buf.getHeight(null);
+
+        // if verbose flag is set, print out dimensions
+        // to STDOUT
+        if (MediaFilterManager.isVerbose)
+        {
+            System.out.println("original size: " + xsize + "," + ysize);
+        }
+
+        // scale by x first if needed
+        if (xsize > xmax)
+        {
+            // calculate scaling factor so that xsize * scale = new size (max)
+            float scale_factor = xmax / xsize;
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println("x scale factor: " + scale_factor);
+            }
+
+            // now reduce x size
+            // and y size
+            xsize = xsize * scale_factor;
+            ysize = ysize * scale_factor;
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println("new size: " + xsize + "," + ysize);
+            }
+        }
+
+        // scale by y if needed
+        if (ysize > ymax)
+        {
+            float scale_factor = ymax / ysize;
+
+            // now reduce x size
+            // and y size
+            xsize = xsize * scale_factor;
+            ysize = ysize * scale_factor;
+        }
+
+        // if verbose flag is set, print details to STDOUT
+        if (MediaFilterManager.isVerbose)
+        {
+            System.out.println("created thumbnail size: " + xsize + ", "
+                    + ysize);
+        }
+
+        // create an image buffer for the thumbnail with the new xsize, ysize
+        BufferedImage thumbnail = new BufferedImage((int) xsize, (int) ysize,
+                BufferedImage.TYPE_INT_RGB);
+
+        // Use blurring if selected in config.
+        // a little blur before scaling does wonders for keeping moire in check.
+        if (blurring)
+        {
+                // send the buffered image off to get blurred.
+                buf = getBlurredInstance((BufferedImage) buf);
+        }
+
+        // Use high quality scaling method if selected in config.
+        // this has a definite performance penalty.
+        if (hqscaling)
+        {
+                // send the buffered image off to get an HQ downscale.
+                buf = getScaledInstance((BufferedImage) buf, (int) xsize, (int) ysize,
+                        (Object) RenderingHints.VALUE_INTERPOLATION_BICUBIC, (boolean) true);
+        }
+
+        // now render the image into the thumbnail buffer
+        Graphics2D g2d = thumbnail.createGraphics();
+        g2d.drawImage(buf, 0, 0, (int) xsize, (int) ysize, null);
+
+        // now create an input stream for the thumbnail buffer and return it
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        ImageIO.write(thumbnail, "jpeg", baos);
+
+        // now get the array
+        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+
+        return bais; // hope this gets written out before its garbage collected!
+    }
+
+
+    public String[] getInputMIMETypes()
+    {
+        return ImageIO.getReaderMIMETypes();
+    }
+
+    public String[] getInputDescriptions()
+    {
+        return null;
+    }
+
+    public String[] getInputExtensions()
+    {
+        // Temporarily disabled as JDK 1.6 only
+        // return ImageIO.getReaderFileSuffixes();
+        return null;
+    }
+
+    public BufferedImage getNormalizedInstance(BufferedImage buf)
+    {
+     int type = (buf.getTransparency() == Transparency.OPAQUE) ?
+            BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB_PRE;
+     int w, h;
+     w = buf.getWidth();
+     h = buf.getHeight();
+     BufferedImage normal = new BufferedImage(w, h, type);
+     Graphics2D g2d = normal.createGraphics();
+     g2d.drawImage(buf, 0, 0, w, h, Color.WHITE, null);
+     g2d.dispose();
+     return normal;
+    }
+
+    public BufferedImage getBlurredInstance(BufferedImage buf)
+    {
+    /**
+     * Convenience method that returns a blurred instance of the
+     * provided {@code BufferedImage}.
+     *
+     */
+
+     buf = getNormalizedInstance(buf);
+
+     // kernel for blur op
+     float[] matrix = {
+        0.111f, 0.111f, 0.111f,
+        0.111f, 0.111f, 0.111f,
+        0.111f, 0.111f, 0.111f,
+      };
+
+     // perform the blur and return the blurred version.
+     BufferedImageOp blur = new ConvolveOp( new Kernel(3, 3, matrix) );
+     BufferedImage blurbuf = blur.filter(buf, null);
+     return blurbuf;
+    }
+
+    /**
+     * Convenience method that returns a scaled instance of the
+     * provided {@code BufferedImage}.
+     *
+     * @param buf the original image to be scaled
+     * @param targetWidth the desired width of the scaled instance,
+     *    in pixels
+     * @param targetHeight the desired height of the scaled instance,
+     *    in pixels
+     * @param hint one of the rendering hints that corresponds to
+     *    {@code RenderingHints.KEY_INTERPOLATION} (e.g.
+     *    {@code RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR},
+     *    {@code RenderingHints.VALUE_INTERPOLATION_BILINEAR},
+     *    {@code RenderingHints.VALUE_INTERPOLATION_BICUBIC})
+     * @param higherQuality if true, this method will use a multi-step
+     *    scaling technique that provides higher quality than the usual
+     *    one-step technique (only useful in downscaling cases, where
+     *    {@code targetWidth} or {@code targetHeight} is
+     *    smaller than the original dimensions, and generally only when
+     *    the {@code BILINEAR} hint is specified)
+     * @return a scaled version of the original {@code BufferedImage}
+     */
+    public BufferedImage getScaledInstance(BufferedImage buf,
+                                           int targetWidth,
+                                           int targetHeight,
+                                           Object hint,
+                                           boolean higherQuality)
+    {
+        int type = (buf.getTransparency() == Transparency.OPAQUE) ?
+            BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+        BufferedImage scalebuf = (BufferedImage)buf;
+        int w, h;
+        if (higherQuality) {
+            // Use multi-step technique: start with original size, then
+            // scale down in multiple passes with drawImage()
+            // until the target size is reached
+            w = buf.getWidth();
+            h = buf.getHeight();
+        } else {
+            // Use one-step technique: scale directly from original
+            // size to target size with a single drawImage() call
+            w = targetWidth;
+            h = targetHeight;
+        }
+
+        do {
+            if (higherQuality && w > targetWidth) {
+                w /= 2;
+                if (w < targetWidth) {
+                    w = targetWidth;
+                }
+            }
+
+            if (higherQuality && h > targetHeight) {
+                h /= 2;
+                if (h < targetHeight) {
+                    h = targetHeight;
+                }
+            }
+
+            BufferedImage tmp = new BufferedImage(w, h, type);
+            Graphics2D g2d = tmp.createGraphics();
+            g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
+            g2d.drawImage(scalebuf, 0, 0, w, h, Color.WHITE, null);
+            g2d.dispose();
+
+            scalebuf = tmp;
+        } while (w != targetWidth || h != targetHeight);
+
+        return scalebuf;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/MediaFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/MediaFilter.java
@@ -0,0 +1,70 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.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
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/MediaFilterManager.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/MediaFilterManager.java
@@ -0,0 +1,850 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+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.apache.commons.lang.ArrayUtils;
+import org.apache.log4j.Logger;
+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.eperson.Group;
+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
+{
+    private static final Logger log = Logger.getLogger(MediaFilterManager.class);
+
+	//key (in dspace.cfg) which lists all enabled filters by name
+    public static final String MEDIA_FILTER_PLUGINS_KEY = "filter.plugins";
+	
+    //prefix (in dspace.cfg) for all filter properties
+    public static final String FILTER_PREFIX = "filter";
+    
+    //suffix (in dspace.cfg) for input formats supported by each filter
+    public static final String INPUT_FORMATS_SUFFIX = "inputFormats";
+
+    static boolean isVerbose = false; // default to not verbose
+
+    static boolean isQuiet = false; // default is noisy
+
+    static boolean isForce = false; // default to not forced
+    
+    static String identifier = null; // object scope limiter
+    
+    static int max2Process = Integer.MAX_VALUE;  // maximum number items to process
+    
+    static int processed = 0;   // number items processed
+    
+    private static Item currentItem = null;   // current item being processed
+    
+    private static FormatFilter[] filterClasses = null;
+    
+    private static final Map<String, List<String>> filterFormats = new HashMap<>();
+
+    private static List<String> skipList = null; //list of identifiers to skip during processing
+
+    private static final List<String> publicFiltersClasses = new ArrayList<>();
+
+    //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 final String FILTER_PLUGIN_SEPARATOR = "\034";
+
+    static {
+        String publicPermissionFilters = ConfigurationManager.getProperty("filter.org.dspace.app.mediafilter.publicPermission");
+        if(publicPermissionFilters != null) {
+            String[] publicPermisionFiltersArray = publicPermissionFilters.split(",");
+            for(String filter : publicPermisionFiltersArray) {
+                publicFiltersClasses.add(filter.trim());
+            }
+        }
+    }
+    
+    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("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('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<FormatFilter> filterList = new ArrayList<FormatFilter>();
+                
+        //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: ");
+            Iterator<String> i = filterFormats.keySet().iterator();
+            while(i.hasNext())
+            {
+                String filterName = 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.turnOffAuthorisationSystem();
+
+            // 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;
+            	}
+            }
+
+            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<String> fmts = 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();
+                	long size = myBitstream.getSize();
+                	String checksum = myBitstream.getChecksum() + " ("+myBitstream.getChecksumAlgorithm()+")";
+                	int assetstore = myBitstream.getStoreNumber();
+   
+                	// Printout helpful information to find the errored bitstream.
+                	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();
+                }
+    		}
+            else if (filterClasses[i] instanceof SelfRegisterInputFormats)
+            {
+                // Filter implements self registration, so check to see if it should be applied
+                // given the formats it claims to support
+                SelfRegisterInputFormats srif = (SelfRegisterInputFormats)filterClasses[i];
+                boolean applyFilter = false;
+
+                // Check MIME type
+                String[] mimeTypes = srif.getInputMIMETypes();
+                if (mimeTypes != null)
+                {
+                    for (String mimeType : mimeTypes)
+                    {
+                        if (mimeType.equalsIgnoreCase(myBitstream.getFormat().getMIMEType()))
+                        {
+                            applyFilter = true;
+                        }
+                    }
+                }
+
+                // Check description
+                if (!applyFilter)
+                {
+                    String[] descriptions = srif.getInputDescriptions();
+                    if (descriptions != null)
+                    {
+                        for (String desc : descriptions)
+                        {
+                            if (desc.equalsIgnoreCase(myBitstream.getFormat().getShortDescription()))
+                            {
+                                applyFilter = true;
+                            }
+                        }
+                    }
+                }
+
+                // Check extensions
+                if (!applyFilter)
+                {
+                    String[] extensions = srif.getInputExtensions();
+                    if (extensions != null)
+                    {
+                        for (String ext : extensions)
+                        {
+                            String[] formatExtensions = myBitstream.getFormat().getExtensions();
+                            if (formatExtensions != null && ArrayUtils.contains(formatExtensions, ext))
+                            {
+                                applyFilter = true;
+                            }
+                        }
+                    }
+                }
+
+                // Filter claims to handle this type of file, so attempt to apply it
+                if (applyFilter)
+                {
+                    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)
+                    {
+                        System.out.println("ERROR filtering, skipping bitstream #"
+                                + myBitstream.getID() + " " + e);
+                        e.printStackTrace();
+                    }
+                }
+            }
+    	}
+        return filtered;
+    }
+    
+    /**
+     * 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;
+        }
+        
+        if(isVerbose) {
+            System.out.println("PROCESSING: bitstream " + source.getID()
+                + " (item: " + item.getHandle() + ")");
+        }
+
+        InputStream destStream;
+        try {
+            System.out.println("File: " + newName);
+            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;
+            }
+        }
+        catch (OutOfMemoryError oome)
+        {
+            System.out.println("!!! OutOfMemoryError !!!");
+            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();
+        
+        //Set permissions on the derivative bitstream
+        //- First remove any existing policies
+        AuthorizeManager.removeAllPolicies(c, b);
+
+        //- Determine if this is a public-derivative format
+        if(publicFiltersClasses.contains(formatFilter.getClass().getSimpleName())) {
+            //- Set derivative bitstream to be publicly accessible
+            Group anonymous = Group.find(c, 0);
+            AuthorizeManager.addPolicy(c, b, Constants.READ, anonymous);
+        } else {
+            //- Inherit policies from the source bitstream
+            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;
+        }
+    }
+    
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/PDFFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/PDFFilter.java
@@ -0,0 +1,148 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+import org.apache.log4j.Logger;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.util.PDFTextStripper;
+import org.dspace.core.ConfigurationManager;
+
+/*
+ *
+ * to do: helpful error messages - can't find mediafilter.cfg - can't
+ * instantiate filter - bitstream format doesn't exist
+ *
+ */
+public class PDFFilter extends MediaFilter
+{
+
+    private static Logger log = Logger.getLogger(PDFFilter.class);
+
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".txt";
+    }
+
+    /**
+     * @return String bundle name
+     *
+     */
+    public String getBundleName()
+    {
+        return "TEXT";
+    }
+
+    /**
+     * @return String bitstreamformat
+     */
+    public String getFormatString()
+    {
+        return "Text";
+    }
+
+    /**
+     * @return String description
+     */
+    public String getDescription()
+    {
+        return "Extracted text";
+    }
+
+    /**
+     * @param source
+     *            source input stream
+     *
+     * @return InputStream the resulting input stream
+     */
+    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();
+            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
+            {
+                pdfDoc = PDDocument.load(source);
+                pts.writeText(pdfDoc, writer);
+            }
+            finally
+            {
+                try
+                {
+                    if (pdfDoc != null)
+                    {
+                        pdfDoc.close();
+                    }
+                }
+                catch(Exception e)
+                {
+                   log.error("Error closing PDF file: " + e.getMessage(), e);
+                }
+
+                try
+                {
+                    writer.close();
+                }
+                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;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/PowerPointFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/PowerPointFilter.java
@@ -0,0 +1,124 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import org.apache.poi.extractor.ExtractorFactory;
+import org.apache.poi.xslf.extractor.XSLFPowerPointExtractor;
+import org.apache.poi.hslf.extractor.PowerPointExtractor;
+import org.apache.poi.POITextExtractor;
+
+import org.apache.log4j.Logger;
+
+/*
+ * TODO: Allow user to configure extraction of only text or only notes
+ * 
+ */
+public class PowerPointFilter extends MediaFilter
+{
+
+    private static Logger log = Logger.getLogger(PowerPointFilter.class);
+
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".txt";
+    }
+
+    /**
+     * @return String bundle name
+     * 
+     */
+    public String getBundleName()
+    {
+        return "TEXT";
+    }
+
+    /**
+     * @return String bitstream format
+     * 
+     *         TODO: Check that this is correct
+     */
+    public String getFormatString()
+    {
+        return "Text";
+    }
+
+    /**
+     * @return String description
+     */
+    public String getDescription()
+    {
+        return "Extracted text";
+    }
+
+    /**
+     * @param source
+     *            source input stream
+     * 
+     * @return InputStream the resulting input stream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception
+    {
+
+        try
+        {
+
+            String extractedText = null;
+            new ExtractorFactory();
+            POITextExtractor pptExtractor = ExtractorFactory
+                    .createExtractor(source);
+
+            // PowerPoint XML files and legacy format PowerPoint files
+            // require different classes and APIs for text extraction
+
+            // If this is a PowerPoint XML file, extract accordingly
+            if (pptExtractor instanceof XSLFPowerPointExtractor)
+            {
+
+                // The true method arguments indicate that text from
+                // the slides and the notes is desired
+                extractedText = ((XSLFPowerPointExtractor) pptExtractor)
+                        .getText(true, true);
+            }
+
+            // Legacy PowerPoint files
+            else if (pptExtractor instanceof PowerPointExtractor)
+            {
+
+                extractedText = ((PowerPointExtractor) pptExtractor).getText()
+                        + " " + ((PowerPointExtractor) pptExtractor).getNotes();
+
+            }
+            if (extractedText != null)
+            {
+                // if verbose flag is set, print out extracted text
+                // to STDOUT
+                if (MediaFilterManager.isVerbose)
+                {
+                    System.out.println(extractedText);
+                }
+
+                // generate an input stream with the extracted text
+                byte[] textBytes = extractedText.getBytes();
+                ByteArrayInputStream bais = new ByteArrayInputStream(textBytes);
+
+                return bais;
+            }
+        }
+        catch (Exception e)
+        {
+            log.error("Error filtering bitstream: " + e.getMessage(), e);
+            throw e;
+        }
+
+        return null;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/SelfRegisterInputFormats.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/SelfRegisterInputFormats.java
@@ -0,0 +1,21 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+/**
+ * Interface to allow filters to register the input formats they handle
+ * (useful for exposing underlying capabilities of libraries used)
+ */
+public interface SelfRegisterInputFormats
+{
+    public String[] getInputMIMETypes();
+
+    public String[] getInputDescriptions();
+
+    public String[] getInputExtensions();
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/WordFilter.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/WordFilter.java
@@ -0,0 +1,98 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+
+import org.apache.log4j.Logger;
+
+import org.textmining.extraction.TextExtractor;
+import org.textmining.extraction.word.WordTextExtractorFactory;
+
+/*
+ * 
+ * to do: helpful error messages - can't find mediafilter.cfg - can't
+ * instantiate filter - bitstream format doesn't exist.
+ *  
+ */
+public class WordFilter extends MediaFilter
+{
+
+    private static Logger log = Logger.getLogger(WordFilter.class);
+
+    public String getFilteredName(String oldFilename)
+    {
+        return oldFilename + ".txt";
+    }
+
+    /**
+     * @return String bundle name
+     *  
+     */
+    public String getBundleName()
+    {
+        return "TEXT";
+    }
+
+    /**
+     * @return String bitstreamformat
+     */
+    public String getFormatString()
+    {
+        return "Text";
+    }
+
+    /**
+     * @return String description
+     */
+    public String getDescription()
+    {
+        return "Extracted text";
+    }
+
+    /**
+     * @param source
+     *            source input stream
+     * 
+     * @return InputStream the resulting input stream
+     */
+    public InputStream getDestinationStream(InputStream source)
+            throws Exception
+    {
+        // get input stream from bitstream
+        // pass to filter, get string back
+        try  
+        {
+            WordTextExtractorFactory factory = new WordTextExtractorFactory();
+            TextExtractor e = factory.textExtractor(source);
+            String extractedText = e.getText();
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println(extractedText);
+            }
+
+            // 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 (IOException ioe)
+        {
+            System.out.println("Invalid Word Format");
+            log.error("Error detected - Word File format not recognized: "
+                    + ioe.getMessage(), ioe);
+            throw ioe;
+        }
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/XPDF2Text.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/XPDF2Text.java
@@ -0,0 +1,160 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+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
+        {
+            if (!sourceTmp.delete())
+            {
+                log.error("Unable to delete temporary file");
+            }
+            if (status != 0)
+            {
+                log.error("PDF conversion proc failed, returns=" + status + ", file=" + sourceTmp);
+            }
+        }
+    }
+}
+
+ 	  	 
--- a/dspace-api/src/main/java/org/dspace/app/mediafilter/XPDF2Thumbnail.java
+++ b/dspace-api/src/main/java/org/dspace/app/mediafilter/XPDF2Thumbnail.java
@@ -0,0 +1,514 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.mediafilter;
+
+import java.awt.Graphics2D;
+import java.awt.Color;
+import java.awt.image.*;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+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 xmax = 0;
+
+    // backup default for size, on the large side.
+    private static final int DEFAULT_XMAX = 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
+    {
+        // get config params
+        float xmax = (float) ConfigurationManager
+                .getIntProperty("thumbnail.maxwidth");
+        float ymax = (float) ConfigurationManager
+                .getIntProperty("thumbnail.maxheight");
+        boolean blurring = (boolean) ConfigurationManager
+                .getBooleanProperty("thumbnail.blurring");
+        boolean hqscaling = (boolean) ConfigurationManager
+                .getBooleanProperty("thumbnail.hqscaling");
+        
+        // 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.");
+            }
+                
+            if (xmax == 0)
+            {
+                xmax = DEFAULT_XMAX;
+            }
+        }
+
+        // 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();
+            BufferedReader lr = null;
+            try
+            {
+                MatchResult mediaBox = null;
+                Process pdfProc = Runtime.getRuntime().exec(pdfinfoCmd);
+                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
+                {
+                    double x0 = Double.parseDouble(mediaBox.group(1));
+                    double y0 = Double.parseDouble(mediaBox.group(2));
+                    double x1 = Double.parseDouble(mediaBox.group(3));
+                    double y1 = Double.parseDouble(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);
+            }
+            finally
+            {
+                if (lr != null)
+                {
+                    lr.close();
+                }
+            }
+
+            // 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();
+            if (!outPrefixF.delete())
+            {
+                log.error("Unable to delete output file");
+            }
+            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();
+                if (!outf.exists()) outf = new File(outPrefix+"-00001.ppm");
+                if (!outf.exists()) outf = new File(outPrefix+"-0001.ppm");
+                if (!outf.exists()) outf = new File(outPrefix+"-001.ppm");
+                if (!outf.exists()) outf = new File(outPrefix+"-01.ppm");
+                if (!outf.exists()) outf = new File(outPrefix+"-1.ppm");
+                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
+            {
+                if (!outf.delete())
+                {
+                    log.error("Unable to delete file");
+                }
+            }
+        }
+        finally
+        {
+            if (!sourceTmp.delete())
+            {
+                log.error("Unable to delete temporary source");
+            }
+            
+            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.");
+        }
+        
+        // read in bitstream's image
+        BufferedImage buf = source;
+
+        // now get the image dimensions
+        float xsize = (float) buf.getWidth(null);
+        float ysize = (float) buf.getHeight(null);
+        
+        // if verbose flag is set, print out dimensions
+        // to STDOUT
+        if (MediaFilterManager.isVerbose)
+        {
+            System.out.println("original size: " + xsize + "," + ysize);
+        }
+        
+        // scale by x first if needed
+        if (xsize > xmax)
+        {
+            // calculate scaling factor so that xsize * scale = new size (max)
+            float scale_factor = xmax / xsize;
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println("x scale factor: " + scale_factor);
+            }
+
+            // now reduce x size
+            // and y size
+            xsize = xsize * scale_factor;
+            ysize = ysize * scale_factor;
+
+            // if verbose flag is set, print out extracted text
+            // to STDOUT
+            if (MediaFilterManager.isVerbose)
+            {
+                System.out.println("new size: " + xsize + "," + ysize);
+            }
+        }
+
+        // scale by y if needed
+        if (ysize > ymax)
+        {
+            float scale_factor = ymax / ysize;
+
+            // now reduce x size
+            // and y size
+            xsize = xsize * scale_factor;
+            ysize = ysize * scale_factor;
+        }
+
+        // if verbose flag is set, print details to STDOUT
+        if (MediaFilterManager.isVerbose)
+        {
+            System.out.println("created thumbnail size: " + xsize + ", "
+                    + ysize);
+        }
+
+        // create an image buffer for the thumbnail with the new xsize, ysize
+        BufferedImage thumbnail = new BufferedImage((int) xsize, (int) ysize,
+                BufferedImage.TYPE_INT_RGB);
+
+        // Use blurring if selected in config.
+        // a little blur before scaling does wonders for keeping moire in check.
+        if (blurring)
+        {
+                // send the buffered image off to get blurred.
+                buf = getBlurredInstance((BufferedImage) buf);
+        }
+
+        // Use high quality scaling method if selected in config.
+        // this has a definite performance penalty.
+        if (hqscaling)
+        {
+                // send the buffered image off to get an HQ downscale.
+                buf = getScaledInstance((BufferedImage) buf, (int) xsize, (int) ysize,
+                        (Object) RenderingHints.VALUE_INTERPOLATION_BICUBIC, (boolean) true);
+        }
+
+        // now render the image into the thumbnail buffer
+        Graphics2D g2d = thumbnail.createGraphics();
+        g2d.drawImage(buf, 0, 0, (int) xsize, (int) ysize, null);
+
+        // now create an input stream for the thumbnail buffer and return it
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        ImageIO.write(thumbnail, "jpeg", baos);
+
+        // now get the array
+        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+
+        return bais; // hope this gets written out before its garbage collected!
+    }
+    
+   public String[] getInputMIMETypes()
+    {
+        return ImageIO.getReaderMIMETypes();
+    }
+
+    public String[] getInputDescriptions()
+    {
+        return null;
+    }
+
+    public String[] getInputExtensions()
+    {
+        // Temporarily disabled as JDK 1.6 only
+        // return ImageIO.getReaderFileSuffixes();
+        return null;
+    }
+
+    public BufferedImage getNormalizedInstance(BufferedImage buf)
+    {
+     int type = (buf.getTransparency() == Transparency.OPAQUE) ?
+            BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB_PRE;
+     int w, h;
+     w = buf.getWidth();
+     h = buf.getHeight();
+     BufferedImage normal = new BufferedImage(w, h, type);
+     Graphics2D g2d = normal.createGraphics();
+     g2d.drawImage(buf, 0, 0, w, h, Color.WHITE, null);
+     g2d.dispose();
+     return normal;
+    }
+
+    public BufferedImage getBlurredInstance(BufferedImage buf)
+    {
+    /**
+     * Convenience method that returns a blurred instance of the
+     * provided {@code BufferedImage}.
+     *
+     */
+
+     buf = getNormalizedInstance(buf);
+
+     // kernel for blur op
+     float[] matrix = {
+        0.111f, 0.111f, 0.111f,
+        0.111f, 0.111f, 0.111f,
+        0.111f, 0.111f, 0.111f,
+      };
+
+     // perform the blur and return the blurred version.
+     BufferedImageOp blur = new ConvolveOp( new Kernel(3, 3, matrix) );
+     BufferedImage blurbuf = blur.filter(buf, null);
+     return blurbuf;
+    }
+
+    /**
+     * Convenience method that returns a scaled instance of the
+     * provided {@code BufferedImage}.
+     *
+     * @param buf the original image to be scaled
+     * @param targetWidth the desired width of the scaled instance,
+     *    in pixels
+     * @param targetHeight the desired height of the scaled instance,
+     *    in pixels
+     * @param hint one of the rendering hints that corresponds to
+     *    {@code RenderingHints.KEY_INTERPOLATION} (e.g.
+     *    {@code RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR},
+     *    {@code RenderingHints.VALUE_INTERPOLATION_BILINEAR},
+     *    {@code RenderingHints.VALUE_INTERPOLATION_BICUBIC})
+     * @param higherQuality if true, this method will use a multi-step
+     *    scaling technique that provides higher quality than the usual
+     *    one-step technique (only useful in downscaling cases, where
+     *    {@code targetWidth} or {@code targetHeight} is
+     *    smaller than the original dimensions, and generally only when
+     *    the {@code BILINEAR} hint is specified)
+     * @return a scaled version of the original {@code BufferedImage}
+     */
+    public BufferedImage getScaledInstance(BufferedImage buf,
+                                           int targetWidth,
+                                           int targetHeight,
+                                           Object hint,
+                                           boolean higherQuality)
+    {
+        int type = (buf.getTransparency() == Transparency.OPAQUE) ?
+            BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+        BufferedImage scalebuf = (BufferedImage)buf;
+        int w, h;
+        if (higherQuality) {
+            // Use multi-step technique: start with original size, then
+            // scale down in multiple passes with drawImage()
+            // until the target size is reached
+            w = buf.getWidth();
+            h = buf.getHeight();
+        } else {
+            // Use one-step technique: scale directly from original
+            // size to target size with a single drawImage() call
+            w = targetWidth;
+            h = targetHeight;
+        }
+
+        do {
+            if (higherQuality && w > targetWidth) {
+                w /= 2;
+                if (w < targetWidth) {
+                    w = targetWidth;
+                }
+            }
+
+            if (higherQuality && h > targetHeight) {
+                h /= 2;
+                if (h < targetHeight) {
+                    h = targetHeight;
+                }
+            }
+
+            BufferedImage tmp = new BufferedImage(w, h, type);
+            Graphics2D g2d = tmp.createGraphics();
+            g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
+            g2d.drawImage(scalebuf, 0, 0, w, h, Color.WHITE, null);
+            g2d.dispose();
+
+            scalebuf = tmp;
+        } while (w != targetWidth || h != targetHeight);
+
+        return scalebuf;
+    }    
+}
--- a/dspace-api/src/main/java/org/dspace/app/packager/Packager.java
+++ b/dspace-api/src/main/java/org/dspace/app/packager/Packager.java
@@ -0,0 +1,786 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.packager;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.sql.SQLException;
+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.Options;
+import org.apache.commons.cli.PosixParser;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.DSpaceObject;
+import org.dspace.content.crosswalk.CrosswalkException;
+import org.dspace.content.packager.PackageDisseminator;
+import org.dspace.content.packager.PackageException;
+import org.dspace.content.packager.PackageParameters;
+import org.dspace.content.packager.PackageIngester;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.core.PluginManager;
+import org.dspace.eperson.EPerson;
+import org.dspace.handle.HandleManager;
+
+/**
+ * Command-line interface to the Packager plugin.
+ * <p>
+ * This class ONLY exists to provide a CLI for the packager plugins. It does not
+ * "manage" the plugins and it is not called from within DSpace, but the name
+ * follows a DSpace convention.
+ * <p>
+ * It can invoke one of the Submission (SIP) packagers to create a new DSpace
+ * Item out of a package, or a Dissemination (DIP) packager to write an Item out
+ * as a package.
+ * <p>
+ * Usage is as follows:<br>
+ * (Add the -h option to get the command to show its own help)
+ *
+ * <pre>
+ *  1. To submit a SIP  (submissions tend to create a *new* object, with a new handle.  If you want to restore an object, see -r option below)
+ *   dspace packager
+ *       -e {ePerson}
+ *       -t {PackagerType}
+ *       -p {parent-handle} [ -p {parent2} ...]
+ *       [-o {name}={value} [ -o {name}={value} ..]]
+ *       [-a] --- also recursively ingest all child packages of the initial package
+ *                (child pkgs must be referenced from parent pkg)
+ *       [-w]   --- skip Workflow
+ *       {package-filename}
+ *
+ *   {PackagerType} must match one of the aliases of the chosen Packager
+ *   plugin.
+ *
+ *   The &quot;-w&quot; option circumvents Workflow, and is optional.  The &quot;-o&quot;
+ *   option, which may be repeated, passes options to the packager
+ *   (e.g. &quot;metadataOnly&quot; to a DIP packager).
+ *
+ *  2. To restore an AIP  (similar to submit mode, but attempts to restore with the handles/parents specified in AIP):
+ *   dspace packager
+ *       -r     --- restores a object from a package info, including the specified handle (will throw an error if handle is already in use)
+ *       -e {ePerson}
+ *       -t {PackagerType}
+ *       [-o {name}={value} [ -o {name}={value} ..]]
+ *       [-a] --- also recursively restore all child packages of the initial package
+ *                (child pkgs must be referenced from parent pkg)
+ *       [-k]   --- Skip over errors where objects already exist and Keep Existing objects by default.
+ *                  Use with -r to only restore objects which do not already exist.  By default, -r will throw an error
+ *                  and rollback all changes when an object is found that already exists.
+ *       [-f]   --- Force a restore (even if object already exists).
+ *                  Use with -r to replace an existing object with one from a package (essentially a delete and restore).
+ *                  By default, -r will throw an error and rollback all changes when an object is found that already exists.
+ *       [-i {identifier-handle-of-object}] -- Optional when -f is specified.  When replacing an object, you can specify the
+ *                  object to replace if it cannot be easily determined from the package itself.
+ *       {package-filename}
+ *
+ *   Restoring is very similar to submitting, except that you are recreating pre-existing objects.  So, in a restore, the object(s) are
+ *   being recreated based on the details in the AIP.  This means that the object is recreated with the same handle and same parent/children
+ *   objects.  Not all {PackagerTypes} may support a "restore".
+ *
+ *  3. To write out a DIP:
+ *   dspace packager
+ *       -d
+ *       -e {ePerson}
+ *       -t {PackagerType}
+ *       -i {identifier-handle-of-object}
+ *       [-a] --- also recursively disseminate all child objects of this object
+ *       [-o {name}={value} [ -o {name}={value} ..]]
+ *       {package-filename}
+ *
+ *   The &quot;-d&quot; switch chooses a Dissemination packager, and is required.
+ *   The &quot;-o&quot; option, which may be repeated, passes options to the packager
+ *   (e.g. &quot;metadataOnly&quot; to a DIP packager).
+ * </pre>
+ *
+ * Note that {package-filename} may be "-" for standard input or standard
+ * output, respectively.
+ *
+ * @author Larry Stone
+ * @author Tim Donohue
+ * @version $Revision$
+ */
+public class Packager
+{
+    /* Various private global settings/options */
+    private String packageType = null;
+    private boolean submit = true;
+    private boolean userInteractionEnabled = true;
+
+    // die from illegal command line
+    private static void usageError(String msg)
+    {
+        System.out.println(msg);
+        System.out.println(" (run with -h flag for details)");
+        System.exit(1);
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        Options options = new Options();
+        options.addOption("p", "parent", true,
+                "Handle(s) of parent Community or Collection into which to ingest object (repeatable)");
+        options.addOption("e", "eperson", true,
+                "email address of eperson doing importing");
+        options
+                .addOption(
+                        "w",
+                        "install",
+                        false,
+                        "disable workflow; install immediately without going through collection's workflow");
+        options.addOption("r", "restore", false, "ingest in \"restore\" mode.  Restores a missing object based on the contents in a package.");
+        options.addOption("k", "keep-existing", false, "if an object is found to already exist during a restore (-r), then keep the existing object and continue processing.  Can only be used with '-r'.  This avoids object-exists errors which are thrown by -r by default.");
+        options.addOption("f", "force-replace", false, "if an object is found to already exist during a restore (-r), then remove it and replace it with the contents of the package.  Can only be used with '-r'.  This REPLACES the object(s) in the repository with the contents from the package(s).");
+        options.addOption("t", "type", true, "package type or MIMEtype");
+        options
+                .addOption("o", "option", true,
+                        "Packager option to pass to plugin, \"name=value\" (repeatable)");
+        options.addOption("d", "disseminate", false,
+                "Disseminate package (output); default is to submit.");
+        options.addOption("s", "submit", false,
+                "Submission package (Input); this is the default. ");
+        options.addOption("i", "identifier", true, "Handle of object to disseminate.");
+        options.addOption("a", "all", false, "also recursively ingest/disseminate any child packages, e.g. all Items within a Collection (not all packagers may support this option!)");
+        options.addOption("h", "help", false, "help (you may also specify '-h -t [type]' for additional help with a specific type of packager)");
+        options.addOption("u", "no-user-interaction", false, "Skips over all user interaction (i.e. [y/n] question prompts) within this script. This flag can be used if you want to save (pipe) a report of all changes to a file, and therefore need to bypass all user interaction.");
+
+        CommandLineParser parser = new PosixParser();
+        CommandLine line = parser.parse(options, argv);
+
+        String sourceFile = null;
+        String eperson = null;
+        String[] parents = null;
+        String identifier = null;
+        PackageParameters pkgParams = new PackageParameters();
+
+        //initialize a new packager -- we'll add all our current params as settings
+        Packager myPackager = new Packager();
+
+        if (line.hasOption('h'))
+        {
+            HelpFormatter myhelp = new HelpFormatter();
+            myhelp.printHelp("Packager  [options]  package-file|-\n",
+                    options);
+            //If user specified a type, also print out the SIP and DIP options
+            // that are specific to that type of packager
+            if (line.hasOption('t'))
+            {
+                System.out.println("\n--------------------------------------------------------------");
+                System.out.println("Additional options for the " + line.getOptionValue('t') + " packager:");
+                System.out.println("--------------------------------------------------------------");
+                System.out.println("(These options may be specified using --option as described above)");
+
+                PackageIngester sip = (PackageIngester) PluginManager
+                    .getNamedPlugin(PackageIngester.class, line.getOptionValue('t'));
+
+                if (sip != null)
+                {
+                    System.out.println("\n\n" + line.getOptionValue('t') + " Submission (SIP) plugin options:\n");
+                    System.out.println(sip.getParameterHelp());
+                }
+                else
+                {
+                    System.out.println("\nNo valid Submission plugin found for " + line.getOptionValue('t') + " type.");
+                }
+
+                PackageDisseminator dip = (PackageDisseminator) PluginManager
+                    .getNamedPlugin(PackageDisseminator.class, line.getOptionValue('t'));
+
+                if (dip != null)
+                {
+                    System.out.println("\n\n" + line.getOptionValue('t') + " Dissemination (DIP) plugin options:\n");
+                    System.out.println(dip.getParameterHelp());
+                }
+                else
+                {
+                    System.out.println("\nNo valid Dissemination plugin found for " + line.getOptionValue('t') + " type.");
+                }
+
+            }
+            else  //otherwise, display list of valid packager types
+            {
+                System.out.println("\nAvailable Submission Package (SIP) types:");
+                String pn[] = PluginManager
+                        .getAllPluginNames(PackageIngester.class);
+                for (int i = 0; i < pn.length; ++i)
+                {
+                    System.out.println("  " + pn[i]);
+                }
+                System.out
+                        .println("\nAvailable Dissemination Package (DIP) types:");
+                pn = PluginManager.getAllPluginNames(PackageDisseminator.class);
+                for (int i = 0; i < pn.length; ++i)
+                {
+                    System.out.println("  " + pn[i]);
+                }
+            }
+            System.exit(0);
+        }
+
+        //look for flag to disable all user interaction
+        if(line.hasOption('u'))
+        {
+            myPackager.userInteractionEnabled = false;
+        }
+        if (line.hasOption('w'))
+        {
+            pkgParams.setWorkflowEnabled(false);
+        }
+        if (line.hasOption('r'))
+        {
+            pkgParams.setRestoreModeEnabled(true);
+        }
+        //keep-existing is only valid in restoreMode (-r) -- otherwise ignore -k option.
+        if (line.hasOption('k') && pkgParams.restoreModeEnabled())
+        {
+            pkgParams.setKeepExistingModeEnabled(true);
+        }
+        //force-replace is only valid in restoreMode (-r) -- otherwise ignore -f option.
+        if (line.hasOption('f') && pkgParams.restoreModeEnabled())
+        {
+            pkgParams.setReplaceModeEnabled(true);
+        }
+        if (line.hasOption('e'))
+        {
+            eperson = line.getOptionValue('e');
+        }
+        if (line.hasOption('p'))
+        {
+            parents = line.getOptionValues('p');
+        }
+        if (line.hasOption('t'))
+        {
+            myPackager.packageType = line.getOptionValue('t');
+        }
+        if (line.hasOption('i'))
+        {
+            identifier = line.getOptionValue('i');
+        }
+        if (line.hasOption('a'))
+        {
+            //enable 'recursiveMode' param to packager implementations, in case it helps with packaging or ingestion process
+            pkgParams.setRecursiveModeEnabled(true);
+        }
+        String files[] = line.getArgs();
+        if (files.length > 0)
+        {
+            sourceFile = files[0];
+        }
+        if (line.hasOption('d'))
+        {
+            myPackager.submit = false;
+        }
+        if (line.hasOption('o'))
+        {
+            String popt[] = line.getOptionValues('o');
+            for (int i = 0; i < popt.length; ++i)
+            {
+                String pair[] = popt[i].split("\\=", 2);
+                if (pair.length == 2)
+                {
+                    pkgParams.addProperty(pair[0].trim(), pair[1].trim());
+                }
+                else if (pair.length == 1)
+                {
+                    pkgParams.addProperty(pair[0].trim(), "");
+                }
+                else
+                {
+                    System.err
+                            .println("Warning: Illegal package option format: \""
+                                    + popt[i] + "\"");
+                }
+            }
+        }
+
+        // Sanity checks on arg list: required args
+        // REQUIRED: sourceFile, ePerson (-e), packageType (-t)
+        if (sourceFile == null || eperson == null || myPackager.packageType == null)
+        {
+            System.err.println("Error - missing a REQUIRED argument or option.\n");
+            HelpFormatter myhelp = new HelpFormatter();
+            myhelp.printHelp("PackageManager  [options]  package-file|-\n", options);
+            System.exit(0);
+        }
+
+        // find the EPerson, assign to context
+        Context context = new Context();
+        EPerson myEPerson = null;
+        myEPerson = EPerson.findByEmail(context, eperson);
+        if (myEPerson == null)
+        {
+            usageError("Error, eperson cannot be found: " + eperson);
+        }
+        context.setCurrentUser(myEPerson);
+
+
+        //If we are in REPLACE mode
+        if(pkgParams.replaceModeEnabled())
+        {
+            PackageIngester sip = (PackageIngester) PluginManager
+                    .getNamedPlugin(PackageIngester.class, myPackager.packageType);
+            if (sip == null)
+            {
+                usageError("Error, Unknown package type: " + myPackager.packageType);
+            }
+
+            DSpaceObject objToReplace = null;
+
+            //if a specific identifier was specified, make sure it is valid
+            if(identifier!=null && identifier.length()>0)
+            {
+                objToReplace = HandleManager.resolveToObject(context, identifier);
+                if (objToReplace == null)
+                {
+                    throw new IllegalArgumentException("Bad identifier/handle -- "
+                            + "Cannot resolve handle \"" + identifier + "\"");
+                }
+            }
+
+            String choiceString = null;
+            if(myPackager.userInteractionEnabled)
+            {
+                BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
+                System.out.println("\n\nWARNING -- You are running the packager in REPLACE mode.");
+                System.out.println("\nREPLACE mode may be potentially dangerous as it will automatically remove and replace contents within DSpace.");
+                System.out.println("We highly recommend backing up all your DSpace contents (files & database) before continuing.");
+                System.out.print("\nWould you like to continue? [y/n]: ");
+                choiceString = input.readLine();
+            }
+            else
+            {
+                //user interaction disabled -- default answer to 'yes', otherwise script won't continue
+                choiceString = "y";
+            }
+
+            if (choiceString.equalsIgnoreCase("y"))
+            {
+                System.out.println("Beginning replacement process...");
+
+                try
+                {
+                    //replace the object from the source file
+                    myPackager.replace(context, sip, pkgParams, sourceFile, objToReplace);
+
+                    //commit all changes & exit successfully
+                    context.complete();
+                    System.exit(0);
+                }
+                catch (Exception e)
+                {
+                    // abort all operations
+                    e.printStackTrace();
+                    context.abort();
+                    System.out.println(e);
+                    System.exit(1);
+                }
+            }
+
+        }
+        //else if normal SUBMIT mode (or basic RESTORE mode -- which is a special type of submission)
+        else if (myPackager.submit || pkgParams.restoreModeEnabled())
+        {
+            PackageIngester sip = (PackageIngester) PluginManager
+                    .getNamedPlugin(PackageIngester.class, myPackager.packageType);
+            if (sip == null)
+            {
+                usageError("Error, Unknown package type: " + myPackager.packageType);
+            }
+
+            // validate each parent arg (if any)
+            DSpaceObject parentObjs[] = null;
+            if(parents!=null)
+            {
+                System.out.println("Destination parents:");
+
+                parentObjs = new DSpaceObject[parents.length];
+                for (int i = 0; i < parents.length; i++)
+                {
+                    // sanity check: did handle resolve?
+                    parentObjs[i] = HandleManager.resolveToObject(context,
+                            parents[i]);
+                    if (parentObjs[i] == null)
+                    {
+                        throw new IllegalArgumentException(
+                                "Bad parent list -- "
+                                        + "Cannot resolve parent handle \""
+                                        + parents[i] + "\"");
+                    }
+                    System.out.println((i == 0 ? "Owner: " : "Parent: ")
+                            + parentObjs[i].getHandle());
+                }
+            }
+
+            try
+            {
+                //ingest the object from the source file
+                myPackager.ingest(context, sip, pkgParams, sourceFile, parentObjs);
+
+                //commit all changes & exit successfully
+                context.complete();
+                System.exit(0);
+            }
+            catch (Exception e)
+            {
+                // abort all operations
+                e.printStackTrace();
+                context.abort();
+                System.out.println(e);
+                System.exit(1);
+            }
+        }// else, if DISSEMINATE mode
+        else
+        {
+            //retrieve specified package disseminator
+            PackageDisseminator dip = (PackageDisseminator) PluginManager
+                .getNamedPlugin(PackageDisseminator.class, myPackager.packageType);
+            if (dip == null)
+            {
+                usageError("Error, Unknown package type: " + myPackager.packageType);
+            }
+
+            DSpaceObject dso = HandleManager.resolveToObject(context, identifier);
+            if (dso == null)
+            {
+                throw new IllegalArgumentException("Bad identifier/handle -- "
+                        + "Cannot resolve handle \"" + identifier + "\"");
+            }
+
+            //disseminate the requested object
+            myPackager.disseminate(context, dip, dso, pkgParams, sourceFile);
+        }
+        System.exit(0);
+    }
+
+    /**
+     * Ingest one or more DSpace objects from package(s) based on the
+     * options passed to the 'packager' script.  This method is called
+     * for both 'submit' (-s) and 'restore' (-r) modes.
+     * <p>
+     * Please note that replace (-r -f) mode calls the replace() method instead.
+     *
+     * @param context DSpace Context
+     * @param sip PackageIngester which will actually ingest the package
+     * @param pkgParams Parameters to pass to individual packager instances
+     * @param sourceFile location of the source package to ingest
+     * @param parentObjs Parent DSpace object(s) to attach new object to
+     * @throws IOException
+     * @throws SQLException
+     * @throws FileNotFoundException
+     * @throws AuthorizeException
+     * @throws CrosswalkException
+     * @throws PackageException
+     */
+    protected void ingest(Context context, PackageIngester sip, PackageParameters pkgParams, String sourceFile, DSpaceObject parentObjs[])
+            throws IOException, SQLException, FileNotFoundException, AuthorizeException, CrosswalkException, PackageException
+    {
+        // make sure we have an input file
+        File pkgFile = new File(sourceFile);
+
+        if(!pkgFile.exists())
+        {
+            System.out.println("\nERROR: Package located at " + sourceFile + " does not exist!");
+            System.exit(1);
+        }
+
+        System.out.println("\nIngesting package located at " + sourceFile);
+
+        //find first parent (if specified) -- this will be the "owner" of the object
+        DSpaceObject parent = null;
+        if(parentObjs!=null && parentObjs.length>0)
+        {
+            parent = parentObjs[0];
+        }
+        //NOTE: at this point, Parent may be null -- in which case it is up to the PackageIngester
+        // to either determine the Parent (from package contents) or throw an error.
+
+
+        //If we are doing a recursive ingest, call ingestAll()
+        if(pkgParams.recursiveModeEnabled())
+        {
+            System.out.println("\nAlso ingesting all referenced packages (recursive mode)..");
+            System.out.println("This may take a while, please check your logs for ongoing status while we process each package.");
+
+            //ingest first package & recursively ingest anything else that package references (child packages, etc)
+            List<String> hdlResults = sip.ingestAll(context, parent, pkgFile, pkgParams, null);
+
+            if(hdlResults!=null)
+            {
+                //Report total objects created
+                System.out.println("\nCREATED a total of " + hdlResults.size() + " DSpace Objects.");
+
+                String choiceString = null;
+                //Ask if user wants full list printed to command line, as this may be rather long.
+                if(this.userInteractionEnabled)
+                {
+                    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
+                    System.out.print("\nWould you like to view a list of all objects that were created? [y/n]: ");
+                    choiceString = input.readLine();
+                }
+                else
+                {
+                    // user interaction disabled -- default answer to 'yes', as
+                    // we want to provide user with as detailed a report as possible.
+                    choiceString = "y";
+                }
+
+                // Provide detailed report if user answered 'yes'
+                if (choiceString.equalsIgnoreCase("y"))
+                {
+                    System.out.println("\n\n");
+                    for(String result : hdlResults)
+                    {
+                        DSpaceObject dso = HandleManager.resolveToObject(context, result);
+                        
+                        if(dso!=null)
+                        {
+                            if(pkgParams.restoreModeEnabled())
+                            {
+                                System.out.println("RESTORED DSpace " + Constants.typeText[dso.getType()] +
+                                        " [ hdl=" + dso.getHandle() + ", dbID=" + dso.getID() + " ] ");
+                            }
+                            else
+                            {
+                                System.out.println("CREATED new DSpace " + Constants.typeText[dso.getType()] +
+                                        " [ hdl=" + dso.getHandle() + ", dbID=" + dso.getID() + " ] ");
+                            }
+                        }
+                    }
+                }
+
+            }
+        }
+        else
+        {
+
+            //otherwise, just one package to ingest
+            try
+            {
+
+                DSpaceObject dso = sip.ingest(context, parent, pkgFile, pkgParams, null);
+
+                if(dso!=null)
+                {
+                    if(pkgParams.restoreModeEnabled())
+                    {
+                        System.out.println("RESTORED DSpace " + Constants.typeText[dso.getType()] +
+                                " [ hdl=" + dso.getHandle() + ", dbID=" + dso.getID() + " ] ");
+                    }
+                    else
+                    {
+                        System.out.println("CREATED new DSpace " + Constants.typeText[dso.getType()] +
+                                " [ hdl=" + dso.getHandle() + ", dbID=" + dso.getID() + " ] ");
+                    }
+                }
+            }
+            catch(IllegalStateException ie)
+            {
+                // NOTE: if we encounter an IllegalStateException, this means the
+                // handle is already in use and this object already exists.
+
+                //if we are skipping over (i.e. keeping) existing objects
+                if(pkgParams.keepExistingModeEnabled())
+                {
+                    System.out.println("\nSKIPPED processing package '" + pkgFile + "', as an Object already exists with this handle.");
+                }
+                else // Pass this exception on -- which essentially causes a full rollback of all changes (this is the default)
+                {
+                    throw ie;
+                }
+            }
+
+        }
+
+    }
+
+
+    /**
+     * Disseminate one or more DSpace objects into package(s) based on the
+     * options passed to the 'packager' script
+     *
+     * @param context DSpace context
+     * @param dip PackageDisseminator which will actually create the package
+     * @param dso DSpace Object to disseminate as a package
+     * @param pkgParams Parameters to pass to individual packager instances
+     * @param outputFile File where final package should be saved
+     * @throws IOException
+     * @throws SQLException
+     * @throws FileNotFoundException
+     * @throws AuthorizeException
+     * @throws CrosswalkException
+     * @throws PackageException
+     */
+    protected void disseminate(Context context, PackageDisseminator dip,
+			       DSpaceObject dso, PackageParameters pkgParams,
+			       String outputFile)
+            throws IOException, SQLException, FileNotFoundException, AuthorizeException, CrosswalkException, PackageException
+    {
+        // initialize output file
+        File pkgFile = new File(outputFile);
+
+        System.out.println("\nDisseminating DSpace " + Constants.typeText[dso.getType()] +
+                            " [ hdl=" + dso.getHandle() + " ] to " + outputFile);
+
+        //If we are doing a recursive dissemination of this object & all its child objects, call disseminateAll()
+        if(pkgParams.recursiveModeEnabled())
+        {
+            System.out.println("\nAlso disseminating all child objects (recursive mode)..");
+            System.out.println("This may take a while, please check your logs for ongoing status while we process each package.");
+
+            //disseminate initial object & recursively disseminate all child objects as well
+            List<File> fileResults = dip.disseminateAll(context, dso, pkgParams, pkgFile);
+
+            if(fileResults!=null)
+            {
+                //Report total files created
+                System.out.println("\nCREATED a total of " + fileResults.size() + " dissemination package files.");
+
+                String choiceString = null;
+                //Ask if user wants full list printed to command line, as this may be rather long.
+                if(this.userInteractionEnabled)
+                {
+                    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
+                    System.out.print("\nWould you like to view a list of all files that were created? [y/n]: ");
+                    choiceString = input.readLine();
+                }
+                else
+                {
+                    // user interaction disabled -- default answer to 'yes', as
+                    // we want to provide user with as detailed a report as possible.
+                    choiceString = "y";
+                }
+
+                // Provide detailed report if user answered 'yes'
+                if (choiceString.equalsIgnoreCase("y"))
+                {
+                    System.out.println("\n\n");
+                    for(File result : fileResults)
+                    {
+                        System.out.println("CREATED package file: " + result.getCanonicalPath());
+                    }
+                }
+            }
+        }
+        else
+        {
+            //otherwise, just disseminate a single object to a single package file
+            dip.disseminate(context, dso, pkgParams, pkgFile);
+
+            if(pkgFile!=null && pkgFile.exists())
+            {
+                System.out.println("\nCREATED package file: " + pkgFile.getCanonicalPath());
+            }
+        }
+    }
+
+
+
+    /**
+     * Replace an one or more existing DSpace objects with the contents of
+     * specified package(s) based on the options passed to the 'packager' script.
+     * This method is only called for full replaces ('-r -f' options specified)
+     *
+     * @param context DSpace Context
+     * @param sip PackageIngester which will actually replace the object with the package
+     * @param pkgParams Parameters to pass to individual packager instances
+     * @param sourceFile location of the source package to ingest as the replacement
+     * @param objToReplace DSpace object to replace (may be null if it will be specified in the package itself)
+     * @throws IOException
+     * @throws SQLException
+     * @throws FileNotFoundException
+     * @throws AuthorizeException
+     * @throws CrosswalkException
+     * @throws PackageException
+     */
+    protected void replace(Context context, PackageIngester sip, PackageParameters pkgParams, String sourceFile, DSpaceObject objToReplace)
+            throws IOException, SQLException, FileNotFoundException, AuthorizeException, CrosswalkException, PackageException
+    {
+
+        // make sure we have an input file
+        File pkgFile = new File(sourceFile);
+
+        if(!pkgFile.exists())
+        {
+            System.out.println("\nPackage located at " + sourceFile + " does not exist!");
+            System.exit(1);
+        }
+
+        System.out.println("\nReplacing DSpace object(s) with package located at " + sourceFile);
+        if(objToReplace!=null)
+        {
+            System.out.println("Will replace existing DSpace " + Constants.typeText[objToReplace.getType()] +
+                            " [ hdl=" + objToReplace.getHandle() + " ]");
+        }
+        // NOTE: At this point, objToReplace may be null.  If it is null, it is up to the PackageIngester
+        // to determine which Object needs to be replaced (based on the handle specified in the pkg, etc.)
+
+
+        //If we are doing a recursive replace, call replaceAll()
+        if(pkgParams.recursiveModeEnabled())
+        {
+            //ingest first object using package & recursively replace anything else that package references (child objects, etc)
+            List<String> hdlResults = sip.replaceAll(context, objToReplace, pkgFile, pkgParams);
+
+            if(hdlResults!=null)
+            {
+                //Report total objects replaced
+                System.out.println("\nREPLACED a total of " + hdlResults.size() + " DSpace Objects.");
+
+                String choiceString = null;
+                //Ask if user wants full list printed to command line, as this may be rather long.
+                if(this.userInteractionEnabled)
+                {
+                    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
+                    System.out.print("\nWould you like to view a list of all objects that were replaced? [y/n]: ");
+                    choiceString = input.readLine();
+                }
+                else
+                {
+                    // user interaction disabled -- default answer to 'yes', as
+                    // we want to provide user with as detailed a report as possible.
+                    choiceString = "y";
+                }
+
+                // Provide detailed report if user answered 'yes'
+                if (choiceString.equalsIgnoreCase("y"))
+                {
+                    System.out.println("\n\n");
+                    for(String result : hdlResults)
+                    {
+                        DSpaceObject dso = HandleManager.resolveToObject(context, result);
+                        
+                        if(dso!=null)
+                        {
+                            System.out.println("REPLACED DSpace " + Constants.typeText[dso.getType()] +
+                                        " [ hdl=" + dso.getHandle() + " ] ");
+                        }
+                    }
+                }
+
+
+            }
+        }
+        else
+        {
+            //otherwise, just one object to replace
+            DSpaceObject dso = sip.replace(context, objToReplace, pkgFile, pkgParams);
+
+            if(dso!=null)
+            {
+                System.out.println("REPLACED DSpace " + Constants.typeText[dso.getType()] +
+                        " [ hdl=" + dso.getHandle() + " ] ");
+            }
+        }
+    }
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/packager/package-info.java
+++ b/dspace-api/src/main/java/org/dspace/app/packager/package-info.java
@@ -0,0 +1,16 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+
+/**
+ * <p>Tools for exporting and importing DSpace objects (Community, Collection,
+ * Item, etc.) wrapped in various kinds of packaging.</p>
+ * 
+ * @see org.dspace.content.packager
+ */
+
+package org.dspace.app.packager;
--- a/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItem.java
+++ b/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItem.java
@@ -0,0 +1,159 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.requestitem;
+
+import org.apache.log4j.Logger;
+import org.dspace.core.Context;
+import org.dspace.core.Utils;
+import org.dspace.storage.rdbms.DatabaseManager;
+import org.dspace.storage.rdbms.TableRow;
+
+import java.sql.SQLException;
+import java.util.Date;
+
+/**
+ * Object representing an Item Request
+ */
+public class RequestItem {
+    private static Logger log = Logger.getLogger(RequestItem.class);
+
+    private int bitstreamId, itemID;
+    private String reqEmail;
+    private String reqName;
+    private String reqMessage;
+    private String token;
+    private boolean allfiles;
+    private Date decision_date;
+    private boolean accept_request;
+
+    public RequestItem(int itemID, int bitstreamId, String reqEmail, String reqName, String reqMessage, boolean allfiles){
+        this.itemID = itemID;
+        this.bitstreamId = bitstreamId;
+        this.reqEmail = reqEmail;
+        this.reqName = reqName;
+        this.reqMessage = reqMessage;
+        this.allfiles = allfiles;
+    }
+
+    private RequestItem(TableRow record) {
+        this.itemID = record.getIntColumn("item_id");
+        this.bitstreamId = record.getIntColumn("bitstream_id");
+        this.token = record.getStringColumn("token");
+        this.reqEmail = record.getStringColumn("request_email");
+        this.reqName = record.getStringColumn("request_name");
+        this.reqMessage = record.getStringColumn("request_message");
+        this.allfiles = record.getBooleanColumn("allfiles");
+        this.decision_date = record.getDateColumn("decision_date");
+        this.accept_request = record.getBooleanColumn("accept_request");
+    }
+
+    public static RequestItem findByToken(Context context, String token) {
+        try {
+            TableRow requestItem = DatabaseManager.findByUnique(context, "requestitem", "token", token);
+            return new RequestItem(requestItem);
+        } catch (SQLException e) {
+            log.error(e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Save updates to the record. Only accept_request, and decision_date are set-able.
+     * @param context
+     */
+    public void update(Context context) {
+        try {
+            TableRow record = DatabaseManager.findByUnique(context, "requestitem", "token", token);
+
+            record.setColumn("accept_request", accept_request);
+            record.setColumn("decision_date", decision_date);
+
+            DatabaseManager.update(context, record);
+
+        } catch (SQLException e) {
+            log.error(e.getMessage());
+        }
+
+    }
+
+    /**
+     * Generate a unique id of the request and put it into the DB
+     * @param context
+     * @return
+     * @throws java.sql.SQLException
+     */
+    public String getNewToken(Context context) throws SQLException
+    {
+        TableRow record = DatabaseManager.create(context, "requestitem");
+        record.setColumn("token", Utils.generateHexKey());
+        record.setColumn("bitstream_id", bitstreamId);
+        record.setColumn("item_id", itemID);
+        record.setColumn("allfiles", allfiles);
+        record.setColumn("request_email", reqEmail);
+        record.setColumn("request_name", reqName);
+        record.setColumn("request_message", reqMessage);
+        record.setColumnNull("accept_request");
+        record.setColumn("request_date", new Date());
+        record.setColumnNull("decision_date");
+        record.setColumnNull("expires");
+
+        DatabaseManager.update(context, record);
+
+        if (log.isDebugEnabled())
+        {
+            log.debug("Created requestitem_token " + record.getIntColumn("requestitem_id")
+                    + " with token " + record.getStringColumn("token") +  "\"");
+        }
+        return record.getStringColumn("token");
+
+    }
+
+    public boolean isAllfiles() {
+        return allfiles;
+    }
+
+    public String getReqMessage() {
+        return reqMessage;
+    }
+
+    public String getReqName() {
+        return reqName;
+    }
+
+    public String getReqEmail() {
+        return reqEmail;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public int getItemID() {
+        return itemID;
+    }
+
+    public int getBitstreamId() {
+        return bitstreamId;
+    }
+
+    public Date getDecision_date() {
+        return decision_date;
+    }
+
+    public void setDecision_date(Date decision_date) {
+        this.decision_date = decision_date;
+    }
+
+    public boolean isAccept_request() {
+        return accept_request;
+    }
+
+    public void setAccept_request(boolean accept_request) {
+        this.accept_request = accept_request;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemAuthor.java
+++ b/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemAuthor.java
@@ -0,0 +1,42 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.requestitem;
+
+import org.dspace.eperson.EPerson;
+
+/**
+ * Simple DTO to transfer data about the corresponding author for the Request
+ * Copy feature
+ * 
+ * @author Andrea Bollini
+ * 
+ */
+public class RequestItemAuthor {
+	private String fullName;
+	private String email;
+
+	public RequestItemAuthor(String fullName, String email) {
+		super();
+		this.fullName = fullName;
+		this.email = email;
+	}
+
+    public RequestItemAuthor(EPerson ePerson) {
+        super();
+        this.fullName = ePerson.getFullName();
+        this.email = ePerson.getEmail();
+    }
+
+	public String getEmail() {
+		return email;
+	}
+
+	public String getFullName() {
+		return fullName;
+	}
+}
--- a/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemAuthorExtractor.java
+++ b/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemAuthorExtractor.java
@@ -0,0 +1,25 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.requestitem;
+
+import java.sql.SQLException;
+
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+/**
+ * Interface to abstract the strategy for select the author to contact for
+ * request copy
+ * 
+ * @author Andrea Bollini
+ * 
+ */
+public interface RequestItemAuthorExtractor {
+	public RequestItemAuthor getRequestItemAuthor(Context context, Item item)
+			throws SQLException;
+}
--- a/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemHelpdeskStrategy.java
+++ b/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemHelpdeskStrategy.java
@@ -0,0 +1,77 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.requestitem;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Item;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.I18nUtil;
+import org.dspace.eperson.EPerson;
+
+import java.sql.SQLException;
+
+/**
+ * RequestItem strategy to allow DSpace support team's helpdesk to receive requestItem request
+ * With this enabled, then the Item author/submitter doesn't receive the request, but the helpdesk instead does.
+ *
+ * Failover to the RequestItemSubmitterStrategy, which means the submitter would get the request if there is no specified helpdesk email.
+ *
+ *  @author Sam Ottenhoff
+ *  @author Peter Dietz
+ */
+public class RequestItemHelpdeskStrategy extends RequestItemSubmitterStrategy {
+
+    private static Logger log = Logger.getLogger(RequestItemHelpdeskStrategy.class);
+
+    public RequestItemHelpdeskStrategy() {}
+
+    @Override
+    public RequestItemAuthor getRequestItemAuthor(Context context, Item item) throws SQLException {
+        boolean helpdeskOverridesSubmitter = ConfigurationManager.getBooleanProperty("request.item.helpdesk.override", false);
+        String helpDeskEmail = ConfigurationManager.getProperty("mail.helpdesk");
+
+        if (helpdeskOverridesSubmitter && StringUtils.isNotBlank(helpDeskEmail)) {
+            return getHelpDeskPerson(context, helpDeskEmail);
+        } else {
+            //Fallback to default logic (author of Item) if helpdesk isn't fully enabled or setup
+            return super.getRequestItemAuthor(context, item);
+        }
+    }
+
+    /**
+     * Return a RequestItemAuthor object for the specified helpdesk email address.
+     * It makes an attempt to find if there is a matching eperson for the helpdesk address, to use the name,
+     * Otherwise it falls back to a helpdeskname key in the Messages.props.
+     * @param context
+     * @param helpDeskEmail
+     * @return
+     */
+    public RequestItemAuthor getHelpDeskPerson(Context context, String helpDeskEmail) throws SQLException{
+        EPerson helpdeskEPerson = null;
+
+        try {
+            context.turnOffAuthorisationSystem();
+            helpdeskEPerson = EPerson.findByEmail(context, helpDeskEmail);
+            context.restoreAuthSystemState();
+        } catch (AuthorizeException e) {
+            log.error(e.getMessage());
+        }
+
+        if(helpdeskEPerson != null) {
+            return new RequestItemAuthor(helpdeskEPerson);
+        } else {
+            String helpdeskName = I18nUtil.getMessage(
+                "org.dspace.app.requestitem.RequestItemHelpdeskStrategy.helpdeskname",
+                context);
+            return new RequestItemAuthor(helpdeskName, helpDeskEmail);
+        }
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemMetadataStrategy.java
+++ b/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemMetadataStrategy.java
@@ -0,0 +1,75 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.requestitem;
+
+import java.sql.SQLException;
+
+import org.apache.commons.lang.StringUtils;
+import org.dspace.content.Metadatum;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.dspace.core.I18nUtil;
+
+/**
+ * Try to look to an item metadata for the corresponding author name and email.
+ * Failover to the RequestItemSubmitterStrategy
+ * 
+ * @author Andrea Bollini
+ * 
+ */
+public class RequestItemMetadataStrategy extends RequestItemSubmitterStrategy {
+
+	private String emailMetadata;
+	private String fullNameMatadata;
+
+	public RequestItemMetadataStrategy() {
+	}
+
+	@Override
+	public RequestItemAuthor getRequestItemAuthor(Context context, Item item)
+			throws SQLException {
+		if (emailMetadata != null)
+		{
+			Metadatum[] vals = item.getMetadataByMetadataString(emailMetadata);
+			if (vals.length > 0)
+			{
+				String email = vals[0].value;
+				String fullname = null;
+				if (fullNameMatadata != null)
+				{
+					Metadatum[] nameVals = item.getMetadataByMetadataString(fullNameMatadata);
+					if (nameVals.length > 0)
+					{
+						fullname = nameVals[0].value;
+					}
+				}
+				
+				if (StringUtils.isBlank(fullname))
+				{
+					fullname = I18nUtil
+							.getMessage(
+									"org.dspace.app.requestitem.RequestItemMetadataStrategy.unnamed",
+									context);					
+				}
+				RequestItemAuthor author = new RequestItemAuthor(
+						fullname, email);
+				return author;
+			}
+		}
+		return super.getRequestItemAuthor(context, item);
+	}
+
+	public void setEmailMetadata(String emailMetadata) {
+		this.emailMetadata = emailMetadata;
+	}
+
+	public void setFullNameMatadata(String fullNameMatadata) {
+		this.fullNameMatadata = fullNameMatadata;
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemSubmitterStrategy.java
+++ b/dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemSubmitterStrategy.java
@@ -0,0 +1,36 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.requestitem;
+
+import java.sql.SQLException;
+
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+
+/**
+ * Basic strategy that looks to the original submitter.
+ * 
+ * @author Andrea Bollini
+ *
+ */
+public class RequestItemSubmitterStrategy implements RequestItemAuthorExtractor {
+
+	public RequestItemSubmitterStrategy() {		
+	}
+
+	@Override
+	public RequestItemAuthor getRequestItemAuthor(Context context, Item item)
+			throws SQLException {
+		EPerson submitter = item.getSubmitter();
+		RequestItemAuthor author = new RequestItemAuthor(
+				submitter.getFullName(), submitter.getEmail());
+		return author;
+	}
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/sfx/SFXFileReader.java
+++ b/dspace-api/src/main/java/org/dspace/app/sfx/SFXFileReader.java
@@ -0,0 +1,340 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.sfx;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URLEncoder;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.w3c.dom.Document;
+
+import org.dspace.content.DCPersonName;
+import org.dspace.content.Metadatum;
+import org.dspace.content.Item;
+import org.dspace.core.Constants;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+/**
+ * XML configuration file reader for DSpace metadata fields (DC) mapping
+ * to OpenURL parameters.
+ * <p>
+ * This class reads the [dspace]/config/sfx.xml configuration file, which
+ * contains pairs of DSpace item metadata values and OpenURL parameter names.
+ * Then it takes an item and constructs an OpenURL for it with values of
+ * parameters filled in from the paired metadata fields.
+ * </p>
+ *
+ * @author Stuart Lewis
+ * @author Graham Triggs
+ * @version $Revision$
+ */
+
+public class SFXFileReader {
+
+    /** The SFX configuration file */
+    private static Document doc;
+
+    /** log4j logger */
+    private static final Logger log = Logger.getLogger(SFXFileReader.class);
+
+
+    /**
+     * Loads the SFX configuration file
+     *
+     * @param fileName The name of the SFX configuration file
+     * @param item The item to process, from which metadata values will be taken
+     *
+     * @return the SFX string
+     * @throws IOException
+     */
+    public static String loadSFXFile(String fileName, Item item) throws IOException
+    {
+        // Parse XML file -> XML document will be built
+        if (doc == null)
+        {
+            doc = parseFile(fileName);
+        }
+
+        // Return final sfx Query String
+        return  doNodes(doc, item);
+    }
+
+   /** Parses XML file and returns XML document.
+    * @param fileName XML file to parse
+    * @return XML document or <B>null</B> if error occurred. The error is caught and logged.
+    */
+
+   public static Document parseFile(String fileName) {
+	log.info("Parsing XML file... " + fileName);
+       DocumentBuilder docBuilder;
+       Document doc = null;
+       DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
+       docBuilderFactory.setIgnoringElementContentWhitespace(true);
+       try {
+           docBuilder = docBuilderFactory.newDocumentBuilder();
+       }
+       catch (ParserConfigurationException e) {
+	    log.error("Wrong parser configuration: " + e.getMessage());
+           return null;
+       }
+       File sourceFile = new File(fileName);
+       try {
+           doc = docBuilder.parse(sourceFile);
+       }
+       catch (SAXException e) {
+           log.error("Wrong XML file structure: " + e.getMessage());
+           return null;
+       }
+       catch (IOException e) {
+           log.error("Could not read source file: " + e.getMessage());
+       }
+       log.info("XML file parsed");
+       return doc;
+   }
+
+    /**
+     * Process the item, mapping each of its metadata fields defined in the
+     * configuration file to an OpenURL parameter
+     *
+     * @param node DOM node of the mapping pair in the XML file (field element)
+     * @param item The item to process, from which metadata values will be taken
+     * @return processed fields.
+     * @throws IOException
+     */
+   public static String doNodes(Node node, Item item) throws IOException
+   {
+        if (node == null)
+        {
+	    log.error (" Empty Node ");
+            return null;
+        }
+        Node e = getElement(node);
+        NodeList nl = e.getChildNodes();
+        int len = nl.getLength();
+        String sfxfield = "";
+        int i = 0;
+
+        while ((i < len) && StringUtils.isEmpty(sfxfield))
+        {
+            Node nd = nl.item(i);
+            if ((nd == null) || isEmptyTextNode(nd))
+            {
+                i++;
+                continue;
+            }
+            String tagName = nd.getNodeName();
+            if (tagName.equals("query-pairs"))
+            {
+                sfxfield = processFields(nd, item);
+
+            }
+            i++;
+        }
+           log.info("Process fields : " + sfxfield);
+        return sfxfield;
+   }
+
+    /**
+     * Process the field nodes, mapping each metadata field defined in the
+     * configuration file to an OpenURL parameter
+     *
+     * @param e DOM node of the mapping pair in the XML file (field element)
+     * @param item The item to process, from which metadata values will be taken
+     * @return assembled OpenURL query.
+     * @throws IOException
+     */
+   private static String processFields(Node e, Item item) throws IOException
+   {
+        NodeList cl = e.getChildNodes();
+        int lench = cl.getLength();
+        String  myquery = "";
+
+        for (int j = 0; j < lench; j++)
+        {
+            Node nch = cl.item(j);
+            String querystring = "";
+            String schema = "";
+            String qualifier = "";
+            String element = "";
+
+            if (nch.getNodeName().equals("field"))
+            {
+                NodeList pl = nch.getChildNodes();
+                int plen = pl.getLength();
+                int finish = 0;
+                for (int k = 0; k < plen; k++)
+                {
+                    Node vn= pl.item(k);
+                    String vName = vn.getNodeName();
+                    if (vName.equals("querystring"))
+                    {
+                        querystring = getValue(vn);
+                        finish ++;
+                    }
+                    else if (vName.equals("dc-schema"))
+                    {
+                        schema = getValue(vn);
+                        finish ++;
+                        }
+                        else if (vName.equals("dc-element"))
+                        {
+                            element = getValue(vn);
+                            finish ++;
+                        }
+                        else if (vName.equals("dc-qualifier"))
+                        {
+                            qualifier = getValue(vn);
+                            finish ++;
+                            if (StringUtils.isEmpty(qualifier))
+                            {
+                                qualifier = null;
+                            }
+                        }
+                        if (finish == 4)
+                        {
+                        Metadatum[] dcvalue = item.getMetadata(schema, element, qualifier, Item.ANY);
+                        if (dcvalue.length > 0)
+                            {
+                            // Issued Date
+                                if (element.equals("date") && qualifier.equals("issued"))
+                            {
+                            String fullDate = dcvalue[0].value;
+                            // Remove the time if there is one - day is greatest granularity for SFX
+                                if (fullDate.length() > 10)
+                                {
+                                     fullDate = fullDate.substring(0, 10);
+                                }
+                                if (myquery.equals(""))
+                                { myquery = querystring + URLEncoder.encode(fullDate, Constants.DEFAULT_ENCODING); }
+                                else
+                                { myquery =  myquery + "&" + querystring + URLEncoder.encode(fullDate, Constants.DEFAULT_ENCODING); }
+                            }
+                            else
+                            {
+                                // Contributor Author
+                                if (element.equals("contributor") && qualifier.equals("author"))
+                                    {
+                                    DCPersonName dpn = new DCPersonName(dcvalue[0].value);
+                                        String dpnName = dcvalue[0].value;
+
+                                        if (querystring.endsWith("aulast="))  { dpnName = dpn.getLastName(); }
+                                        else { if (querystring.endsWith("aufirst=")) { dpnName = dpn.getFirstNames(); }}
+
+                                    if (myquery.equals(""))
+                                    { myquery = querystring + URLEncoder.encode(dpnName, Constants.DEFAULT_ENCODING); }
+                                            else
+                                    { myquery =  myquery + "&" + querystring + URLEncoder.encode(dpnName, Constants.DEFAULT_ENCODING); }
+                                }
+                                else
+                                {
+                                    if (myquery.equals(""))
+                                    { myquery =  querystring + URLEncoder.encode(dcvalue[0].value, Constants.DEFAULT_ENCODING);}
+                                    else
+                                        { myquery =  myquery + "&" + querystring + URLEncoder.encode(dcvalue[0].value, Constants.DEFAULT_ENCODING);}
+                                    }
+                                }
+                            } // if dc.length > 0
+
+                    finish = 0;
+                        querystring = "";
+                    schema = "";
+                        element = "";
+                    qualifier = "";
+                    } // if finish == 4
+                } //for k
+            } // if field
+        } // for j
+        return myquery;
+   }
+
+   /** Returns element node
+    * @param node element (it is XML tag)
+    * @return Element node otherwise null
+    */
+  public static Node getElement(Node node)
+  {
+       NodeList child = node.getChildNodes();
+       int length = child.getLength();
+       for (int i = 0; i < length; i++)
+       {
+   	    Node kid = child.item(i);
+   	    if (kid.getNodeType() == Node.ELEMENT_NODE)
+   	    {
+   	    	return kid;
+         }
+       }
+       return null;
+  }
+
+		/** Is Empty text Node **/
+   public static 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>
+   **/
+   public static String getAttribute(Node e, String name)
+   {
+   	NamedNodeMap attrs = e.getAttributes();
+   	int len = attrs.getLength();
+   	if (len > 0)
+   	{
+   		for (int 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.
+   */
+   public static String getValue(Node node)
+   {
+   	NodeList child = node.getChildNodes();
+   	for (int i = 0; i < child.getLength(); i++)
+   	{
+   		Node kid = child.item(i);
+   		short type = kid.getNodeType();
+   		if (type == Node.TEXT_NODE)
+   		{
+		    return kid.getNodeValue().trim();
+   		}
+   	}
+   	// Didn't find a text node
+   	return null;
+   }
+}
--- a/dspace-api/src/main/java/org/dspace/app/sfx/package-info.java
+++ b/dspace-api/src/main/java/org/dspace/app/sfx/package-info.java
@@ -0,0 +1,16 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+
+/**
+ * <p>SFX/OpenURL link server support.</p>
+ * 
+ * @see org.dspace.app.webui.jsptag.SFXLinkTag
+ * @see org.dspace.app.xmlui.aspect.artifactbrowser.ItemViewer
+ */
+
+package org.dspace.app.sfx;
--- a/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAJournal.java
+++ b/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAJournal.java
@@ -0,0 +1,56 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.sherpa;
+
+/**
+ * POJO representation for a SHERPA journal
+ * 
+ * @author Andrea Bollini
+ * 
+ */
+public class SHERPAJournal
+{
+    private String title;
+
+    private String issn;
+
+    private String zetopub;
+
+    private String romeopub;
+
+    public SHERPAJournal(String title, String issn, String zetopub,
+            String romeopub)
+    {
+        super();
+        this.title = title;
+        this.issn = issn;
+        this.zetopub = zetopub;
+        this.romeopub = romeopub;
+    }
+
+    public String getTitle()
+    {
+        return title;
+    }
+
+    public String getIssn()
+    {
+        return issn;
+    }
+
+    public String getZetopub()
+    {
+        return zetopub;
+    }
+
+    public String getRomeopub()
+    {
+        return romeopub;
+    }
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAPublisher.java
+++ b/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAPublisher.java
@@ -0,0 +1,183 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.sherpa;
+
+import java.util.List;
+
+/**
+ * POJO representation for a SHERPA Publisher record
+ * 
+ * @author Andrea Bollini
+ * 
+ */
+public class SHERPAPublisher
+{
+    private String name;
+
+    private String alias;
+
+    private String homeurl;
+
+    private String prearchiving;
+
+    private List<String> prerestriction;
+
+    private String postarchiving;
+
+    private List<String> postrestriction;
+
+    private String pubarchiving;
+
+    private List<String> pubrestriction;
+    
+    private List<String> condition;
+
+    private String paidaccessurl;
+
+    private String paidaccessname;
+
+    private String paidaccessnotes;
+
+    private List<String[]> copyright;
+
+    private String romeocolour;
+
+    private String dateadded;
+
+    private String dateupdated;
+
+    public SHERPAPublisher(String name, String alias, String homeurl,
+            String prearchiving, List<String> prerestriction,
+            String postarchiving, List<String> postrestriction,
+            String pubarchiving, List<String> pubrestriction,
+            List<String> condition, String paidaccessurl,
+            String paidaccessname, String paidaccessnotes,
+            List<String[]> copyright, String romeocolour, String datedded,
+            String dateupdated)
+    {
+        this.name = name;
+
+        this.alias = alias;
+
+        this.homeurl = homeurl;
+
+        this.prearchiving = prearchiving;
+
+        this.prerestriction = prerestriction;
+
+        this.postarchiving = postarchiving;
+
+        this.postrestriction = postrestriction;
+
+        this.pubarchiving = pubarchiving;
+
+        this.pubrestriction = pubrestriction;
+
+        this.condition = condition;
+
+        this.paidaccessurl = paidaccessurl;
+
+        this.paidaccessname = paidaccessname;
+
+        this.paidaccessnotes = paidaccessnotes;
+
+        this.copyright = copyright;
+
+        this.romeocolour = romeocolour;
+
+        this.dateadded = datedded;
+
+        this.dateupdated = dateupdated;
+    }
+
+    public String getName()
+    {
+        return name;
+    }
+
+    public String getAlias()
+    {
+        return alias;
+    }
+
+    public String getHomeurl()
+    {
+        return homeurl;
+    }
+
+    public String getPrearchiving()
+    {
+        return prearchiving;
+    }
+
+    public List<String> getPrerestriction()
+    {
+        return prerestriction;
+    }
+
+    public String getPostarchiving()
+    {
+        return postarchiving;
+    }
+
+    public List<String> getPostrestriction()
+    {
+        return postrestriction;
+    }
+
+    public String getPubarchiving()
+    {
+        return pubarchiving;
+    }
+    
+    public List<String> getPubrestriction()
+    {
+        return pubrestriction;
+    }
+    
+    public List<String> getCondition()
+    {
+        return condition;
+    }
+
+    public String getPaidaccessurl()
+    {
+        return paidaccessurl;
+    }
+
+    public String getPaidaccessname()
+    {
+        return paidaccessname;
+    }
+
+    public String getPaidaccessnotes()
+    {
+        return paidaccessnotes;
+    }
+
+    public List<String[]> getCopyright()
+    {
+        return copyright;
+    }
+
+    public String getRomeocolour()
+    {
+        return romeocolour;
+    }
+
+    public String getDatedded()
+    {
+        return dateadded;
+    }
+
+    public String getDateupdated()
+    {
+        return dateupdated;
+    }
+
+}
--- a/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAResponse.java
+++ b/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAResponse.java
@@ -0,0 +1,223 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.sherpa;
+
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.apache.commons.lang.StringUtils;
+import org.dspace.app.util.XMLUtils;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * JAVA representation for a SHERPA API Response
+ * 
+ * @author Andrea Bollini
+ * 
+ */
+public class SHERPAResponse
+{
+    private boolean error;
+
+    private String message;
+
+    private String license;
+
+    private String licenseURL;
+
+    private String disclaimer;
+
+    private List<SHERPAJournal> journals;
+
+    private List<SHERPAPublisher> publishers;
+
+    public SHERPAResponse(InputStream xmlData)
+    {
+        try
+        {
+            DocumentBuilderFactory factory = DocumentBuilderFactory
+                    .newInstance();
+            factory.setValidating(false);
+            factory.setIgnoringComments(true);
+            factory.setIgnoringElementContentWhitespace(true);
+
+            DocumentBuilder db = factory.newDocumentBuilder();
+            Document inDoc = db.parse(xmlData);
+
+            Element xmlRoot = inDoc.getDocumentElement();
+            Element dataRoot = XMLUtils.getSingleElement(xmlRoot, "romeoapi");
+
+            Element headersElement = XMLUtils.getSingleElement(xmlRoot,
+                    "header");
+            Element journalsElement = XMLUtils.getSingleElement(xmlRoot,
+                    "journals");
+            Element publishersElement = XMLUtils.getSingleElement(xmlRoot,
+                    "publishers");
+
+            message = XMLUtils.getElementValue(headersElement, "message");
+
+            if (StringUtils.isNotBlank(message))
+            {
+                error = true;
+                return;
+            }
+
+            license = XMLUtils.getElementValue(headersElement, "license");
+            licenseURL = XMLUtils.getElementValue(headersElement, "licenseurl");
+            disclaimer = XMLUtils.getElementValue(headersElement, "disclaimer");
+
+            List<Element> journalsList = XMLUtils.getElementList(
+                    journalsElement, "journal");
+            List<Element> publishersList = XMLUtils.getElementList(
+                    publishersElement, "publisher");
+
+            if (journalsList != null)
+            {
+                journals = new LinkedList<SHERPAJournal>();
+                for (Element journalElement : journalsList)
+                {
+                    journals.add(new SHERPAJournal(
+                            XMLUtils.getElementValue(journalElement, "jtitle"),
+                            XMLUtils.getElementValue(journalElement, "issn"),
+                            XMLUtils.getElementValue(journalElement, "zetopub"),
+                            XMLUtils.getElementValue(journalElement, "romeopub")));
+                }
+            }
+
+            if (publishersList != null)
+            {
+                publishers = new LinkedList<SHERPAPublisher>();
+                for (Element publisherElement : publishersList)
+                {
+                    Element preprintsElement = XMLUtils.getSingleElement(
+                            publisherElement, "preprints");
+                    Element preprintsRestrictionElement = XMLUtils
+                            .getSingleElement(publisherElement,
+                                    "prerestrictions");
+
+                    Element postprintsElement = XMLUtils.getSingleElement(
+                            publisherElement, "postprints");
+                    Element postprintsRestrictionElement = XMLUtils
+                            .getSingleElement(publisherElement,
+                                    "postrestrictions");
+
+                    Element pdfversionElement = XMLUtils.getSingleElement(
+                            publisherElement, "pdfversion");
+                    Element pdfversionRestrictionElement = XMLUtils
+                            .getSingleElement(publisherElement,
+                                    "pdfrestrictions");
+                    
+                    Element conditionsElement = XMLUtils.getSingleElement(
+                            publisherElement, "conditions");
+                    Element paidaccessElement = XMLUtils.getSingleElement(
+                            publisherElement, "paidaccess");
+
+                    Element copyrightlinksElement = XMLUtils.getSingleElement(
+                            publisherElement, "copyrightlinks");
+
+                    publishers
+                            .add(new SHERPAPublisher(XMLUtils.getElementValue(
+                                    publisherElement, "name"),
+                                    XMLUtils.getElementValue(publisherElement,
+                                            "alias"), XMLUtils.getElementValue(
+                                            publisherElement, "homeurl"),
+                                            
+                                    XMLUtils.getElementValue(preprintsElement,
+                                            "prearchiving"),
+                                    XMLUtils.getElementValueList(
+                                            preprintsRestrictionElement,
+                                            "prerestriction"),
+                                            
+                                    XMLUtils.getElementValue(postprintsElement,
+                                            "postarchiving"),
+                                    XMLUtils.getElementValueList(
+                                            postprintsRestrictionElement,
+                                            "postrestriction"),
+                                            
+                                    XMLUtils.getElementValue(pdfversionElement,
+                                            "pdfarchiving"),
+                                    XMLUtils.getElementValueList(
+                                            pdfversionRestrictionElement,
+                                            "pdfrestriction"), 
+                                    
+                                    XMLUtils
+                                            .getElementValueList(
+                                                    conditionsElement,
+                                                    "condition"), XMLUtils
+                                            .getElementValue(paidaccessElement,
+                                                    "paidaccessurl"), XMLUtils
+                                            .getElementValue(paidaccessElement,
+                                                    "paidaccessname"), XMLUtils
+                                            .getElementValue(paidaccessElement,
+                                                    "paidaccessnotes"),
+                                    XMLUtils.getElementValueArrayList(
+                                            copyrightlinksElement,
+                                            "copyrightlink",
+                                            "copyrightlinktext",
+                                            "copyrightlinkurl"), XMLUtils
+                                            .getElementValue(publisherElement,
+                                                    "romeocolour"), XMLUtils
+                                            .getElementValue(publisherElement,
+                                                    "dateadded"), XMLUtils
+                                            .getElementValue(publisherElement,
+                                                    "dateupdated")));
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            error = true;
+        }
+    }
+
+    public SHERPAResponse(String message)
+    {
+        this.message = message;
+        this.error = true;
+    }
+
+    public boolean isError()
+    {
+        return error;
+    }
+
+    public String getMessage()
+    {
+        return message;
+    }
+
+    public String getLicense()
+    {
+        return license;
+    }
+
+    public String getLicenseURL()
+    {
+        return licenseURL;
+    }
+
+    public String getDisclaimer()
+    {
+        return disclaimer;
+    }
+
+    public List<SHERPAJournal> getJournals()
+    {
+        return journals;
+    }
+
+    public List<SHERPAPublisher> getPublishers()
+    {
+        return publishers;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAService.java
+++ b/dspace-api/src/main/java/org/dspace/app/sherpa/SHERPAService.java
@@ -0,0 +1,105 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.sherpa;
+
+import org.apache.http.HttpStatus;
+import org.apache.http.config.SocketConfig;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.commons.lang.StringUtils;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.log4j.Logger;
+import org.dspace.core.ConfigurationManager;
+
+public class SHERPAService
+{
+    private CloseableHttpClient client = null;
+
+    private int maxNumberOfTries;
+    private long sleepBetweenTimeouts;
+    private int timeout;
+
+    /** log4j category */
+    private static final Logger log = Logger.getLogger(SHERPAService.class);
+
+    public SHERPAService() {
+        HttpClientBuilder custom = HttpClients.custom();
+        // httpclient 4.3+ doesn't appear to have any sensible defaults any more. Setting conservative defaults as not to hammer the SHERPA service too much.
+        client=custom.disableAutomaticRetries().setMaxConnTotal(5).setDefaultSocketConfig(SocketConfig.custom().setSoTimeout(timeout).build()).build();
+
+    }
+
+
+    public SHERPAResponse searchByJournalISSN(String query)
+    {
+        String endpoint = ConfigurationManager.getProperty("sherpa.romeo.url");
+        String apiKey = ConfigurationManager.getProperty("sherpa.romeo.apikey");
+
+        HttpGet method = null;
+        SHERPAResponse sherpaResponse = null;
+        int numberOfTries = 0;
+
+        while(numberOfTries<maxNumberOfTries && sherpaResponse==null) {
+            numberOfTries++;
+
+            try {
+                Thread.sleep(sleepBetweenTimeouts * (numberOfTries-1));
+
+                URIBuilder uriBuilder = new URIBuilder(endpoint);
+                uriBuilder.addParameter("issn", query);
+                uriBuilder.addParameter("versions", "all");
+                if (StringUtils.isNotBlank(apiKey))
+                    uriBuilder.addParameter("ak", apiKey);
+
+                method = new HttpGet(uriBuilder.build());
+
+                // Execute the method.
+
+                HttpResponse response = client.execute(method);
+                int statusCode = response.getStatusLine().getStatusCode();
+
+                if (statusCode != HttpStatus.SC_OK) {
+                    sherpaResponse = new SHERPAResponse("SHERPA/RoMEO return not OK status: "
+                            + statusCode);
+                }
+
+                HttpEntity responseBody = response.getEntity();
+
+                if (null != responseBody)
+                    sherpaResponse = new SHERPAResponse(responseBody.getContent());
+                else
+                    sherpaResponse = new SHERPAResponse("SHERPA/RoMEO returned no response");
+            } catch (Exception e) {
+                log.error(e.getMessage(),e);
+            }
+        }
+
+        if(sherpaResponse==null){
+            sherpaResponse = new SHERPAResponse(
+                    "Error processing the SHERPA/RoMEO answer");
+        }
+
+        return sherpaResponse;
+    }
+
+    public void setMaxNumberOfTries(int maxNumberOfTries) {
+        this.maxNumberOfTries = maxNumberOfTries;
+    }
+
+    public void setSleepBetweenTimeouts(long sleepBetweenTimeouts) {
+        this.sleepBetweenTimeouts = sleepBetweenTimeouts;
+    }
+
+    public void setTimeout(int timeout) {
+        this.timeout = timeout;
+    }
+}
--- a/dspace-api/src/main/java/org/dspace/app/sherpa/submit/ISSNItemExtractor.java
+++ b/dspace-api/src/main/java/org/dspace/app/sherpa/submit/ISSNItemExtractor.java
@@ -0,0 +1,18 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.sherpa.submit;
+
+import java.util.List;
+
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+
+public interface ISSNItemExtractor
+{
+    public List<String> getISSNs(Context context, Item item);
+}
--- a/Show More
+++ b/Show More