Bibliographic external database feature on submission - DS-1252

dspace-api/pom.xml

@@ -517,6 +517,18 @@
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
         </dependency>
+
+		<dependency>
+	    	<groupId>backport-util-concurrent</groupId>
+	    	<artifactId>backport-util-concurrent</artifactId>
+	    	<version>3.1</version>
+		</dependency>
+
+        <dependency>
+            <groupId>net.sf.flexjson</groupId>
+            <artifactId>flexjson</artifactId>            
+        </dependency>
+        
     </dependencies>
 
 </project>

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

@@ -189,4 +189,4 @@ public class XMLUtils
         }
         return result;
     }
-}
+}

dspace-api/src/main/java/org/dspace/submit/importer/ImportResultBean.java

@@ -0,0 +1,87 @@
+package org.dspace.submit.importer;
+
+import java.util.List;
+
+public class ImportResultBean
+{
+    private boolean scheduled;
+
+    private int tot;
+
+    private int failure;
+
+    private int success;
+
+    private int warning;
+
+    private List<SingleImportResultBean> details;
+
+    public boolean isScheduled()
+    {
+        return scheduled;
+    }
+
+    public void setScheduled(boolean scheduled)
+    {
+        this.scheduled = scheduled;
+    }
+
+    public int getTot()
+    {
+        return tot;
+    }
+
+    public void setTot(int tot)
+    {
+        this.tot = tot;
+    }
+
+    public int getFailure()
+    {
+        return failure;
+    }
+
+    public int getSuccess()
+    {
+        return success;
+    }
+
+    public int getWarning()
+    {
+        return warning;
+    }
+
+    public List<SingleImportResultBean> getDetails()
+    {
+        return details;
+    }
+
+    public void setDetails(List<SingleImportResultBean> details)
+    {
+        this.details = details;
+        int success = 0;
+        int failure = 0;
+        int warning = 0;
+        if (details != null)
+        {
+            for (SingleImportResultBean result : details)
+            {
+                switch (result.getStatus())
+                {
+                case SingleImportResultBean.ERROR:
+                    failure++;
+                    break;
+                case SingleImportResultBean.WARNING:
+                    warning++;
+                    break;
+                case SingleImportResultBean.SUCCESS:
+                    success++;
+                    break;
+                }
+            }
+        }
+        this.failure = failure;
+        this.success = success;
+        this.warning = warning;
+    }
+}

dspace-api/src/main/java/org/dspace/submit/importer/Importer.java

@@ -0,0 +1,8 @@
+package org.dspace.submit.importer;
+
+import org.dspace.eperson.EPerson;
+
+public interface Importer
+{
+    public ImportResultBean ingest(String data, EPerson eperson);
+}

dspace-api/src/main/java/org/dspace/submit/importer/ImporterException.java

@@ -0,0 +1,42 @@
+package org.dspace.submit.importer;
+
+public class ImporterException extends RuntimeException {
+	
+	private int total;
+	
+	private int limit;
+	
+		private String pluginName;
+	
+	public ImporterException(String cause, int tot, int limit, String pluginName) {
+		super(cause);
+		this.total = tot;
+		this.limit = limit;
+		this.pluginName = pluginName;
+	}
+
+   	public int getTotal() {
+		return total;
+	}
+
+	public void setTotal(int total) {
+		this.total = total;
+	}
+
+	public int getLimit() {
+		return limit;
+	}
+
+	public void setLimit(int limit) {
+		this.limit = limit;
+	}
+
+	public String getPluginName() {
+		return pluginName;
+	}
+
+	public void setPluginName(String pluginName) {
+		this.pluginName = pluginName;
+	}
+
+}

dspace-api/src/main/java/org/dspace/submit/importer/ItemImport.java

@@ -0,0 +1,17 @@
+package org.dspace.submit.importer;
+/*
+ *  Per ogni item che viene importato viene effettuato
+ *  il set del metadato dc.identifier.source e il nome 
+ *  della classe istanziata.
+ *  Tutti gli _importer estendono questa classe.
+ */
+public interface ItemImport {
+
+	public void setSource(String source);
+
+	public String getSource();
+
+	public void setRecord(String record);
+
+	public String getRecord();
+}

dspace-api/src/main/java/org/dspace/submit/importer/SingleImportResultBean.java

@@ -0,0 +1,57 @@
+package org.dspace.submit.importer;
+
+public class SingleImportResultBean
+{
+    public static final int ERROR = 2;
+
+    public static final int WARNING = 1;
+
+    public static final int SUCCESS = 0;
+
+    private int status;
+
+    private int witemId;
+
+    private String message;
+
+    private String importIdentifier;
+
+    private String importData;
+
+    public SingleImportResultBean(int status, int itemId, String message,
+            String importIdentifier, String importData)
+    {
+        super();
+        this.status = status;
+        this.witemId = itemId;
+        this.message = message;
+        this.importIdentifier = importIdentifier;
+        this.importData = importData;
+    }
+
+    public int getStatus()
+    {
+        return status;
+    }
+
+    public int getWitemId()
+    {
+        return witemId;
+    }
+
+    public String getMessage()
+    {
+        return message;
+    }
+
+    public String getImportIdentifier()
+    {
+        return importIdentifier;
+    }
+
+    public String getImportData()
+    {
+        return importData;
+    }
+
+}

dspace-api/src/main/java/org/dspace/submit/importer/arxiv/ArXivItem.java

@@ -0,0 +1,208 @@
+package org.dspace.submit.importer.arxiv;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.dspace.app.util.XMLUtils;
+import org.dspace.submit.importer.ItemImport;
+import org.jdom.JDOMException;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+public class ArXivItem implements ItemImport {
+	
+	// Nome della classe istanziata
+	private String source;
+	// Valore del metadato source
+	private String record;
+
+    private List<String[]> authors = new LinkedList<String[]>();
+
+    private String year;
+
+    private String articleTitle;
+
+    private String splashPageUrl;
+
+    private String comment;
+
+    private String summary;
+
+    private String pdfUrl;
+    
+    private String journalRef;
+    
+    private String doi;
+
+    private List<String> primaryCategory = new LinkedList<String>();
+
+    private List<String> category = new LinkedList<String>();
+
+    public ArXivItem(Element dataRoot) throws JDOMException, IOException,
+            ParserConfigurationException, SAXException
+    {
+        articleTitle = XMLUtils.getElementValue(dataRoot, "title");
+        summary = XMLUtils.getElementValue(dataRoot, "summary");
+        year = XMLUtils.getElementValue(dataRoot, "published");
+        splashPageUrl = XMLUtils.getElementValue(dataRoot, "id");
+        comment= XMLUtils.getElementValue(dataRoot, "arxiv:comment");
+
+        List<Element> links = XMLUtils.getElementList(dataRoot, "link");
+        if (links != null)
+        {
+            for (Element link : links)
+            {
+                if ("related".equals(link.getAttribute("rel")) && "pdf".equals(link.getAttribute("title")))
+                {
+                        pdfUrl = link.getAttribute("href");
+                }
+            }
+        }
+        
+        doi = XMLUtils.getElementValue(dataRoot, "arxiv:doi");
+        journalRef = XMLUtils.getElementValue(dataRoot, "arxiv:journal_ref");
+        
+        List<Element> primaryCategoryList = XMLUtils.getElementList(dataRoot, "arxiv:primary_category");
+        if (primaryCategoryList != null)
+        {
+            for (Element primaryCategoryElement : primaryCategoryList)
+            {
+                primaryCategory.add(primaryCategoryElement.getAttribute("term"));
+            }
+        }
+        
+        List<Element> categoryList = XMLUtils.getElementList(dataRoot, "category");
+        if (categoryList != null)
+        {
+            for (Element categoryElement : categoryList)
+            {
+                category.add(categoryElement.getAttribute("term"));
+            }
+        }
+        
+        List<Element> authorList = XMLUtils.getElementList(dataRoot, "author");
+        if (authorList != null)
+        {
+            for (Element authorElement : authorList)
+            {
+                String nomeCompleto = authorElement.getTextContent();
+                String[] nomeSplit = nomeCompleto.split("\\s+");
+                String nome = "";
+                String cognome = "";
+                if (nomeSplit.length > 2)
+                {
+                    String senzaPunti = nomeCompleto.replace("\\.", "");
+                    String[] tmp = senzaPunti.split("\\s+");
+                   
+                    int start = 1;
+                    if (tmp.length == nomeSplit.length)
+                    {
+                        for (int idx = 2; idx < tmp.length; idx++)
+                        {
+                            if (tmp[idx].length() > 1)
+                            {
+                                start = idx;
+                            }
+                        }
+                    }
+                    for (int i = 0; i < start; i++)
+                    {
+                        nome += nomeSplit[i];
+                    }
+                    for (int i = start; i < nomeSplit.length; i++)
+                    {
+                        cognome += nomeSplit[i];
+                    }
+                }
+                else if (nomeSplit.length == 2)
+                {
+                    nome = nomeSplit[0];
+                    cognome = nomeSplit[1];
+                }
+                else
+                {
+                    cognome = nomeCompleto;
+                }
+                authors.add(new String[]{nome, cognome});
+            }
+        }
+    }
+
+    public List<String[]> getAuthors()
+    {
+        return authors;
+    }
+
+    public String getYear()
+    {
+        return year;
+    }
+    
+    public String getArticleTitle()
+    {
+        return articleTitle;
+    }
+
+    public String getSplashPageUrl()
+    {
+        return splashPageUrl;
+    }
+
+    public String getComment()
+    {
+        return comment;
+    }
+
+    public String getSummary()
+    {
+        return summary;
+    }
+
+    public String getPdfUrl()
+    {
+        return pdfUrl;
+    }
+
+    public String getDoi()
+    {
+        return doi;
+    }
+    
+    public String getJournalRef()
+    {
+        return journalRef;
+    }
+    
+    public List<String> getPrimaryCategory()
+    {
+        return primaryCategory;
+    }
+
+    public List<String> getCategory()
+    {
+        return category;
+    }
+
+	@Override
+	public void setSource(String source) {
+		this.source = source;
+	}
+
+	@Override
+	public void setRecord(String record) {
+		this.record = record;
+	}
+
+	@Override
+	public String getRecord() {
+		return record;
+	}
+	
+	@Override
+	public String getSource() {
+		return source;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/importer/crossref/CrossrefItem.java

@@ -0,0 +1,284 @@
+package org.dspace.submit.importer.crossref;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.lang.StringUtils;
+import org.dspace.app.util.XMLUtils;
+import org.dspace.submit.importer.ItemImport;
+import org.jdom.JDOMException;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+public class CrossrefItem implements ItemImport
+{
+	// Nome della classe istanziata
+	private String source;
+	// Valore del metadato source
+	private String record;
+	
+    private String doi;
+
+    private String itemType;
+
+    private String issn;
+
+    private String eissn;
+
+    private String isbn;
+
+    private String seriesTitle;
+
+    private String journalTitle;
+
+    private String volumeTitle;
+
+    private List<String[]> authors = new LinkedList<String[]>();
+
+    private List<String[]> editors = new LinkedList<String[]>();
+
+    private List<String[]> translators = new LinkedList<String[]>();
+
+    private List<String[]> chairs = new LinkedList<String[]>();
+
+    private String volume;
+
+    private String issue;
+
+    private String firstPage;
+
+    private String lastPage;
+
+    private String editionNumber;
+
+    private String year;
+
+    private String publicationType;
+
+    private String articleTitle;
+
+    public CrossrefItem(InputStream xmlData) throws JDOMException, IOException,
+            ParserConfigurationException, SAXException
+    {
+        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 queryResult = XMLUtils.getSingleElement(xmlRoot, "query_result");
+        Element body = XMLUtils.getSingleElement(xmlRoot, "body");
+        Element dataRoot = XMLUtils.getSingleElement(xmlRoot, "query");
+        loadData(dataRoot);
+    }
+
+    public CrossrefItem(Element dataRoot) {
+    	loadData(dataRoot);
+	}
+    
+	private void loadData(Element dataRoot) {
+		String status = dataRoot.getAttribute("status");
+//        <xsd:enumeration value="resolved"/>
+//        <xsd:enumeration value="unresolved"/>
+//        <xsd:enumeration value="multiresolved"/>
+//        <xsd:enumeration value="malformed"/>
+        if (!"resolved".equals(status)) {
+            String msg = XMLUtils.getElementValue(dataRoot, "msg");
+            String exMsg = status + " - " + msg;
+            throw new RuntimeException(exMsg);
+        }
+        doi = XMLUtils.getElementValue(dataRoot, "doi");
+        itemType = doi != null ? XMLUtils.getElementAttribute(dataRoot, "doi",
+                "type") : "unspecified";
+
+        List<Element> identifier = XMLUtils.getElementList(dataRoot, "issn");
+        for (Element ident : identifier)
+        {
+            if ("print".equalsIgnoreCase(ident.getAttribute("type"))
+                    || StringUtils.isNotBlank(ident.getAttribute("type")))
+            {
+                issn = ident.getTextContent().trim();
+            }
+            else
+            {
+                eissn = ident.getTextContent().trim();
+            }
+        }
+
+        isbn = XMLUtils.getElementValue(dataRoot, "isbn");
+        editionNumber = XMLUtils.getElementValue(dataRoot, "editionNumber");
+        volume = XMLUtils.getElementValue(dataRoot, "volume");
+        issue = XMLUtils.getElementValue(dataRoot, "issue");
+        year = XMLUtils.getElementValue(dataRoot, "year");
+        firstPage = XMLUtils.getElementValue(dataRoot, "first_page");
+        lastPage = XMLUtils.getElementValue(dataRoot, "last_page");
+        seriesTitle = XMLUtils.getElementValue(dataRoot, "series_title");
+        journalTitle = XMLUtils.getElementValue(dataRoot, "journal_title");
+        volumeTitle = XMLUtils.getElementValue(dataRoot, "volume_title");
+        articleTitle = XMLUtils.getElementValue(dataRoot, "article_title");
+        publicationType = XMLUtils.getElementValue(dataRoot, "pubblication_type");
+
+        List<Element> contributors = XMLUtils.getElementList(dataRoot, "contributors");
+        List<Element> contributor = null;
+        if (contributors != null && contributors.size() > 0)
+        {
+        	contributor = XMLUtils.getElementList(contributors.get(0), "contributor");
+	        		
+	        for (Element contrib : contributor) {
+	        	
+	            String givenName = XMLUtils.getElementValue(contrib, "given_name");
+	            String surname = XMLUtils.getElementValue(contrib, "surname");
+	
+	            if ("editor".equalsIgnoreCase(contrib
+	                    .getAttribute("contributor_role")))
+	            {
+	                editors.add(new String[] { givenName, surname });
+	            }
+	            else if ("chair".equalsIgnoreCase(contrib
+	                    .getAttribute("contributor_role")))
+	            {
+	                chairs.add(new String[] { givenName, surname });
+	            }
+	            else if ("translator".equalsIgnoreCase(contrib
+	                    .getAttribute("contributor_role")))
+	            {
+	                translators.add(new String[] { givenName, surname });
+	            }
+	            else
+	            {
+	                authors.add(new String[] { givenName, surname });
+	            }
+	        }
+        }
+	}
+
+    public String getDoi()
+    {
+        return doi;
+    }
+
+    public String getItemType()
+    {
+        return itemType;
+    }
+
+    public String getIssn()
+    {
+        return issn;
+    }
+
+    public String getEissn()
+    {
+        return eissn;
+    }
+
+    public String getIsbn()
+    {
+        return isbn;
+    }
+
+    public String getSeriesTitle()
+    {
+        return seriesTitle;
+    }
+
+    public String getJournalTitle()
+    {
+        return journalTitle;
+    }
+
+    public String getVolumeTitle()
+    {
+        return volumeTitle;
+    }
+
+    public List<String[]> getAuthors()
+    {
+        return authors;
+    }
+
+    public List<String[]> getEditors()
+    {
+        return editors;
+    }
+
+    public List<String[]> getTranslators()
+    {
+        return translators;
+    }
+
+    public List<String[]> getChairs()
+    {
+        return chairs;
+    }
+
+    public String getVolume()
+    {
+        return volume;
+    }
+
+    public String getIssue()
+    {
+        return issue;
+    }
+
+    public String getFirstPage()
+    {
+        return firstPage;
+    }
+
+    public String getLastPage()
+    {
+        return lastPage;
+    }
+
+    public String getEditionNumber()
+    {
+        return editionNumber;
+    }
+
+    public String getYear()
+    {
+        return year;
+    }
+
+    public String getPublicationType()
+    {
+        return publicationType;
+    }
+
+    public String getArticleTitle()
+    {
+        return articleTitle;
+    }
+    
+    @Override
+	public void setSource(String source) {
+		this.source = source;
+	}
+
+	@Override
+	public void setRecord(String record) {
+		this.record = record;
+	}
+
+	@Override
+	public String getRecord() {
+		return record;
+	}
+	
+	@Override
+	public String getSource() {
+		return source;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/importer/pubmed/PubmedItem.java

@@ -0,0 +1,389 @@
+package org.dspace.submit.importer.pubmed;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.lang.StringUtils;
+import org.dspace.app.util.XMLUtils;
+import org.dspace.submit.importer.ItemImport;
+import org.jdom.JDOMException;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+public class PubmedItem implements ItemImport
+{
+	// Nome della classe istanziata
+	private String source;
+	// Valore del metadato source
+	private String record;
+	
+    private String pubmedID;
+
+    private String doi;
+
+    private String issn;
+
+    private String eissn;
+
+    private String journalTitle;
+    
+    private String title;
+
+    private String pubblicationModel;
+
+    private String year;
+
+    private String volume;
+    
+    private String issue;
+
+    private String language;
+
+    private List<String> type = new LinkedList<String>();
+
+    private List<String> primaryKeywords = new LinkedList<String>();
+
+    private List<String> secondaryKeywords = new LinkedList<String>();
+    
+    private List<String> primaryMeshHeadings = new LinkedList<String>();
+
+    private List<String> secondaryMeshHeadings = new LinkedList<String>();
+
+    private String startPage;
+
+    private String endPage;
+
+    private String summary;
+
+    private String status;
+
+    private List<String[]> authors = new LinkedList<String[]>();
+
+    public PubmedItem(InputStream xmlData) throws JDOMException, IOException,
+            ParserConfigurationException, SAXException
+    {
+    	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 pubArticle = XMLUtils
+                .getSingleElement(xmlRoot, "PubmedArticle");
+
+        loadData(pubArticle);
+    }
+    
+    public PubmedItem(Element xmlArticle) {
+    	loadData(xmlArticle);
+	}
+
+	private void loadData(Element pubArticle) {
+		Map<String, String> mounthToNum = new HashMap<String, String>();
+        mounthToNum.put("Jan", "01");
+        mounthToNum.put("Feb", "02");
+        mounthToNum.put("Mar", "03");
+        mounthToNum.put("Apr", "04");
+        mounthToNum.put("May", "05");
+        mounthToNum.put("Jun", "06");
+        mounthToNum.put("Jul", "07");
+        mounthToNum.put("Aug", "08");
+        mounthToNum.put("Sep", "09");
+        mounthToNum.put("Oct", "10");
+        mounthToNum.put("Nov", "11");
+        mounthToNum.put("Dec", "12");
+                
+        Element medline = XMLUtils.getSingleElement(pubArticle, "MedlineCitation");
+        
+        Element article = XMLUtils.getSingleElement(medline, "Article");
+        Element pubmed = XMLUtils.getSingleElement(pubArticle, "PubmedData");
+        
+        Element identifierList = XMLUtils.getSingleElement(pubmed, "ArticleIdList");
+        if (identifierList != null)
+        {
+            List<Element> identifiers = XMLUtils.getElementList(identifierList, "ArticleId");
+            if (identifiers != null)
+            {
+                for (Element id : identifiers)
+                {
+                    if ("pubmed".equals(id.getAttribute("IdType")))
+                    {
+                        pubmedID = id.getTextContent().trim();
+                    }
+                    else if ("doi".equals(id.getAttribute("IdType")))
+                    {
+                        doi = id.getTextContent().trim();
+                    }
+                }
+            }
+        }
+        
+        status = XMLUtils.getElementValue(pubmed, "PublicationStatus");
+        pubblicationModel = XMLUtils.getElementAttribute(medline, "Article", "PubModel");
+        title = XMLUtils.getElementValue(article, "ArticleTitle");
+        Element abstractElement = XMLUtils.getSingleElement(medline, "Abstract");
+        if (abstractElement == null)
+        {
+            abstractElement = XMLUtils.getSingleElement(medline, "OtherAbstract");
+        }
+        if (abstractElement != null)
+        {
+            summary = XMLUtils.getElementValue(abstractElement, "AbstractText");
+        }
+        
+        Element authorList = XMLUtils.getSingleElement(article, "AuthorList");
+        if (authorList != null)
+        {
+            List<Element> authorsElement = XMLUtils.getElementList(authorList, "Author");
+            if (authorsElement != null)
+            {
+                for (Element author : authorsElement)
+                {
+                    if (StringUtils.isBlank(XMLUtils.getElementValue(author, "CollectiveName")))
+                    {
+                        authors.add(new String[]{XMLUtils.getElementValue(author, "ForeName"),XMLUtils.getElementValue(author, "LastName")});
+                    }
+                }
+            }
+        }
+        
+        Element journal = XMLUtils.getSingleElement(article, "Journal");
+        if (journal != null)
+        {
+            List<Element> jnumbers = XMLUtils.getElementList(journal, "ISSN");
+            if (jnumbers != null)
+            {
+                for (Element jnumber : jnumbers)
+                {
+                    if ("Print".equals(jnumber.getAttribute("IssnType")))
+                    {
+                        issn = jnumber.getTextContent().trim();
+                    }
+                    else
+                    {
+                        eissn = jnumber.getTextContent().trim();
+                    }
+                }
+            }
+            
+            journalTitle = XMLUtils.getElementValue(journal, "Title");
+            Element journalIssueElement = XMLUtils.getSingleElement(journal, "JournalIssue");
+            if (journalIssueElement != null)
+            {
+                volume = XMLUtils.getElementValue(journalIssueElement, "Volume");
+                issue = XMLUtils.getElementValue(journalIssueElement, "Issue");
+                
+                Element pubDataElement = XMLUtils.getSingleElement(journalIssueElement, "PubDate");
+                
+                if (pubDataElement != null)
+                {
+                    year = XMLUtils.getElementValue(pubDataElement, "Year");
+                    String mounth = XMLUtils.getElementValue(pubDataElement, "Month");
+                    String day = XMLUtils.getElementValue(pubDataElement, "Day");
+                    if (StringUtils.isNotBlank(mounth) && mounthToNum.containsKey(mounth))
+                    {
+                        year += "-" + mounthToNum.get(mounth);
+                        if (StringUtils.isNotBlank(day))
+                        {
+                            year += "-" + (day.length() == 1 ? "0" + day : day);
+                        }
+                    }
+                }
+            }
+            
+            language = XMLUtils.getElementValue(article, "Language");
+            
+            Element publicationTypeList = XMLUtils.getSingleElement(article, "PublicationTypeList");
+            if (publicationTypeList != null)
+            {
+                List<Element> publicationTypes = XMLUtils.getElementList(publicationTypeList, "PublicationType");
+                for (Element publicationType : publicationTypes)
+                {
+                    type.add(publicationType.getTextContent().trim());
+                }
+            }
+            
+            Element keywordsList = XMLUtils.getSingleElement(medline, "KeywordList");
+            if (keywordsList != null)
+            {
+                List<Element> keywords = XMLUtils.getElementList(keywordsList, "Keyword");
+                for (Element keyword : keywords)
+                {
+                    if ("Y".equals(keyword.getAttribute("MajorTopicYN")))
+                    {
+                        primaryKeywords.add(keyword.getTextContent().trim());
+                    }
+                    else
+                    {
+                        secondaryKeywords.add(keyword.getTextContent().trim());
+                    }
+                }
+            }
+            
+            Element meshHeadingsList = XMLUtils.getSingleElement(medline, "MeshHeadingList");
+            if (meshHeadingsList != null)
+            {
+                List<Element> meshHeadings = XMLUtils.getElementList(meshHeadingsList, "MeshHeading");
+                for (Element meshHeading : meshHeadings)
+                {
+                    if ("Y".equals(XMLUtils.getElementAttribute(meshHeading, "DescriptorName", "MajorTopicYN")))
+                    {
+                        primaryMeshHeadings.add(XMLUtils.getElementValue(meshHeading, "DescriptorName"));
+                    }
+                    else
+                    {
+                        secondaryMeshHeadings.add(XMLUtils.getElementValue(meshHeading, "DescriptorName"));
+                    }
+                }
+            }
+         
+            Element paginationElement = XMLUtils.getSingleElement(article, "Pagination");
+            if (paginationElement != null)
+            {
+                startPage = XMLUtils.getElementValue(paginationElement, "StartPage");
+                endPage = XMLUtils.getElementValue(paginationElement, "EndPage");
+                if (StringUtils.isBlank(startPage))
+                {
+                    startPage = XMLUtils.getElementValue(paginationElement, "MedlinePgn");
+                }
+            }
+        }
+	}
+
+    public String getPubmedID()
+    {
+        return pubmedID;
+    }
+
+    public String getDoi()
+    {
+        return doi;
+    }
+
+    public String getIssn()
+    {
+        return issn;
+    }
+
+    public String getEissn()
+    {
+        return eissn;
+    }
+
+    public String getJournalTitle()
+    {
+        return journalTitle;
+    }
+
+    public String getTitle()
+    {
+        return title;
+    }
+
+    public String getPubblicationModel()
+    {
+        return pubblicationModel;
+    }
+
+    public String getYear()
+    {
+        return year;
+    }
+
+    public String getVolume()
+    {
+        return volume;
+    }
+
+    public String getIssue()
+    {
+        return issue;
+    }
+
+    public String getLanguage()
+    {
+        return language;
+    }
+
+    public List<String> getType()
+    {
+        return type;
+    }
+
+    public List<String> getPrimaryKeywords()
+    {
+        return primaryKeywords;
+    }
+
+    public List<String> getSecondaryKeywords()
+    {
+        return secondaryKeywords;
+    }
+
+    public List<String> getPrimaryMeshHeadings()
+    {
+        return primaryMeshHeadings;
+    }
+
+    public List<String> getSecondaryMeshHeadings()
+    {
+        return secondaryMeshHeadings;
+    }
+
+    public String getStartPage()
+    {
+        return startPage;
+    }
+
+    public String getEndPage()
+    {
+        return endPage;
+    }
+
+    public String getSummary()
+    {
+        return summary;
+    }
+
+    public String getStatus()
+    {
+        return status;
+    }
+
+    public List<String[]> getAuthors()
+    {
+        return authors;
+    }
+    
+    @Override
+	public void setSource(String source) {
+		this.source = source;
+	}
+
+	@Override
+	public void setRecord(String record) {
+		this.record = record;
+	}
+
+	@Override
+	public String getRecord() {
+		return record;
+	}
+	
+	@Override
+	public String getSource() {
+		return source;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/ArXivLookupProvider.java

@@ -0,0 +1,93 @@
+package org.dspace.submit.lookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.lang.StringUtils;
+import org.dspace.core.Context;
+import org.dspace.submit.importer.arxiv.ArXivItem;
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+public class ArXivLookupProvider extends ConfigurableLookupProvider {
+	private ArXivService arXivService;
+	private boolean searchProvider = true;
+	
+	public void setArXivService(ArXivService arXivService) {
+		this.arXivService = arXivService;
+	}
+
+	@Override
+	public List<String> getSupportedIdentifiers() {
+		return Arrays.asList(new String[] { ARXIV, DOI });
+	}
+
+	public void setSearchProvider(boolean searchProvider)
+    {
+        this.searchProvider = searchProvider;
+    }
+	
+	@Override
+	public boolean isSearchProvider() {
+		return searchProvider;
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> getByIdentifier(
+			Context context, Map<String, String> keys) throws HttpException, IOException {
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		if (keys != null) {
+			String doi = keys.get(DOI);
+			String arxivid = keys.get(ARXIV);
+			List<ArXivItem> items = new ArrayList<ArXivItem>();
+			if (StringUtils.isNotBlank(doi)) {
+				Set<String> dois = new HashSet<String>();
+				dois.add(doi);
+				items.addAll(arXivService.getByDOIs(dois));
+			}
+			if (StringUtils.isNotBlank(arxivid)) {
+				items.add(arXivService.getByArXivIDs(arxivid));
+			}
+
+			for (ArXivItem item : items) {
+				results.add(convert(item));
+			}
+		}
+		return results;
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> search(Context context, String title,
+			String author, int year) throws HttpException, IOException {
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		List<ArXivItem> items = arXivService.searchByTerm(title, author, year);
+		for (ArXivItem item : items) {
+			results.add(convert(item));
+		}
+		return results;
+	}
+
+	@Override
+	public String getShortName() {
+		return "arxiv";
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> getByDOIs(Context context, Set<String> doiToSearch)
+			throws HttpException, IOException {
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		if (doiToSearch != null && doiToSearch.size() > 0) {
+			List<ArXivItem> items = arXivService.getByDOIs(doiToSearch);
+
+			for (ArXivItem item : items) {
+				results.add(convert(item));
+			}
+		}
+		return results;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/ArXivService.java

@@ -0,0 +1,206 @@
+package org.dspace.submit.lookup;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpStatus;
+import org.apache.commons.httpclient.NameValuePair;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.lang.StringUtils;
+import org.dspace.app.util.XMLUtils;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.submit.importer.arxiv.ArXivItem;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+public class ArXivService
+{
+    private int timeout = 1000;
+
+    public void setTimeout(int timeout)
+    {
+        this.timeout = timeout;
+    }
+
+    public List<ArXivItem> getByDOIs(Set<String> dois) throws HttpException,
+            IOException
+    {
+        if (dois != null && dois.size() > 0)
+        {
+            String doisQuery = StringUtils.join(dois.iterator(), " OR ");
+            return search(doisQuery, null, 100);
+        }
+        return null;
+    }
+
+    public List<ArXivItem> searchByTerm(String title, String author, int year)
+            throws HttpException, IOException
+    {
+        StringBuffer query = new StringBuffer();
+        if (StringUtils.isNotBlank(title))
+        {
+            query.append("ti:\"").append(title).append("\"");
+        }
+        if (StringUtils.isNotBlank(author))
+        {
+            // [FAU]
+            if (query.length() > 0)
+                query.append(" AND ");
+            query.append("au:\"").append(author).append("\"");
+        }
+        return search(query.toString(), "", 10);
+    }
+
+    private List<ArXivItem> search(String query, String arxivid, int max_result)
+            throws IOException, HttpException
+    {
+        List<ArXivItem> results = new ArrayList<ArXivItem>();
+        if (!ConfigurationManager.getBooleanProperty("remoteservice.demo"))
+        {
+            GetMethod method = null;
+            try
+            {
+                HttpClient client = new HttpClient();
+                client.setTimeout(timeout);
+                method = new GetMethod("http://export.arxiv.org/api/query");
+                NameValuePair id = new NameValuePair("id_list", arxivid);
+                NameValuePair queryParam = new NameValuePair("search_query",
+                        query);
+                NameValuePair count = new NameValuePair("max_results",
+                        String.valueOf(max_result));
+                method.setQueryString(new NameValuePair[] { id, queryParam,
+                        count });
+                // Execute the method.
+                int statusCode = client.executeMethod(method);
+
+                if (statusCode != HttpStatus.SC_OK)
+                {
+                    if (statusCode == HttpStatus.SC_BAD_REQUEST)
+                        throw new RuntimeException("Query arXiv non valida");
+                    else
+                        throw new RuntimeException("Chiamata http fallita: "
+                                + method.getStatusLine());
+                }
+
+                try
+                {
+                    DocumentBuilderFactory factory = DocumentBuilderFactory
+                            .newInstance();
+                    factory.setValidating(false);
+                    factory.setIgnoringComments(true);
+                    factory.setIgnoringElementContentWhitespace(true);
+
+                    DocumentBuilder db = factory.newDocumentBuilder();
+                    Document inDoc = db.parse(method.getResponseBodyAsStream());
+
+                    Element xmlRoot = inDoc.getDocumentElement();
+                    List<Element> dataRoots = XMLUtils.getElementList(xmlRoot,
+                            "entry");
+
+                    for (Element dataRoot : dataRoots)
+                    {
+                        ArXivItem crossitem;
+
+                        crossitem = new ArXivItem(dataRoot);
+                        if (crossitem != null)
+                        {
+                            results.add(crossitem);
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    throw new RuntimeException(
+                            "Identificativo arXiv non valido o inesistente");
+                }
+            }
+            finally
+            {
+                if (method != null)
+                {
+                    method.releaseConnection();
+                }
+            }
+        }
+        else
+        {
+            InputStream stream = null;
+            try
+            {
+                File file = new File(
+                        ConfigurationManager.getProperty("dspace.dir")
+                                + "/config/crosswalks/demo/arxiv.xml");
+                stream = new FileInputStream(file);
+                try
+                {
+                    DocumentBuilderFactory factory = DocumentBuilderFactory
+                            .newInstance();
+                    factory.setValidating(false);
+                    factory.setIgnoringComments(true);
+                    factory.setIgnoringElementContentWhitespace(true);
+                    DocumentBuilder db = factory.newDocumentBuilder();
+                    Document inDoc = db.parse(stream);
+
+                    Element xmlRoot = inDoc.getDocumentElement();
+                    List<Element> dataRoots = XMLUtils.getElementList(xmlRoot,
+                            "entry");
+                    for (Element dataRoot : dataRoots)
+                    {
+                        ArXivItem crossitem = new ArXivItem(dataRoot);
+
+                        if (crossitem != null)
+                        {
+                            results.add(crossitem);
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    throw new RuntimeException(
+                            "Identificativo arXiv non valido o inesistente");
+                }
+            }
+            finally
+            {
+                if (stream != null)
+                {
+                    stream.close();
+                }
+            }
+        }
+        return results;
+    }
+
+    public ArXivItem getByArXivIDs(String raw) throws HttpException,
+            IOException
+    {
+        if (StringUtils.isNotBlank(raw))
+        {
+            raw = raw.trim();
+            if (raw.startsWith("http://arxiv.org/abs/"))
+            {
+                raw = raw.substring("http://arxiv.org/abs/".length());
+            }
+            else if (raw.toLowerCase().startsWith("arxiv:"))
+            {
+                raw = raw.substring("arxiv:".length());
+            }
+            List<ArXivItem> result = search("", raw, 1);
+            if (result != null && result.size() > 0)
+            {
+                return result.get(0);
+            }
+        }
+        return null;
+    }
+}

dspace-api/src/main/java/org/dspace/submit/lookup/ConfigurableLookupProvider.java

@@ -0,0 +1,14 @@
+package org.dspace.submit.lookup;
+
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+
+public abstract class ConfigurableLookupProvider implements SubmissionLookupProvider {
+	protected SubmissionLookupPublication convert(Object bean) {
+		try {
+			return SubmissionLookupUtils.convert(getShortName(), bean);
+		} catch (Exception e) {
+			throw new RuntimeException(e.getMessage(), e);
+		}
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/CrossRefLookupProvider.java

@@ -0,0 +1,115 @@
+package org.dspace.submit.lookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.httpclient.HttpException;
+import org.dspace.core.Context;
+import org.dspace.submit.importer.crossref.CrossrefItem;
+import org.dspace.submit.util.SubmissionLookupPublication;
+import org.jdom.JDOMException;
+import org.xml.sax.SAXException;
+
+public class CrossRefLookupProvider extends ConfigurableLookupProvider {
+	private CrossRefService crossrefService;
+
+	private boolean searchProvider = true;
+	
+	public void setSearchProvider(boolean searchProvider)
+    {
+        this.searchProvider = searchProvider;
+    }
+	
+	public void setCrossrefService(CrossRefService crossrefService) {
+		this.crossrefService = crossrefService;
+	}
+
+	@Override
+	public List<String> getSupportedIdentifiers() {
+		return Arrays.asList(new String[] { DOI });
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> getByIdentifier(Context context, 
+			Map<String, String> keys) throws HttpException, IOException {
+		if (keys != null && keys.containsKey(DOI)) {
+			Set<String> dois = new HashSet<String>();
+			dois.add(keys.get(DOI));
+			List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+			List<CrossrefItem> items = null;
+			try {
+				items = crossrefService.search(context, dois);
+			} catch (JDOMException e) {
+				throw new RuntimeException(e.getMessage(), e);
+			} catch (ParserConfigurationException e) {
+				throw new RuntimeException(e.getMessage(), e);
+			} catch (SAXException e) {
+				throw new RuntimeException(e.getMessage(), e);
+			}
+			if (items != null) {
+				for (CrossrefItem p : items) {
+					results.add(convert(p));
+				}
+				return results;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> search(Context context, String title,
+			String author, int year) throws HttpException, IOException {
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		List<CrossrefItem> items = null;
+		items = crossrefService.search(context, title, author, year, 10);
+		if (items != null) {
+			for (CrossrefItem p : items) {
+				results.add(convert(p));
+			}
+			return results;
+		}
+		return null;
+	}
+
+	@Override
+	public boolean isSearchProvider() {
+		return searchProvider;
+	}
+
+	@Override
+	public String getShortName() {
+		return "crossref";
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> getByDOIs(Context context, Set<String> doiToSearch)
+			throws HttpException, IOException {
+		if (doiToSearch != null) {
+			List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+			List<CrossrefItem> items = null;
+			try {
+				items = crossrefService.search(context, doiToSearch);
+			} catch (JDOMException e) {
+				throw new RuntimeException(e.getMessage(), e);
+			} catch (ParserConfigurationException e) {
+				throw new RuntimeException(e.getMessage(), e);
+			} catch (SAXException e) {
+				throw new RuntimeException(e.getMessage(), e);
+			}
+			if (items != null) {
+				for (CrossrefItem p : items) {
+					results.add(convert(p));
+				}
+				return results;
+			}
+		}
+		return null;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/CrossRefService.java

@@ -0,0 +1,176 @@
+package org.dspace.submit.lookup;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpStatus;
+import org.apache.commons.httpclient.NameValuePair;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+import org.dspace.submit.importer.crossref.CrossrefItem;
+import org.jdom.JDOMException;
+import org.xml.sax.SAXException;
+
+import flexjson.JSONDeserializer;
+
+public class CrossRefService {
+    
+    private static final Logger log = Logger.getLogger(CrossRefService.class);
+    
+	private int timeout = 1000;
+	
+	public void setTimeout(int timeout) {
+		this.timeout = timeout;
+	}
+	
+	public List<CrossrefItem> search(Context context, Set<String> dois) throws HttpException,
+			IOException, JDOMException, ParserConfigurationException,
+			SAXException {
+		List<CrossrefItem> results = new ArrayList<CrossrefItem>();
+		if (dois != null && dois.size() > 0) {
+			for (String record : dois) {
+				try
+				{
+					if (!ConfigurationManager
+							.getBooleanProperty("remoteservice.demo")) {
+						GetMethod method = null;
+						try {
+							String apiKey = ConfigurationManager
+									.getProperty("crossref.api-key");
+	
+							HttpClient client = new HttpClient();
+							client.setConnectionTimeout(timeout);
+							method = new GetMethod(
+									"http://www.crossref.org/openurl/");
+	
+							NameValuePair pid = new NameValuePair("pid", apiKey);
+							NameValuePair noredirect = new NameValuePair(
+									"noredirect", "true");
+							NameValuePair id = new NameValuePair("id", record);
+							method.setQueryString(new NameValuePair[] { pid,
+									noredirect, id });
+							// Execute the method.
+							int statusCode = client.executeMethod(method);
+	
+							if (statusCode != HttpStatus.SC_OK) {
+								throw new RuntimeException(
+										"Chiamata http fallita: "
+												+ method.getStatusLine());
+							}
+	
+							CrossrefItem crossitem;
+							try {
+								crossitem = new CrossrefItem(
+										method.getResponseBodyAsStream());
+								results.add(crossitem);
+							} catch (Exception e) {
+								log.warn(LogManager
+										.getHeader(
+												context,
+												"retrieveRecordDOI",
+												record
+														+ " DOI non valido o inesistente: "
+														+ e.getMessage()));
+							}
+						} finally {
+							if (method != null) {
+								method.releaseConnection();
+							}
+						}
+					} else {
+						InputStream stream = null;
+						try {
+							File file = new File(
+									ConfigurationManager.getProperty("dspace.dir")
+											+ "/config/crosswalks/demo/doi.xml");
+							stream = new FileInputStream(file);
+							results.add(new CrossrefItem(stream));
+						} finally {
+							if (stream != null) {
+								stream.close();
+							}
+						}
+					}
+				}
+				catch (RuntimeException rt)
+				{
+					rt.printStackTrace();
+				}
+			}
+		}
+		return results;
+	}
+
+	public NameValuePair[] buildQueryPart(String title, String author, int year, int count) {
+		StringBuffer sb = new StringBuffer();
+		if (StringUtils.isNotBlank(title)) {
+			sb.append(title);
+		}
+		sb.append(" ");
+		if (StringUtils.isNotBlank(author)) {
+			sb.append(author);
+		}
+		String q = sb.toString().trim();
+		NameValuePair qParam = new NameValuePair("q", title);
+		NameValuePair yearParam = new NameValuePair("year",
+				year != -1?String.valueOf(year):"");
+		NameValuePair countParam = new NameValuePair("rows",
+				count!= -1?String.valueOf(count):"");
+		
+		NameValuePair[] query = new NameValuePair[] { qParam,
+				yearParam, countParam };
+		return query;
+	}
+
+	public List<CrossrefItem> search(Context context, String title, String authors, int year,
+			int count) throws IOException, HttpException {
+		List<CrossrefItem> results = new ArrayList<CrossrefItem>();
+		GetMethod method = null;
+		try {
+			NameValuePair[] query = buildQueryPart(title, authors, year, count);
+			HttpClient client = new HttpClient();
+			client.setTimeout(timeout);
+			method = new GetMethod("http://search.labs.crossref.org/dois");
+
+			method.setQueryString(query);
+			// Execute the method.
+			int statusCode = client.executeMethod(method);
+
+			if (statusCode != HttpStatus.SC_OK) {
+				throw new RuntimeException("Chiamata http fallita: "
+						+ method.getStatusLine());
+			}
+
+			JSONDeserializer<List<Map>> des = new JSONDeserializer<List<Map>>();
+			List<Map> json = des.deserialize(method.getResponseBodyAsString());
+			Set<String> dois = new HashSet<String>();
+			for (Map r : json) {
+				dois.add(SubmissionLookupUtils.normalizeDOI((String) r.get("doi")));
+			}
+			method.releaseConnection();
+
+			return search(context, dois);
+		} catch (Exception e) {
+			throw new RuntimeException(e.getMessage(), e);
+		} finally {
+			if (method != null) {
+				method.releaseConnection();
+			}
+		}
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/EnhancerSubmissionLookup.java

@@ -0,0 +1,12 @@
+package org.dspace.submit.lookup;
+
+import java.util.List;
+
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+public interface EnhancerSubmissionLookup {
+
+	List<String> getValues(
+			SubmissionLookupPublication publication);
+
+}

dspace-api/src/main/java/org/dspace/submit/lookup/LookupProvidersCheck.java

@@ -0,0 +1,22 @@
+package org.dspace.submit.lookup;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LookupProvidersCheck {
+	private List<String> providersOk = new ArrayList<String>();
+	private List<String> providersErr = new ArrayList<String>();
+	public List<String> getProvidersOk() {
+		return providersOk;
+	}
+	public void setProvidersOk(List<String> providersOk) {
+		this.providersOk = providersOk;
+	}
+	public List<String> getProvidersErr() {
+		return providersErr;
+	}
+	public void setProvidersErr(List<String> providersErr) {
+		this.providersErr = providersErr;
+	}
+	
+}

dspace-api/src/main/java/org/dspace/submit/lookup/PubmedLookupProvider.java

@@ -0,0 +1,114 @@
+package org.dspace.submit.lookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.httpclient.HttpException;
+import org.apache.log4j.Logger;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+import org.dspace.submit.importer.pubmed.PubmedItem;
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+public class PubmedLookupProvider extends ConfigurableLookupProvider {
+    private boolean searchProvider = true;
+    private static Logger log = Logger.getLogger(PubmedLookupProvider.class);
+    
+    private PubmedService pubmedService;
+	
+	public void setPubmedService(PubmedService pubmedService) {
+		this.pubmedService = pubmedService;
+	}
+
+	@Override
+	public List<String> getSupportedIdentifiers() {
+		return Arrays.asList(new String[] { PUBMED, DOI });
+	}
+
+	public void setSearchProvider(boolean searchProvider)
+    {
+        this.searchProvider = searchProvider;
+    }
+	
+	@Override
+	public boolean isSearchProvider() {
+		return searchProvider;
+	}
+
+	@Override
+	public String getShortName() {
+		return "pubmed";
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> getByIdentifier(Context context, 
+			Map<String, String> keys) throws HttpException, IOException {
+		String pmid = keys != null ? keys.get(PUBMED) : null;
+		String doi = keys != null ? keys.get(DOI) : null;
+		SubmissionLookupPublication publication = null;
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		if (pmid != null && doi == null) {
+			try
+            {
+                publication = convert(pubmedService.getByPubmedID(pmid));
+            }
+            catch (Exception e)
+            {
+                log.error(LogManager.getHeader(context, "getByIdentifier", "pmid="+pmid), e);
+            }
+			if (publication != null)
+				results.add(publication);
+		}
+		else
+		{
+			List<PubmedItem> pubmedResults = pubmedService.search(doi, pmid);
+			if (pubmedResults != null) {
+				for (PubmedItem p : pubmedResults) {
+					results.add(convert(p));
+				}
+			}
+		}
+		
+		return results;
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> search(Context context, String title,
+			String author, int year) throws HttpException, IOException {
+		List<PubmedItem> pubmedResults = pubmedService.search(title, author,
+				year);
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		if (pubmedResults != null) {
+			for (PubmedItem p : pubmedResults) {
+				results.add(convert(p));
+			}
+		}
+		return results;
+	}
+
+	@Override
+	public List<SubmissionLookupPublication> getByDOIs(Context context, 
+			Set<String> doiToSearch)
+			throws HttpException, IOException {
+		StringBuffer query = new StringBuffer();
+		for (String d : doiToSearch) {
+			if (query.length() > 0) {
+				query.append(" OR ");
+			}
+			query.append(d).append("[AI]");
+		}
+
+		List<PubmedItem> pubmedResults = pubmedService.search(query.toString());
+		List<SubmissionLookupPublication> results = new ArrayList<SubmissionLookupPublication>();
+		if (pubmedResults != null) {
+			for (PubmedItem p : pubmedResults) {
+				results.add(convert(p));
+			}
+		}
+		return results;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/PubmedService.java

@@ -0,0 +1,276 @@
+package org.dspace.submit.lookup;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpStatus;
+import org.apache.commons.httpclient.NameValuePair;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.lang.StringUtils;
+import org.dspace.app.util.XMLUtils;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.submit.importer.pubmed.PubmedItem;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+public class PubmedService {
+	private int timeout = 1000;
+	
+	public void setTimeout(int timeout) {
+		this.timeout = timeout;
+	}
+	
+	public PubmedItem getByPubmedID(String pubmedid) throws HttpException,
+			IOException, ParserConfigurationException, SAXException {
+		List<String> ids = new ArrayList<String>();
+		ids.add(pubmedid.trim());
+		List<PubmedItem> items = getByPubmedIDs(ids);
+		if (items != null && items.size() > 0)
+		{
+			return items.get(0);
+		}
+		return null;
+	}
+
+	public List<PubmedItem> search(String title, String author, int year)
+			throws HttpException, IOException {
+		StringBuffer query = new StringBuffer();
+		if (StringUtils.isNotBlank(title)) {
+			query.append("((").append(title).append("[TI]) OR (");
+			// [TI] non funziona sempre, titolo di capitoli di libro
+			query.append("(").append(title).append("[book]))");
+		}
+		if (StringUtils.isNotBlank(author)) {
+			// [FAU]
+			if (query.length() > 0)
+				query.append(" AND ");
+			query.append("(").append(author).append("[AU])");
+		}
+		if (year != -1)
+		{
+			// [DP]
+			if (query.length() > 0)
+				query.append(" AND ");
+			query.append(year).append("[DP]");
+		}
+		return search(query.toString());
+	}
+
+	public List<PubmedItem> search(String query) throws IOException,
+			HttpException {
+		List<PubmedItem> results = null;
+		if (!ConfigurationManager.getBooleanProperty("remoteservice.demo")) {
+			GetMethod method = null;
+			try {
+				HttpClient client = new HttpClient();
+				client.setTimeout(timeout);
+				method = new GetMethod(
+						"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi");
+
+				NameValuePair db = new NameValuePair("db", "pubmed");
+				NameValuePair datetype = new NameValuePair("datetype", "edat");
+				NameValuePair retmax = new NameValuePair("retmax", "10");
+				NameValuePair queryParam = new NameValuePair("term",
+						query.toString());
+				method.setQueryString(new NameValuePair[] { db, queryParam,
+						retmax, datetype });
+				// Execute the method.
+				int statusCode = client.executeMethod(method);
+
+				if (statusCode != HttpStatus.SC_OK) {
+					throw new RuntimeException(
+							"Chiamata al webservice fallita: "
+									+ method.getStatusLine());
+				}
+
+				DocumentBuilderFactory factory = DocumentBuilderFactory
+						.newInstance();
+				factory.setValidating(false);
+				factory.setIgnoringComments(true);
+				factory.setIgnoringElementContentWhitespace(true);
+
+				DocumentBuilder builder;
+				try {
+					builder = factory.newDocumentBuilder();
+
+					Document inDoc = builder.parse(method
+							.getResponseBodyAsStream());
+
+					Element xmlRoot = inDoc.getDocumentElement();
+					Element idList = XMLUtils.getSingleElement(xmlRoot,
+							"IdList");
+					List<String> pubmedIDs = XMLUtils.getElementValueList(
+							idList, "Id");
+					results = getByPubmedIDs(pubmedIDs);
+				} catch (ParserConfigurationException e) {
+					e.printStackTrace();
+				}
+				catch (SAXException e1) {
+					e1.printStackTrace();
+				}
+			} finally {
+				if (method != null) {
+					method.releaseConnection();
+				}
+			}
+		} else {
+			InputStream stream = null;
+			try {
+				File file = new File(
+						ConfigurationManager.getProperty("dspace.dir")
+								+ "/config/crosswalks/demo/pubmed-search.xml");
+				stream = new FileInputStream(file);
+				DocumentBuilderFactory factory = DocumentBuilderFactory
+						.newInstance();
+				factory.setValidating(false);
+				factory.setIgnoringComments(true);
+				factory.setIgnoringElementContentWhitespace(true);
+
+				DocumentBuilder builder = factory.newDocumentBuilder();
+				Document inDoc = builder.parse(stream);
+
+				Element xmlRoot = inDoc.getDocumentElement();
+				Element idList = XMLUtils.getSingleElement(xmlRoot, "IdList");
+				List<String> pubmedIDs = XMLUtils.getElementValueList(idList,
+						"Id");
+				results = getByPubmedIDs(pubmedIDs);
+			} catch (Exception e) {
+				throw new RuntimeException(e.getMessage(), e);
+			} finally {
+				if (stream != null) {
+					try {
+						stream.close();
+					} catch (IOException e) {
+						e.printStackTrace();
+					}
+				}
+			}
+		}
+		return results;
+	}
+
+	public List<PubmedItem> getByPubmedIDs(List<String> pubmedIDs)
+			throws HttpException, IOException, ParserConfigurationException, SAXException {
+		List<PubmedItem> results = new ArrayList<PubmedItem>();
+		if (!ConfigurationManager.getBooleanProperty("remoteservice.demo")) {
+			GetMethod method = null;
+			try {
+				HttpClient client = new HttpClient();
+				client.setTimeout(5 * timeout);
+				method = new GetMethod(
+						"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi");
+
+				NameValuePair db = new NameValuePair("db", "pubmed");
+				NameValuePair retmode = new NameValuePair("retmode", "xml");
+				NameValuePair rettype = new NameValuePair("rettype", "full");
+				NameValuePair id = new NameValuePair("id", StringUtils.join(pubmedIDs.iterator(), ","));
+				method.setQueryString(new NameValuePair[] { db, retmode,
+						rettype, id });
+				// Execute the method.
+				int statusCode = client.executeMethod(method);
+
+				if (statusCode != HttpStatus.SC_OK) {
+					throw new RuntimeException(
+							"Chiamata al webservice fallita: "
+									+ method.getStatusLine());
+				}
+
+		    	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+		        factory.setValidating(false);
+		        factory.setIgnoringComments(true);
+		        factory.setIgnoringElementContentWhitespace(true);
+
+		        DocumentBuilder builder = factory.newDocumentBuilder();
+		        Document inDoc = builder.parse(method.getResponseBodyAsStream());
+
+		        Element xmlRoot = inDoc.getDocumentElement();
+		        List<Element> pubArticles = XMLUtils
+		                .getElementList(xmlRoot, "PubmedArticle");
+
+		        for (Element xmlArticle : pubArticles)
+		        {
+					PubmedItem pubmedItem = null;
+					try {
+						pubmedItem = new PubmedItem(xmlArticle);
+						results.add(pubmedItem);
+					} catch (Exception e) {
+						throw new RuntimeException(
+								"PubmedID non valido o inesistente: "+e.getMessage(), e);
+					}
+		        }
+
+				return results;
+			} finally {
+				if (method != null) {
+					method.releaseConnection();
+				}
+			}
+		} else {
+			InputStream stream = null;
+			try {
+				File file = new File(
+						ConfigurationManager.getProperty("dspace.dir")
+								+ "/config/crosswalks/demo/pubmed.xml");
+				stream = new FileInputStream(file);
+
+		    	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+		        factory.setValidating(false);
+		        factory.setIgnoringComments(true);
+		        factory.setIgnoringElementContentWhitespace(true);
+
+		        DocumentBuilder builder = factory.newDocumentBuilder();
+		        Document inDoc = builder.parse(stream);
+
+		        Element xmlRoot = inDoc.getDocumentElement();
+		        List<Element> pubArticles = XMLUtils
+		                .getElementList(xmlRoot, "PubmedArticle");
+
+		        for (Element xmlArticle : pubArticles)
+		        {
+					PubmedItem pubmedItem = null;
+					try {
+						pubmedItem = new PubmedItem(xmlArticle);
+						results.add(pubmedItem);
+					} catch (Exception e) {
+						throw new RuntimeException(
+								"PubmedID non valido o inesistente: "+e.getMessage(), e);
+					}
+		        }
+
+				return results;
+			} catch (Exception e) {
+				throw new RuntimeException(e.getMessage(), e);
+			} finally {
+				if (stream != null) {
+					stream.close();
+				}
+			}
+		}
+	}
+
+	public List<PubmedItem> search(String doi, String pmid) throws HttpException, IOException {
+		StringBuffer query = new StringBuffer();
+		if (StringUtils.isNotBlank(doi)) {
+			query.append(doi);
+			query.append("[AID]");
+		}
+		if (StringUtils.isNotBlank(pmid)) {
+			// [FAU]
+			if (query.length() > 0)
+				query.append(" OR ");
+			query.append(pmid).append("[PMID]");
+		}
+		return search(query.toString());
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/SubmissionLookupProvider.java

@@ -0,0 +1,34 @@
+package org.dspace.submit.lookup;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.httpclient.HttpException;
+import org.dspace.core.Context;
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+public interface SubmissionLookupProvider {
+	public final static String DOI = "doi";
+	public final static String PUBMED = "pubmed";
+	public final static String ARXIV = "arxiv";
+	public final static String REPEC = "repec";
+	public final static String SCOPUSEID = "scopuseid";
+	public final static String TYPE = "type";
+
+	List<String> getSupportedIdentifiers();
+
+	boolean isSearchProvider();
+
+	String getShortName();
+
+	List<SubmissionLookupPublication> search(Context context, String title, String author,
+			int year) throws HttpException, IOException;
+
+	List<SubmissionLookupPublication> getByIdentifier(Context context, Map<String, String> keys)
+			throws HttpException, IOException;
+
+	List<SubmissionLookupPublication> getByDOIs(Context context, Set<String> doiToSearch) throws HttpException, IOException;
+
+}

dspace-api/src/main/java/org/dspace/submit/lookup/SubmissionLookupService.java

@@ -0,0 +1,569 @@
+package org.dspace.submit.lookup;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.app.util.DCInput;
+import org.dspace.app.util.DCInputSet;
+import org.dspace.app.util.DCInputsReader;
+import org.dspace.app.util.DCInputsReaderException;
+import org.dspace.content.Item;
+import org.dspace.content.MetadataField;
+import org.dspace.content.MetadataSchema;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.submit.util.EnhancedSubmissionLookupPublication;
+import org.dspace.submit.util.ItemSubmissionLookupDTO;
+import org.dspace.submit.util.SubmissionLookupDTO;
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+import edu.emory.mathcs.backport.java.util.Arrays;
+
+public class SubmissionLookupService {
+
+	public static final String SL_NAMESPACE_PREFIX = "http://www.dspace.org/sl/"; 
+
+	public static final String MANUAL_USER_INPUT = "manual";
+
+	private static Logger log = Logger.getLogger(SubmissionLookupUtils.class);
+
+	// Patter to extract the converter name if any
+	private static final Pattern converterPattern = Pattern
+			.compile(".*\\((.*)\\)");
+
+	// attenzione inizializzato dal metodo init
+	private Properties configuration;
+
+	private static final String NOT_FOUND_DOI = "NOT-FOUND-DOI";
+
+	public static final String SEPARATOR_VALUE = "#######";
+
+	private static final String SEPARATOR_VALUE_REGEX = SEPARATOR_VALUE;
+
+	private List<String> extraMetadataToKeep;
+
+	private Map<String, EnhancerSubmissionLookup> enhancedMetadata;
+
+	private List<SubmissionLookupProvider> providers;
+
+	private Map<String, List<SubmissionLookupProvider>> idents2provs;
+
+	private List<SubmissionLookupProvider> searchProviders;
+
+	private synchronized void init() {
+		if (configuration != null)
+			return;
+		String configFilePath = ConfigurationManager.getProperty("dspace.dir")
+				+ File.separator + "config" + File.separator + "crosswalks"
+				+ File.separator + "submission-lookup-mapping.properties";
+		configuration = new Properties();
+		FileInputStream fis = null;
+		try {
+			fis = new FileInputStream(configFilePath);
+			configuration.load(fis);
+		} catch (Exception notfound) {
+			throw new IllegalArgumentException(
+					"Impossibile leggere la configurazione per il SubmissionLookupService (database esterno -> SURplus)",
+					notfound);
+		} finally {
+			if (fis != null) {
+				try {
+					fis.close();
+				} catch (IOException ioe) {
+					log.error(ioe.getMessage(), ioe);
+				}
+			}
+		}
+	}
+
+	public void setExtraMetadataToKeep(List<String> extraMetadataToKeep) {
+		this.extraMetadataToKeep = extraMetadataToKeep;
+	}
+
+	public List<String> getExtraMetadataToKeep() {
+		return extraMetadataToKeep;
+	}
+
+	public void setEnhancedMetadata(
+			Map<String, EnhancerSubmissionLookup> enhancedMetadata) {
+		this.enhancedMetadata = enhancedMetadata;
+	}
+
+	public Map<String, EnhancerSubmissionLookup> getEnhancedMetadata() {
+		return enhancedMetadata;
+	}
+
+	public void setProviders(List<SubmissionLookupProvider> providers) {
+		this.providers = providers;
+		this.idents2provs = new HashMap<String, List<SubmissionLookupProvider>>();
+		this.searchProviders = new ArrayList<SubmissionLookupProvider>();
+
+		if (providers != null) {
+			for (SubmissionLookupProvider p : providers) {
+				if (p.isSearchProvider()) {
+					searchProviders.add(p);
+				}
+				List<String> suppIdentifiers = p.getSupportedIdentifiers();
+				if (suppIdentifiers != null) {
+					for (String ident : suppIdentifiers) {
+						List<SubmissionLookupProvider> tmp = idents2provs
+								.get(ident);
+						if (tmp == null) {
+							tmp = new ArrayList<SubmissionLookupProvider>();
+							idents2provs.put(ident, tmp);
+						}
+						tmp.add(p);
+					}
+				}
+			}
+		}
+	}
+
+	public List<String> getIdentifiers() {
+		List<String> identifiers = new ArrayList<String>();
+		identifiers.add("doi");
+		identifiers.add("pubmed");
+		identifiers.add("arxiv");
+		return identifiers;
+	}
+
+	public Map<String, List<SubmissionLookupProvider>> getProvidersIdentifiersMap() {
+		return idents2provs;
+	}
+
+	public void merge(String formName, Item item, ItemSubmissionLookupDTO dto) {
+		init();
+		SubmissionLookupPublication lookupPub = dto
+				.getTotalPublication(providers);
+		EnhancedSubmissionLookupPublication itemLookup = new EnhancedSubmissionLookupPublication(
+				enhancedMetadata, lookupPub);
+		Set<String> addedMetadata = new HashSet<String>();
+		for (String field : itemLookup.getFields()) {
+			String metadata = getMetadata(formName, itemLookup, field);
+			if (StringUtils.isBlank(metadata)) {
+				continue;
+			}
+			if (item.getMetadata(metadata).length == 0
+					|| addedMetadata.contains(metadata)) {
+				addedMetadata.add(metadata);
+				String[] md = splitMetadata(metadata);
+				if (isValidMetadata(formName, md)) {
+					if (isRepeatableMetadata(formName, md)) {
+						for (String value : itemLookup.getValues(field)) {
+							String[] splitValue = splitValue(value);
+							if (splitValue[3] != null) {
+								item.addMetadata(md[0], md[1], md[2], md[3],
+										splitValue[0], splitValue[1],
+										Integer.parseInt(splitValue[2]));
+							} else {
+								item.addMetadata(md[0], md[1], md[2], md[3],
+										value);
+							}
+						}
+					} else {
+						String value = itemLookup.getFirstValue(field);
+						String[] splitValue = splitValue(value);
+						if (splitValue[3] != null) {
+							item.addMetadata(md[0], md[1], md[2], md[3],
+									splitValue[0], splitValue[1],
+									Integer.parseInt(splitValue[2]));
+						} else {
+							item.addMetadata(md[0], md[1], md[2], md[3], value);
+						}
+					}
+				}
+			}
+		}
+
+		// creo un nuovo context per il check di esistenza dei metadata di cache
+		Context context = null;
+		try {
+			context = new Context();
+			for (SubmissionLookupPublication pub : dto.getPublications()) {
+				String providerName = pub.getProviderName();
+				if (providerName != MANUAL_USER_INPUT) {
+					for (String field : pub.getFields()) {
+						String metadata = getMetadata(formName, pub, field);
+						if (StringUtils.isBlank(metadata)) {
+							continue;
+						}
+
+						String[] md = splitMetadata(metadata);
+						if (isValidMetadata(formName, md)) {
+							makeSureMetadataExist(context, providerName, md[1],
+									md[2]);
+							if (isRepeatableMetadata(formName, md)) {
+								for (String value : pub.getValues(field)) {
+									String[] splitValue = splitValue(value);
+									item.addMetadata(providerName, md[1],
+											md[2], md[3], splitValue[0],
+											splitValue[1],
+											Integer.parseInt(splitValue[2]));
+								}
+							} else {
+								String[] splitValue = splitValue(pub
+										.getFirstValue(field));
+								item.addMetadata(providerName, md[1], md[2],
+										md[3], splitValue[0], splitValue[1],
+										Integer.parseInt(splitValue[2]));
+							}
+						}
+					}
+				}
+			}
+		} catch (Exception e) {
+			throw new RuntimeException(e.getMessage(), e);
+		} finally {
+			if (context != null && context.isValid()) {
+				context.abort();
+			}
+		}
+	}
+
+	private void makeSureMetadataExist(Context context, String schema,
+			String element, String qualifier) {
+		try {
+			context.turnOffAuthorisationSystem();
+			boolean create = false;
+			MetadataSchema mdschema = MetadataSchema.find(context, schema);
+			MetadataField mdfield = null;
+			if (mdschema == null) {
+				mdschema = new MetadataSchema(SL_NAMESPACE_PREFIX + schema,
+						schema);
+				mdschema.create(context);
+				create = true;
+			} else {
+				mdfield = MetadataField.findByElement(context,
+						mdschema.getSchemaID(), element, qualifier);
+			}
+
+			if (mdfield == null) {
+				mdfield = new MetadataField(mdschema, element, qualifier,
+						"Campo utilizzato per la cache del provider submission-lookup: "
+								+ schema);
+				mdfield.create(context);
+				create = true;
+			}
+			if (create) {
+				context.commit();
+			}
+			context.restoreAuthSystemState();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	private boolean isRepeatableMetadata(String formName, String[] md) {
+		try {
+			DCInput dcinput = getDCInput(formName, md[0], md[1], md[2]);
+			if (dcinput != null) {
+				return dcinput.isRepeatable();
+			}
+			return true;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	private boolean isValidMetadata(String formName, String[] md) {
+		try {
+			if (extraMetadataToKeep != null
+					&& extraMetadataToKeep.contains(StringUtils.join(
+							Arrays.copyOfRange(md, 0, 3), "."))) {
+				return true;
+			}
+            return getDCInput(formName, md[0], md[1], md[2])!=null;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+    private DCInput getDCInput(String formName, String schema,
+            String element, String qualifier) throws DCInputsReaderException
+    {
+        DCInputSet dcinputset = new DCInputsReader().getInputs(formName);
+        for (int idx = 0; idx < dcinputset.getNumberPages(); idx++)
+        {
+            for (DCInput dcinput : dcinputset.getPageRows(idx, true, true))
+            {
+                if (dcinput.getSchema().equals(schema)
+                        && dcinput.getElement().equals(element)
+                        && (dcinput.getQualifier() != null && dcinput
+                                .getQualifier().equals(qualifier))
+                        || (dcinput.getQualifier() == null && qualifier == null))
+                {
+                    return dcinput;
+                }
+            }
+        }
+        return null;
+    }
+
+	private String[] splitValue(String value) {
+		String[] splitted = value.split(SEPARATOR_VALUE_REGEX);
+		String[] result = new String[6];
+		result[0] = splitted[0];
+		result[2] = "-1";
+		result[3] = "-1";
+		result[4] = "-1";
+		if (splitted.length > 1) {
+			result[5] = "splitted";
+			if (StringUtils.isNotBlank(splitted[1])) {
+				result[1] = splitted[1];
+			}
+			if (splitted.length > 2) {
+				result[2] = String.valueOf(Integer.parseInt(splitted[2]));
+				if (splitted.length > 3) {
+					result[3] = String.valueOf(Integer.parseInt(splitted[3]));
+					if (splitted.length > 4) {
+						result[4] = String.valueOf(Integer
+								.parseInt(splitted[4]));
+					}
+				}
+			}
+		}
+		return result;
+	}
+
+	private String[] splitMetadata(String metadata) {
+		String[] mdSplit = new String[3];
+		if (StringUtils.isNotBlank(metadata)) {
+			String tmpSplit[] = metadata.split("\\.");
+			if (tmpSplit.length == 4) {
+				mdSplit = new String[4];
+				mdSplit[0] = tmpSplit[0];
+				mdSplit[1] = tmpSplit[1];
+				mdSplit[2] = tmpSplit[2];
+				mdSplit[3] = tmpSplit[3];
+			} else if (tmpSplit.length == 3) {
+				mdSplit = new String[4];
+				mdSplit[0] = tmpSplit[0];
+				mdSplit[1] = tmpSplit[1];
+				mdSplit[2] = tmpSplit[2];
+				mdSplit[3] = null;
+			} else if (tmpSplit.length == 2) {
+				mdSplit = new String[4];
+				mdSplit[0] = tmpSplit[0];
+				mdSplit[1] = tmpSplit[1];
+				mdSplit[2] = null;
+				mdSplit[3] = null;
+			}
+		}
+		return mdSplit;
+	}
+
+	private String getMetadata(String formName,
+			SubmissionLookupPublication itemLookup, String name) {
+		String type = itemLookup.getType();
+		String md = configuration.getProperty(
+				type + "." + name,
+				configuration.getProperty(formName + "." + name,
+						configuration.getProperty(name)));
+		if (md != null && md.contains("|")) {
+			String[] cond = md.trim().split("\\|");
+			for (int idx = 1; idx < cond.length; idx++) {
+				boolean temp = itemLookup.getFields().contains(cond[idx]);
+				if (temp) {
+					return null;
+				}
+			}
+			return cond[0];
+		}
+		return md;
+	}
+
+	public SubmissionLookupDTO getSubmissionLookupDTO(
+			HttpServletRequest request, String uuidSubmission) {
+		SubmissionLookupDTO dto = (SubmissionLookupDTO) request.getSession()
+				.getAttribute("submission_lookup_" + uuidSubmission);
+		if (dto == null) {
+			dto = new SubmissionLookupDTO();
+			storeDTOs(request, uuidSubmission, dto);
+		}
+		return dto;
+	}
+
+	public void invalidateDTOs(HttpServletRequest request, String uuidSubmission) {
+		request.getSession().removeAttribute(
+				"submission_lookup_" + uuidSubmission);
+	}
+
+	public void storeDTOs(HttpServletRequest request, String uuidSubmission,
+			SubmissionLookupDTO dto) {
+		request.getSession().setAttribute(
+				"submission_lookup_" + uuidSubmission, dto);
+	}
+
+	public List<SubmissionLookupProvider> getSearchProviders() {
+		return searchProviders;
+	}
+
+	public List<ItemSubmissionLookupDTO> searchByTerms(Context context,
+			String title, String author, int year) {
+		List<SubmissionLookupPublication> publications = new ArrayList<SubmissionLookupPublication>();
+		List<String> timeoutProviders = new ArrayList<String>();
+		for (SubmissionLookupProvider provider : searchProviders) {
+			List<SubmissionLookupPublication> pPublications = null;
+			try {
+				pPublications = provider.search(context, title, author, year);
+			} catch (SocketTimeoutException st) {
+				timeoutProviders.add(provider.getShortName());
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+			if (pPublications != null) {
+				publications.addAll(pPublications);
+			}
+		}
+		return buildItemSubmissionLookupDTO(context, publications, true,
+				timeoutProviders);
+	}
+
+	public List<ItemSubmissionLookupDTO> searchByIdentifiers(Context context,
+			Map<String, String> keys) {
+		Set<String> ids = keys.keySet();
+		List<SubmissionLookupPublication> publications = new ArrayList<SubmissionLookupPublication>();
+		List<String> timeoutProviders = new ArrayList<String>();
+		for (SubmissionLookupProvider provider : providers) {
+			for (String id : ids) {
+				if (provider.getSupportedIdentifiers().contains(id)) {
+					List<SubmissionLookupPublication> pPublications = null;
+					try {
+						pPublications = provider.getByIdentifier(context, keys);
+					} catch (SocketTimeoutException st) {
+						timeoutProviders.add(provider.getShortName());
+					} catch (Exception e) {
+						e.printStackTrace();
+					}
+					if (pPublications != null) {
+						publications.addAll(pPublications);
+					}
+					break;
+				}
+			}
+		}
+		return buildItemSubmissionLookupDTO(context, publications,
+				!ids.contains(SubmissionLookupProvider.DOI), timeoutProviders);
+	}
+
+	private List<ItemSubmissionLookupDTO> buildItemSubmissionLookupDTO(
+			Context context, List<SubmissionLookupPublication> publications,
+			boolean extend, List<String> evictProviders) {
+		Map<String, List<SubmissionLookupPublication>> doi2publications = new HashMap<String, List<SubmissionLookupPublication>>();
+		Map<String, Set<String>> provider2foundDOIs = new HashMap<String, Set<String>>();
+		List<String> foundDOIs = new ArrayList<String>();
+		List<SubmissionLookupPublication> allPublications = new ArrayList<SubmissionLookupPublication>();
+		allPublications.addAll(publications);
+
+		for (SubmissionLookupPublication publication : publications) {
+			String doi = publication
+					.getFirstValue(SubmissionLookupProvider.DOI);
+			if (doi == null) {
+				doi = NOT_FOUND_DOI;
+			} else {
+				doi = SubmissionLookupUtils.normalizeDOI(doi);
+				if (!foundDOIs.contains(doi))
+				{
+				    foundDOIs.add(doi);
+				}
+				Set<String> tmp = provider2foundDOIs.get(publication
+						.getProviderName());
+				if (tmp == null) {
+					tmp = new HashSet<String>();
+					provider2foundDOIs.put(publication.getProviderName(), tmp);
+				}
+				tmp.add(doi);
+			}
+
+			List<SubmissionLookupPublication> tmp = doi2publications.get(doi);
+			if (tmp == null) {
+				tmp = new ArrayList<SubmissionLookupPublication>();
+				doi2publications.put(doi, tmp);
+			}
+			tmp.add(publication);
+		}
+
+		if (extend) {
+			for (SubmissionLookupProvider provider : idents2provs
+					.get(SubmissionLookupProvider.DOI)) {
+				if (evictProviders != null
+						&& evictProviders.contains(provider.getShortName())) {
+					continue;
+				}
+				Set<String> doiToSearch = new HashSet<String>();
+				Set<String> alreadyFoundDOIs = provider2foundDOIs.get(provider
+						.getShortName());
+				for (String doi : foundDOIs) {
+					if (alreadyFoundDOIs == null
+							|| !alreadyFoundDOIs.contains(doi)) {
+						doiToSearch.add(doi);
+					}
+				}
+				List<SubmissionLookupPublication> pPublications = null;
+				try {
+					if (doiToSearch.size() > 0) {
+						pPublications = provider
+								.getByDOIs(context, doiToSearch);
+					}
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+				if (pPublications != null) {
+					allPublications.addAll(pPublications);
+					for (SubmissionLookupPublication publication : pPublications) {
+						String doi = publication
+								.getFirstValue(SubmissionLookupProvider.DOI);
+						List<SubmissionLookupPublication> tmp = doi2publications
+								.get(doi);
+						if (tmp == null) {
+							tmp = new ArrayList<SubmissionLookupPublication>();
+							doi2publications.put(doi, tmp);
+						}
+						tmp.add(publication);
+					}
+				}
+			}
+		}
+
+		List<ItemSubmissionLookupDTO> result = new ArrayList<ItemSubmissionLookupDTO>();
+
+		for (String doi : foundDOIs) {
+			ItemSubmissionLookupDTO dto = new ItemSubmissionLookupDTO(
+					doi2publications.get(doi));
+			result.add(dto);
+		}
+		
+		List<SubmissionLookupPublication> noDOIs = doi2publications
+                .get(NOT_FOUND_DOI);
+        if (noDOIs != null) {
+            for (SubmissionLookupPublication p : noDOIs) {
+                List<SubmissionLookupPublication> single = new ArrayList<SubmissionLookupPublication>();
+                single.add(p);
+                ItemSubmissionLookupDTO dto = new ItemSubmissionLookupDTO(
+                        single);
+                result.add(dto);
+            }
+        }
+		return result;
+	}
+
+	public List<SubmissionLookupProvider> getProviders() {
+		return providers;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/lookup/SubmissionLookupUtils.java

@@ -0,0 +1,217 @@
+package org.dspace.submit.lookup;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.content.DCValue;
+import org.dspace.content.Item;
+import org.dspace.content.MetadataSchema;
+import org.dspace.content.crosswalk.IConverter;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.PluginManager;
+import org.dspace.submit.util.SubmissionLookupPublication;
+
+public class SubmissionLookupUtils {
+	private static Logger log = Logger.getLogger(SubmissionLookupUtils.class);
+
+	/** Location of config file */
+	private static final String configFilePath = ConfigurationManager
+			.getProperty("dspace.dir")
+			+ File.separator
+			+ "config"
+			+ File.separator + "crosswalks" + File.separator;
+
+	private static final Map<String, Properties> importerProps = new HashMap<String, Properties>();
+
+	// Patter to extract the converter name if any
+	private static final Pattern converterPattern = Pattern
+			.compile(".*\\((.*)\\)");
+
+	public static LookupProvidersCheck getProvidersCheck(Context context,
+			Item item, String dcSchema, String dcElement, String dcQualifier) {
+		try {
+			LookupProvidersCheck check = new LookupProvidersCheck();
+			MetadataSchema[] schemas = MetadataSchema.findAll(context);
+			DCValue[] values = item.getMetadata(dcSchema, dcElement, dcQualifier, Item.ANY);
+			
+			for (MetadataSchema schema : schemas)
+			{
+				boolean error = false;
+				if (schema.getNamespace().startsWith(SubmissionLookupService.SL_NAMESPACE_PREFIX))
+				{
+					DCValue[] slCache = item.getMetadata(schema.getName(), dcElement, dcQualifier, Item.ANY);
+					if (slCache.length == 0)
+						continue;
+					
+					if (slCache.length != values.length)
+					{
+						error = true;
+					}
+					else
+					{
+						for (int idx = 0; idx < values.length; idx++)
+						{
+							DCValue v = values[idx];
+							DCValue sl = slCache[idx];
+							// FIXME gestire authority e possibilita' multiple:
+							// match non sicuri, affiliation, etc.
+							if (!v.value.equals(sl.value))
+							{
+								error = true;
+								break;
+							}
+						}
+					}
+					if (error)
+					{
+						check.getProvidersErr().add(schema.getName());
+					}
+					else
+					{
+						check.getProvidersOk().add(schema.getName());
+					}
+				}
+			}
+			return check;
+		} catch (Exception e) {
+			log.error(e.getMessage(), e);
+			throw new RuntimeException(e.getMessage(), e);
+		}
+
+	}
+
+	public static SubmissionLookupPublication convert(String shortName,
+			Object bean) throws SecurityException, NoSuchMethodException,
+			IllegalArgumentException, IllegalAccessException,
+			InvocationTargetException {
+		SubmissionLookupPublication publication = new SubmissionLookupPublication(
+				shortName);
+		Field[] fields = bean.getClass().getDeclaredFields();
+		for (Field field : fields) {
+			if (field.getType() == String.class) {
+				Method getter = bean.getClass().getMethod(
+						"get" + field.getName().substring(0, 1).toUpperCase()
+								+ field.getName().substring(1));
+
+				String value = (String) getter.invoke(bean);
+
+				addMetadata(shortName, publication, field.getName(), value);
+
+			} else if (field.getType() == List.class) {
+				ParameterizedType pt = (ParameterizedType) field
+						.getGenericType();
+
+				Method getter = bean.getClass().getMethod(
+						"get" + field.getName().substring(0, 1).toUpperCase()
+								+ field.getName().substring(1));
+
+				if (pt.getActualTypeArguments()[0] instanceof GenericArrayType) { // nomi
+																					// di
+																					// persone
+					List<String[]> values = (List<String[]>) getter
+							.invoke(bean);
+					if (values != null) {
+						for (String[] nvalue : values) {
+							String value = nvalue[1] + ", " + nvalue[0];
+							addMetadata(shortName, publication,
+									field.getName(), value);
+						}
+					}
+				} else { // metadati ripetibili
+					List<String> values = (List<String>) getter.invoke(bean);
+					if (values != null) {
+						for (String value : values) {
+							addMetadata(shortName, publication,
+									field.getName(), value);
+						}
+					}
+				}
+			}
+		}
+		return publication;
+	}
+
+	private static void addMetadata(String config,
+			SubmissionLookupPublication publication, String name, String value) {
+		String md = getSubmissionLoookupConfiguration(config).getProperty(name);
+
+		if (StringUtils.isBlank(md)) {
+			return;
+		} else {
+			md = md.trim();
+		}
+
+		Matcher converterMatcher = converterPattern.matcher(md);
+		String converterName = null;
+		if (converterMatcher.matches()) {
+			converterName = converterMatcher.group(1);
+			md = md.replaceAll("\\(" + converterName + "\\)", "");
+		}
+		IConverter converter = (IConverter) PluginManager.getNamedPlugin(
+				IConverter.class, converterName);
+
+		String nValue;
+		if (converter != null) {
+			nValue = converter.makeConversion(value);
+		} else {
+			nValue = value;
+		}
+		publication.add(md, nValue);
+	}
+
+	private static synchronized Properties getSubmissionLoookupConfiguration(
+			String config) {
+		Properties properties = importerProps.get(config);
+		if (properties != null) {
+			return properties;
+		}
+		// Read in configuration
+		properties = new Properties();
+		importerProps.put(config, properties);
+		FileInputStream fis = null;
+		try {
+			fis = new FileInputStream(configFilePath + config
+					+ "-submission.properties");
+			properties.load(fis);
+		} catch (Exception notfound) {
+			throw new IllegalArgumentException(
+					"Impossibile leggere la configurazione per il SubmissionLookupProvider "
+							+ config, notfound);
+		} finally {
+			if (fis != null) {
+				try {
+					fis.close();
+				} catch (IOException ioe) {
+					log.error(ioe.getMessage(), ioe);
+				}
+			}
+		}
+
+		return properties;
+	}
+
+	public static String normalizeDOI(String doi) {
+		if (doi != null)
+		{
+		    return doi.trim().replaceAll("^http://dx.doi.org/", "")
+	                .replaceAll("^doi:", "");	
+		}
+		return null;
+		
+	}
+}

dspace-api/src/main/java/org/dspace/submit/step/StartSubmissionLookupStep.java

@@ -0,0 +1,268 @@
+/*
+ * SelectCollectionStep.java
+ *
+ * Version: $Revision: 3738 $
+ *
+ * Date: $Date: 2009-04-24 06:32:12 +0200 (ven, 24 apr 2009) $
+ *
+ * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the DSpace Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.submit.step;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.app.util.DCInputSet;
+import org.dspace.app.util.DCInputsReader;
+import org.dspace.app.util.SubmissionInfo;
+import org.dspace.app.util.Util;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.content.Collection;
+import org.dspace.content.WorkspaceItem;
+import org.dspace.core.Context;
+import org.dspace.submit.AbstractProcessingStep;
+import org.dspace.submit.lookup.SubmissionLookupService;
+import org.dspace.submit.util.ItemSubmissionLookupDTO;
+import org.dspace.submit.util.SubmissionLookupDTO;
+import org.dspace.submit.util.SubmissionLookupPublication;
+import org.dspace.utils.DSpace;
+
+/**
+ * SelectCollection Step which processes the collection that the user selected
+ * in that step of the DSpace Submission process
+ * <P>
+ * This class performs all the behind-the-scenes processing that
+ * this particular step requires.  This class's methods are utilized 
+ * by both the JSP-UI and the Manakin XML-UI
+ * 
+ * @see org.dspace.app.util.SubmissionConfig
+ * @see org.dspace.app.util.SubmissionStepConfig
+ * @see org.dspace.submit.AbstractProcessingStep
+ * 
+ * @author Tim Donohue
+ * @version $Revision: 3738 $
+ */
+public class StartSubmissionLookupStep extends AbstractProcessingStep
+{
+    /***************************************************************************
+     * STATUS / ERROR FLAGS (returned by doProcessing() if an error occurs or
+     * additional user interaction may be required)
+     * 
+     * (Do NOT use status of 0, since it corresponds to STATUS_COMPLETE flag
+     * defined in the JSPStepManager class)
+     **************************************************************************/
+    // no collection was selected
+    public static final int STATUS_NO_COLLECTION = 1;
+
+    // invalid collection or error finding collection
+    public static final int STATUS_INVALID_COLLECTION = 2;
+    
+    public static final int STATUS_NO_SUUID = 3;
+    
+    public static final int STATUS_SUBMISSION_EXPIRED = 4;
+
+	private SubmissionLookupService slService = new DSpace()
+			.getServiceManager().getServiceByName(
+					SubmissionLookupService.class.getCanonicalName(),
+					SubmissionLookupService.class);
+	
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(StartSubmissionLookupStep.class);
+
+    /**
+     * Do any processing of the information input by the user, and/or perform
+     * step processing (if no user interaction required)
+     * <P>
+     * It is this method's job to save any data to the underlying database, as
+     * necessary, and return error messages (if any) which can then be processed
+     * by the appropriate user interface (JSP-UI or XML-UI)
+     * <P>
+     * NOTE: If this step is a non-interactive step (i.e. requires no UI), then
+     * it should perform *all* of its processing in this method!
+     * 
+     * @param context
+     *            current DSpace context
+     * @param request
+     *            current servlet request object
+     * @param response
+     *            current servlet response object
+     * @param subInfo
+     *            submission info object
+     * @return Status or error flag which will be processed by
+     *         doPostProcessing() below! (if STATUS_COMPLETE or 0 is returned,
+     *         no errors occurred!)
+     */
+    public int doProcessing(Context context, HttpServletRequest request,
+            HttpServletResponse response, SubmissionInfo subInfo)
+            throws ServletException, IOException, SQLException,
+            AuthorizeException
+    {
+        // First we find the collection which was selected
+        int id = Util.getIntParameter(request, "collectionid");
+        String titolo = request.getParameter("search_title");
+        String date = request.getParameter("search_year");
+        String autori = request.getParameter("search_authors");
+        String uuidSubmission = request.getParameter("suuid");
+        String uuidLookup = request.getParameter("iuuid");
+        
+        if (StringUtils.isBlank(uuidSubmission))
+        {
+        	return STATUS_NO_SUUID;
+        }
+        
+		SubmissionLookupDTO submissionDTO = slService.getSubmissionLookupDTO(
+				request, uuidSubmission);
+		
+        if (submissionDTO == null)
+        {
+        	return STATUS_SUBMISSION_EXPIRED;
+        }
+        
+        ItemSubmissionLookupDTO itemLookup = null;
+    	if (StringUtils.isNotBlank(uuidLookup))
+        {
+    		itemLookup = submissionDTO.getLookupItem(uuidLookup);
+    		if (itemLookup == null)
+    		{
+    			return STATUS_SUBMISSION_EXPIRED;
+    		}
+        }
+        // if the user didn't select a collection,
+        // send him/her back to "select a collection" page
+        if (id < 0)
+        {
+            return STATUS_NO_COLLECTION;
+        }
+
+        // try to load the collection
+        Collection col = Collection.find(context, id);
+
+        // Show an error if the collection is invalid
+        if (col == null)
+        {
+            return STATUS_INVALID_COLLECTION;
+        }
+        else
+        {
+            // create our new Workspace Item
+            WorkspaceItem wi = WorkspaceItem.create(context, col, true);
+            DCInputSet inputSet = null;
+			try {
+				inputSet = new DCInputsReader().getInputs(col.getHandle());
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+            if (itemLookup != null)
+            {
+				slService.merge(inputSet.getFormName(), wi.getItem(),
+						itemLookup);
+            }
+            else
+            {
+				SubmissionLookupPublication manualPub = new SubmissionLookupPublication(
+						SubmissionLookupService.MANUAL_USER_INPUT);
+            	manualPub.add("title", titolo);
+            	manualPub.add("year", date);
+            	manualPub.add("allauthors", autori);
+            	
+            	Enumeration e = request.getParameterNames();
+
+    			while (e.hasMoreElements()) {
+    				String parameterName = (String) e.nextElement();
+    				String parameterValue = request.getParameter(parameterName);
+
+    				if (parameterName.startsWith("identifier_")
+    						&& StringUtils.isNotBlank(parameterValue)) {
+    					manualPub.add(
+    							parameterName.substring("identifier_".length()),
+    							parameterValue);
+    				}
+    			}
+    			List<SubmissionLookupPublication> publications = new ArrayList<SubmissionLookupPublication>();
+    			publications.add(manualPub);
+    			ItemSubmissionLookupDTO dto = new ItemSubmissionLookupDTO(publications);
+            	slService.merge(inputSet.getFormName(), wi.getItem(), dto);
+            }
+            
+            // update Submission Information with this Workspace Item
+            subInfo.setSubmissionItem(wi);
+
+            // commit changes to database
+            context.commit();
+
+            // need to reload current submission process config,
+            // since it is based on the Collection selected
+            subInfo.reloadSubmissionConfig(request);
+        }
+
+        slService.invalidateDTOs(request, uuidSubmission);
+        // no errors occurred
+        return STATUS_COMPLETE;
+    }
+
+	/**
+     * Retrieves the number of pages that this "step" extends over. This method
+     * is used to build the progress bar.
+     * <P>
+     * This method may just return 1 for most steps (since most steps consist of
+     * a single page). But, it should return a number greater than 1 for any
+     * "step" which spans across a number of HTML pages. For example, the
+     * configurable "Describe" step (configured using input-forms.xml) overrides
+     * this method to return the number of pages that are defined by its
+     * configuration file.
+     * <P>
+     * Steps which are non-interactive (i.e. they do not display an interface to
+     * the user) should return a value of 1, so that they are only processed
+     * once!
+     * 
+     * @param request
+     *            The HTTP Request
+     * @param subInfo
+     *            The current submission information object
+     * 
+     * @return the number of pages in this step
+     */
+    public int getNumberOfPages(HttpServletRequest request,
+            SubmissionInfo subInfo) throws ServletException
+    {
+        // there is always just one page in the "select a collection" step!
+        return 1;
+    }
+}

dspace-api/src/main/java/org/dspace/submit/util/EnhancedSubmissionLookupPublication.java

@@ -0,0 +1,78 @@
+package org.dspace.submit.util;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.dspace.submit.lookup.EnhancerSubmissionLookup;
+
+public class EnhancedSubmissionLookupPublication extends SubmissionLookupPublication {
+	private SubmissionLookupPublication lookupPublication;
+	private Map<String, EnhancerSubmissionLookup> enhancedMetadata;
+	
+	private Map<String, List<String>> cacheEnhanched = new HashMap<String, List<String>>();
+
+	public EnhancedSubmissionLookupPublication(Map<String, EnhancerSubmissionLookup> enhancedMetadata, SubmissionLookupPublication pub) {
+		super(pub.getProviderName());
+		this.lookupPublication = pub;
+		this.enhancedMetadata = enhancedMetadata;
+	}	
+
+	@Override
+	public Set<String> getFields() {
+		Set<String> eFields = new HashSet<String>();
+		if (lookupPublication.getFields() != null)
+		{
+			for (String s : lookupPublication.getFields())
+			{
+				eFields.add(s);
+			}
+		}
+		if (enhancedMetadata != null)
+		{
+			for (String s : enhancedMetadata.keySet())
+			{
+				if (getValues(s) != null)
+				{
+					eFields.add(s);
+				}
+			}
+		}
+		
+		return eFields;
+	}
+	
+	@Override
+	public String getFirstValue(String md) {
+		List<String> values = getValues(md);
+		if (values != null && values.size() > 0)
+		{
+			return values.get(0);
+		}
+		return null;
+	}
+	
+	@Override
+	public List<String> getValues(String md) {
+		if (enhancedMetadata != null && enhancedMetadata.keySet().contains(md))
+		{
+			if (cacheEnhanched != null && cacheEnhanched.keySet().contains(md))
+			{
+				return cacheEnhanched.get(md);
+			}
+			else
+			{
+				EnhancerSubmissionLookup enhancer = enhancedMetadata.get(md);
+				List<String> values = enhancer.getValues(this);
+				cacheEnhanched.put(md, values);
+				return values;
+			}
+		}
+		else
+		{
+			return lookupPublication.getValues(md);
+		}
+	}
+}

dspace-api/src/main/java/org/dspace/submit/util/ItemSubmissionLookupDTO.java

@@ -0,0 +1,82 @@
+package org.dspace.submit.util;
+
+import java.io.Serializable;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import org.dspace.submit.lookup.SubmissionLookupProvider;
+
+public class ItemSubmissionLookupDTO implements Serializable {
+	private static final long serialVersionUID = 1;
+
+	private static final String MERGED_PUBLICATION_PROVIDER = "merged";
+	
+	private List<SubmissionLookupPublication> publications;
+	private String uuid;
+
+	public ItemSubmissionLookupDTO(List<SubmissionLookupPublication> publications) {
+		this.uuid = UUID.randomUUID().toString();
+		this.publications = publications;
+	}
+
+	public List<SubmissionLookupPublication> getPublications() {
+		return publications;
+	}
+	
+	public Set<String> getProviders() {
+		Set<String> orderedProviders = new LinkedHashSet<String>();
+		for (SubmissionLookupPublication p : publications)
+		{
+			orderedProviders.add(p.getProviderName());
+		}
+		return orderedProviders;
+	}
+
+	public String getUUID() {
+		return uuid;
+	}
+
+	public SubmissionLookupPublication getTotalPublication(
+			List<SubmissionLookupProvider> providers) {
+		if (publications == null)
+		{
+			return null;
+		}
+		else if (publications.size() == 1)
+		{
+			return publications.get(0);
+		}
+		else
+		{
+			SubmissionLookupPublication pub = new SubmissionLookupPublication(
+					MERGED_PUBLICATION_PROVIDER);
+			for (SubmissionLookupProvider prov : providers)
+			{				
+				for (SubmissionLookupPublication p : publications)
+				{
+					if (!p.getProviderName().equals(prov.getShortName()))
+					{
+						continue;
+					}
+					for (String field : p.getFields())
+					{
+						List<String> values = p.getValues(field);
+						if (values != null && values.size() > 0)
+						{
+							if (!pub.getFields().contains(field))
+							{
+								for (String v : values)
+								{
+									pub.add(field, v);
+								}
+							}
+						}
+					}
+				}
+			}
+			return pub;
+		}
+	}
+}

dspace-api/src/main/java/org/dspace/submit/util/RepeatableToSingleValueEnhancer.java

@@ -0,0 +1,65 @@
+package org.dspace.submit.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.lang.StringUtils;
+import org.dspace.submit.lookup.EnhancerSubmissionLookup;
+
+public class RepeatableToSingleValueEnhancer implements
+		EnhancerSubmissionLookup {
+	private String separator = ",";
+	private boolean separatorWhitespaceAfter = true;
+	private List<String> singleValues;
+
+	@Override
+	public List<String> getValues(SubmissionLookupPublication publication) {
+		List<String> values = new ArrayList<String>();
+		for (String s : singleValues) {
+			if (publication.getValues(s) != null) {
+				values.addAll(publication.getValues(s));
+			}
+		}
+		if (values.size() > 0) {
+			String v = StringUtils.join(values.iterator(), separator
+					+ (separatorWhitespaceAfter ? " " : ""));
+			List<String> res = new ArrayList<String>();
+			res.add(v);
+			return res;
+		} else {
+			return null;
+		}
+
+	}
+
+	public String getSeparator() {
+		return separator;
+	}
+
+	public void setSeparator(String separator) {
+	    if ("\\n".equals(separator))
+	    {
+	        this.separator = "\n";
+	    }
+	    else
+	    {
+	        this.separator = separator;
+	    }
+	}
+
+	public boolean isSeparatorWhitespaceAfter() {
+		return separatorWhitespaceAfter;
+	}
+
+	public void setSeparatorWhitespaceAfter(boolean separatorWhitespaceAfter) {
+		this.separatorWhitespaceAfter = separatorWhitespaceAfter;
+	}
+
+	public List<String> getSingleValues() {
+		return singleValues;
+	}
+
+	public void setSingleValues(List<String> singleValues) {
+		this.singleValues = singleValues;
+	}
+}

dspace-api/src/main/java/org/dspace/submit/util/SubmissionLookupDTO.java

@@ -0,0 +1,35 @@
+package org.dspace.submit.util;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.UUID;
+
+public class SubmissionLookupDTO implements Serializable {
+	private static final long serialVersionUID = 1;
+	
+	private String uuid;
+
+	private List<ItemSubmissionLookupDTO> items;
+
+	public SubmissionLookupDTO() {
+		this.uuid = UUID.randomUUID().toString();
+	}
+	
+	public void setItems(List<ItemSubmissionLookupDTO> items) {
+		this.items = items;
+	}
+
+	public ItemSubmissionLookupDTO getLookupItem(String uuidLookup) {
+		if (items != null)
+		{
+			for (ItemSubmissionLookupDTO item : items)
+			{
+				if (item.getUUID().equals(uuidLookup))
+				{
+					return item;
+				}
+			}
+		}
+		return null;		
+	}
+}

dspace-api/src/main/java/org/dspace/submit/util/SubmissionLookupPublication.java

@@ -0,0 +1,66 @@
+package org.dspace.submit.util;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.lang.StringUtils;
+import org.dspace.submit.lookup.SubmissionLookupProvider;
+
+public class SubmissionLookupPublication implements Serializable {
+	private String providerName;
+
+	private Map<String, List<String>> storage = new HashMap<String, List<String>>();
+
+	public SubmissionLookupPublication(String providerName) {
+		this.providerName = providerName;
+	}
+
+	// necessario per poter effettuare la serializzazione in JSON dei dati
+	public Map<String, List<String>> getStorage() {
+		return storage;
+	}
+	
+	public Set<String> getFields() {
+		return storage.keySet();
+	}
+
+	public List<String> remove(String md) {
+		return storage.remove(md);
+	}
+
+	public void add(String md, String nValue) {
+		if (StringUtils.isNotBlank(nValue))
+		{
+			List<String> tmp = storage.get(md);
+			if (tmp == null) {
+				tmp = new ArrayList<String>();
+				storage.put(md, tmp);
+			}
+			tmp.add(nValue);
+		}
+	}
+
+	public String getFirstValue(String md) {
+		List<String> tmp = storage.get(md);
+		if (tmp == null || tmp.size() == 0) {
+			return null;
+		}
+		return tmp.get(0);
+	}
+
+	public List<String> getValues(String md) {
+		return storage.get(md);
+	}
+
+	public String getProviderName() {
+		return providerName;
+	}
+
+	public String getType() {
+		return getFirstValue(SubmissionLookupProvider.TYPE);
+	}
+}

dspace-api/src/main/resources/Messages.properties

@@ -1676,3 +1676,33 @@ jsp.layout.navbar-admin.accesscontrol	=	Access Control
 jsp.layout.navbar-admin.contents		= 	Content
 jsp.layout.navbar-admin.items			= 	Items
 jsp.layout.navbar-admin.settings		= 	General Settings
+
+jsp.submit.start-lookup-submission.title = Nuova proposta di immissione
+jsp.submit.start-lookup-submission.heading = Nuova proposta di immissione: recupera i dati da database bibliografici
+jsp.submit.start-lookup-submission.tabs.search = Form di ricerca
+jsp.submit.start-lookup-submission.tabs.result = Risultati
+jsp.submit.start-lookup-submission.identifiers = Ricerca per identificativo
+
+jsp.submit.start-lookup-submission.identifiers.hints = Inserisci gli identificativi della pubblicazione, generalmente è sufficiente digitare un unico identificativo preferibilmente il DOI.
+jsp.submit.start-lookup-submission.identifier-doi = DOI (Digital Object Identifier)		
+jsp.submit.start-lookup-submission.identifier-doi.hint = es. 10.1392/dironix		
+jsp.submit.start-lookup-submission.identifier-pubmed = PubMed ID
+jsp.submit.start-lookup-submission.identifier-pubmed.hint = es. 20524090
+jsp.submit.start-lookup-submission.identifier-arxiv = arXiv ID
+jsp.submit.start-lookup-submission.identifier-arxiv.hint = es. arXiv:1302.1497
+jsp.submit.start-lookup-submission.search = Ricerca libera
+
+jsp.submit.start-lookup-submission.search.hints = Insert base info about publication: either <b>title or the couple author / year</b> is required.<br/>If you known an unique identifier about publication like <b>DOI, Pubmed, arXiv</b> you can switch on the <span id="link-ricerca-identificatore">identifier search mode</span>.
+jsp.submit.start-lookup-submission.search.title = Title
+jsp.submit.start-lookup-submission.search.year = Year
+jsp.submit.start-lookup-submission.search.authors = Authors/Publishers	 
+jsp.submit.start-lookup-submission.identifier.lookup = Search
+jsp.submit.start-lookup-submission.search-go = Search
+jsp.submit.start-lookup-submission.exit = Exit
+jsp.submit.start-lookup-submission.search-loading.title = Loading...
+jsp.submit.start-lookup-submission.search-loading.hint = We are contact the external service to retrieve the publication if you desire. Waiting the complete request, if you close this windows the request abort. 
+jsp.submit.edit-metadata.affiliation.select = Multiple possible matches, please select 
+jsp.submit.edit-metadata.affiliation.other = Other
+jsp.submit.start-lookup-submission.no-collection-warn.title = Warning, no collection
+jsp.submit.start-lookup-submission.no-collection-warn.hint = The collection of the pubblication is required.
+jsp.submit.start-lookup-submission.manual-submission = Default mode Submission

dspace-api/src/main/resources/spring/spring-dspace-addon-submissionlookup-services.xml

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans 
+           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+           http://www.springframework.org/schema/context
+           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<bean class="org.dspace.submit.lookup.SubmissionLookupService"
+		name="org.dspace.submit.lookup.SubmissionLookupService">
+		<property name="providers">
+			<list>
+				<!-- <ref bean="scopusLookupProvider" /> -->
+				<ref bean="pubmedLookupProvider" />
+				<ref bean="crossrefLookupProvider" />
+				<ref bean="arxivLookupProvider" />
+			</list>
+		</property>
+		<property name="extraMetadataToKeep">
+			<list>
+				<value>dc.import.contributorauthor</value>
+				<value>dc.import.contributoreditor</value>
+				<value>dc.import.contributortranslator</value>
+				<!-- <value>dc.description.scopusurl</value>
+				<value>dc.description.scopuscitationcount</value>
+				<value>dc.description.scopuscitationurl</value>-->
+			</list>
+		</property> 
+		<property name="enhancedMetadata">
+			<map>
+				<entry key="allauthors">
+					<bean class="org.dspace.submit.util.RepeatableToSingleValueEnhancer">
+						<property name="separator" value="\n" />
+						<property name="separatorWhitespaceAfter" value="false" />
+						<property name="singleValues">
+						<list>
+							<value>authors</value>
+						</list>
+						</property>
+					</bean>
+				</entry>
+				<entry key="allkeywords">
+					<bean class="org.dspace.submit.util.RepeatableToSingleValueEnhancer">
+						<property name="separator" value=";" />
+						<property name="singleValues">
+						<list>
+							<value>keywords</value>
+							<value>mesh</value>
+						</list>
+						</property>
+					</bean>
+				</entry>
+			</map>
+		</property>
+	</bean>
+
+	
+	<bean class="org.dspace.submit.lookup.PubmedService" name="pubmedService" />
+	<bean class="org.dspace.submit.lookup.PubmedLookupProvider"
+		name="pubmedLookupProvider">
+		<property name="pubmedService" ref="pubmedService" />
+		<property name="searchProvider" value="false" />
+	</bean>
+
+	<bean class="org.dspace.submit.lookup.ArXivService" name="arXivService" />
+	<bean class="org.dspace.submit.lookup.ArXivLookupProvider"
+		name="arxivLookupProvider">
+		<property name="arXivService" ref="arXivService" />
+		<property name="searchProvider" value="false" />
+	</bean>
+	
+	<bean class="org.dspace.submit.lookup.CrossRefService" name="crossrefService" />	
+	<bean class="org.dspace.submit.lookup.CrossRefLookupProvider"
+		name="crossrefLookupProvider">
+		<property name="crossrefService" ref="crossrefService" />
+		<property name="searchProvider" value="false" />
+	</bean>
+		
+</beans>

dspace-jspui/pom.xml

@@ -129,8 +129,7 @@
         </dependency>
         <dependency>
             <groupId>net.sf.flexjson</groupId>
-            <artifactId>flexjson</artifactId>
+            <artifactId>flexjson</artifactId>            
-            <version>2.1</version>
         </dependency>
 
     </dependencies>

dspace-jspui/src/main/java/org/dspace/app/webui/json/SubmissionLookupJSONRequest.java

@@ -0,0 +1,154 @@
+package org.dspace.app.webui.json;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.app.webui.util.UIUtil;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Context;
+import org.dspace.core.I18nUtil;
+import org.dspace.submit.lookup.SubmissionLookupService;
+import org.dspace.submit.util.ItemSubmissionLookupDTO;
+import org.dspace.submit.util.SubmissionLookupDTO;
+import org.dspace.submit.util.SubmissionLookupPublication;
+import org.dspace.utils.DSpace;
+
+import flexjson.JSONSerializer;
+
+public class SubmissionLookupJSONRequest extends JSONRequest {
+
+	private SubmissionLookupService service = new DSpace().getServiceManager()
+			.getServiceByName(SubmissionLookupService.class.getName(),
+					SubmissionLookupService.class);
+
+	private static Logger log = Logger
+			.getLogger(SubmissionLookupJSONRequest.class);
+
+	@Override
+	public void doJSONRequest(Context context, HttpServletRequest req,
+			HttpServletResponse resp) throws AuthorizeException, IOException 
+			{
+		String suuid = req.getParameter("s_uuid");
+		SubmissionLookupDTO subDTO = service.getSubmissionLookupDTO(req, suuid);
+		if ("identifiers".equalsIgnoreCase(req.getParameter("type"))) {
+			Map<String, String> identifiers = new HashMap<String, String>();
+			Enumeration e = req.getParameterNames();
+
+			while (e.hasMoreElements()) {
+				String parameterName = (String) e.nextElement();
+				String parameterValue = req.getParameter(parameterName);
+
+				if (parameterName.startsWith("identifier_")
+						&& StringUtils.isNotBlank(parameterValue)) {
+					identifiers.put(
+							parameterName.substring("identifier_".length()),
+							parameterValue);
+				}
+			}
+
+			List<ItemSubmissionLookupDTO> result = service
+					.searchByIdentifiers(context, identifiers);
+			subDTO.setItems(result);
+			service.storeDTOs(req, suuid, subDTO);
+			List<Map<String, Object>> dto = getLightResultList(result);
+			JSONSerializer serializer = new JSONSerializer();
+			serializer.rootName("result");
+			serializer.deepSerialize(dto, resp.getWriter());
+		} else if ("search".equalsIgnoreCase(req.getParameter("type"))) {
+			String title = req.getParameter("title");
+			String author = req.getParameter("authors");
+			int year = UIUtil.getIntParameter(req, "year");
+
+			List<ItemSubmissionLookupDTO> result = service.searchByTerms(context, title,
+					author, year);
+
+			subDTO.setItems(result);
+			service.storeDTOs(req, suuid, subDTO);
+			List<Map<String, Object>> dto = getLightResultList(result);
+			JSONSerializer serializer = new JSONSerializer();
+			serializer.rootName("result");
+			serializer.deepSerialize(dto, resp.getWriter());
+		} else if ("details".equalsIgnoreCase(req.getParameter("type"))) {
+			String i_uuid = req.getParameter("i_uuid");
+			JSONSerializer serializer = new JSONSerializer();
+			serializer.rootName("result");
+			Map<String, Object> dto = getDetails(subDTO.getLookupItem(i_uuid),
+					context);
+			serializer.deepSerialize(dto, resp.getWriter());
+		}
+	}
+
+	private Map<String, Object> getDetails(ItemSubmissionLookupDTO item,
+			Context context) {
+		List<String> fieldOrder = getFieldOrderFromConfiguration();
+		SubmissionLookupPublication totalData = item.getTotalPublication(service.getProviders());
+		Set<String> availableFields = totalData.getFields();
+		List<String[]> fieldsLabels = new ArrayList<String[]>();
+		for (String f : fieldOrder) {
+			if (availableFields.contains(f)) {
+				try {
+					fieldsLabels.add(new String[] {
+							f,
+							I18nUtil.getMessage("jsp.submission-lookup.detail."
+									+ f, context) });
+				} catch (MissingResourceException e) {
+					fieldsLabels.add(new String[] { f, f });
+				}
+			}
+		}
+		Map<String, Object> data = new HashMap<String, Object>();
+		String uuid = item.getUUID();
+		SubmissionLookupPublication pub = item.getTotalPublication(service.getProviders());
+		data.put("uuid", uuid);
+		data.put("providers", item.getProviders());
+		data.put("publication", pub);
+		data.put("fieldsLabels", fieldsLabels);
+		return data;
+	}
+
+	private List<String> getFieldOrderFromConfiguration() {
+		String config = ConfigurationManager
+				.getProperty("submission-lookup.detail.fields");
+		if (config == null) {
+			config = "title,authors,editors,years,doi,pmid,eid,arxiv,journal,jissn,jeissn,volume,issue,serie,sissn,seissn,abstract,mesh,keywords,subtype";
+		}
+		List<String> result = new ArrayList<String>();
+		String[] split = config.split(",");
+		for (String s : split) {
+			if (StringUtils.isNotBlank(s)) {
+				result.add(s.trim());
+			}
+		}
+		return result;
+	}
+
+	private List<Map<String, Object>> getLightResultList(
+			List<ItemSubmissionLookupDTO> result) {
+		List<Map<String, Object>> publications = new ArrayList<Map<String, Object>>();
+		for (ItemSubmissionLookupDTO item : result) {
+			String uuid = item.getUUID();
+			SubmissionLookupPublication pub = item.getTotalPublication(service.getProviders());
+			Map<String, Object> data = new HashMap<String, Object>();
+			data.put("uuid", uuid);
+			data.put("providers", item.getProviders());
+			data.put("title", pub.getFirstValue("title"));
+			data.put("authors",pub.getValues("authors")!=null?
+					StringUtils.join(pub.getValues("authors").iterator(), ", "):"");
+			data.put("issued", pub.getFirstValue("issued"));
+			publications.add(data);
+		}
+		return publications;
+	}
+}

dspace-jspui/src/main/java/org/dspace/app/webui/submit/step/JSPStartSubmissionLookupStep.java

@@ -0,0 +1,311 @@
+/*
+ * JSPSelectCollectionStep.java
+ *
+ * Version: $Revision$
+ *
+ * Date: $Date$
+ *
+ * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts
+ * Institute of Technology.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Hewlett-Packard Company nor the name of the
+ * Massachusetts Institute of Technology nor the names of their
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package org.dspace.app.webui.submit.step;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.dspace.app.util.SubmissionInfo;
+import org.dspace.app.webui.submit.JSPStep;
+import org.dspace.app.webui.submit.JSPStepManager;
+import org.dspace.app.webui.util.JSPManager;
+import org.dspace.app.webui.util.UIUtil;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.authorize.AuthorizeManager;
+import org.dspace.content.Collection;
+import org.dspace.content.Community;
+import org.dspace.core.ConfigurationManager;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.submit.lookup.SubmissionLookupProvider;
+import org.dspace.submit.lookup.SubmissionLookupService;
+import org.dspace.submit.step.StartSubmissionLookupStep;
+import org.dspace.utils.DSpace;
+
+/**
+ * Step which controls selecting an item from external database service to auto fill metadata 
+ * for DSpace JSP-UI
+ * <P>
+ * This JSPStep class works with the SubmissionController servlet
+ * for the JSP-UI
+ * <P>
+ * The following methods are called in this order:
+ * <ul>
+ * <li>Call doPreProcessing() method</li>
+ * <li>If showJSP() was specified from doPreProcessing(), then the JSP
+ * specified will be displayed</li>
+ * <li>If showJSP() was not specified from doPreProcessing(), then the
+ * doProcessing() method is called an the step completes immediately</li>
+ * <li>Call doProcessing() method on appropriate AbstractProcessingStep after the user returns from the JSP, in order
+ * to process the user input</li>
+ * <li>Call doPostProcessing() method to determine if more user interaction is
+ * required, and if further JSPs need to be called.</li>
+ * <li>If there are more "pages" in this step then, the process begins again
+ * (for the new page).</li>
+ * <li>Once all pages are complete, control is forwarded back to the
+ * SubmissionController, and the next step is called.</li>
+ * </ul>
+ * 
+ * @see org.dspace.app.webui.servlet.SubmissionController
+ * @see org.dspace.app.webui.submit.JSPStep
+ * @see org.dspace.submit.step.StartSubmissionLookupStep
+ * 
+ * @author Andrea Bollini
+ * @version $Revision$
+ */
+public class JSPStartSubmissionLookupStep extends JSPStep
+{
+    /** JSP which displays HTML for this Class * */
+    private static final String START_LOOKUP_JSP = "/submit/start-lookup-submission.jsp";
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(JSPStartSubmissionLookupStep.class);
+
+    SubmissionLookupService slService = new DSpace().getServiceManager()
+			.getServiceByName(
+					SubmissionLookupService.class.getCanonicalName(),
+					SubmissionLookupService.class);
+    /**
+     * Do any pre-processing to determine which JSP (if any) is used to generate
+     * the UI for this step. This method should include the gathering and
+     * validating of all data required by the JSP. In addition, if the JSP
+     * requires any variable to passed to it on the Request, this method should
+     * set those variables.
+     * <P>
+     * If this step requires user interaction, then this method must call the
+     * JSP to display, using the "showJSP()" method of the JSPStepManager class.
+     * <P>
+     * If this step doesn't require user interaction OR you are solely using
+     * Manakin for your user interface, then this method may be left EMPTY,
+     * since all step processing should occur in the doProcessing() method.
+     * 
+     * @param context
+     *            current DSpace context
+     * @param request
+     *            current servlet request object
+     * @param response
+     *            current servlet response object
+     * @param subInfo
+     *            submission info object
+     */
+    public void doPreProcessing(Context context, HttpServletRequest request,
+            HttpServletResponse response, SubmissionInfo subInfo)
+            throws ServletException, IOException, SQLException,
+            AuthorizeException
+    {
+        if (request.getAttribute("no.collection") == null
+                || !(Boolean) request.getAttribute("no.collection"))
+        {
+            request.setAttribute("s_uuid", UUID.randomUUID().toString());
+        }
+
+        /*
+         * Possible parameters from JSP:
+         * 
+         * collection= <collection_id> - a collection that has already been
+         * selected!
+         * 
+         * With no parameters, this servlet prepares for display of the Select
+         * Collection JSP.
+         */
+        String collectionID = request.getParameter("collection");
+        Collection col = null;
+
+        if (collectionID != null)
+        {
+            col = Collection.find(context, Integer.parseInt(collectionID));
+        }
+
+        // if we already have a valid collection, then we can forward directly
+        // to post-processing
+        if (col != null)
+        {
+            log.debug("Select Collection page skipped, since a Collection ID was already found.  Collection ID="
+                    + collectionID);
+        }
+        else
+        {
+            // gather info for JSP page
+            Community com = UIUtil.getCommunityLocation(request);
+
+            Collection[] collections;
+
+            if (com != null)
+            {
+                // In a community. Show collections in that community only.
+                collections = Collection.findAuthorized(context, com,
+                        Constants.ADD);
+            }
+            else
+            {
+                // Show all collections
+                collections = Collection.findAuthorized(context, null,
+                        Constants.ADD);
+            }
+
+            // This is a special case, where the user came back to this
+            // page after not selecting a collection. This will display
+            // the "Please select a collection" message to the user
+            if (collectionID != null && Integer.parseInt(collectionID) == -1)
+            {
+                // specify "no collection" error message should be displayed
+                request.setAttribute("no.collection", Boolean.TRUE);
+            }
+
+            // save collections to request for JSP
+            request.setAttribute("collections", collections);
+
+            List<String> identifiers = slService.getIdentifiers();
+
+            Map<String, List<SubmissionLookupProvider>> identifiers2providers = slService
+                    .getProvidersIdentifiersMap();
+            List<SubmissionLookupProvider> searchProviders = slService
+                    .getSearchProviders();
+            request.setAttribute("identifiers2providers", identifiers2providers);
+            request.setAttribute("searchProviders", searchProviders);
+            request.setAttribute("identifiers", slService.getIdentifiers());
+            // we need to load the select collection JSP
+            JSPStepManager
+                    .showJSP(request, response, subInfo, START_LOOKUP_JSP);
+        }
+    }
+
+    /**
+     * Do any post-processing after the step's backend processing occurred (in
+     * the doProcessing() method).
+     * <P>
+     * It is this method's job to determine whether processing completed
+     * successfully, or display another JSP informing the users of any potential
+     * problems/errors.
+     * <P>
+     * If this step doesn't require user interaction OR you are solely using
+     * Manakin for your user interface, then this method may be left EMPTY,
+     * since all step processing should occur in the doProcessing() method.
+     * 
+     * @param context
+     *            current DSpace context
+     * @param request
+     *            current servlet request object
+     * @param response
+     *            current servlet response object
+     * @param subInfo
+     *            submission info object
+     * @param status
+     *            any status/errors reported by doProcessing() method
+     */
+    public void doPostProcessing(Context context, HttpServletRequest request,
+            HttpServletResponse response, SubmissionInfo subInfo, int status)
+            throws ServletException, IOException, SQLException,
+            AuthorizeException
+    {
+        // if the user didn't select a collection,
+        // send him/her back to "select a collection" page
+        if (status == StartSubmissionLookupStep.STATUS_NO_COLLECTION)
+        {
+            // specify "no collection" error message should be displayed
+            request.setAttribute("no.collection", new Boolean(true));
+
+            // reload this page, by re-calling doPreProcessing()
+            doPreProcessing(context, request, response, subInfo);
+        }
+        else if (status == StartSubmissionLookupStep.STATUS_INVALID_COLLECTION)
+        {
+            JSPManager.showInvalidIDError(request, response, request
+                    .getParameter("collectionid"), Constants.COLLECTION);
+        }
+        else if (status == StartSubmissionLookupStep.STATUS_NO_SUUID)
+        {
+        	// specify "no suuid" error message should be displayed
+            request.setAttribute("no.suuid", new Boolean(true));
+
+            // reload this page, by re-calling doPreProcessing()
+            doPreProcessing(context, request, response, subInfo);
+        }
+        else if (status == StartSubmissionLookupStep.STATUS_SUBMISSION_EXPIRED)
+        {
+        	// specify "no collection" error message should be displayed
+            request.setAttribute("expired", new Boolean(true));
+
+            // reload this page, by re-calling doPreProcessing()
+            doPreProcessing(context, request, response, subInfo);        	
+        }
+        else if (status != StartSubmissionLookupStep.STATUS_COMPLETE)
+        {
+        	// specify "no suuid" error message should be displayed
+            request.setAttribute("no.suuid", new Boolean(true));
+
+            // reload this page, by re-calling doPreProcessing()
+            doPreProcessing(context, request, response, subInfo);
+        }
+    }
+    
+    /**
+     * Return the URL path (e.g. /submit/review-metadata.jsp) of the JSP
+     * which will review the information that was gathered in this Step.
+     * <P>
+     * This Review JSP is loaded by the 'Verify' Step, in order to dynamically
+     * generate a submission verification page consisting of the information
+     * gathered in all the enabled submission steps.
+     * 
+     * @param context
+     *            current DSpace context
+     * @param request
+     *            current servlet request object
+     * @param response
+     *            current servlet response object
+     * @param subInfo
+     *            submission info object
+     */
+    public String getReviewJSP(Context context, HttpServletRequest request,
+            HttpServletResponse response, SubmissionInfo subInfo)
+    {
+        return NO_JSP;  //at this time, you cannot review what collection you selected.
+    }
+}

dspace-jspui/src/main/webapp/submit/start-lookup-submission.jsp

@@ -0,0 +1,284 @@
+<%--
+  - UI page for start of a submission with lookup on external sources.
+  -
+  - Required attributes:
+  -    collections - Array of collection objects to show in the drop-down.
+  	   collectionID - the collection ID of preference for the user
+  	   identifiers2providers
+       searchProviders
+  --%>
+
+<%@ page contentType="text/html;charset=UTF-8" %>
+
+<%@ page import="javax.servlet.jsp.jstl.fmt.LocaleSupport" %>
+
+<%@ page import="org.dspace.content.Collection" %>
+<%@ page import="org.dspace.submit.lookup.SubmissionLookupProvider" %>
+<%@ page import="java.lang.Boolean" %>
+<%@ page import="java.util.List" %>
+<%@ page import="java.util.Map" %>
+
+<%@ taglib uri="http://java.sun.com/jsp/jstl/core"
+    prefix="c" %>
+<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"
+    prefix="fmt" %>
+	
+<%@ taglib uri="http://www.dspace.org/dspace-tags.tld" prefix="dspace" %>
+<%@ taglib uri="http://ajaxtags.org/tags/ajax" prefix="ajax"%>
+
+<%
+    String contextPath = "/dspace-jspui";
+	request.setAttribute("LanguageSwitch", "hide");
+
+    //get collections to choose from
+    Collection[] collections =
+        (Collection[]) request.getAttribute("collections");
+
+    //get community handle
+    int communityId = (Integer) request.getAttribute("collectionID");
+    
+    //check if we need to display the "no collection selected" error
+    Boolean noCollection = (Boolean) request.getAttribute("no.collection");
+    Boolean nosuuid = (Boolean) request.getAttribute("nouuid");
+    Boolean expired = (Boolean) request.getAttribute("expired");
+    
+    Map<String, List<SubmissionLookupProvider>> identifiers2providers = (Map<String, List<SubmissionLookupProvider>>) request.getAttribute("identifiers2providers");
+    List<SubmissionLookupProvider> searchProviders = (List<SubmissionLookupProvider>) request.getAttribute("searchProviders");
+    List<String> identifiers = (List<String>) request.getAttribute("identifiers");
+    String uuid = (String) request.getAttribute("s_uuid");
+%>
+<c:set var="dspace.layout.head" scope="request">
+	<script type="text/javascript" src="<%= request.getContextPath() %>/js/submission-lookup.js"></script>	
+</c:set>
+
+<dspace:layout locbar="off"
+               navbar="off"
+               titlekey="jsp.submit.start-lookup-submission.title"
+               nocache="true">
+
+    <h1><fmt:message key="jsp.submit.start-lookup-submission.heading"/></h1>
+<%  if (collections.length > 0)
+    {
+		//if no collection was selected, display an error
+		if((noCollection != null) && (noCollection.booleanValue()==true))
+		{
+%>
+                <div class="error-message">
+					<p><fmt:message key="jsp.submit.start-lookup-submission.no-collection"/></p>
+				</div>
+<%
+		}
+		//if no collection was selected, display an error
+		if((nosuuid != null) && (nosuuid.booleanValue()==true))
+		{
+%>
+                <div class="error-message">
+					<p><fmt:message key="jsp.submit.start-lookup-submission.nosuuid"/></p>
+				</div>
+<%
+		}
+		//if no collection was selected, display an error
+		if((expired != null) && (expired.booleanValue()==true))
+		{
+%>
+                <div class="error-message">
+					<p><fmt:message key="jsp.submit.start-lookup-submission.expired"/></p>
+				</div>
+<%
+		}
+%>            
+
+<div id="tabs">
+	<ul>
+		<li><a href="#tabs-search"><fmt:message key="jsp.submit.start-lookup-submission.tabs.search" /></a></li>
+		<li><a href="#tabs-result"><fmt:message key="jsp.submit.start-lookup-submission.tabs.result" /></a></li>
+	</ul>
+	<div id="tabs-search">
+	<form id="form-submission" action="" method="post">
+		<input type="hidden" id="suuid" name="suuid" value="<%= uuid %>"/>
+		<input type="hidden" id="iuuid" name="iuuid" value=""/>
+		<input type="hidden" id="collectionid" name="collectionid" value=""/>
+		<div id="tabs-search-accordion">
+<%		
+	if (searchProviders != null && searchProviders.size() > 0) {
+	%>
+		<h3><a href="#"><fmt:message key="jsp.submit.start-lookup-submission.search"/></a></h3>
+		<div>
+		
+<%	
+		for (SubmissionLookupProvider provider : searchProviders)
+		{			
+%>
+		<img style="vertical-align: middle;" src="<%= request.getContextPath() %>/image/submission-lookup-small-<%= provider.getShortName() %>.jpg" />
+<% 
+		}
+	%>
+	<p><fmt:message key="jsp.submit.start-lookup-submission.search.hints"/></p>
+		<br/><br/><table>
+		<tr><td style="vertical-align: top;"><span><fmt:message key="jsp.submit.start-lookup-submission.search.title"/>:</span></td><td> 
+		<textarea class="submission-lookup-search" name="search_title" id="search_title" cols="50" row="4"></textarea>
+		<br/>&nbsp;</td><td>&nbsp;</td></tr>
+
+		<tr><td><span><fmt:message key="jsp.submit.start-lookup-submission.search.year"/>:</span></td><td> 
+		<input class="submission-lookup-search" type="text" size="7" name="search_year" id="search_year" />
+		<br/>&nbsp;</td><td>&nbsp;</td></tr>
+		
+		<tr><td><span><fmt:message key="jsp.submit.start-lookup-submission.search.authors"/>:</span></td><td> 
+		<textarea class="submission-lookup-search" name="search_authors" id="search_authors"cols="50" row="4"></textarea>
+		<br/>&nbsp;</td><td>&nbsp;</td></tr>
+		
+		<tr><td>&nbsp;</td><td>&nbsp;</td>
+		<td align="right">
+			<button type="button" id="search_go"><fmt:message key="jsp.submit.start-lookup-submission.search-go"/></button>
+			<button type="button" class="exit"><fmt:message key="jsp.submit.start-lookup-submission.exit"/></button>
+		<br/>&nbsp;</td></tr>
+		</table>
+	</div>
+<% } %>	
+	<h3><a href="#"><fmt:message key="jsp.submit.start-lookup-submission.identifiers"/></a></h3>
+	<div>
+<% if (identifiers != null && identifiers.size()>0) {
+	%>
+		
+		<p><fmt:message key="jsp.submit.start-lookup-submission.identifiers.hints"/></p>
+		<br/><br/><table>
+<%	
+		for (String identifier : identifiers)
+		{			
+%>
+<c:set var="identifier"><%= identifier %></c:set>
+		<tr><td><span class="submission-lookup-label"><fmt:message key="jsp.submit.start-lookup-submission.identifier-${identifier}"/>:</span></td><td> 
+		<span class="submission-lookup-hint"><fmt:message key="jsp.submit.start-lookup-submission.identifier-${identifier}.hint"/></span><br/>
+		<input class="submission-lookup-identifier" type="text" size="50" name="identifier_<%= identifier%>" id="identifier_<%= identifier%>" /><br/>&nbsp;</td><td class="submission-lookup-providers">
+<%	
+			for (SubmissionLookupProvider provider : identifiers2providers.get(identifier))
+			{			
+%>
+		<img src="<%= request.getContextPath() %>/image/submission-lookup-small-<%= provider.getShortName() %>.jpg" />&nbsp;
+<% 
+			}
+%></td></tr><%
+		} %>				
+		<tr><td>&nbsp;</td><td>&nbsp;</td><td><br/>
+		<button type="button" id="lookup_idenfifiers"><fmt:message key="jsp.submit.start-lookup-submission.identifier.lookup"/></button>
+		<button type="button" class="exit"><fmt:message key="jsp.submit.start-lookup-submission.exit"/></button></td></tr>
+	</table>
+	</div>
+<% 
+		
+	} %>
+	
+	<h3><a href="#"><fmt:message key="jsp.submit.start-lookup-submission.manual-submission"/></a></h3>
+	<div id="manual-accordion">&nbsp;</div>
+	</div>
+</div>
+
+	<div id="tabs-result">
+		<div id="empty-result">
+			<p>Nessun risultato disponibile</p>
+		</div>
+		<div id="result-list"></div>
+		<div id="manual-submission">
+			Seleziona la tipologia della pubblicazione:
+			<select id="select-collection-manual">
+				<option value="-1">Seleziona</option>
+				<% for (Collection c : collections) { %>
+				<option value="<%= c.getID() %>"><%= c.getName() %></option>
+				<% }  %>
+			</select>
+			<button id="manual-submission-button" type="button">Inserisci manualmente</button>
+		</div>	
+	</div>
+</div>
+
+		<div id="hidden-area" style="display: none;">
+			<div id="select-collection-div">
+				<select id="select-collection">
+					<% for (Collection c : collections) { %>
+					<option value="<%= c.getID() %>"><%= c.getName() %></option>
+					<% }  %>
+				</select>
+			</div>
+		</div>
+<div id="no-collection-warn" title="<fmt:message key="jsp.submit.start-lookup-submission.no-collection-warn.title" />">
+<p><fmt:message key="jsp.submit.start-lookup-submission.no-collection-warn.hint" /></p>
+</div>
+<div id="loading-search-result" title="<fmt:message key="jsp.submit.start-lookup-submission.search-loading.title" />">
+<p><fmt:message key="jsp.submit.start-lookup-submission.search-loading.hint" /></p>
+<center><img src="<%= request.getContextPath()  %>/sherpa/image/ajax-loader-big.gif"/></center>
+</div>
+      
+<%  } else { %>
+	<p class="submitFormWarn"><fmt:message key="jsp.submit.select-collection.none-authorized"/></p>
+<%  } %>
+<div>
+  In alternativa &egrave; possibile utilizzare l'import automatico da file bibliografico (BibTeX, ISI): <button id="fileimport"><fmt:message key="jsp.mydspace.main.import.button"/></button>
+</div>	
+	   <p><fmt:message key="jsp.general.goto"/><br />
+	   <a href="<%= request.getContextPath() %>"><fmt:message key="jsp.general.home"/></a><br />
+	   <a href="<%= request.getContextPath() %>/mydspace"><fmt:message key="jsp.general.mydspace" /></a>
+	   </p>
+	       <script type="text/javascript"><!--
+    	var j = jQuery.noConflict();
+    	j('#tabs').tabs({
+    		select: function( event, ui ) {
+    			if ('tabs-result' == j(ui.panel).attr('id'))
+   				{
+    				j('#manual-submission').appendTo(j(ui.panel)); 
+    			}
+    			else
+   				{
+    				j('#manual-submission').appendTo(j('#manual-accordion'));
+   				}
+    		}
+    	});
+    	j('#tabs-search-accordion').accordion({ 
+    			change: function( event, ui ) {
+    				if ('manual-accordion' == ui.newContent.attr('id'))
+   					{
+    					j('#manual-submission').appendTo(ui.newContent);	
+   					}
+    			}
+    	});
+    	j('#link-ricerca-identificatore').click(function(){
+    		j('#tabs-search-accordion').accordion({'active': 1});
+    	});
+    	j('button').button();
+    	j('#manual-submission-button').click(function(event){
+    		var colman = j('#select-collection-manual').val();
+    		if (colman != -1)
+    		{
+    			j('#collectionid').val(colman);
+    			j('#form-submission').submit();
+    		}
+    		else
+   			{
+    			j('#no-collection-warn').dialog("open");
+   			}
+    	});
+    	j('#no-collection-warn').dialog({autoOpen: false,modal: true});
+    	j('#lookup_idenfifiers').click(function(){
+    		submissionLookupIdentifiers(j('input.submission-lookup-identifier'));
+    	});
+    	j('#search_go').click(function(){
+    		submissionLookupSearch(j('.submission-lookup-search'));
+    	});
+    	j('button.exit').click(function(event){
+    		event.preventDefault();
+    		window.location = "<%= request.getContextPath() %>/mydspace";
+    	});
+    	j('#fileimport').click(function(event){
+    		event.preventDefault();
+    		window.location = "<%= request.getContextPath() %>/tools/import";
+    	});
+    	j('#loading-search-result').dialog({
+    		autoOpen: false,
+    		modal: true,
+    		onClose: function(){
+    			j(this).data('ajaxCall').abort();
+    		},
+    		width: 600
+    	});
+    --></script>
+	   
+</dspace:layout>

dspace/config/crosswalks/submission-lookup-mapping.properties

@@ -0,0 +1,23 @@
+pmid = dc.identifier.pmid
+doi = dc.identifier.doi
+jissn = dc.relation.issn 
+jeissn = dc.relation.eissn
+journal = dc.relation.ispartofjournal
+title = dc.title
+issued = dc.date.issued
+volume = dc.relation.volume
+issue = dc.relation.issue
+language = dc.language.iso
+subtype = dc.type.contribution
+#keywords = dc.subject
+mesh = dc.subject
+firstpage = dc.relation.firstpage
+lastpage = dc.relation.lastpage
+abstract = dc.description.abstract
+publicationstatus = dc.type.publicationstatus
+#authorsWithAffiliations = dc.contributor.author
+#authors = dc.contributor.author|authorsWithAffiliations
+authorsWithAffiliations =
+authors =
+articleNumber = dc.relation.article
+#to see enhancer visit spring-dspace-addon-submissionlookup-services.xml

dspace/config/dspace.cfg

@@ -1243,6 +1243,7 @@ plugin.sequence.org.dspace.plugin.SiteHomeProcessor = \
 # comment out this line if you disable Discovery
 plugin.named.org.dspace.app.webui.json.JSONRequest = \
 	org.dspace.app.webui.discovery.DiscoveryJSONRequest = discovery,\
+	org.dspace.app.webui.json.SubmissionLookupJSONRequest = submissionLookup,\
 	org.dspace.app.webui.json.UploadProgressJSON = uploadProgress
 
 

dspace/config/item-submission.xml

@@ -87,6 +87,15 @@
        <xmlui-binding>org.dspace.app.xmlui.aspect.submission.submit.SelectCollectionStep</xmlui-binding>
        <workflow-editable>false</workflow-editable>
      </step>
+     
+	 <!-- Uncomment this to make available the bibliographic import from external source - note ONLY for JSPUI -->     
+	 <!-- <step id="collection">
+       <heading></heading> can specify heading, if you want it to appear in Progress Bar
+	   <processing-class>org.dspace.submit.step.StartSubmissionLookupStep</processing-class>
+       <jspui-binding>org.dspace.submit.step.JSPStartSubmissionLookupStep</jspui-binding>
+       <xmlui-binding>org.dspace.app.xmlui.aspect.submission.submit.SelectCollectionStep</xmlui-binding>
+       <workflow-editable>false</workflow-editable>
+     </step> -->
    
      <!-- The "complete" step is a "special step" which is *REQUIRED* to be-->
      <!-- in this section!  In DSpace, when a submission is completed,       -->

pom.xml

@@ -1004,6 +1004,11 @@
             <version>1.06</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>net.sf.flexjson</groupId>
+            <artifactId>flexjson</artifactId>
+            <version>2.1</version>
+        </dependency>
       </dependencies>
    </dependencyManagement>