/ - Diff - D-Net - D-Net project tracking tool

« Previous | Next »

Revision 34760

Added by Katerina Iatropoulou over 9 years ago

mavenizing refactoring project

     package gr.uoa.di.web.utils;
     import eu.dnetlib.domain.data.Document;
     import eu.dnetlib.domain.enabling.Vocabulary;
     import eu.dnetlib.domain.functionality.DocumentField;
     import eu.dnetlib.domain.functionality.SwitchDocumentField;
     import gr.uoa.di.web.utils.bibtex.BibTeX;
     import java.util.List;
     import java.util.Locale;
     import org.apache.log4j.Logger;
     public class BibTeXGenerator {
     	private static Logger logger = Logger.getLogger(BibTeXGenerator.class);
     	public static BibTeX generateBibTeX(List<DocumentField> fields, Document document, Vocabulary bibTeXVocabulary) {
     		BibTeX bibTeX = new BibTeX();
     		//Create entry
     		List<String> entryValues = document.getMap().get("CobjCategory");
     		if (entryValues != null && !entryValues.isEmpty()) {
     			String entry = bibTeXVocabulary.getEnglishName(entryValues.get(0));
     			if (entry == null) { bibTeX.setEntry("article"); }
     			else { bibTeX.setEntry(entry); }
     		} else {
     			bibTeX.setEntry("article");
+    		}
     		bibTeX.setKey(generateBibTeXKey(fields, document));
     		for (DocumentField field: fields) {
     			if (field instanceof SwitchDocumentField) {
     				String conditionField = ((SwitchDocumentField) field).getConditionField();
     				String conditionFieldValue = null;
     				/* if there is no value in the document for the condition field, consider it 'default' */
     				if ( document.getMap().get(conditionField) == null || document.getMap().get(conditionField).isEmpty() ) {
     					conditionFieldValue = "default";
     				} else { //else get the one from the document
     					conditionFieldValue = document.getMap().get(conditionField).get(0);
+    				}
     				/* in case where there is no field for the given conditionFieldValue
     				 * because this was not part of the configuration use "default". If
     				 * there is no field for "default" just continue   */
     				if (((SwitchDocumentField) field).getDocumentField(conditionFieldValue) != null ) {
     					field = ((SwitchDocumentField) field).getDocumentField(conditionFieldValue);
     				} else if (((SwitchDocumentField) field).getDocumentField("default") != null) {
     					field =  ((SwitchDocumentField) field).getDocumentField("default");
     				} else {
     					continue;
+    				}
+    		}
     			String fieldDescription = LocaleDescriptionUtil.getFieldDescription(field.getDescriptionMap(), Locale.ENGLISH);
     			String value = generate(field.getName(), document);
     			if (!value.isEmpty() && !value.equals("\"\"")) {
     				bibTeX.getFields().put(fieldDescription, value);
+    			}
+    		}
     		return bibTeX;
+    	}
     	public static String generate(String indexField, Document document) {
     		List<String> values = document.getFieldValues(indexField);
     		if (values == null) return "";
     		StringBuffer buffer = new StringBuffer();
     		buffer.append("\"");
     		int i = 0;
     		for (String value:values) {
     			if ( i > 0 ) { buffer.append(" and "); }
     			buffer.append(escapeCharacters(value));
     			i++;
+    		}
     		buffer.append("\"");
     		return buffer.toString();
+    	}
     	public static String escapeCharacters(String value) {
     		return value.replace("\"", "\\\"").replace("{", "\\{").replace("}", "\\}").replace("$", "\\$");
+    	}
     	public static String generateBibTeXKey(List<DocumentField> fields, Document document) {
     		String index4author = null;
     		//Get the index field for author BibTeX field
     		for ( DocumentField field:fields ) {
     			if(field.getDescriptionMap().get(new Locale("en", "GB")) != null) {
     				if (field.getDescriptionMap().get(new Locale("en", "GB")).equals("author")) {
     					index4author = field.getName();
     					break;
+    				}
+    			}
+    		}
     		StringBuffer buffer = new StringBuffer();
     		if (index4author != null) {
     			List<String> authornames = document.getFieldValues(index4author);
     			if (authornames != null && !authornames.isEmpty()) {
     				for (String fullname: authornames) {
     					String parts[] = fullname.split(",");
     					String part = parts[0].replace(" ", "");
     					if (authornames.size() > 1){
     						if(part.length() > 4){
     							buffer.append(part.substring(0, 4));
     						} else {
     							buffer.append(part);
+    						}
     					} else {
     						buffer.append(part);
+    					}
+    				}
+    			}
+    		}
     		//TODO: reconsider following the same procedure as for author to get the index field name
     		if (document.getMap().get("publicationyear") != null && !document.getMap().get("publicationyear").isEmpty()) {
     			String publicationYear = document.getMap().get("publicationyear").get(0);
     			if (publicationYear.length() > 3) {
     				buffer.append(publicationYear.substring(publicationYear.length()-2, publicationYear.length()));
     			} else {
     				buffer.append(publicationYear);
+    			}
+    		}
     		return buffer.toString();
+    	}
+    }

     package gr.uoa.di.web.utils.ep.entity;
     import java.util.Set;
     public class Entity {
     	private String name;
     	private Set<Field> fields;
     	private String idField;
     	private String labelField;
     	private String label;
     	private String color;
     	private Shape shape;
     	private boolean internal;
     	private String typeField;
     	private String type;
     	public Entity(String name, Set<Field> fields, String idField, String labelField, String label, String color, Shape shape) {
     		this.name = name;
     		this.fields = fields;
     		this.idField = idField;
     		this.labelField = labelField;
     		this.label = label;
     		this.color = color;
     		this.shape = shape;
     		internal = true;
     		typeField = null;
     		type = null;
+    	}
     	public Entity(String name, Set<Field> fields, String idField, String labelField, String label, String color, Shape shape, String typeField, String type) {
     		this.name = name;
     		this.fields = fields;
     		this.idField = idField;
     		this.labelField = labelField;
     		this.label = label;
     		this.color = color;
     		this.shape = shape;
     		this.typeField = typeField;
     		this.type = type;
     		internal = false;
+    	}
     	public String getName() {
     		return name;
+    	}
     	public Set<Field> getFields() {
     		return fields;
+    	}
     	public String getIdField() {
     		return idField;
+    	}
     	public String getLabelField() {
     		return labelField;
+    	}
     	public String getLabel() {
     		return label;
+    	}
     	public String getColor() {
     		return color;
+    	}
     	public Shape getShape() {
     		return shape;
+    	}
     	public boolean getInternal() {
     		return internal;
+    	}
     	public String getTypeField() {
     		return typeField;
+    	}
     	public String getType() {
     		return type;
+    	}
     	@Override
     	public int hashCode() {
     		return name.hashCode();
+    	}
     	@Override
     	public boolean equals(Object object) {
     		if (object == this)
     			return true;
     		if (!(object instanceof Entity))
     			return false;
     		Entity entity = (Entity) object;
     		return name.equals(entity.getName());
+    	}
+    }

     package gr.uoa.di.web.utils.ep.entity;
     public enum Shape {
     	BLOCK("block"),
     	CIRCLE("circle"),
     	DIAMOND("diamond"),
     	SQUARE("square"),
     	TRIANGLE_DOWN("triangleDown"),
     	TRIANGLE_LEFT("triangleLeft"),
     	TRIANGLE_RIGHT("triangleRight"),
     	TRIANGLE_UP("triangleUp");
     	private final String shape;
     	private Shape(String shape) {
     		this.shape = shape;
+    	}
     	public static Shape parseShape(String shape) {
     		for (Shape s : Shape.class.getEnumConstants()) {
     			if (shape.equals(s.shape))
     				return s;
+    		}
     		return null;
+    	}
     	@Override
     	public String toString() {
     		return shape;
+    	}
+    }

     package gr.uoa.di.web.utils.ep.entity;
     public class Field {
     	private String name;
     	private String label;
     	private boolean collection;
     	private boolean editable;
     	private String defaultValue;
     	public Field(String name, String label, boolean collection, boolean editable, String defaultValue) {
     		this.name = name;
     		this.label = label;
     		this.collection = collection;
     		this.editable = editable;
     		this.defaultValue = defaultValue;
+    	}
     	public String getName() {
     		return name;
+    	}
     	public String getLabel() {
     		return label;
+    	}
     	public boolean getCollection() {
     		return collection;
+    	}
     	public boolean getEditable() {
     		return editable;
+    	}
     	public String getDefaultValue() {
     		return defaultValue;
+    	}
     	public String toString() {
     		return "field " + label;
+    	}
+    }

     package gr.uoa.di.web.utils.ep.relation;
     import java.util.Set;
     public class Relation {
     	private String name;
     	private Set<String> sourceEntities;
     	private Set<String> targetEntities;
     	private Cardinality cardinality;
     	private Partiality partiality;
     	private String label;
     	private int width;
     	private String color;
     	public Relation(String name, Set<String> sourceEntities, Set<String> targetEntities, Cardinality cardinality,
     			Partiality partiality, String label, int width, String color) {
     		this.name = name;
     		this.sourceEntities = sourceEntities;
     		this.targetEntities = targetEntities;
     		this.cardinality = cardinality;
     		this.partiality = partiality;
     		this.label = label;
     		this.width = width;
     		this.color = color;
+    	}
     	public String getName() {
     		return name;
+    	}
     	public Set<String> getSourceEntities() {
     		return sourceEntities;
+    	}
     	public Set<String> getTargetEntities() {
     		return targetEntities;
+    	}
     	public Cardinality getCardinality() {
     		return cardinality;
+    	}
     	public Partiality getPartiality() {
     		return partiality;
+    	}
     	public String getLabel() {
     		return label;
+    	}
     	public int getWidth() {
     		return width;
+    	}
     	public String getColor() {
     		return color;
+    	}
     	@Override
     	public int hashCode() {
     		return name.hashCode();
+    	}
     	@Override
     	public boolean equals(Object object) {
     		if (object == this)
     			return true;
     		if (!(object instanceof Relation))
     			return false;
     		Relation relation = (Relation) object;
     		return name.equals(relation.getName());
+    	}
+    }

     package gr.uoa.di.web.utils.ep.relation;
     public enum Partiality {
     	PARTIAL_TO_PARTIAL("part_part"),
     	PARTIAL_TO_TOTAL("part_tot"),
     	TOTAL_TO_PARTIAL("tot_part"),
     	TOTAL_TO_TOTAL("tot_tot");
     	private final String partiality;
     	private Partiality(String partiality) {
     		this.partiality = partiality;
+    	}
     	public static Partiality parsePartiality(String partiality) {
     		for (Partiality p : Partiality.class.getEnumConstants()) {
     			if (partiality.equals(p.partiality))
     				return p;
+    		}
     		return null;
+    	}
+    }

     package gr.uoa.di.web.utils.ep.relation;
     public enum Cardinality {
     	ONE_TO_ONE("one_to_one"),
     	ONE_TO_MANY("one_to_many"),
     	MANY_TO_ONE("many_to_one"),
     	MANY_TO_MANY("many_to_many");
     	private final String cardinality;
     	private Cardinality(String cardinality) {
     		this.cardinality = cardinality;
+    	}
     	public static Cardinality parseCardinality(String cardinality) {
     		for (Cardinality c : Cardinality.class.getEnumConstants()) {
     			if (cardinality.equals(c.cardinality))
     				return c;
+    		}
     		return null;
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     import eu.dnetlib.domain.data.Document;
     import eu.dnetlib.domain.functionality.UserProfile;
     import gr.uoa.di.web.utils.ep.domain.Entity;
     import gr.uoa.di.web.utils.ep.domain.Graph;
     import gr.uoa.di.web.utils.ep.domain.Node;
     import gr.uoa.di.web.utils.ep.domain.RelatedNode;
     import gr.uoa.di.web.utils.ep.domain.Relation;
     import gr.uoa.di.web.utils.search.DocumentPage;
     import java.util.List;
     import java.util.Map;
     import java.util.Set;
     /**
      * This interface describes a manager for enhanced publications.
      * @author thanos
+     *
      */
     public interface EPManager {
     	/**
     	 * Get the available entities.
     	 * @return a set containing the available entities
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Set<Entity> getEntities() throws EPManagerException;
     	/**
     	 * Get the available relations.
     	 * @return a set containing the available relations
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Set<Relation> getRelations() throws EPManagerException;
     	/**
     	 * Get the dropbox contents of a user
     	 * @param userProfile the user to get dropbox contents of
     	 * @return a set containing the documents of the user
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Set<Map<String, List<String>>> getDropboxContents(UserProfile userProfile) throws EPManagerException;
     	/**
     	 * Get a graph by its root node id.
     	 * @param rootId the id of the root node
     	 * @return a graph containing all the ancestors of the root node, its immediate parents and the edges connecting them or null if no such root node exists
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Graph getGraph(String rootId) throws EPManagerException;
     	/**
     	 * Save a graph.
     	 * @param userProfile the user profile of the user attempting to save the graph
     	 * @param rootId the id of the root node
     	 * @param commands the commands to execute in order to save the graph
     	 * @return the (possibly) new id of the root node
     	 * @throws EPManagerException if any errors occur
     	 */
     	public void saveGraph(UserProfile userProfile, String [] commands) throws EPManagerException;
     	/**
     	 * Save an enhanced publication.
     	 * @param userProfile the user profile of the user that requests the creation
     	 * @param creator the creator of the enhanced publication (if null or empty will be the aforementioned user)
     	 * @param description the description of the enhanced publication
     	 * @param language the language of the enhanced publication
     	 * @param subject the subject of the enhanced publication
     	 * @param title the title of the enhanced publication
     	 * @param ePrintId the id of the e-Print of the enhanced publication
     	 * @param nonEPrintIds the ids of the other contents (non-e-Prints) of the enhanced publication
     	 * @return the id of the created enhanced publication
     	 * @throws EPManagerException if any errors occur
     	 */
     	public String saveEnhancedPublication(UserProfile userProfile, String description, String language, String subject, String title, String ePrintId, Set<String> nonEPrintIds) throws EPManagerException;
     	/**
     	 * Save an aggregation object.
     	 * @param userProfile the user profile of the user that requests the creation
     	 * @param creator the creator of the aggregation object (if null or empty will be the aforementioned user)
     	 * @param description the description of the aggregation object
     	 * @param language the language of the aggregation object
     	 * @param subject the subject of the aggregation object
     	 * @param title the title of the aggregation object
     	 * @param contentIds the ids of the contents of the aggregation object
     	 * @return the id of the created aggregation object
     	 * @throws EPManagerException if any errors occur
     	 */
     	public String saveAggregationObject(UserProfile userProfile, String description, String language, String subject, String title, Set<String> contentIds) throws EPManagerException;
     	/**
     	 * Get available enhanced publications.
     	 * @param pageSize the page size to use
     	 * @param pageNumber the number of the page to fetch
     	 * @return a document page containing the corresponding subset of available enhanced publications
     	 * @throws EPManagerException if any errors occur
     	 */
     	public DocumentPage getEnhancedPublications(int pageSize, int pageNumber) throws EPManagerException;
     	/**
     	 * Get an existing enhanced publication.
     	 * @param id the id of the enhanced publication to fetch
     	 * @return the enhanced publication with this id or null if none is found
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Document getEnhancedPublication(String id) throws EPManagerException;
     	/**
     	 * Get an existing node.
     	 * @param id the id of the node to fetch
     	 * @return the node with the given id or null if none is found
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Node getNode(String id) throws EPManagerException;
     	/**
     	 * Get the parents of a node.
     	 * @param node the node to fetch parents of
     	 * @return a set containing all the parents as related nodes
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Set<RelatedNode> getParents(Node node) throws EPManagerException;
     	/**
     	 * Get the children of a node.
     	 * @param node the node to fetch children of
     	 * @return a set containing all the children as related nodes
     	 * @throws EPManagerException if any errors occur
     	 */
     	public Set<RelatedNode> getChildren(Node node) throws EPManagerException;
+    }

     package gr.uoa.di.web.utils.ep;
     import java.util.Set;
     public class Graph {
     	private Set<Node> nodes;
     	private Set<Edge> edges;
     	public Graph(Set<Node> nodes, Set<Edge> edges) {
     		this.nodes = nodes;
     		this.edges = edges;
+    	}
     	public Set<Node> getNodes() {
     		return nodes;
+    	}
     	public Set<Edge> getEdges() {
     		return edges;
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     public class Edge {
     	private String type;
     	private long source;
     	private long target;
     	public Edge(String type, long source, long target) {
     		this.type = type;
     		this.source = source;
     		this.target = target;
+    	}
     	public String getType() {
     		return type;
+    	}
     	public long getSource() {
     		return source;
+    	}
     	public long getTarget() {
     		return target;
+    	}
     	@Override
     	public int hashCode() {
     		return (int) (type.hashCode() + source + target);
+    	}
     	@Override
     	public boolean equals(Object object) {
     		if (object == this)
     			return true;
     		if (!(object instanceof Edge))
     			return false;
     		Edge edge = (Edge) object;
     		return type.equals(edge.getType()) && (source == edge.getSource()) && (target == edge.getTarget());
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     import gr.uoa.di.web.utils.webdocument.WebDocument;
     public class RelatedObject {
     	public String relation = null;
     	public WebDocument object = null;
     	public RelatedObject(String relation, WebDocument object) {
     		super();
     		this.relation = relation;
     		this.object = object;
+    	}
     	public String getRelation() {
     		return relation;
+    	}
     	public WebDocument getobject() {
     		return object;
+    	}
     	@Override
     	public int hashCode() {
     		final int prime = 31;
     		int result = 1;
     		result = prime * result
     				+ ((object == null) ? 0 : object.getId().hashCode());
     		result = prime * result + ((relation == null) ? 0 : relation.hashCode());
     		return result;
+    	}
     	@Override
     	public boolean equals(Object obj) {
     		if (this == obj)
     			return true;
     		if (obj == null)
     			return false;
     		if (getClass() != obj.getClass())
     			return false;
     		RelatedObject other = (RelatedObject) obj;
     		if (object == null) {
     			if (other.object != null)
     				return false;
     		} else if (!object.getId().equals(other.object.getId()))
     			return false;
     		if (relation == null) {
     			if (other.relation != null)
     				return false;
     		} else if (!relation.equals(other.relation))
     			return false;
     		return true;
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     import edu.emory.mathcs.backport.java.util.Collections;
     import eu.dnetlib.api.data.PublisherService;
     import eu.dnetlib.api.data.PublisherServiceException;
     import eu.dnetlib.domain.data.Document;
     import eu.dnetlib.domain.functionality.UserProfile;
     import gr.uoa.di.driver.util.ServiceLocator;
     import gr.uoa.di.web.utils.ep.domain.Edge;
     import gr.uoa.di.web.utils.ep.domain.Entity;
     import gr.uoa.di.web.utils.ep.domain.Field;
     import gr.uoa.di.web.utils.ep.domain.Graph;
     import gr.uoa.di.web.utils.ep.domain.Node;
     import gr.uoa.di.web.utils.ep.domain.RelatedNode;
     import gr.uoa.di.web.utils.ep.domain.Relation;
     import gr.uoa.di.web.utils.search.DocumentPage;
     import gr.uoa.di.web.utils.search.DocumentReader;
     import java.io.UnsupportedEncodingException;
     import java.net.URLDecoder;
     import java.util.ArrayList;
     import java.util.HashMap;
     import java.util.HashSet;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import java.util.Set;
     import java.util.UUID;
     import org.apache.log4j.Logger;
     public class EPManagerMock implements EPManager {
     	private static final String FORMAT = "DMF";
     	private static final String COMMAND = "command";
     	private static final String CREATE = "create";
     	private static final String IMPORT = "import";
     	private static final String EDIT = "edit";
     	private static final String DELETE ="delete";
     	private static final String ADD = "add";
     	private static final String REMOVE = "remove";
     	private static final String ID = "id";
     	private static final String ENTITY = "entity";
     	private static final String RELATION = "relation";
     	private static final String SOURCE = "source";
     	private static final String TARGET = "target";
     	private static final String DOCUMENT_PREFIX = "document.";
     	private static final String PARAMETER_DELIMITER = "&";
     	private static final String UTF8 = "utf8";
     	private static final String VALUE_DELIMITER = "=";
     	private static final String USER_PLACEHOLDER = "$user";
     	private static final String TEMP_ID_PREFIX = "temporaryId";
     	private static Logger logger = Logger.getLogger(EPManagerMock.class);
     	private ServiceLocator<PublisherService> publisherServiceLocator;
     	private DocumentReader documentReader;
     	private Field description;
     	private Field language;
     	private Field subject;
     	private Field title;
     	private Entity aggregationObjects;
     	private Entity ePrints;
     	private Entity ePubs;
     	private Entity nonEPrints;
     	private Relation aggregates;
     	private Relation composedBy;
     	private Relation hasEPrint;
     	private Set<Entity> entities;
     	private Set<Relation> relations;
     	private Graph graph;
     	private Map<String, Map<String, String>> temporaryIds;
     	@SuppressWarnings("unchecked")
     	public EPManagerMock() {
     		Field cObjCategory = new Field("CobjCategory", "Compound Object Category", false, false, null);
     		Field cObjContentSynthesis = new Field("CobjContentSynthesis", "Compound Object Content Synthesis", false, false, null);
     		Field cObjDescriptionSynthesis = new Field("CobjDescriptionSynthesis", "Compound Object Description Synthesis", false, false, null);
     		Field cObjIdentifier = new Field("id", "Compound Object Identifier", false, false, null);
     		Field cObjMDFormats = new Field("CobjMDFormats", "Compound Object Metadata Formats", false, false, null);
     		Field cObjModel = new Field("CobjModel", "Compound Object Model", false, false, null);
     		Field cObjTypologyCompoundObject = new Field("CobjTypology", "Compound Object Typology", false, false, "Compound Object");
     		Field cObjTypologyTextual = new Field("CobjTypology", "Compound Object Typology", false, false, "Textual");
     		Field cObjTypologyDataSet = new Field("CobjTypology", "Compound Object Typology", false, false, "Data Set");
     		Field contributor = new Field("contributor", "Contributor", true, false, null);
     		Field creator = new Field("creator", "Creator", true, false, "$user");
     		Field dateAccepted = new Field("dateAccepted", "Date Accepted", false, false, null);
     		Field dateOfCollection = new Field("dateOfCollection", "Date Of Collection", false, false, null);
     		description = new Field("description", "Description", false, true, null);
     		Field identifier = new Field("identifier", "Identifier", false, false, null);
     		Field itemIdentifier = new Field("itemIdentifier", "Item Identifier", false, false, null);
     		language = new Field("language", "Language", false, true, null);
     		Field mdFormat = new Field("mdFormat", "Metadata Format", false, false, "DMF");
     		Field mdFormatInterpretation = new Field("mdFormatInterpretation", "Metadata Format Interpretation", false, false, null);
     		Field objIdentifier = new Field("objIdentifier", "Object Identifier", false, false, null);
     		Field objectIdentifier = new Field("objectIdentifier", "Object Identifier", false, false, null);
     		Field publisher = new Field("publisher", "Publisher", false, false, null);
     		Field recordIdentifier = new Field("recordIdentifier", "Record Identifier", false, false, null);
     		Field relation = new Field("relation", "Relation", true, false, null);
     		Field repositoryCountry = new Field("repositoryCountry", "Repository Country", false, false, null);
     		Field repositoryId = new Field("repositoryId", "Repository Identifier", false, false, null);
     		Field repositoryInstitution = new Field("repositoryInstitution", "RepositoryInstitution", false, false, "Driver");
     		Field repositoryLink = new Field("repositoryLink", "Repository Link", false, false, "http://search.driver.research-infrastructures.eu/");
     		Field repositoryName = new Field("repositoryName", "Repository Name", false, false, "Driver");
     		Field source = new Field("source", "Source", false, false, null);
     		subject = new Field("subject", "Subject", true, true, null);
     		title = new Field("title", "Title", true, true, null);
     		Field sequenceNo = new Field("sequenceNo", "Sequence Number", false, true, null);
     		Set<Field> commonFields = new HashSet<Field>();
     		commonFields.add(cObjCategory);
     		commonFields.add(cObjContentSynthesis);
     		commonFields.add(cObjDescriptionSynthesis);
     		commonFields.add(cObjIdentifier);
     		commonFields.add(cObjMDFormats);
     		commonFields.add(cObjModel);
     		commonFields.add(contributor);
     		commonFields.add(creator);
     		commonFields.add(dateAccepted);
     		commonFields.add(dateOfCollection);
     		commonFields.add(description);
     		commonFields.add(identifier);
     		commonFields.add(itemIdentifier);
     		commonFields.add(language);
     		commonFields.add(mdFormat);
     		commonFields.add(mdFormatInterpretation);
     		commonFields.add(objIdentifier);
     		commonFields.add(objectIdentifier);
     		commonFields.add(publisher);
     		commonFields.add(recordIdentifier);
     		commonFields.add(relation);
     		commonFields.add(repositoryCountry);
     		commonFields.add(repositoryId);
     		commonFields.add(repositoryInstitution);
     		commonFields.add(repositoryLink);
     		commonFields.add(repositoryName);
     		commonFields.add(source);
     		commonFields.add(subject);
     		commonFields.add(title);
     		Set<Field> compoundObjectFields = new HashSet<Field>(commonFields);
     		compoundObjectFields.add(cObjTypologyCompoundObject);
     		Set<Field> textualFields = new HashSet<Field>(commonFields);
     		textualFields.add(cObjTypologyTextual);
     		Set<Field> dataSetFields = new HashSet<Field>(commonFields);
     		dataSetFields.add(cObjTypologyDataSet);
     		aggregationObjects = new Entity("AggregationObjects", compoundObjectFields, cObjIdentifier.getName(), cObjTypologyCompoundObject.getName(), title.getName(), true, "Aggregation Object", 0xffa9a9ff, "diamond");
     		ePrints = new Entity("ePrints", textualFields, cObjIdentifier.getName(), cObjTypologyTextual.getName(), title.getName(), false, "E-Print", 0xffdd7a00, "circle");
     		ePubs = new Entity("ePubs", compoundObjectFields, cObjIdentifier.getName(), cObjTypologyCompoundObject.getName(), title.getName(), true, "E-Pub", 0xffa13ba4, "square");
     		nonEPrints = new Entity("nonEPrints", textualFields, cObjIdentifier.getName(), cObjTypologyTextual.getName(), title.getName(), false, "Non-E-Print", 0xff3a9db8, "circle");
     		Entity researchData = new Entity("ResearchData", dataSetFields, cObjIdentifier.getName(), cObjTypologyDataSet.getName(), title.getName(), false, "Research Data", 0xff8aac46, "circle");
     		Entity sequence = new Entity("Sequence", Collections.singleton(sequenceNo), null, null, sequenceNo.getName(), true, "Sequence", 0xff7f7f7f, "circle");
     		entities = new HashSet<Entity>();
     		entities.add(aggregationObjects);
     		entities.add(ePrints);
     		entities.add(ePubs);
     		entities.add(nonEPrints);
     		entities.add(researchData);
     		entities.add(sequence);
     		Set<String> components = new HashSet<String>();
     		components.add(aggregationObjects.getName());
     		components.add(ePrints.getName());
     		components.add(nonEPrints.getName());
     		components.add(researchData.getName());
     		aggregates = new Relation("aggregates", Collections.singleton(aggregationObjects.getName()), components, "many_to_many", "part_part", "aggregates", 2, 0xff7f7f7f);
     		Relation cites = new Relation("cites", Collections.singleton(ePrints.getName()), Collections.singleton(ePrints.getName()), "many_to_many", "part_part", "cites", 2, 0xff7f7f7f);
     		composedBy = new Relation("composedBy", Collections.singleton(ePubs.getName()), components, "many_to_many", "part_part", "composed by", 2, 0xff7f7f7f);
     		Relation generatedBy = new Relation("generatedBy", Collections.singleton(researchData.getName()), Collections.singleton(researchData.getName()), "many_to_many", "part_part", "generated by", 2, 0xff7f7f7f);
     		hasEPrint = new Relation("hasEPrint", Collections.singleton(ePubs.getName()), Collections.singleton(ePrints.getName()), "many_to_one", "tot_part", "has e-print", 3, 0xffa13ba4);
     		Relation order = new Relation("order", Collections.singleton(aggregates.getName()), Collections.singleton(sequence.getName()), "one_to_one", "part_tot", "order", 2, 0xff7f7f7f);
     		Relation relatedWith = new Relation("relatedWith", Collections.singleton(ePubs.getName()), Collections.singleton(ePubs.getName()), "many_to_many", "part_part", "related with", 2, 0xff7f7f7f);
     		relations = new HashSet<Relation>();
     		relations.add(aggregates);
     		relations.add(cites);
     		relations.add(composedBy);
     		relations.add(generatedBy);
     		relations.add(hasEPrint);
     		relations.add(order);
     		relations.add(relatedWith);
     		graph = new Graph();
     		temporaryIds = new HashMap<String, Map<String, String>>();
     		logger.debug("EPManagerMock initialized successfully");
+    	}
     	public void setPublisherServiceLocator(ServiceLocator<PublisherService> publisherServiceLocator) {
     		this.publisherServiceLocator = publisherServiceLocator;
+    	}
     	public void setDocumentReader(DocumentReader documentReader) {
     		this.documentReader = documentReader;
+    	}
     	@Override
     	public Set<Entity> getEntities() {
     		logger.debug("Retrieved entities");
     		return entities;
+    	}
     	@Override
     	public Set<Relation> getRelations() {
     		logger.debug("Retrieved relations");
     		return relations;
+    	}
     	@Override
     	public Set<Map<String, List<String>>> getDropboxContents(UserProfile userProfile) throws EPManagerException {
     		Set<Map<String, List<String>>> dropboxContents = new HashSet<Map<String, List<String>>>();
     		try {
     			for (String documentId : userProfile.getDocumentIds()) {
     				String xml = publisherServiceLocator.getService().getResourceById(documentId, FORMAT);
     				Map<String, List<String>> document = null;
     				if (xml != null)
     					document = documentReader.read(xml).getMap();
     				else
     					document = getNode(documentId).getDocumentMap();
     				if (document != null)
     					dropboxContents.add(document);
+    			}
     		} catch (PublisherServiceException e) {
     			logger.error("Error retrieving dropbox contents of user " + userProfile, e);
     			throw new EPManagerException("Error retrieving dropbox contents of user " + userProfile, e);
+    		}
     		logger.debug("Retrieved dropbox contents of user " + userProfile);
     		return dropboxContents;
+    	}
     	@Override
     	public Graph getGraph(String rootId) {
     		Graph graph = new Graph();
     		Node root = getNode(rootId);
     		if (root == null) {
     			logger.debug("No graph with root " + rootId + " exists");
     			return null;
+    		}
     		graph.getNodes().add(root);
     		for (RelatedNode parent : getParents(root)) {
     			Node node = parent.getNode();
     			graph.getNodes().add(node);
     			graph.getEdges().add(new Edge(parent.getRelation(), node.getDocumentMap().get(getEntity(node.getEntity()).getIdField()).get(0), root.getDocumentMap().get(getEntity(root.getEntity()).getIdField()).get(0)));
+    		}
     		getDescendants(root, graph);
     		logger.debug("Retrieved graph with root " + rootId);
     		return graph;
+    	}
     	@Override
     	public void saveGraph(UserProfile userProfile, String [] commands) throws EPManagerException {
     		for (String command : commands)
     			executeCommand(userProfile, command);
     		temporaryIds.put(userProfile.getResourceId(), null);
     		logger.debug("User " + userProfile + " saved graph");
+    	}
     	@Override
     	public String saveEnhancedPublication(UserProfile userProfile, String description, String language, String subject, String title, String ePrintId, Set<String> nonEPrintIds) throws EPManagerException {
     		Map<String, List<String>> document = new HashMap<String, List<String>>();
     		document.put(DOCUMENT_PREFIX + this.description.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.description.getName()).add(description);
     		document.put(DOCUMENT_PREFIX + this.language.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.language.getName()).add(language);
     		document.put(DOCUMENT_PREFIX + this.subject.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.subject.getName()).add(subject);
     		document.put(DOCUMENT_PREFIX + this.title.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.title.getName()).add(title);
     		String id = createNode(userProfile, TEMP_ID_PREFIX + Math.round(Math.random() * Long.MAX_VALUE), ePubs.getName());
     		editNode(userProfile, id, document);
     		importNode(userProfile, ePrintId, ePrints.getName());
     		addEdge(userProfile, hasEPrint.getName(), id, ePrintId);
     		for (String nonEPrintId : nonEPrintIds) {
     			importNode(userProfile, nonEPrintId, nonEPrints.getName());
     			addEdge(userProfile, composedBy.getName(), id, nonEPrintId);
+    		}
     		logger.debug("User " + userProfile + " saved enhanced publication " + id);
     		return id;
+    	}
     	@Override
     	public String saveAggregationObject(UserProfile userProfile, String description, String language, String subject, String title, Set<String> contentIds) throws EPManagerException {
     		Map<String, List<String>> document = new HashMap<String, List<String>>();
     		document.put(DOCUMENT_PREFIX + this.description.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.description.getName()).add(description);
     		document.put(DOCUMENT_PREFIX + this.language.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.language.getName()).add(language);
     		document.put(DOCUMENT_PREFIX + this.subject.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.subject.getName()).add(subject);
     		document.put(DOCUMENT_PREFIX + this.title.getName(), new ArrayList<String>());
     		document.get(DOCUMENT_PREFIX + this.title.getName()).add(title);
     		String id = createNode(userProfile, TEMP_ID_PREFIX + Math.round(Math.random() * Long.MAX_VALUE), aggregationObjects.getName());
     		editNode(userProfile, id, document);
     		for (String contentId : contentIds) {
     			importNode(userProfile, contentId, nonEPrints.getName());
     			addEdge(userProfile, aggregates.getName(), id, contentId);
+    		}
     		logger.debug("User " + userProfile + " saved aggregation object " + id);
     		return id;
+    	}
     	@Override
     	public DocumentPage getEnhancedPublications(int pageSize, int pageNumber) {
     		List<Document> documents = new ArrayList<Document>();
     		for (Node node : graph.getNodes()) {
     			if (node.getEntity().equals(ePubs.getName()))
     				documents.add(new Document(node.getDocumentMap()));
+    		}
     		int numberOfDocuments = documents.size();
     		int numberOfPages = numberOfDocuments / pageSize;
     		if ((numberOfDocuments % pageSize) > 0)
     			numberOfPages++;
     		int start = (pageNumber - 1) * pageSize;
     		if (start < 0)
     			start = 0;
     		int end = pageNumber * pageSize;
     		if (end > numberOfDocuments)
     			end = numberOfDocuments;
     		documents = documents.subList(start, end);
     		logger.debug("Retrieved enhanced publications");
     		return new DocumentPage(documents, pageSize, pageNumber, numberOfDocuments, numberOfPages);
+    	}
     	@Override
     	public Document getEnhancedPublication(String id) {
     		Node node = getNode(id);
     		if ((node == null) || (!node.getEntity().equals(ePubs.getName()))) {
     			logger.debug("Enhanced publication " + id + " not found");
     			return null;
     		} else {
     			logger.debug("Retrieved enhanced publication " + id);
     			return new Document(node.getDocumentMap());
+    		}
+    	}
     	@Override
     	public Node getNode(String id) {
     		for (Node node : graph.getNodes()) {
     			if (node.getDocumentMap().get(getEntity(node.getEntity()).getIdField()).get(0).equals(id)) {
     				logger.debug("Retrieved node " + id);
     				return node;
+    			}
+    		}
     		logger.debug("Node " + id + " not found");
     		return null;
+    	}
     	@Override
     	public Set<RelatedNode> getParents(Node node) {
     		Set<RelatedNode> parents = new HashSet<RelatedNode>();
     		String id = node.getDocumentMap().get(getEntity(node.getEntity()).getIdField()).get(0);
     		for (Edge edge : graph.getEdges()) {
     			if (edge.getTarget().equals(id))
     				parents.add(new RelatedNode(edge.getRelation(), getNode(edge.getSource())));
+    		}
     		logger.debug("Retrieved parents of node " + id);
     		return parents;
+    	}
     	@Override
     	public Set<RelatedNode> getChildren(Node node) {
     		Set<RelatedNode> children = new HashSet<RelatedNode>();
     		String id = node.getDocumentMap().get(getEntity(node.getEntity()).getIdField()).get(0);
     		for (Edge edge : graph.getEdges()) {
     			if (edge.getSource().equals(id))
     				children.add(new RelatedNode(edge.getRelation(), getNode(edge.getTarget())));
+    		}
     		logger.debug("Retrieved children of node " + id);
     		return children;
+    	}
     	private void getDescendants(Node root, Graph graph){
     		String rootId = root.getDocumentMap().get(getEntity(root.getEntity()).getIdField()).get(0);
     		for (RelatedNode child : getChildren(root)) {
     			Node node = child.getNode();
     			graph.getNodes().add(node);
     			graph.getEdges().add(new Edge(child.getRelation(), rootId, node.getDocumentMap().get(getEntity(node.getEntity()).getIdField()).get(0)));
     			getDescendants(node, graph);
+    		}
     		logger.debug("Retrieved descendants of node " + rootId);
+    	}
     	private void executeCommand(UserProfile userProfile, String command) throws EPManagerException {
     		Map<String, List<String>> arguments = parseCommand(command);
     		if (arguments.get(COMMAND).get(0).equals(CREATE)) {
     			createNode(userProfile, arguments.get(ID).get(0), arguments.get(ENTITY).get(0));
     		} else if (arguments.get(COMMAND).get(0).equals(IMPORT)) {
     			importNode(userProfile, arguments.get(ID).get(0), arguments.get(ENTITY).get(0));
     		} else if (arguments.get(COMMAND).get(0).equals(EDIT)) {
     			editNode(userProfile, arguments.get(ID).get(0), arguments);
     		} else if (arguments.get(COMMAND).get(0).equals(DELETE)) {
     			deleteNode(userProfile, arguments.get(ID).get(0));
     		} else if (arguments.get(COMMAND).get(0).equals(ADD)) {
     			addEdge(userProfile, arguments.get(RELATION).get(0), arguments.get(SOURCE).get(0), arguments.get(TARGET).get(0));
     		} else if (arguments.get(COMMAND).get(0).equals(REMOVE)) {
     			removeEdge(userProfile, arguments.get(RELATION).get(0), arguments.get(SOURCE).get(0), arguments.get(TARGET).get(0));
+    		}
     		logger.debug("User " + userProfile + " executed command " + command);
+    	}
     	private Map<String, List<String>> parseCommand(String command) throws EPManagerException {
     		Map<String, List<String>> arguments = new HashMap<String, List<String>>();
     		try {
     			for (String parameter: command.split(PARAMETER_DELIMITER)) {
     				String [] pair = parameter.split(VALUE_DELIMITER);
     				String key = URLDecoder.decode(pair[0], UTF8);
     				String value = (pair.length > 1) ? URLDecoder.decode(pair[1], UTF8) : "";
     				if (arguments.get(key) == null)
     					arguments.put(key, new ArrayList<String>());
     				arguments.get(key).add(value);
+    			}
     		} catch (UnsupportedEncodingException e) {
     			logger.error("Error parsing command " + command);
     			throw new EPManagerException("Error parsing command " + command, e);
+    		}
     		return arguments;
+    	}
     	private String createNode(UserProfile userProfile, String id, String entity) {
     		String userId = userProfile.getResourceId();
     		String uuid = UUID.randomUUID().toString();
     		if (temporaryIds.get(userId) == null)
     			temporaryIds.put(userId, new HashMap<String, String>());
     		temporaryIds.get(userId).put(id, uuid);
     		Entity ent = getEntity(entity);
     		Map<String, List<String>> document = new HashMap<String, List<String>>();
     		for (Field field : ent.getFields()) {
     			String name = field.getName();
     			String defaultValue = field.getDefaultValue();
     			document.put(name, new ArrayList<String>());
     			if (name.equals(ent.getIdField()))
     				document.get(name).add(uuid);
     			if (defaultValue == null)
     				continue;
     			else if(defaultValue.equals(USER_PLACEHOLDER)) {
     				String user = userProfile.getFirstname() + " " + userProfile.getLastname();
     				if (user.trim().isEmpty())
     					user = userProfile.getEmail();
     				document.get(name).add(user);
     			} else
     				document.get(name).add(defaultValue);
+    		}
     		graph.getNodes().add(new Node(entity, document));
     		logger.debug("User " + userProfile + " created node " + id + " as " + entity + " (new id " + uuid + ")");
     		return uuid;
+    	}
     	private void importNode(UserProfile userProfile, String id, String entity) throws EPManagerException {
     		Entity ent = getEntity(entity);
     		for (Map<String, List<String>> document: getDropboxContents(userProfile)) {
     			if (document.get(ent.getIdField()).get(0).equals(id)) {
     				graph.getNodes().add(new Node(entity, document));
     				logger.debug("User " + userProfile + " imported node " + id + " as " + entity);
     				return;
+    			}
+    		}
     		logger.debug("Document " + id + " not found in dropbox of user " + userProfile);
+    	}
     	private void editNode(UserProfile userProfile, String id, Map<String, List<String>> document) {
     		id = resolveId(userProfile.getResourceId(), id);
     		for (Node node : graph.getNodes()) {
     			Entity entity = getEntity(node.getEntity());
     			if (node.getDocumentMap().get(entity.getIdField()).get(0).equals(id)) {
     				for (Field field : entity.getFields()) {
     					String name = field.getName();
     					List<String> values = document.get(DOCUMENT_PREFIX + name);
     					if (values != null)
     							node.getDocumentMap().put(name, values);
+    				}
     				logger.debug("User " + userProfile + " edited node " + id);
     				return;
+    			}
+    		}
+    	}
     	private void deleteNode(UserProfile userProfile, String id) {
     		id = resolveId(userProfile.getResourceId(), id);
     		for (Iterator<Node> i = graph.getNodes().iterator(); i.hasNext();) {
     			Node node = i.next();
     			if (node.getDocumentMap().get(getEntity(node.getEntity()).getIdField()).get(0).equals(id)) {
     				for (RelatedNode parent : getParents(node)) // break relations with parents
     					removeEdge(userProfile, parent.getRelation(), parent.getNode().getDocumentMap().get(getEntity(parent.getNode().getEntity()).getIdField()).get(0), id);
     				for (RelatedNode child: getChildren(node)) // break relations with children
     					removeEdge(userProfile, child.getRelation(), id, child.getNode().getDocumentMap().get(getEntity(child.getNode().getEntity()).getIdField()).get(0));
     				i.remove(); // remove node
     				break;
+    			}
+    		}
     		logger.debug("User " + userProfile + " deleted node " + id);
+    	}
     	private void addEdge(UserProfile userProfile, String relation, String source, String target) {
     		source = resolveId(userProfile.getResourceId(), source);
     		target = resolveId(userProfile.getResourceId(), target);
     		graph.getEdges().add(new Edge(relation, source, target));
     		logger.debug("User " + userProfile + " added edge " + relation + " from node " + source + " to node " + target);
+    	}
     	private void removeEdge(UserProfile userProfile, String relation, String source, String target) {
     		source = resolveId(userProfile.getResourceId(), source);
     		target = resolveId(userProfile.getResourceId(), target);
     		for (Iterator<Edge> i = graph.getEdges().iterator(); i.hasNext();) {
     			Edge edge = i.next();
     			if (edge.getRelation().equals(relation) && edge.getSource().equals(source) && edge.getTarget().equals(target)) {
     				i.remove();
     				break;
+    			}
+    		}
     		logger.debug("User " + userProfile + " removed edge " + relation + " from node " + source + " to node " + target);
+    	}
     	private Entity getEntity(String name) {
     		for (Entity entity : entities) {
     			if (entity.getName().equals(name))
     				return entity;
+    		}
     		return null;
+    	}
     	private String resolveId(String userId, String id) {
     		return id.startsWith(TEMP_ID_PREFIX) ? temporaryIds.get(userId).get(id) : id;
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     import eu.dnetlib.domain.data.Document;
     import eu.dnetlib.domain.functionality.UserProfile;
     import gr.uoa.di.web.utils.ep.domain.Entity;
     import gr.uoa.di.web.utils.ep.domain.Graph;
     import gr.uoa.di.web.utils.ep.domain.Node;
     import gr.uoa.di.web.utils.ep.domain.RelatedNode;
     import gr.uoa.di.web.utils.ep.domain.Relation;
     import gr.uoa.di.web.utils.search.DocumentPage;
     import java.util.HashMap;
     import java.util.List;
     import java.util.Map;
     import java.util.Set;
     /**
      * This class implements an EPManager that caches entities and relations.
      * @author thanos
+     *
      */
     public class CachingEPManager implements EPManager {
     	private EPManager epManager;
     	private Set<Entity> entities;
     	private Set<Relation> relations;
     	private Map<String, Set<Map<String, List<String>>>> dropboxContents;
     	public CachingEPManager() {
     		epManager = null;
     		entities = null;
     		relations = null;
     		dropboxContents = new HashMap<String, Set<Map<String, List<String>>>>();
+    	}
     	public EPManager getEpManager() {
     		return epManager;
+    	}
     	public void setEpManager(EPManager epManager) {
     		this.epManager = epManager;
+    	}
     	@Override
     	public Set<Entity> getEntities() throws EPManagerException {
     		if (entities == null)
     			entities = epManager.getEntities();
     		return entities;
+    	}
     	@Override
     	public Set<Relation> getRelations() throws EPManagerException {
     		if (relations == null)
     			relations = epManager.getRelations();
     		return relations;
+    	}
     	@Override
     	public Set<Map<String, List<String>>> getDropboxContents(UserProfile userProfile) throws EPManagerException {
     		if (dropboxContents.get(userProfile.getResourceId()) == null)
     			dropboxContents.put(userProfile.getResourceId(), epManager.getDropboxContents(userProfile));
     		return dropboxContents.get(userProfile.getResourceId());
+    	}
     	@Override
     	public Graph getGraph(String rootDriverId) throws EPManagerException {
     		return epManager.getGraph(rootDriverId); // can not cache graphs since may be edited by other user
+    	}
     	@Override
     	public void saveGraph(UserProfile userProfile, String [] commands) throws EPManagerException {
     		epManager.saveGraph(userProfile, commands);
+    	}
     	@Override
     	public String saveEnhancedPublication(UserProfile userProfile, String description, String language, String subject, String title, String ePrintId, Set<String> nonEPrintIds) throws EPManagerException {
     		return epManager.saveEnhancedPublication(userProfile, description, language, subject, title, ePrintId, nonEPrintIds);
+    	}
     	@Override
     	public String saveAggregationObject(UserProfile userProfile, String description, String language, String subject, String title, Set<String> contentIds) throws EPManagerException {
     		return epManager.saveAggregationObject(userProfile, description, language, subject, title, contentIds);
+    	}
     	@Override
     	public DocumentPage getEnhancedPublications(int pageSize, int pageNumber) throws EPManagerException {
     		return epManager.getEnhancedPublications(pageSize, pageNumber);
+    	}
     	@Override
     	public Document getEnhancedPublication(String id) throws EPManagerException {
     		return epManager.getEnhancedPublication(id);
+    	}
     	@Override
     	public Node getNode(String id) throws EPManagerException {
     		return epManager.getNode(id);
+    	}
     	@Override
     	public Set<RelatedNode> getParents(Node node) throws EPManagerException {
     		return epManager.getParents(node);
+    	}
     	@Override
     	public Set<RelatedNode> getChildren(Node node) throws EPManagerException {
     		return epManager.getChildren(node);
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     public class EPManagerException extends Exception {
     	private static final long serialVersionUID = 1L;
     	public EPManagerException() {
     		super();
+    	}
     	public EPManagerException(String message, Throwable cause) {
     		super(message, cause);
+    	}
     	public EPManagerException(String message) {
     		super(message);
+    	}
     	public EPManagerException(Throwable cause) {
     		super(cause);
+    	}
+    }

     package gr.uoa.di.web.utils.ep;
     import eu.dnetlib.domain.data.Document;
     import eu.dnetlib.domain.functionality.UserProfile;
     import gr.uoa.di.web.utils.ep.domain.Entity;
     import gr.uoa.di.web.utils.ep.domain.Graph;
     import gr.uoa.di.web.utils.ep.domain.Node;
     import gr.uoa.di.web.utils.ep.domain.RelatedNode;
     import gr.uoa.di.web.utils.ep.domain.Relation;
     import gr.uoa.di.web.utils.search.DocumentPage;
     import java.util.List;
     import java.util.Map;
     import java.util.Set;
     public class DLMSEPManager implements EPManager {
     	@Override
     	public Set<RelatedNode> getChildren(Node node) throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Set<Map<String, List<String>>> getDropboxContents(
     			UserProfile userProfile) throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Document getEnhancedPublication(String id) throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public DocumentPage getEnhancedPublications(int pageSize, int pageNumber)
     			throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Set<Entity> getEntities() throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Graph getGraph(String rootId) throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Node getNode(String id) throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Set<RelatedNode> getParents(Node node) throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	@Override
     	public Set<Relation> getRelations() throws EPManagerException {
     		// TODO Auto-generated method stub
     		return null;
+    	}

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

D-Net

Revision 34760

Added by Katerina Iatropoulou over 9 years ago