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

     package eu.dnetlib.enabling.datastructures;
     import com.google.gson.Gson;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetDataStructure;
     import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;
     public abstract class AbstractJsonResource implements BaseResource {
     	private String code;
     	private boolean valid = true;
     	private String name;
     	private String description;
     	public String getCode() {
     		return code;
+    	}
     	public void setCode(final String code) {
     		this.code = code;
+    	}
     	public boolean isValid() {
     		return valid;
+    	}
     	public void setValid(final boolean valid) {
     		this.valid = valid;
+    	}
     	public String getName() {
     		return name;
+    	}
     	public void setName(final String name) {
     		this.name = name;
+    	}
     	public String getDescription() {
     		return description;
+    	}
     	public void setDescription(final String description) {
     		this.description = description;
+    	}
     	@Override
     	public final DnetDataStructure asDnetDataStructure() throws InformationServiceException {
     		if (getClass().isAnnotationPresent(DnetResource.class)) {
     			final DnetDataStructure ds = new DnetDataStructure();
     			ds.setCode(code);
     			ds.setType(getClass().getAnnotation(DnetResource.class).type());
     			ds.setValid(valid);
     			ds.setName(name);
     			ds.setDescription(description);
     			ds.setContent(new Gson().toJson(this));
     			return ds;
     		} else {
     			throw new InformationServiceException("Missing DnetResource annotation in class " + getClass());
+    		}
+    	}
+    }

     import java.util.TreeSet;
     import com.google.common.collect.Sets;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetResourceFormat;
     import eu.dnetlib.rmi.objects.is.DnetResourceKind;
     @DnetResource(type = "Vocabulary", kind = DnetResourceKind.CONFIGURATION, format = DnetResourceFormat.JSON)
     public class Vocabulary extends TreeSet<VocabularyTerms> {
     public class Vocabulary extends AbstractJsonResource {
     	private static final long serialVersionUID = 1457952741071376416L;
     	private TreeSet<VocabularyTerms> terms = Sets.newTreeSet();
     	public TreeSet<VocabularyTerms> getTerms() {
     		return terms;
+    	}
     	public void setTerms(final TreeSet<VocabularyTerms> terms) {
     		this.terms = terms;
+    	}
+    }

     package eu.dnetlib.enabling.datastructures;
     import java.util.ArrayList;
     import java.util.List;
     import com.google.common.collect.Lists;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetResourceFormat;
     import eu.dnetlib.rmi.objects.is.DnetResourceKind;
     @DnetResource(type = "CleaningRule", kind = DnetResourceKind.CONFIGURATION, format = DnetResourceFormat.JSON)
     public class CleaningRule extends ArrayList<AtomicCleaningRule> {
     public class CleaningRule extends AbstractJsonResource {
     	private static final long serialVersionUID = -840852796902412057L;
     	private List<AtomicCleaningRule> rules = Lists.newArrayList();
     	public List<AtomicCleaningRule> getRules() {
     		return rules;
+    	}
     	public void setRules(final List<AtomicCleaningRule> rules) {
     		this.rules = rules;
+    	}
+    }

     package eu.dnetlib.enabling.datastructures;
     import java.io.IOException;
     import javax.xml.bind.annotation.XmlRootElement;
     import org.dom4j.Document;
     import org.dom4j.DocumentException;
     import org.springframework.core.io.Resource;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetResourceFormat;
     import eu.dnetlib.rmi.objects.is.DnetResourceKind;
     @XmlRootElement
     @DnetResource(type = "Workflow", kind = DnetResourceKind.CONFIGURATION, format = DnetResourceFormat.XML)
     public class Workflow extends AbstractXmlResource {
     	public Workflow(final Resource res) throws IOException, DocumentException {
     		super(res);
+    	}
     	@Override
     	protected String getName(final Document doc) {
     		return doc.valueOf("/process-definition/@name");
+    	}
     	@Override
     	protected String getCode(final Document doc) {
     		return doc.valueOf("/process-definition/@name");
+    	}
+    }

     @XmlRootElement
     @DnetResource(type = "MDStore", kind = DnetResourceKind.UNIT, format = DnetResourceFormat.JSON)
     public class MDStore {
     public class MDStore extends AbstractJsonResource {
     	private int size;
     	private Date lastUpdate;

     import eu.dnetlib.rmi.objects.is.DnetResourceKind;
     @DnetResource(type = "GroovyRule", kind = DnetResourceKind.CONFIGURATION, format = DnetResourceFormat.JSON)
     public class GroovyRule {
     public class GroovyRule extends AbstractJsonResource {
     	private String classpath;
     	private String mainClass;

     package eu.dnetlib.enabling.datastructures;
     import java.io.IOException;
     import org.apache.commons.io.IOUtils;
     import org.springframework.core.io.Resource;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetDataStructure;
     import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;
     public class AbstractTextResource implements BaseResource {
     	private Resource resource;
     	public AbstractTextResource(final Resource resource) {
     		this.resource = resource;
+    	}
     	@Override
     	public DnetDataStructure asDnetDataStructure() throws InformationServiceException {
     		try {
     			if (getClass().isAnnotationPresent(DnetResource.class)) {
     				final String code = resource.getFilename();
     				final DnetDataStructure ds = new DnetDataStructure();
     				ds.setCode(code);
     				ds.setType(getClass().getAnnotation(DnetResource.class).type());
     				ds.setValid(true);
     				ds.setName(code);
     				ds.setDescription("");
     				ds.setContent(IOUtils.toString(resource.getInputStream()));
     				return ds;
     			} else {
     				throw new InformationServiceException("Missing DnetResource annotation in class " + getClass());
+    			}
     		} catch (IOException e) {
     			throw new InformationServiceException("Error reading resource " + resource.getFilename());
+    		}
+    	}
+    }

     @XmlRootElement
     @DnetResource(type = "MetaWorkflow", kind = DnetResourceKind.UNIT, format = DnetResourceFormat.JSON)
     public class MetaWorkflow {
     public class MetaWorkflow extends AbstractJsonResource {
     	@XmlEnum
     	public enum Status {
-...
     		this.section = section;
+    	}
     	@Override
     	public String getName() {
     		return name;
+    	}
     	@Override
     	public void setName(final String name) {
     		this.name = name;
+    	}

     package eu.dnetlib.enabling.datastructures;
     import eu.dnetlib.rmi.objects.is.DnetDataStructure;
     import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;
     public interface BaseResource {
     	DnetDataStructure asDnetDataStructure() throws InformationServiceException;
+    }

     @XmlRootElement
     @DnetResource(type = "ObjectStore", kind = DnetResourceKind.UNIT, format = DnetResourceFormat.JSON)
     public class ObjectStore {
     public class ObjectStore extends AbstractJsonResource {
     	private int size;
     	private Date lastUpdate;

     package eu.dnetlib.enabling.datastructures;
     import java.io.IOException;
     import javax.xml.bind.annotation.XmlRootElement;
     import org.dom4j.Document;
     import org.dom4j.DocumentException;
     import org.springframework.core.io.Resource;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetResourceFormat;
     import eu.dnetlib.rmi.objects.is.DnetResourceKind;
     @XmlRootElement
     @DnetResource(type = "MetadataFormat", kind = DnetResourceKind.CONFIGURATION, format = DnetResourceFormat.XML)
     public class MetadataFormat {
     public class MetadataFormat extends AbstractXmlResource {
     	public MetadataFormat(final Resource res) throws IOException, DocumentException {
     		super(res);
+    	}
     	@Override
     	protected String getName(final Document doc) {
     		return doc.valueOf("/format/@name");
+    	}
     	@Override
     	protected String getCode(final Document doc) {
     		return doc.valueOf("/format/@name");
+    	}
+    }

     @XmlRootElement
     @DnetResource(format = DnetResourceFormat.JSON, kind = DnetResourceKind.UNIT, type = DatasourceConstants.DATASOURCE_TYPE)
     public class Datasource {
     public class Datasource extends AbstractJsonResource {
     	private String id;
     	private String officialName;
-...
     		this.mergehomonyms = mergehomonyms;
+    	}
     	@Override
     	public String getDescription() {
     		return description;
+    	}
     	@Override
     	public void setDescription(final String description) {
     		this.description = description;
+    	}

     package eu.dnetlib.enabling.datastructures;
     import java.io.IOException;
     import java.io.StringReader;
     import org.dom4j.Document;
     import org.dom4j.DocumentException;
     import org.dom4j.io.SAXReader;
     import org.springframework.core.io.Resource;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetDataStructure;
     import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;
     public abstract class AbstractXmlResource implements BaseResource {
     	private transient Document doc;
     	public AbstractXmlResource(final String xml) throws DocumentException {
     		this.doc = new SAXReader().read(new StringReader(xml));
+    	}
     	public AbstractXmlResource(final Resource res) throws IOException, DocumentException {
     		this.doc = new SAXReader().read(res.getInputStream());
+    	}
     	public final Document asDocument() {
     		return doc;
+    	}
     	abstract protected String getName(Document doc);
     	abstract protected String getCode(Document doc);
     	protected String getDescription(final Document doc) {
     		return "";
+    	}
     	protected boolean isValid(final Document doc) {
     		return true;
+    	}
     	@Override
     	public DnetDataStructure asDnetDataStructure() throws InformationServiceException {
     		if (getClass().isAnnotationPresent(DnetResource.class)) {
     			final DnetDataStructure ds = new DnetDataStructure();
     			ds.setCode(getCode(doc));
     			ds.setType(getClass().getAnnotation(DnetResource.class).type());
     			ds.setValid(isValid(doc));
     			ds.setName(getName(doc));
     			ds.setDescription(getDescription(doc));
     			ds.setContent(doc.asXML());
     			return ds;
     		} else {
     			throw new InformationServiceException("Missing DnetResource annotation in class " + getClass());
+    		}
+    	}
+    }

     package eu.dnetlib.enabling.datastructures;
     import org.springframework.core.io.Resource;
     import eu.dnetlib.enabling.annotations.DnetResource;
     import eu.dnetlib.rmi.objects.is.DnetResourceFormat;
     import eu.dnetlib.rmi.objects.is.DnetResourceKind;
     @DnetResource(type = "TransformationRule", kind = DnetResourceKind.CONFIGURATION, format = DnetResourceFormat.TEXT)
     public class TransformationRule {
     public class TransformationRule extends AbstractTextResource {
     	private String code;
     	public TransformationRule() {}
     	public TransformationRule(final String code) {
     		this.code = code;
     	public TransformationRule(final Resource resource) {
     		super(resource);
+    	}
     	public String getCode() {
     		return code;
+    	}
     	public void setCode(final String code) {
     		this.code = code;
+    	}
     	@Override
     	public String toString() {
     		return getCode();
+    	}
+    }

modules/dnet-node-services/trunk/src/main/java/eu/dnetlib/enabling/nodeManager/ContentInitializer.java
42	42	try {
43	43	log.info("Content initialization - START");
44	44	registerAnnotatedResouceTypes(basePackage);
45		// registerServices(); // TO DELETE
46	45	registerDatastructures(initDsPath, false);
47	46	log.info("Content initialization - END");
48	47	} catch (Throwable e) {

     		this.vocabularies = vocabularies;
     		for (final String vocName : vocabularies) {
     			try {
     				for (VocabularyTerms term : isClient.getResourceByCode(vocName, Vocabulary.class)) {
     				for (VocabularyTerms term : isClient.getResourceByCode(vocName, Vocabulary.class).getTerms()) {
     					final String code = term.getCode();
     					validTerms.add(code.toLowerCase());
     					synonyms.put(code.toLowerCase(), code);

     	public Cleaner createCleaner(final CleaningRule rule) {
     		final List<XPathCleaningRule> xpathRules = Lists.transform(rule, new Function<AtomicCleaningRule, XPathCleaningRule>() {
     		final List<XPathCleaningRule> xpathRules = Lists.transform(rule.getRules(), new Function<AtomicCleaningRule, XPathCleaningRule>() {
     			@Override
     			public XPathCleaningRule apply(final AtomicCleaningRule r) {

Project

General

Profile

D-Net

Revision 36812

Added by Michele Artini about 9 years ago