git-svn-id: http://svn.research-infrastructures.eu/public/d4science/gcube/branches/data-access/catalogue-of-life-spd-plugin/1.8@142404 82a268e6-3cf1-43bd-a215-b396298e98cf
Valentina Marioli
7 years ago
commit
6038a9a5f9
@ -0,0 +1,36 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<classpath>
|
||||
<classpathentry kind="src" output="target/classes" path="src/main/java">
|
||||
<attributes>
|
||||
<attribute name="optional" value="true"/>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
|
||||
<attributes>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="src" output="target/test-classes" path="src/test/java">
|
||||
<attributes>
|
||||
<attribute name="optional" value="true"/>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
|
||||
<attributes>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
|
||||
<attributes>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
|
||||
<attributes>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="output" path="target/classes"/>
|
||||
</classpath>
|
||||
@ -0,0 +1,29 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>catalogue-of-life-spd-plugin</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
<buildSpec>
|
||||
<buildCommand>
|
||||
<name>org.eclipse.jdt.core.javabuilder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
<buildCommand>
|
||||
<name>org.eclipse.m2e.core.maven2Builder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
</buildSpec>
|
||||
<natures>
|
||||
<nature>org.eclipse.jdt.core.javanature</nature>
|
||||
<nature>org.eclipse.m2e.core.maven2Nature</nature>
|
||||
</natures>
|
||||
<variableList>
|
||||
<variable>
|
||||
<name>GLOBUS_LOCATION</name>
|
||||
<value>file:/home/valentina/gCore</value>
|
||||
</variable>
|
||||
</variableList>
|
||||
</projectDescription>
|
||||
@ -0,0 +1,6 @@
|
||||
eclipse.preferences.version=1
|
||||
encoding//src/main/java=UTF-8
|
||||
encoding//src/main/resources=UTF-8
|
||||
encoding//src/test/java=UTF-8
|
||||
encoding//src/test/resources=UTF-8
|
||||
encoding/<project>=UTF-8
|
||||
@ -0,0 +1,12 @@
|
||||
eclipse.preferences.version=1
|
||||
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
|
||||
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
|
||||
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
|
||||
org.eclipse.jdt.core.compiler.compliance=1.7
|
||||
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
|
||||
org.eclipse.jdt.core.compiler.debug.localVariable=generate
|
||||
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
|
||||
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
|
||||
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
|
||||
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
|
||||
org.eclipse.jdt.core.compiler.source=1.7
|
||||
@ -0,0 +1,2 @@
|
||||
eclipse.preferences.version=1
|
||||
org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false
|
||||
@ -0,0 +1,5 @@
|
||||
#Wed Jul 10 13:01:54 CEST 2013
|
||||
activeProfiles=
|
||||
eclipse.preferences.version=1
|
||||
resolveWorkspaceProjects=true
|
||||
version=1
|
||||
@ -0,0 +1,6 @@
|
||||
gCube System - License
|
||||
------------------------------------------------------------
|
||||
|
||||
The gCube/gCore software is licensed as Free Open Source software conveying to the EUPL (http://ec.europa.eu/idabc/eupl).
|
||||
The software and documentation is provided by its authors/distributors "as is" and no expressed or
|
||||
implied warranty is given for its use, quality or fitness for a particular case.
|
||||
@ -0,0 +1,61 @@
|
||||
The gCube System - ${name}
|
||||
--------------------------------------------------
|
||||
|
||||
${description}
|
||||
|
||||
|
||||
${gcube.description}
|
||||
|
||||
${gcube.funding}
|
||||
|
||||
|
||||
Version
|
||||
--------------------------------------------------
|
||||
|
||||
${version} (${buildDate})
|
||||
|
||||
Please see the file named "changelog.xml" in this directory for the release notes.
|
||||
|
||||
|
||||
Authors
|
||||
--------------------------------------------------
|
||||
|
||||
* Valentina Marioli (valentina.marioli-AT-isti.cnr.it), CNR, Italy
|
||||
|
||||
MAINTAINERS
|
||||
--------------------------------------------------
|
||||
|
||||
* Valentina Marioli (valentina.marioli-AT-isti.cnr.it), CNR, Italy
|
||||
|
||||
Download information
|
||||
--------------------------------------------------
|
||||
|
||||
Source code is available from SVN:
|
||||
${scm.url}
|
||||
|
||||
Binaries can be downloaded from the gCube website:
|
||||
${gcube.website}
|
||||
|
||||
|
||||
Installation
|
||||
--------------------------------------------------
|
||||
|
||||
Installation documentation is available on-line in the gCube Wiki:
|
||||
${gcube.wikiRoot}
|
||||
|
||||
Documentation
|
||||
--------------------------------------------------
|
||||
|
||||
Documentation is available on-line in the gCube Wiki:
|
||||
${gcube.wikiRoot}
|
||||
Support
|
||||
--------------------------------------------------
|
||||
|
||||
Bugs and support requests can be reported in the gCube issue tracking tool:
|
||||
${gcube.issueTracking}
|
||||
|
||||
|
||||
Licensing
|
||||
--------------------------------------------------
|
||||
|
||||
This software is licensed under the terms you may find in the file named "LICENSE" in this directory.
|
||||
@ -0,0 +1,39 @@
|
||||
<ReleaseNotes>
|
||||
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-0-0"
|
||||
date="2012-05-04">
|
||||
<Change>First Release</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-1-0"
|
||||
date="2012-09-14">
|
||||
<Change>Bugs fixed</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-2-0"
|
||||
date="2012-10-18">
|
||||
<Change>Added plugin info</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-3-0"
|
||||
date="2012-11-30">
|
||||
<Change>Bugs fixed</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-4-0"
|
||||
date="2013-01-17">
|
||||
<Change>updated to spd-plugin-framework 2.0</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-5-0"
|
||||
date="2013-04-30">
|
||||
<Change>added ExpansionCapability</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-6-0"
|
||||
date="2013-07-19">
|
||||
<Change>no more getSynonymCapability</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-7-0"
|
||||
date="2014-04-28">
|
||||
<Change>Added citation</Change>
|
||||
</Changeset>
|
||||
<Changeset component="org.gcube.data.spd.catalogue-of-life-spd-plugin.1-8-0"
|
||||
date="2017-02-08">
|
||||
<Change>GCore removed</Change>
|
||||
</Changeset>
|
||||
</ReleaseNotes>
|
||||
@ -0,0 +1,31 @@
|
||||
<assembly
|
||||
xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
|
||||
<id>servicearchive</id>
|
||||
<formats>
|
||||
<format>tar.gz</format>
|
||||
</formats>
|
||||
<baseDirectory>/</baseDirectory>
|
||||
<fileSets>
|
||||
<fileSet>
|
||||
<directory>${distroDirectory}</directory>
|
||||
<outputDirectory>/</outputDirectory>
|
||||
<useDefaultExcludes>true</useDefaultExcludes>
|
||||
<includes>
|
||||
<include>README</include>
|
||||
<include>LICENSE</include>
|
||||
<include>profile.xml</include>
|
||||
<include>changelog.xml</include>
|
||||
</includes>
|
||||
<fileMode>755</fileMode>
|
||||
<filtered>true</filtered>
|
||||
</fileSet>
|
||||
</fileSets>
|
||||
<files>
|
||||
<file>
|
||||
<source>target/${build.finalName}.jar</source>
|
||||
<outputDirectory>/${artifactId}</outputDirectory>
|
||||
</file>
|
||||
</files>
|
||||
</assembly>
|
||||
@ -0,0 +1,28 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Resource>
|
||||
<ID></ID>
|
||||
<Type>Service</Type>
|
||||
<Profile>
|
||||
<Description>${description}</Description>
|
||||
<Class>DataAccess</Class>
|
||||
<Name>${artifactId}</Name>
|
||||
<Version>1.0.0</Version>
|
||||
<Packages>
|
||||
<Software>
|
||||
<Description>${description}</Description>
|
||||
<Name>${artifactId}</Name>
|
||||
<Version>${version}</Version>
|
||||
<MavenCoordinates>
|
||||
<groupId>${groupId}</groupId>
|
||||
<artifactId>${artifactId}</artifactId>
|
||||
<version>${version}</version>
|
||||
</MavenCoordinates>
|
||||
<Type>library</Type>
|
||||
<Files>
|
||||
<File>${build.finalName}.jar</File>
|
||||
</Files>
|
||||
</Software>
|
||||
</Packages>
|
||||
</Profile>
|
||||
</Resource>
|
||||
|
||||
@ -0,0 +1,128 @@
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<parent>
|
||||
<artifactId>maven-parent</artifactId>
|
||||
<groupId>org.gcube.tools</groupId>
|
||||
<version>1.0.0</version>
|
||||
<relativePath />
|
||||
</parent>
|
||||
|
||||
|
||||
<groupId>org.gcube.data.spd</groupId>
|
||||
<artifactId>catalogue-of-life-spd-plugin</artifactId>
|
||||
<version>1.8.0-SNAPSHOT</version>
|
||||
<name>catalogue-of-life-spd-plugin</name>
|
||||
<description>Catalogue Of Life Plugin</description>
|
||||
|
||||
<scm>
|
||||
<connection>scm:svn:http://svn.d4science.research-infrastructures.eu/gcube/trunk/data-access/${project.artifactId}</connection>
|
||||
<developerConnection>scm:svn:https://svn.d4science.research-infrastructures.eu/gcube/trunk/data-access/${project.artifactId}</developerConnection>
|
||||
<url>http://svn.d4science.research-infrastructures.eu/gcube/trunk/data-access/${project.artifactId}</url>
|
||||
</scm>
|
||||
|
||||
<properties>
|
||||
<distroDirectory>distro</distroDirectory>
|
||||
</properties>
|
||||
|
||||
<dependencyManagement>
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.gcube.distribution</groupId>
|
||||
<artifactId>gcube-bom</artifactId>
|
||||
<version>LATEST</version>
|
||||
<type>pom</type>
|
||||
<scope>import</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
</dependencyManagement>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.gcube.resources</groupId>
|
||||
<artifactId>common-gcore-resources</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.gcube.resources.discovery</groupId>
|
||||
<artifactId>ic-client</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.gcube.data.spd</groupId>
|
||||
<artifactId>spd-model</artifactId>
|
||||
<version>[3.0.0-SNAPSHOT, 4.0.0-SNAPSHOT)</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.gcube.data.spd</groupId>
|
||||
<artifactId>spd-plugin-framework</artifactId>
|
||||
<version>[3.0.0-SNAPSHOT, 4.0.0-SNAPSHOT)</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>junit</groupId>
|
||||
<artifactId>junit</artifactId>
|
||||
<version>4.10</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>joda-time</groupId>
|
||||
<artifactId>joda-time</artifactId>
|
||||
<version>2.1</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.slf4j</groupId>
|
||||
<artifactId>slf4j-api</artifactId>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
<build>
|
||||
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-resources-plugin</artifactId>
|
||||
<version>2.5</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>copy-profile</id>
|
||||
<phase>install</phase>
|
||||
<goals>
|
||||
<goal>copy-resources</goal>
|
||||
</goals>
|
||||
<configuration>
|
||||
<outputDirectory>target</outputDirectory>
|
||||
<resources>
|
||||
<resource>
|
||||
<directory>${distroDirectory}</directory>
|
||||
<filtering>true</filtering>
|
||||
<includes>
|
||||
<include>profile.xml</include>
|
||||
</includes>
|
||||
</resource>
|
||||
</resources>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-assembly-plugin</artifactId>
|
||||
<version>2.2</version>
|
||||
<configuration>
|
||||
<descriptors>
|
||||
<descriptor>${distroDirectory}/descriptor.xml</descriptor>
|
||||
</descriptors>
|
||||
</configuration>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>servicearchive</id>
|
||||
<phase>install</phase>
|
||||
<goals>
|
||||
<goal>single</goal>
|
||||
</goals>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
</project>
|
||||
@ -0,0 +1,146 @@
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
|
||||
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
||||
import org.gcube.common.resources.gcore.ServiceEndpoint.AccessPoint;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.ClassificationCapabilityImpl;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.ExpansionCapabilityImpl;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.NamesMappingImpl;
|
||||
import org.gcube.data.spd.model.Condition;
|
||||
import org.gcube.data.spd.model.RepositoryInfo;
|
||||
import org.gcube.data.spd.model.products.ResultItem;
|
||||
import org.gcube.data.spd.model.util.Capabilities;
|
||||
import org.gcube.data.spd.plugin.fwk.AbstractPlugin;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.ClassificationCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.ExpansionCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.MappingCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.UnfoldCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
|
||||
public class CatalogueOfLifePlugin extends AbstractPlugin {
|
||||
|
||||
static Logger logger = LoggerFactory.getLogger(CatalogueOfLifePlugin.class);
|
||||
final static String citation = "Bisby F., Roskov Y., Culham A., Orrell T., Nicolson D., Paglinawan L., Bailly N., Appeltans W., Kirk P., Bourgoin T., Baillargeon G., Ouvrard D., eds (2012). Species 2000 & ITIS Catalogue of Life, 30th May 2012. Digital resource at www.catalogueoflife.org/col/. Species 2000: Reading, UK. Accessed through: Catalogue of Life at http://www.catalogueoflife.org/ on ";
|
||||
final static String credits = "This information object has been generated via the Species Product Discovery service on XDATEX by interfacing with the Catalogue of Life (http://www.catalogueoflife.org/)";
|
||||
|
||||
private ClassificationCapabilityImpl classificationCapability = new ClassificationCapabilityImpl();
|
||||
|
||||
public static String baseurl;
|
||||
//public static String baseurl = "http://www.catalogueoflife.org/col/webservice";
|
||||
|
||||
@Override
|
||||
public void initialize(ServiceEndpoint res) throws Exception {
|
||||
setUseCache(true);
|
||||
for (AccessPoint ap:res.profile().accessPoints()) {
|
||||
if (ap.name().equals("catalogueoflife")) {
|
||||
baseurl = ap.address();
|
||||
// logger.trace(baseurl);
|
||||
}
|
||||
}
|
||||
super.initialize(res);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update(ServiceEndpoint res) throws Exception {
|
||||
for (org.gcube.common.resources.gcore.ServiceEndpoint.AccessPoint ap:res.profile().accessPoints()) {
|
||||
if (ap.name().equals("catalogueoflife")) {
|
||||
baseurl = ap.address();
|
||||
// logger.trace(baseurl);
|
||||
}
|
||||
}
|
||||
super.update(res);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDescription() {
|
||||
return ("Catalogue of Life Plugin");
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRepositoryName() {
|
||||
return ("CatalogueOfLife");
|
||||
}
|
||||
|
||||
@SuppressWarnings("serial")
|
||||
@Override
|
||||
public Set<Capabilities> getSupportedCapabilities() {
|
||||
return new HashSet<Capabilities>(){{add(Capabilities.NamesMapping); add(Capabilities.Classification);add(Capabilities.Expansion);add(Capabilities.Unfold);}};
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public MappingCapability getMappingInterface() {
|
||||
return new NamesMappingImpl();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public ClassificationCapability getClassificationInterface() {
|
||||
return classificationCapability;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UnfoldCapability getUnfoldInterface() {
|
||||
return classificationCapability;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ExpansionCapability getExpansionInterface() {
|
||||
return new ExpansionCapabilityImpl();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void searchByScientificName(String word,
|
||||
ObjectWriter<ResultItem> writer, Condition... properties) {
|
||||
logger.trace("Search by Scientific Name "+ word + " in CoL");
|
||||
|
||||
Utils.searchRI(word, "accepted name", writer, 0, new HashSet<String>());
|
||||
|
||||
}
|
||||
|
||||
protected XMLEventReader checkRICommonName(XMLEventReader eventReader, ObjectWriter<ResultItem> writer) throws XMLStreamException {
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "name_status")){
|
||||
event = eventReader.nextEvent();
|
||||
|
||||
if ((event.asCharacters().getData()).equals("common name")){
|
||||
// logger.trace("common name");
|
||||
continue;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "accepted_name")){
|
||||
// logger.trace("accepted_name");
|
||||
Utils.getResultItem(eventReader, writer, "accepted name");
|
||||
return eventReader;
|
||||
}
|
||||
}
|
||||
return eventReader;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RepositoryInfo getRepositoryInfo() {
|
||||
RepositoryInfo info = new RepositoryInfo(
|
||||
"http://www.catalogueoflife.org/prototype/images/head/head_leaves.jpg",
|
||||
"http://www.catalogueoflife.org/",
|
||||
"The Catalogue of Life is a quality-assured checklist of more than 1.3 million species of plants, animals, fungi and micro-organisms, about 70% of all those known to science. An uncomplicated structure, and both minimal and standardised dataset provide a sound baseline of species information for all biologists. The Catalogue of Life is unique in its breadth of coverage of organisms, the degree of validation in the knowledge set, and its wide global take-up. The Catalogue of Life is a remarkable global partnership. The content is contributed by an array of some 100 expert taxonomic databases world-wide, involving over 3,000 taxonomic specialists: the Global Species Databases. Expert teams peer review the databases and integrate them into a single coherent catalogue, and have established a single hierarchical classification. The Catalogue of Life is evolving to provide an effective partner to six global biodiversity programmes (through the i4Life European e-Infrastructure project, 2010-2013), creating an ecosystem of services. The Catalogue is able to support the needs of these partner programmes in establishing validated taxonomy, and moreover share a variety of related services amongst all: Global Biodiversity Information Facility (GBIF); Barcode of Life Data Systems (BOLD); IUCN Red List, Encyclopedia of Life, EMBL European Nucleotide Archive (ENA), LifeWatch.");
|
||||
return info;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,85 @@
|
||||
/**
|
||||
* Date validation using Pattern matching
|
||||
*/
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
|
||||
import java.util.Date;
|
||||
|
||||
import org.joda.time.format.DateTimeFormat;
|
||||
import org.joda.time.format.DateTimeFormatter;
|
||||
|
||||
/**
|
||||
* @author "Federico De Faveri defaveri@isti.cnr.it"
|
||||
*
|
||||
*/
|
||||
public class DateUtil {
|
||||
//Unsupported:
|
||||
//2010-05-03T14:44:04Z+01:00
|
||||
//2009-04-09TMountain Da:ylight Time
|
||||
//2008-05-20T13:03:08OZ
|
||||
//2008-11-01T14:45OZ
|
||||
//0000-00-00 00:00:00
|
||||
|
||||
protected static final String[] DATE_FORMATS = new String[]{
|
||||
"yyyy-MM-dd'T'HH:mm:ss.SSSZZ", //2005-10-24T13:33:11.000Z
|
||||
"yyyy-MM-dd'T'HH:mm:ss:mm:ssZ", //2003-02-18T11:35:13:35:13Z
|
||||
"yyyy-MM-dd' 'HH:mm:ss.SSSSSS", //2006-12-20 10:27:02.477563
|
||||
"yyyy-MM-dd'T'HH:mm:ssZZ", //2001-02-10T12:00:00+00:00
|
||||
"yyyy-MM-dd'T'HH:mm:sssZZ", //2011-09-25T11:00:000Z
|
||||
"yyyy-MM-dd' 'HH:mm:ssZZ", //2007-05-11 14:01:15-04
|
||||
"yyyy-MM-dd'T'HH:mm:ssz", //2005-10-11T15:40:00Z
|
||||
"yyyy-MM-dd' 'HH:mm:ss", //2007-07-18 06:13:06
|
||||
"yyyy-MM-dd'T'HH:mmZ", //2009-10-01T01:00Z
|
||||
"dd/MM/yyyyHH:mm:ssZ", //13/9/201012:00:00Z
|
||||
"yyyy-MM-dd' 'HH:mm", //2005-12-20 17:12
|
||||
"yyyy-MM-dd'T'", //2010-06-09T
|
||||
"yyyy-MM-dd-'T'", //2009-08-05-T
|
||||
"yyyy-MM-dd", //2009-09-08
|
||||
"yyyy", //2009
|
||||
"MM-yyyy", //09-2009
|
||||
"MMM-yyyy", //May-2009
|
||||
"dd-MMM-yy", //28-MAR-01 08-AUG-96
|
||||
"dd/MM/yyyy", //11/2/2010
|
||||
"dd-MM-yyyy", //11-02-2010
|
||||
"MM/dd/yyyy' 'HH:mm:ss", //8/23/2010 0:00:00
|
||||
"MM/dd/yyyy", //10/19/2010
|
||||
"yyyy/MM/dd' 'HH:mm:ss", //2010/10/27 22:29:04
|
||||
|
||||
};
|
||||
|
||||
|
||||
protected static DateUtil instance;
|
||||
|
||||
public static DateUtil getInstance()
|
||||
{
|
||||
if (instance == null) {
|
||||
instance = new DateUtil();
|
||||
instance.initialize();
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
protected DateTimeFormatter[] FORMATS;
|
||||
|
||||
protected DateUtil() {
|
||||
FORMATS = new DateTimeFormatter[DATE_FORMATS.length];
|
||||
}
|
||||
|
||||
protected void initialize()
|
||||
{
|
||||
int i = 0;
|
||||
for (String dateFormat:DATE_FORMATS) {
|
||||
FORMATS[i++] = DateTimeFormat.forPattern(dateFormat);
|
||||
}
|
||||
}
|
||||
|
||||
public Date parse(String dateString) {
|
||||
for (DateTimeFormatter formatter:FORMATS) {
|
||||
try {
|
||||
return formatter.parseDateTime(dateString).toDate();
|
||||
} catch (Exception e){}
|
||||
}
|
||||
return null; // Unknown format.
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,719 @@
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.URI;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
import javax.xml.namespace.QName;
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLStreamConstants;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.Attribute;
|
||||
import javax.xml.stream.events.StartElement;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
import org.gcube.data.spd.model.CommonName;
|
||||
import org.gcube.data.spd.model.exceptions.StreamBlockingException;
|
||||
import org.gcube.data.spd.model.products.DataProvider;
|
||||
import org.gcube.data.spd.model.products.DataSet;
|
||||
import org.gcube.data.spd.model.products.ResultItem;
|
||||
import org.gcube.data.spd.model.products.TaxonomyItem;
|
||||
import org.gcube.data.spd.model.products.TaxonomyStatus;
|
||||
import org.gcube.data.spd.model.products.TaxonomyStatus.Status;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.Node;
|
||||
import org.w3c.dom.NodeList;
|
||||
|
||||
|
||||
public class Utils {
|
||||
|
||||
|
||||
static Logger logger = LoggerFactory.getLogger(Utils.class);
|
||||
|
||||
|
||||
public static boolean checkStartElement(XMLEvent event, String value){
|
||||
return event.getEventType() == XMLStreamConstants.START_ELEMENT && event.asStartElement().getName().getLocalPart().equals(value);
|
||||
}
|
||||
|
||||
public static boolean checkEndElement(XMLEvent event, String value){
|
||||
return event.getEventType() == XMLStreamConstants.END_ELEMENT && event.asEndElement().getName().getLocalPart().equals(value);
|
||||
}
|
||||
|
||||
|
||||
public static String readCharacters(XMLEventReader eventReader) throws XMLStreamException{
|
||||
String characters="";
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
while (eventReader.hasNext() && event.isCharacters() ){
|
||||
characters+= event.asCharacters().getData();
|
||||
event = eventReader.nextEvent();
|
||||
}
|
||||
return characters.trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* Search an element using name or an id
|
||||
*/
|
||||
public static void searchRI(String name, String name_status, ObjectWriter<ResultItem> writer, int start, Set<String> hash) {
|
||||
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?name=*" + name.replaceAll(" ", "+") + "*&response=full&start=" + start;
|
||||
// logger.trace("PATH " + pathUrl);
|
||||
int total_number_of_results = 0;
|
||||
int number_of_results_returned = 0;
|
||||
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
try{
|
||||
is = URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "results")){
|
||||
|
||||
StartElement element = (StartElement) event;
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterator<Attribute> iterator = element.getAttributes();
|
||||
while (iterator.hasNext()) {
|
||||
|
||||
Attribute attribute = (Attribute) iterator.next();
|
||||
QName att = attribute.getName();
|
||||
|
||||
if (att.toString().equals("total_number_of_results")){
|
||||
total_number_of_results = (Integer.parseInt(attribute.getValue()));
|
||||
// logger.trace(total_number_of_results);
|
||||
}
|
||||
else if (att.toString().equals("number_of_results_returned")){
|
||||
number_of_results_returned = (Integer.parseInt(attribute.getValue()));
|
||||
// logger.trace(number_of_results_returned);
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "result")){
|
||||
eventReader = getResultItem(eventReader, writer, name_status);
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "results")){
|
||||
if (total_number_of_results > number_of_results_returned + start)
|
||||
searchRI( name, name_status, writer, start+50, hash);
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
writer.write(new StreamBlockingException("CatalogueOfLife", ""));
|
||||
}finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public static TaxonomyItem retrieveTIById(String id, Boolean skip) throws XMLStreamException{
|
||||
|
||||
TaxonomyItem item = null;
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
try{
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?id=" + id + "&response=full";
|
||||
// logger.trace(pathUrl);
|
||||
|
||||
is = URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
if (item == null){
|
||||
item = new TaxonomyItem(readCharacters(eventReader));
|
||||
item.setCredits(Utils.createCredits());
|
||||
item.setCitation(Utils.createCitation());
|
||||
}
|
||||
continue;
|
||||
} else if (Utils.checkStartElement(event, "name")){
|
||||
if (item == null) break;
|
||||
if (item.getScientificName() == null)
|
||||
item.setScientificName(readCharacters(eventReader));
|
||||
continue;
|
||||
} else if (Utils.checkStartElement(event, "rank")){
|
||||
if (item.getRank() == null)
|
||||
item.setRank(readCharacters(eventReader));
|
||||
continue;
|
||||
} else if (Utils.checkStartElement(event, "author")){
|
||||
if (item.getScientificNameAuthorship() == null)
|
||||
item.setScientificNameAuthorship(readCharacters(eventReader));
|
||||
continue;
|
||||
} else if (Utils.checkStartElement(event, "record_scrutiny_date")){
|
||||
Calendar modified = null;
|
||||
modified = Utils.getCalendar(readCharacters(eventReader));
|
||||
item.setModified(modified);
|
||||
continue;
|
||||
} else if (Utils.checkStartElement(event, "name_status")){
|
||||
|
||||
event = eventReader.nextEvent();
|
||||
if (item.getStatus() == null){
|
||||
// System.out.println("name_status " + event.asCharacters().getData());
|
||||
if ((event.asCharacters().getData()).equals("accepted name")){
|
||||
item.setStatus(new TaxonomyStatus(event.asCharacters().getData(), Status.ACCEPTED));
|
||||
} else if ((event.asCharacters().getData()).equals("synonym")){
|
||||
// item.setStatus( new TaxonomyStatus(Status.SYNONYM, sn_id));
|
||||
} else if ((event.asCharacters().getData()).equals("ambiguous synonym")){
|
||||
// item.setStatus( new TaxonomyStatus(Status.SYNONYM, sn_id));
|
||||
} else if ((event.asCharacters().getData()).equals("misapplied name")){
|
||||
item.setStatus( new TaxonomyStatus("misapplied name", Status.MISAPPLIED));
|
||||
} else if ((event.asCharacters().getData()).equals("provisional accepted name")){
|
||||
item.setStatus( new TaxonomyStatus("provisional accepted name", Status.PROVISIONAL));
|
||||
} else
|
||||
item.setStatus(new TaxonomyStatus(event.asCharacters().getData(), Status.UNKNOWN));
|
||||
}
|
||||
continue;
|
||||
|
||||
}else if (Utils.checkStartElement(event, "sn_id") && (item.getStatus() == null)){
|
||||
event = eventReader.nextEvent();
|
||||
|
||||
if (!(event.asCharacters().getData()).equals(0)){
|
||||
// logger.trace("SYNONYM");
|
||||
item.setStatus(new TaxonomyStatus(Status.SYNONYM, event.asCharacters().getData(), "synonym"));
|
||||
}
|
||||
continue;
|
||||
} else if (Utils.checkStartElement(event, "common_names")){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "common_name")){
|
||||
// System.out.println("common_names *****");
|
||||
event = eventReader.nextEvent();
|
||||
// System.out.println(event.asCharacters().getData());
|
||||
|
||||
item.setCommonNames(Utils.getCommonNames(eventReader));
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (Utils.checkStartElement(event, "classification") & !skip){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "taxon")){
|
||||
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
// System.out.println("item.setParent(retrieveTIById(event.asCharacters().getData(), true))");
|
||||
item.setParent(retrieveTIById(event.asCharacters().getData(), true));
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "result")){
|
||||
break;
|
||||
}
|
||||
}
|
||||
}catch(Exception e){
|
||||
throw new XMLStreamException(e);
|
||||
}finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
public static XMLEventReader getResultItem(XMLEventReader eventReader, ObjectWriter<ResultItem> writer, String name_status) throws XMLStreamException {
|
||||
|
||||
Set<DataSet> setDataSet = null;
|
||||
ResultItem item = null;
|
||||
ResultItem parent = null;
|
||||
Boolean flag = true;
|
||||
Boolean flag_source = true;
|
||||
Boolean flag_ref = true;
|
||||
DataProvider dp = null;
|
||||
DataSet dataSet = null;
|
||||
String source_database = null;
|
||||
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
if (flag){
|
||||
item = createItem(eventReader, writer, name_status);
|
||||
flag = false;
|
||||
}
|
||||
|
||||
if (item != null){
|
||||
|
||||
if (Utils.checkStartElement(event, "source_database") && flag_source){
|
||||
// System.out.println("source db");
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters()){
|
||||
source_database = event.asCharacters().getData();
|
||||
flag_source = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "references") && flag_ref){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "reference")){
|
||||
setDataSet = getReferences(eventReader);
|
||||
flag_ref = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "classification")){
|
||||
// System.out.println("classification");
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "taxon")){
|
||||
item.setParent(searchTaxonomyRI(eventReader, parent));
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "common_names")){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "common_name")){
|
||||
// System.out.println("common names");
|
||||
event = eventReader.nextEvent();
|
||||
item.setCommonNames(getCommonNames(eventReader));
|
||||
// System.out.println("common_names *****");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkEndElement(event, "result")){
|
||||
// System.out.println("****** result*****");
|
||||
|
||||
if (setDataSet != null){
|
||||
// System.out.println("****** dataset size***** " + setDataSet.size());
|
||||
for(DataSet d: setDataSet){
|
||||
|
||||
ResultItem item1 = new ResultItem(item.getId(), item.getScientificName());
|
||||
item1.setScientificNameAuthorship(item.getScientificNameAuthorship());
|
||||
item1.setCommonNames(item.getCommonNames());
|
||||
item1.setParent(item.getParent());
|
||||
item1.setRank(item.getRank());
|
||||
|
||||
item.setCredits(Utils.createCredits());
|
||||
item1.setCitation(Utils.createCitation());
|
||||
|
||||
|
||||
dataSet = new DataSet(d.getId());
|
||||
dataSet.setName(d.getName());
|
||||
dataSet.setCitation(d.getCitation());
|
||||
|
||||
if (dp == null){
|
||||
dp = new DataProvider("CoL");
|
||||
dp.setName("Catalogue of Life");
|
||||
} else{
|
||||
dp = new DataProvider(source_database);
|
||||
dp.setName(source_database);
|
||||
}
|
||||
|
||||
dataSet.setDataProvider(dp);
|
||||
item1.setDataSet(dataSet);
|
||||
|
||||
if (writer.isAlive())
|
||||
writer.write(item1);
|
||||
else
|
||||
break;
|
||||
}
|
||||
} else{
|
||||
|
||||
item.setCitation(Utils.createCitation());
|
||||
|
||||
// logger.trace("no reference");
|
||||
dataSet = new DataSet("CoL");
|
||||
dataSet.setName("Catalogue of Life");
|
||||
dataSet.setCitation("");
|
||||
|
||||
if (dp == null){
|
||||
dp = new DataProvider("CoL");
|
||||
dp.setName("Catalogue of Life");
|
||||
}
|
||||
|
||||
dataSet.setDataProvider(dp);
|
||||
item.setDataSet(dataSet);
|
||||
|
||||
// Calendar now = Calendar.getInstance();
|
||||
// SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
||||
// String credits = "This information object has been generated via the Species Product Discovery service on " +format.format(now.getTime()) + " by interfacing with of the Catalogue of Life (http://www.catalogueoflife.org/)";
|
||||
item.setCredits(Utils.createCredits());
|
||||
|
||||
if (writer.isAlive())
|
||||
writer.write(item);
|
||||
else
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
return eventReader;
|
||||
}
|
||||
|
||||
|
||||
public static Set<DataSet> getReferences(XMLEventReader eventReader) throws XMLStreamException {
|
||||
|
||||
String author = null;
|
||||
String source = null;
|
||||
|
||||
Set<DataSet> setDataSet = new HashSet<DataSet>();
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "author")){
|
||||
try {
|
||||
author = readCharacters(eventReader);
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "source")){
|
||||
try {
|
||||
source = readCharacters(eventReader);
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "reference")){
|
||||
DataSet dataSet = new DataSet(source);
|
||||
dataSet.setName(source);
|
||||
dataSet.setCitation(author);
|
||||
setDataSet.add(dataSet);
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "references")){
|
||||
return setDataSet;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return setDataSet;
|
||||
|
||||
}
|
||||
|
||||
public static ResultItem createItem(XMLEventReader eventReader, ObjectWriter<ResultItem> writer, String name_status) throws XMLStreamException {
|
||||
|
||||
ResultItem item = null;
|
||||
String id = null;
|
||||
String name = null;
|
||||
String rank = null;
|
||||
String author = null;
|
||||
String status = null;
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters() && (id == null)){
|
||||
id = event.asCharacters().getData();
|
||||
// logger.trace("id " + event.asCharacters().getData());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "name") && (name == null)){
|
||||
try {
|
||||
name = readCharacters(eventReader);
|
||||
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "rank") && (rank == null)){
|
||||
try {
|
||||
rank = readCharacters(eventReader);
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "name_status") && (status == null)){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters()){
|
||||
status = event.asCharacters().getData();
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
// logger.trace((name_status));
|
||||
|
||||
if (!(event.asCharacters().getData()).equals(name_status)){
|
||||
// logger.trace("no accepted name");
|
||||
break;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "author") && (author == null)){
|
||||
try {
|
||||
author = readCharacters(eventReader);
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "author") || Utils.checkStartElement(event, "url")){
|
||||
|
||||
if ((id != null) && (name != null)){
|
||||
// System.out.println("** return item first part ***** ");
|
||||
item = new ResultItem(id, name);
|
||||
item.setCitation(author);
|
||||
item.setRank(rank);
|
||||
|
||||
return item;
|
||||
}
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
|
||||
|
||||
public static ResultItem searchTaxonomyRI(XMLEventReader eventReader, ResultItem t){
|
||||
String id = null;
|
||||
ResultItem p = null;
|
||||
// TaxonomyItem t = null;
|
||||
while (eventReader.hasNext()){
|
||||
try {
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
id = event.asCharacters().getData();
|
||||
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
continue;
|
||||
}else if (Utils.checkStartElement(event, "name")){
|
||||
event = eventReader.nextEvent();
|
||||
t = new ResultItem(id, event.asCharacters().getData());
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
continue;
|
||||
}else if (Utils.checkStartElement(event, "rank")){
|
||||
event = eventReader.nextEvent();
|
||||
t.setRank(event.asCharacters().getData());
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
continue;
|
||||
}else if (Utils.checkEndElement(event, "taxon")){
|
||||
event = eventReader.nextEvent();
|
||||
t.setParent(p);
|
||||
p = t;
|
||||
continue;
|
||||
}else if (Utils.checkEndElement(event, "classification")){
|
||||
// logger.trace("exit searchTaxonomy *****");
|
||||
break;
|
||||
}
|
||||
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("printStackTrace", e);
|
||||
}
|
||||
}
|
||||
|
||||
return p;
|
||||
|
||||
}
|
||||
|
||||
|
||||
//create chain of taxon
|
||||
public static TaxonomyItem searchTaxonomy(TaxonomyItem t, List<String> parents) throws XMLStreamException{
|
||||
TaxonomyItem p = null;
|
||||
for (String parent: parents){
|
||||
// logger.trace("ID " + parent);
|
||||
// System.out.println("retrieveTIById skip");
|
||||
// t = new TaxonomyItem(null);
|
||||
t = retrieveTIById(parent, true);
|
||||
if (t ==null) continue;
|
||||
// t.setStatus(new TaxonomyStatus("accepted name",Status.ACCEPTED));
|
||||
// logger.trace("accepted name");
|
||||
t.setParent(p);
|
||||
p = t;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
public static List<CommonName> getCommonNames(XMLEventReader eventReader) throws XMLStreamException {
|
||||
|
||||
List<CommonName> list = new ArrayList<CommonName> ();
|
||||
CommonName comm = null;
|
||||
String language = null;
|
||||
String name = null;
|
||||
String country = null;
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "name")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters())
|
||||
name = event.asCharacters().getData();
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "language")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters())
|
||||
language = event.asCharacters().getData();
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "country")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters())
|
||||
country = event.asCharacters().getData();
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "common_name")){
|
||||
comm = new CommonName(language, name);
|
||||
comm.setLocality(country);
|
||||
list.add(comm);
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "common_names")){
|
||||
// System.out.println("****** close common_names *****");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Get tag value
|
||||
*/
|
||||
|
||||
public static String getTagValue(String sTag, Element eElement) {
|
||||
|
||||
String a = "";
|
||||
NodeList nlList = eElement.getElementsByTagName(sTag);
|
||||
if (nlList!= null){
|
||||
Element xmlNode = (Element)nlList.item(0);
|
||||
if (xmlNode != null){
|
||||
NodeList textFNList = xmlNode.getChildNodes();
|
||||
if (textFNList != null){
|
||||
Node nValue = (Node) textFNList.item(0);
|
||||
if (nValue != null)
|
||||
{
|
||||
a = nValue.getNodeValue();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
public static Calendar getDate(NodeList date2) {
|
||||
|
||||
// SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy");
|
||||
|
||||
Calendar cal = null;
|
||||
|
||||
if (date2.getLength()!= 0) {
|
||||
Node nNode = date2.item(0);
|
||||
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
|
||||
|
||||
Element eElement = (Element) nNode;
|
||||
String scrutiny = getTagValue("scrutiny", eElement);
|
||||
if (!(scrutiny.equals(""))){
|
||||
String modified = scrutiny;
|
||||
Date date = DateUtil.getInstance().parse(modified);
|
||||
|
||||
// d = DateUtil.getInstance().parse(modified);
|
||||
if (date != null){
|
||||
cal=Calendar.getInstance();
|
||||
cal.setTime(new Date(date.getTime()));
|
||||
}
|
||||
// else
|
||||
// logger.warn("Unknown data format");
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
return cal;
|
||||
}
|
||||
|
||||
|
||||
//format date
|
||||
public static String createDate() {
|
||||
Calendar now = Calendar.getInstance();
|
||||
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
||||
String date = format.format(now.getTime());
|
||||
return date;
|
||||
}
|
||||
|
||||
public static String createCitation() {
|
||||
StringBuilder cit = new StringBuilder();
|
||||
cit.append(CatalogueOfLifePlugin.citation);
|
||||
cit.append(createDate());
|
||||
return cit.toString();
|
||||
}
|
||||
|
||||
public static String createCredits() {
|
||||
String cred = CatalogueOfLifePlugin.credits;
|
||||
cred.replace("XDATEX",createDate());
|
||||
return cred;
|
||||
}
|
||||
|
||||
public static Calendar getCalendar(String date1) {
|
||||
|
||||
// SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy");
|
||||
Calendar cal = null;
|
||||
Date date = DateUtil.getInstance().parse(date1);
|
||||
// d = DateUtil.getInstance().parse(modified);
|
||||
if (date != null){
|
||||
cal=Calendar.getInstance();
|
||||
cal.setTime(new Date(date.getTime()));
|
||||
}
|
||||
// else
|
||||
// logger.warn("Unknown data format");
|
||||
|
||||
return cal;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,469 @@
|
||||
package org.gcube.data.spd.catalogueoflife.capabilities;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URI;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.Attribute;
|
||||
import javax.xml.stream.events.StartElement;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
import org.gcube.data.spd.catalogueoflife.CatalogueOfLifePlugin;
|
||||
import org.gcube.data.spd.catalogueoflife.Utils;
|
||||
import org.gcube.data.spd.catalogueoflife.parsers.ChildrenParser;
|
||||
import org.gcube.data.spd.catalogueoflife.parsers.ResultParser;
|
||||
import org.gcube.data.spd.catalogueoflife.parsers.TaxonParser;
|
||||
import org.gcube.data.spd.model.Condition;
|
||||
import org.gcube.data.spd.model.Conditions;
|
||||
import org.gcube.data.spd.model.exceptions.ExternalRepositoryException;
|
||||
import org.gcube.data.spd.model.exceptions.IdNotValidException;
|
||||
import org.gcube.data.spd.model.exceptions.MethodNotSupportedException;
|
||||
import org.gcube.data.spd.model.exceptions.StreamException;
|
||||
import org.gcube.data.spd.model.exceptions.StreamNonBlockingException;
|
||||
import org.gcube.data.spd.model.products.TaxonomyItem;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.ClassificationCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.UnfoldCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ClosableWriter;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class ClassificationCapabilityImpl extends ClassificationCapability implements UnfoldCapability {
|
||||
|
||||
|
||||
Logger logger = LoggerFactory.getLogger(ClassificationCapabilityImpl.class);
|
||||
|
||||
public Set<Conditions> getSupportedProperties() {
|
||||
return Collections.emptySet();
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
@Override
|
||||
public void getSynonymnsById(ObjectWriter<TaxonomyItem> writer, String id)
|
||||
throws IdNotValidException, MethodNotSupportedException, ExternalRepositoryException {
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?id=" + id + "&response=full";
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
try{
|
||||
is =URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "synonym")){
|
||||
event = eventReader.nextEvent();
|
||||
// logger.trace("result");
|
||||
if (event.isCharacters())
|
||||
getSynonym(eventReader, writer, new TaxonParser(true));
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (Utils.checkEndElement(event, "result")){
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}catch (XMLStreamException e) {
|
||||
logger.error("error retrieving synonyms");
|
||||
throw new ExternalRepositoryException();
|
||||
} catch (Exception e) {
|
||||
logger.error("error",e);
|
||||
}finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (Exception e) {
|
||||
logger.error("error closing streams",e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public TaxonomyItem retrieveTaxonById(String id) {
|
||||
try {
|
||||
return retrieveById(id, new TaxonParser(true));
|
||||
} catch (Exception e) {
|
||||
logger.error("error retreiving taxon item with id "+id);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private List<String> getChildren(XMLEventReader eventReader) {
|
||||
|
||||
Set<String> setIds = new HashSet<String>();
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event;
|
||||
try {
|
||||
event = eventReader.nextEvent();
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
String tempId = event.asCharacters().getData();
|
||||
logger.trace("found id "+ tempId);
|
||||
setIds.add(tempId);
|
||||
}else if (Utils.checkEndElement(event, "child_taxa")){
|
||||
logger.trace("found child taxa closed");
|
||||
break;
|
||||
}
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
}
|
||||
}
|
||||
return Collections.list(Collections.enumeration(setIds));
|
||||
}
|
||||
|
||||
protected void checkCommonName(XMLEventReader eventReader,
|
||||
ObjectWriter<TaxonomyItem> writer, ResultParser<TaxonomyItem> parser) throws XMLStreamException {
|
||||
try{
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "name_status")){
|
||||
event = eventReader.nextEvent();
|
||||
|
||||
if ((event.asCharacters().getData()).equals("common name")){
|
||||
continue;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "accepted_name")){
|
||||
if (writer.isAlive())
|
||||
writer.write(parser.parse(eventReader));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public <T> void retrieveByScientificName(ObjectWriter<T> writer, ResultParser<T> parser, String name, int start, Set<String> hash) {
|
||||
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?name=" + name.replaceAll(" ", "+") + "&response=full&start=" + start;
|
||||
logger.trace("PATH " + pathUrl);
|
||||
int total_number_of_results = 0;
|
||||
int number_of_results_returned = 0;
|
||||
|
||||
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
|
||||
try{
|
||||
is =URI.create(pathUrl).toURL().openStream();
|
||||
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while(eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
if (Utils.checkStartElement(event, "results")){
|
||||
|
||||
StartElement element = event.asStartElement();
|
||||
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterator<Attribute> attributes = element.getAttributes();
|
||||
while(attributes.hasNext()){
|
||||
|
||||
Attribute attribute = attributes.next();
|
||||
if(attribute.getName().toString().equals("total_number_of_results")){
|
||||
// logger.trace(attribute.getValue());
|
||||
total_number_of_results = (Integer.parseInt(attribute.getValue()));
|
||||
}
|
||||
else if (attribute.getName().toString().equals("number_of_results_returned")){
|
||||
// logger.trace(attribute.getValue());
|
||||
number_of_results_returned = (Integer.parseInt(attribute.getValue()));
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}else if (Utils.checkStartElement(event, "result")){
|
||||
if (writer.isAlive()){
|
||||
writer.write(parser.parse(eventReader));
|
||||
}
|
||||
else return;
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "results")){
|
||||
if (total_number_of_results > number_of_results_returned + start)
|
||||
retrieveByScientificName(writer, parser , name, start+50, hash);
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (MalformedURLException e) {
|
||||
logger.error("MalformedURLException", e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException", e);
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException", e);
|
||||
} catch (NoSuchElementException e) {
|
||||
logger.error("NoSuchElementException", e);
|
||||
}finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public void searchByScientificName(String word,
|
||||
ObjectWriter<TaxonomyItem> writer, Condition... properties) {
|
||||
try{
|
||||
logger.trace("Retrive taxa by scientific name " + word);
|
||||
retrieveByScientificName(writer, new TaxonParser(true), word+"*", 0, new HashSet<String>());
|
||||
} catch (Exception e) {
|
||||
logger.error("Error searching for scientificName",e);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void retrieveTaxonByIds(Iterator<String> ids,
|
||||
ClosableWriter<TaxonomyItem> writer) {
|
||||
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
TaxonParser parser = new TaxonParser(true);
|
||||
while(ids.hasNext()) {
|
||||
String id = ids.next();
|
||||
try{
|
||||
logger.trace("Retrive taxa by id " + id);
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?id=" + id + "&response=full";
|
||||
//System.out.println(pathUrl);
|
||||
is =URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "result")){
|
||||
if (writer.isAlive())
|
||||
writer.write(parser.parse(eventReader));
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (Utils.checkEndElement(event, "results")){
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
logger.error("error reading id "+id,e);
|
||||
writer.write(new StreamNonBlockingException("CatalogueOfLife",id));
|
||||
}
|
||||
}
|
||||
|
||||
writer.close();
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private <T> T retrieveById(String id, ResultParser<T> parser) throws XMLStreamException, MalformedURLException, IOException{
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?id=" + id + "&response=full";
|
||||
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
|
||||
try{
|
||||
is =URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "result"))
|
||||
return parser.parse(eventReader);
|
||||
}
|
||||
throw new XMLStreamException("result tag not found");
|
||||
}finally{
|
||||
try{
|
||||
if(eventReader!=null)
|
||||
eventReader.close();
|
||||
if (is!=null)
|
||||
is.close();
|
||||
}catch (Exception e) {
|
||||
logger.error("error closing reader",e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void getSynonym(XMLEventReader eventReader, ObjectWriter<TaxonomyItem> writer, ResultParser<TaxonomyItem> parser) throws XMLStreamException {
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters()){
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
if (writer.isAlive()){
|
||||
String id = event.asCharacters().getData();
|
||||
try {
|
||||
writer.write(retrieveById(id, parser));
|
||||
} catch (Exception e) {
|
||||
writer.write(new StreamNonBlockingException("CatalogueOfLife",id));
|
||||
}
|
||||
}else
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (Utils.checkEndElement(event, "synonyms")){
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<TaxonomyItem> retrieveTaxonChildrenByTaxonId(String id)
|
||||
throws IdNotValidException, ExternalRepositoryException {
|
||||
logger.trace("retrieveTaxonChildrenByTaxonId " + id);
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?id=" + id + "&response=full";
|
||||
logger.trace(pathUrl);
|
||||
List<TaxonomyItem> list = new ArrayList<TaxonomyItem>();
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
|
||||
TaxonParser parser = new TaxonParser(false);
|
||||
|
||||
try{
|
||||
is =URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "child_taxa")){
|
||||
List<String> listIds= getChildren(eventReader);
|
||||
// logger.trace("ids found "+listIds);
|
||||
for (String childrenId: listIds )
|
||||
list.add(retrieveById(childrenId, parser));
|
||||
break;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "results")){
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} catch (NoSuchElementException e) {
|
||||
logger.error("element not found",e);
|
||||
throw new IdNotValidException();
|
||||
}catch (Exception e) {
|
||||
logger.error("repository exception",e);
|
||||
throw new ExternalRepositoryException(e);
|
||||
} finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unfold(final ObjectWriter<String> writer, String scientificName) {
|
||||
ObjectWriter<SpeciesIdentifier> internalWriter = new ObjectWriter<SpeciesIdentifier>() {
|
||||
|
||||
@Override
|
||||
public boolean write(SpeciesIdentifier t) {
|
||||
ChildrenParser parser = new ChildrenParser();
|
||||
for (String childId: t.getChildren())
|
||||
writeAllChildrenName(writer, childId, parser);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean write(StreamException error) {
|
||||
return writer.write(error);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isAlive() {
|
||||
return writer.isAlive();
|
||||
}
|
||||
};
|
||||
|
||||
retrieveByScientificName(internalWriter, new ChildrenParser(), scientificName, 0, new HashSet<String>());
|
||||
|
||||
}
|
||||
|
||||
private void writeAllChildrenName(ObjectWriter<String> writer, String id, ChildrenParser parser){
|
||||
final int MAX_RETRIES =10;
|
||||
final long WAIT_TIME = 10000;
|
||||
try{
|
||||
SpeciesIdentifier species;
|
||||
int retries = 0;
|
||||
boolean exit = false;
|
||||
do{
|
||||
try {
|
||||
species = retrieveById(id, parser);
|
||||
writer.write(species.getName());
|
||||
for (String childId: species.getChildren())
|
||||
writeAllChildrenName(writer, childId, parser);
|
||||
exit = true;
|
||||
} catch (IOException e) {
|
||||
retries++;
|
||||
try {
|
||||
Thread.sleep(WAIT_TIME);
|
||||
} catch (InterruptedException e1) {}
|
||||
}
|
||||
}while (retries<MAX_RETRIES && !exit);
|
||||
if (retries==MAX_RETRIES) throw new Exception("too many retries");
|
||||
}catch (Exception e) {
|
||||
writer.write(new StreamNonBlockingException("catalogueOfLife",id));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@ -0,0 +1,133 @@
|
||||
package org.gcube.data.spd.catalogueoflife.capabilities;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.URI;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import javax.xml.namespace.QName;
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.Attribute;
|
||||
import javax.xml.stream.events.StartElement;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
import org.gcube.data.spd.catalogueoflife.CatalogueOfLifePlugin;
|
||||
import org.gcube.data.spd.catalogueoflife.Utils;
|
||||
import org.gcube.data.spd.model.exceptions.StreamNonBlockingException;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.ExpansionCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class ExpansionCapabilityImpl implements ExpansionCapability {
|
||||
|
||||
|
||||
static Logger logger = LoggerFactory.getLogger(ExpansionCapabilityImpl.class);
|
||||
|
||||
@Override
|
||||
public void getSynonyms(ObjectWriter<String> writer, String scientifcName) {
|
||||
getIds(scientifcName, 0, writer);
|
||||
}
|
||||
|
||||
|
||||
//recorvise method to get a list of ids by scientific name
|
||||
private List<String> getIds(String scientifcName, int start, ObjectWriter<String> writer) {
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?name=" + scientifcName.replaceAll(" ", "+") + "*&response=full&start=" + start;
|
||||
// logger.trace("PATH " + pathUrl);
|
||||
int total_number_of_results = 0;
|
||||
int number_of_results_returned = 0;
|
||||
List<String> ids = new ArrayList<String>();
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
try{
|
||||
is = URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "results")){
|
||||
|
||||
StartElement element = (StartElement) event;
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterator<Attribute> iterator = element.getAttributes();
|
||||
while (iterator.hasNext()) {
|
||||
|
||||
Attribute attribute = (Attribute) iterator.next();
|
||||
QName att = attribute.getName();
|
||||
|
||||
if (att.toString().equals("total_number_of_results")){
|
||||
total_number_of_results = (Integer.parseInt(attribute.getValue()));
|
||||
}
|
||||
else if (att.toString().equals("number_of_results_returned")){
|
||||
number_of_results_returned = (Integer.parseInt(attribute.getValue()));
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "synonyms")){
|
||||
readSynonyms(eventReader, writer);
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "results")){
|
||||
if (total_number_of_results > number_of_results_returned + start)
|
||||
getIds(scientifcName, start+50, writer);
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
writer.write(new StreamNonBlockingException("CatalogueOfLife",""));
|
||||
}finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
|
||||
}
|
||||
return ids;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//read from <synonyms> to </synonyms>
|
||||
private void readSynonyms(XMLEventReader eventReader, ObjectWriter<String> writer) throws XMLStreamException {
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "synonym")){
|
||||
while (eventReader.hasNext()){
|
||||
event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "name")){
|
||||
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters()){
|
||||
String id = event.asCharacters().getData();
|
||||
// System.out.println(id);
|
||||
if (!writer.isAlive()) return;
|
||||
writer.write(id);
|
||||
}
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "synonym"))
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "synonyms"))
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,259 @@
|
||||
package org.gcube.data.spd.catalogueoflife.capabilities;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.URI;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
|
||||
import javax.xml.namespace.QName;
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.Attribute;
|
||||
import javax.xml.stream.events.StartElement;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
import org.gcube.data.spd.catalogueoflife.CatalogueOfLifePlugin;
|
||||
import org.gcube.data.spd.catalogueoflife.Utils;
|
||||
import org.gcube.data.spd.model.Conditions;
|
||||
import org.gcube.data.spd.plugin.fwk.capabilities.MappingCapability;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
|
||||
public class NamesMappingImpl implements MappingCapability{
|
||||
|
||||
Logger logger = LoggerFactory.getLogger(NamesMappingImpl.class);
|
||||
|
||||
public Set<Conditions> getSupportedProperties() {
|
||||
return Collections.emptySet();
|
||||
}
|
||||
|
||||
|
||||
public Set<String> commonNameToScientificNamesMapping(String name) {
|
||||
|
||||
Set<String> set = null;
|
||||
try {
|
||||
set = mapping(name, "common name", 0);
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
return set;
|
||||
}
|
||||
|
||||
// public Set<String> scientificNameToCommonNamesMapping(String name) {
|
||||
//
|
||||
// Set<String> set = null;
|
||||
// try {
|
||||
// set = mapping(name, "accepted name", 0);
|
||||
// } catch (Exception e) {
|
||||
// logger.error("Exception",e);
|
||||
// }
|
||||
// return set;
|
||||
// }
|
||||
|
||||
/**
|
||||
* Mapping
|
||||
*/
|
||||
public Set<String> mapping(String name, String type, int start) throws Exception {
|
||||
String pathUrl = CatalogueOfLifePlugin.baseurl + "?name=" + name.replaceAll(" ", "+") + "&response=full&start=" + start;
|
||||
// logger.trace(pathUrl);
|
||||
Set<String> set = new HashSet<String>();
|
||||
|
||||
int total_number_of_results = 0;
|
||||
int number_of_results_returned = 0;
|
||||
|
||||
InputStream is = null;
|
||||
XMLInputFactory ifactory;
|
||||
XMLEventReader eventReader = null;
|
||||
|
||||
try{
|
||||
is =URI.create(pathUrl).toURL().openStream();
|
||||
ifactory = XMLInputFactory.newInstance();
|
||||
eventReader = ifactory.createXMLEventReader(is);
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "results")){
|
||||
|
||||
StartElement element = (StartElement) event;
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterator<Attribute> iterator = element.getAttributes();
|
||||
while (iterator.hasNext()) {
|
||||
|
||||
Attribute attribute = (Attribute) iterator.next();
|
||||
QName att = attribute.getName();
|
||||
|
||||
if (att.toString().equals("total_number_of_results")){
|
||||
total_number_of_results = (Integer.parseInt(attribute.getValue()));
|
||||
}
|
||||
else if (att.toString().equals("number_of_results_returned")){
|
||||
number_of_results_returned = (Integer.parseInt(attribute.getValue()));
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (Utils.checkStartElement(event, "result")){
|
||||
// logger.trace("result");
|
||||
if (type.equals("common name"))
|
||||
checkCommonName(eventReader, set);
|
||||
else
|
||||
checkScientificName(eventReader, set);
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (Utils.checkEndElement(event, "results")){
|
||||
if (total_number_of_results > number_of_results_returned + start)
|
||||
mapping(name, type, start+50);
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
logger.error("ExceptionPrintStackTrace",e);
|
||||
}finally{
|
||||
try {
|
||||
if (eventReader != null)
|
||||
eventReader.close();
|
||||
if (is != null)
|
||||
is.close();
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
} catch (IOException e) {
|
||||
logger.error("IOException",e);
|
||||
}
|
||||
}
|
||||
|
||||
return set;
|
||||
}
|
||||
|
||||
|
||||
private void checkScientificName(XMLEventReader eventReader,Set<String> set) {
|
||||
boolean flag = false;
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event;
|
||||
try {
|
||||
event = eventReader.nextEvent();
|
||||
if (flag){
|
||||
if (Utils.checkStartElement(event, "name_status")){
|
||||
|
||||
event = eventReader.nextEvent();
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
flag = false;
|
||||
if (!event.asCharacters().getData().equals("accepted name"))
|
||||
break;
|
||||
else
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "common_name")){
|
||||
event = eventReader.nextEvent();
|
||||
|
||||
set.add(findScientificName(eventReader));
|
||||
|
||||
continue;
|
||||
}
|
||||
if (Utils.checkStartElement(event, "result")){
|
||||
// logger.trace(set.size());
|
||||
break;
|
||||
}
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
}
|
||||
}
|
||||
|
||||
// return eventReader;
|
||||
}
|
||||
|
||||
|
||||
private String findScientificName(XMLEventReader eventReader) {
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event;
|
||||
try {
|
||||
event = eventReader.nextEvent();
|
||||
if (Utils.checkStartElement(event, "name")){
|
||||
event = eventReader.nextEvent();
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
return event.asCharacters().getData();
|
||||
}
|
||||
|
||||
if (Utils.checkEndElement(event, "common_name")){
|
||||
break;
|
||||
}
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
private void checkCommonName(XMLEventReader eventReader, Set<String> set) {
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event;
|
||||
try {
|
||||
event = eventReader.nextEvent();
|
||||
if (Utils.checkStartElement(event, "name_status")){
|
||||
event = eventReader.nextEvent();
|
||||
// logger.trace(event.asCharacters().getData());
|
||||
if (!event.asCharacters().getData().equals("common name"))
|
||||
break;
|
||||
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Utils.checkStartElement(event, "accepted_name")){
|
||||
event = eventReader.nextEvent();
|
||||
set.add(findCommonName(eventReader));
|
||||
|
||||
break;
|
||||
}
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
}
|
||||
}
|
||||
|
||||
// return eventReader;
|
||||
}
|
||||
|
||||
|
||||
private String findCommonName(XMLEventReader eventReader) {
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event;
|
||||
try {
|
||||
event = eventReader.nextEvent();
|
||||
if (Utils.checkStartElement(event, "name")){
|
||||
event = eventReader.nextEvent();
|
||||
return event.asCharacters().getData();
|
||||
}
|
||||
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException",e);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void getRelatedScientificNames(ObjectWriter<String> writer,
|
||||
String commonName) {
|
||||
Set<String> set = commonNameToScientificNamesMapping(commonName);
|
||||
for (String ScientificName : set) {
|
||||
if (!writer.isAlive()) return;
|
||||
writer.write(ScientificName);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,35 @@
|
||||
package org.gcube.data.spd.catalogueoflife.capabilities;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Collections;
|
||||
|
||||
public class SpeciesIdentifier {
|
||||
|
||||
private String name;
|
||||
|
||||
private List<String> children = Collections.emptyList();
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public List<String> getChildren() {
|
||||
return children;
|
||||
}
|
||||
|
||||
public void setChildren(List<String> children) {
|
||||
this.children = children;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "SpeciesIdentifier [name=" + name + ", children=" + children
|
||||
+ "]";
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,56 @@
|
||||
package org.gcube.data.spd.catalogueoflife.parsers;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
|
||||
import org.gcube.data.spd.catalogueoflife.Utils;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.SpeciesIdentifier;
|
||||
|
||||
public class ChildrenParser implements ResultParser<SpeciesIdentifier> {
|
||||
|
||||
@Override
|
||||
public SpeciesIdentifier parse(XMLEventReader eventReader) throws XMLStreamException {
|
||||
SpeciesIdentifier speciesIdentifier = new SpeciesIdentifier();
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "name")){
|
||||
if (speciesIdentifier.getName()==null){
|
||||
String name = "";
|
||||
try {
|
||||
name =Utils.readCharacters(eventReader);
|
||||
speciesIdentifier.setName(name);
|
||||
} catch (Exception e) {
|
||||
throw new XMLStreamException("error reading string");
|
||||
}
|
||||
}
|
||||
}else if (Utils.checkEndElement(event, "result")){
|
||||
break;
|
||||
}else if (Utils.checkStartElement(event, "child_taxa")){
|
||||
speciesIdentifier.setChildren(retrieveChildTaxa(eventReader));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (speciesIdentifier.getName()!=null) return speciesIdentifier;
|
||||
else throw new XMLStreamException("error retrieving scientificName");
|
||||
}
|
||||
|
||||
private List<String> retrieveChildTaxa(XMLEventReader eventReader) throws XMLStreamException{
|
||||
List<String> children = new ArrayList<String>();
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
if(Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters())
|
||||
children.add(event.asCharacters().getData());
|
||||
}else if (Utils.checkEndElement(event, "child_taxa")){
|
||||
break;
|
||||
}
|
||||
}
|
||||
return children;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,25 @@
|
||||
package org.gcube.data.spd.catalogueoflife.parsers;
|
||||
|
||||
public class ParserException extends Exception {
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
public ParserException() {
|
||||
super();
|
||||
}
|
||||
|
||||
public ParserException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
|
||||
public ParserException(String message) {
|
||||
super(message);
|
||||
}
|
||||
|
||||
public ParserException(Throwable cause) {
|
||||
super(cause);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package org.gcube.data.spd.catalogueoflife.parsers;
|
||||
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
|
||||
public interface ResultParser<T> {
|
||||
|
||||
T parse(XMLEventReader eventReader) throws XMLStreamException;
|
||||
}
|
||||
@ -0,0 +1,286 @@
|
||||
package org.gcube.data.spd.catalogueoflife.parsers;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
import java.util.List;
|
||||
import java.util.NoSuchElementException;
|
||||
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.events.XMLEvent;
|
||||
import org.gcube.data.spd.catalogueoflife.Utils;
|
||||
import org.gcube.data.spd.model.products.TaxonomyItem;
|
||||
import org.gcube.data.spd.model.products.TaxonomyStatus;
|
||||
import org.gcube.data.spd.model.products.TaxonomyStatus.Status;
|
||||
import org.gcube.data.spd.model.util.ElementProperty;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class TaxonParser implements ResultParser<TaxonomyItem> {
|
||||
|
||||
private Logger logger = LoggerFactory.getLogger(TaxonParser.class);
|
||||
|
||||
private boolean addParent = true;
|
||||
|
||||
public TaxonParser(boolean addParent) {
|
||||
super();
|
||||
this.addParent = addParent;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public TaxonomyItem parse(XMLEventReader eventReader) throws XMLStreamException{
|
||||
|
||||
TaxonomyItem item = null;
|
||||
TaxonomyItem parent = null;
|
||||
Boolean flag = true;
|
||||
List<String> parents = null;
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
// if (item!=null)
|
||||
// System.out.println("item.getStatus() " + item.getStatus());
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
if (item == null){
|
||||
item = new TaxonomyItem(event.asCharacters().getData());
|
||||
item.setCredits(Utils.createCredits());
|
||||
item.setCitation(Utils.createCitation());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "name")){
|
||||
if (item == null)
|
||||
break;
|
||||
if ((item.getScientificName() == null))
|
||||
try {
|
||||
item.setScientificName(Utils.readCharacters(eventReader));
|
||||
} catch (Exception e) {
|
||||
logger.error("error reading character");
|
||||
throw new XMLStreamException();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "rank")){
|
||||
event = eventReader.nextEvent();
|
||||
if ((item.getRank() == null) && (event.isCharacters()))
|
||||
item.setRank(event.asCharacters().getData());
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "author")){
|
||||
event = eventReader.nextEvent();
|
||||
if ((item.getScientificNameAuthorship() == null) && (event.isCharacters()))
|
||||
item.setScientificNameAuthorship(event.asCharacters().getData());
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "record_scrutiny_date")){
|
||||
event = eventReader.nextEvent();
|
||||
Calendar modified = null;
|
||||
if (event.isCharacters())
|
||||
modified = Utils.getCalendar(event.asCharacters().getData());
|
||||
item.setModified(modified);
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "source_database")){
|
||||
event = eventReader.nextEvent();
|
||||
if (event.isCharacters()){
|
||||
ElementProperty property = new ElementProperty("Source Database", event.asCharacters().getData());
|
||||
item.addProperty(property);
|
||||
// item.setCitation(event.asCharacters().getData());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "references") && (flag)){
|
||||
flag = false;
|
||||
// event = eventReader.nextEvent();
|
||||
getReferences(eventReader, item);
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "name_status") && (item.getStatus() == null)){
|
||||
// logger.trace("name_status");
|
||||
event = eventReader.nextEvent();
|
||||
// logger.trace("name status " + event.asCharacters().getData());
|
||||
|
||||
if ((event.asCharacters().getData()).equals("accepted name")){
|
||||
|
||||
item.setStatus(new TaxonomyStatus("accepted name", Status.ACCEPTED));
|
||||
}else if ((event.asCharacters().getData()).equals("synonym")){
|
||||
item.setStatus(new TaxonomyStatus(Status.SYNONYM, null, "synonym"));
|
||||
}else if ((event.asCharacters().getData()).equals("ambiguous synonym")){
|
||||
item.setStatus(new TaxonomyStatus(Status.SYNONYM, null, "synonym"));
|
||||
}else if ((event.asCharacters().getData()).equals("provisionally accepted name")){
|
||||
item.setStatus(new TaxonomyStatus("provisionally accepted name", Status.PROVISIONAL));
|
||||
}else if ((event.asCharacters().getData()).equals("misapplied name")){
|
||||
item.setStatus(new TaxonomyStatus("misapplied name", Status.MISAPPLIED));
|
||||
}else {
|
||||
item.setStatus(new TaxonomyStatus((event.asCharacters().getData()).toString(), Status.UNKNOWN));
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
// else if (Utils.checkStartElement(event, "sn_id") && (item.getStatus().equals(Status.SYNONYM))){
|
||||
// event = eventReader.nextEvent();
|
||||
//
|
||||
// if (!(event.asCharacters().getData()).equals(0)){
|
||||
// TaxonomyStatus stat = item.getStatus();
|
||||
// stat.setRefId(event.asCharacters().getData());
|
||||
//// logger.trace("SYNONYM");
|
||||
//// item.setStatus(new TaxonomyStatus(Status.SYNONYM, event.asCharacters().getData(), "synonym"));
|
||||
// }
|
||||
//
|
||||
// continue;
|
||||
// }
|
||||
else if (Utils.checkStartElement(event, "common_names")){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "common_name")){
|
||||
// System.out.println("common_names *****");
|
||||
event = eventReader.nextEvent();
|
||||
// System.out.println(event.asCharacters().getData());
|
||||
item.setCommonNames(Utils.getCommonNames(eventReader));
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "classification") && addParent){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "taxon")){
|
||||
// System.out.println("Classification *****");
|
||||
event = eventReader.nextEvent();
|
||||
|
||||
parents = getParentList(eventReader);
|
||||
//
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "accepted_name")){
|
||||
event = eventReader.nextTag();
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
TaxonomyStatus stat = item.getStatus();
|
||||
stat.setRefId(event.asCharacters().getData());
|
||||
}
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "accepted_name")){
|
||||
|
||||
if (item.getStatus() == null)
|
||||
item.setStatus(new TaxonomyStatus("unknown", Status.UNKNOWN));
|
||||
|
||||
// item.setCitation("Accessed through: World Register of Marine Species at http://www.marinespecies.org/aphia.php?p=taxdetails&id=10194 on 2012-10-26");
|
||||
return item;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "result")){
|
||||
|
||||
// System.out.println("****** close result *****");
|
||||
if (item.getStatus() == null)
|
||||
item.setStatus(new TaxonomyStatus("unknown", Status.UNKNOWN));
|
||||
|
||||
|
||||
//list of parents
|
||||
// for (String p: parents)
|
||||
// System.out.println(p);
|
||||
|
||||
if (parents!=null){
|
||||
if (parents.size()>0){
|
||||
item.setParent(Utils.searchTaxonomy(parent, parents));
|
||||
}
|
||||
}
|
||||
|
||||
// logger.trace("put writer");
|
||||
return item;
|
||||
}
|
||||
}
|
||||
throw new XMLStreamException("error parsing the result");
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//get a list of parents
|
||||
private List<String> getParentList(XMLEventReader eventReader) {
|
||||
|
||||
List<String> parents = new ArrayList<String>();
|
||||
// TaxonomyItem t = null;
|
||||
while (eventReader.hasNext()){
|
||||
// System.out.println("WHILE");
|
||||
try {
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
//System.out.println(event);
|
||||
if (Utils.checkStartElement(event, "id")){
|
||||
event = eventReader.nextEvent();
|
||||
parents.add(event.asCharacters().getData());
|
||||
// logger.trace("ID " + event.asCharacters().getData());
|
||||
continue;
|
||||
}else if (Utils.checkEndElement(event, "classification")){
|
||||
// logger.trace("EXIT searchTaxonomy *****");
|
||||
break;
|
||||
}
|
||||
|
||||
} catch (XMLStreamException e) {
|
||||
logger.error("XMLStreamException", e);
|
||||
} catch (NoSuchElementException e) {
|
||||
logger.error("NoSuchElementException", e);
|
||||
}
|
||||
}
|
||||
return parents;
|
||||
}
|
||||
|
||||
|
||||
//get references
|
||||
private void getReferences(XMLEventReader eventReader, TaxonomyItem item) throws XMLStreamException {
|
||||
|
||||
StringBuilder reference = new StringBuilder();
|
||||
|
||||
while (eventReader.hasNext()){
|
||||
XMLEvent event = eventReader.nextEvent();
|
||||
// if (Utils.checkStartElement(event, "reference")){
|
||||
// System.out.println("****** start reference *****");
|
||||
// continue;
|
||||
// }
|
||||
// else
|
||||
if (Utils.checkStartElement(event, "author")){
|
||||
try {
|
||||
reference.append(Utils.readCharacters(eventReader));
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "year")){
|
||||
try {
|
||||
reference.append(Utils.readCharacters(eventReader));
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "title")){
|
||||
try {
|
||||
reference.append(Utils.readCharacters(eventReader));
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkStartElement(event, "source")){
|
||||
try {
|
||||
reference.append(Utils.readCharacters(eventReader));
|
||||
} catch (Exception e) {
|
||||
logger.error("Exception",e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "reference")){
|
||||
ElementProperty property = new ElementProperty("Reference", reference.toString());
|
||||
item.addProperty(property);
|
||||
//logger.trace(reference.toString());
|
||||
reference.delete(0, reference.length());
|
||||
continue;
|
||||
}
|
||||
else if (Utils.checkEndElement(event, "references")){
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1 @@
|
||||
org.gcube.data.spd.catalogueoflife.CatalogueOfLifePlugin
|
||||
@ -0,0 +1,59 @@
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
||||
import org.gcube.common.scope.api.ScopeProvider;
|
||||
import org.gcube.data.spd.model.exceptions.StreamException;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
||||
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
||||
import org.junit.Before;
|
||||
|
||||
public class GetChildrenTest {
|
||||
|
||||
CatalogueOfLifePlugin col = new CatalogueOfLifePlugin();
|
||||
|
||||
@Before
|
||||
public void start() throws Exception{
|
||||
SimpleQuery query = queryFor(ServiceEndpoint.class);
|
||||
|
||||
query.addCondition("$resource/Profile/Category/text() eq 'BiodiversityRepository' and $resource/Profile/Name eq 'CatalogueOfLife' ");
|
||||
ScopeProvider.instance.set("/gcube/devsec");
|
||||
|
||||
DiscoveryClient<ServiceEndpoint> client = clientFor(ServiceEndpoint.class);
|
||||
|
||||
List<ServiceEndpoint> resources = client.submit(query);
|
||||
col.initialize(resources.get(0));
|
||||
}
|
||||
|
||||
public void getChildren() throws Exception{
|
||||
System.out.println(col.getClassificationInterface().retrieveTaxonChildrenByTaxonId("12640178"));
|
||||
}
|
||||
|
||||
|
||||
public void unfold() throws Exception{
|
||||
col.getUnfoldInterface().unfold(new ObjectWriter<String>() {
|
||||
|
||||
@Override
|
||||
public boolean write(StreamException error) {
|
||||
error.printStackTrace();
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean write(String t) {
|
||||
System.out.println("retuned: "+ t);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isAlive() {
|
||||
return true;
|
||||
}
|
||||
}, "cervidae");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,238 @@
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
||||
import org.gcube.common.scope.api.ScopeProvider;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.ClassificationCapabilityImpl;
|
||||
import org.gcube.data.spd.model.exceptions.StreamException;
|
||||
import org.gcube.data.spd.model.products.TaxonomyItem;
|
||||
import org.gcube.data.spd.plugin.fwk.readers.LocalReader;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ClosableWriter;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.rswrapper.LocalWrapper;
|
||||
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
||||
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestClassification {
|
||||
|
||||
static Logger logger = LoggerFactory.getLogger(TestClassification.class);
|
||||
/**
|
||||
* @param args
|
||||
* @throws Exception
|
||||
*/
|
||||
public static void main(String[] args) throws Exception {
|
||||
CatalogueOfLifePlugin a = new CatalogueOfLifePlugin();
|
||||
|
||||
SimpleQuery query = queryFor(ServiceEndpoint.class);
|
||||
|
||||
query.addCondition("$resource/Profile/Category/text() eq 'BiodiversityRepository' and $resource/Profile/Name eq 'CatalogueOfLife' ");
|
||||
ScopeProvider.instance.set("/gcube/devsec");
|
||||
|
||||
DiscoveryClient<ServiceEndpoint> client = clientFor(ServiceEndpoint.class);
|
||||
|
||||
List<ServiceEndpoint> resources = client.submit(query);
|
||||
|
||||
System.out.println(resources.size());
|
||||
|
||||
if(resources.size() != 0) {
|
||||
try {
|
||||
a.initialize(resources.get(0));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
// String[] query1 ={"marisarabica", "chiru", "Mollusca", "arabica", "Orthoptera"};
|
||||
//
|
||||
// for (int i=0 ; i< 4 ; i++) {
|
||||
// new NewThread(query1[i], i); // creo un nuovo thread
|
||||
// }
|
||||
|
||||
// Test retrieveTaxaByName
|
||||
// ClassificationCapabilityImpl b = new ClassificationCapabilityImpl();
|
||||
// b.searchByScientificName("Scombridae", new ObjectWriter<TaxonomyItem>() {
|
||||
//
|
||||
// @Override
|
||||
// public boolean isAlive() {
|
||||
// // TODO Auto-generated method stub
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(TaxonomyItem t) {
|
||||
// System.out.println(t);
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(StreamException arg0) {
|
||||
// // TODO Auto-generated method stub
|
||||
// return false;
|
||||
// }
|
||||
// });
|
||||
//
|
||||
// b.getSynonymnsById(new ObjectWriter<TaxonomyItem>() {
|
||||
//
|
||||
// @Override
|
||||
// public boolean isAlive() {
|
||||
// // TODO Auto-generated method stub
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(TaxonomyItem t) {
|
||||
// System.out.println(t);
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(StreamException arg0) {
|
||||
// // TODO Auto-generated method stub
|
||||
// return false;
|
||||
// }
|
||||
// },
|
||||
// "10076132"
|
||||
// );
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// List<TaxonomyItem> list = b.retrieveTaxonChildrenByTaxonId(11670252+"");
|
||||
// System.out.println(list);
|
||||
//
|
||||
// b.searchByScientificName("Carcharodon", new ObjectWriter<TaxonomyItem>() {
|
||||
//
|
||||
// @Override
|
||||
// public boolean isAlive() {
|
||||
// // TODO Auto-generated method stub
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(TaxonomyItem t) {
|
||||
// System.out.println(t);
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(StreamException arg0) {
|
||||
// // TODO Auto-generated method stub
|
||||
// return false;
|
||||
// }
|
||||
// });
|
||||
|
||||
|
||||
|
||||
// Test retrieveTaxonChildsByTaxonId
|
||||
ClassificationCapabilityImpl c = new ClassificationCapabilityImpl();
|
||||
// List<TaxonomyItem> lista = c.retrieveTaxonChildrenByTaxonId(14376129+"");
|
||||
// System.out.println("size: " + lista.size());
|
||||
// for (TaxonomyItem item : lista)
|
||||
// System.out.println(item.toString());
|
||||
|
||||
|
||||
|
||||
|
||||
// LocalWrapper<String> wrap = new LocalWrapper<String>();
|
||||
// wrap.add("14376129");
|
||||
// wrap.add("14376358");
|
||||
// wrap.add("13694496");
|
||||
// LocalReader<String> list1 = new LocalReader<String>(wrap);
|
||||
//
|
||||
// c.retrieveTaxonByIds(list1, new ClosableWriter<TaxonomyItem>() {
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(StreamException error) {
|
||||
// // TODO Auto-generated method stub
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean isAlive() {
|
||||
// // TODO Auto-generated method stub
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(TaxonomyItem t) {
|
||||
// System.out.println(t.toString());
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public void close() {
|
||||
// // TODO Auto-generated method stub
|
||||
//
|
||||
// }
|
||||
// });
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
//class NewThread extends Thread {
|
||||
//
|
||||
// Integer idThread;
|
||||
// String query;
|
||||
//
|
||||
// NewThread(String query, Integer idThread) {
|
||||
//
|
||||
// super("Thread");
|
||||
// this.idThread = idThread;
|
||||
// this.query = query;
|
||||
// start(); // Start the thread
|
||||
//
|
||||
// }
|
||||
//
|
||||
// // This is the entry point for the child threads
|
||||
// public void run() {
|
||||
//
|
||||
// ClassificationCapabilityImpl b = new ClassificationCapabilityImpl();
|
||||
//
|
||||
// //
|
||||
// b.searchByScientificName(query, new ObjectWriter<TaxonomyItem>() {
|
||||
//
|
||||
// @Override
|
||||
// public boolean isAlive() {
|
||||
// // TODO Auto-generated method stub
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(TaxonomyItem t) {
|
||||
// System.out.println(t);
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// @Override
|
||||
// public boolean write(StreamException arg0) {
|
||||
// // TODO Auto-generated method stub
|
||||
// return false;
|
||||
// }
|
||||
// } );
|
||||
//
|
||||
// }
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,68 @@
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
|
||||
import java.util.List;
|
||||
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
||||
import org.gcube.common.scope.api.ScopeProvider;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.ExpansionCapabilityImpl;
|
||||
import org.gcube.data.spd.model.exceptions.StreamException;
|
||||
import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter;
|
||||
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
||||
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class TestExpansionCapability {
|
||||
static Logger logger = LoggerFactory.getLogger(TestExpansionCapability.class);
|
||||
/**
|
||||
* @param args
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
CatalogueOfLifePlugin a = new CatalogueOfLifePlugin();
|
||||
|
||||
SimpleQuery query = queryFor(ServiceEndpoint.class);
|
||||
|
||||
query.addCondition("$resource/Profile/Category/text() eq 'BiodiversityRepository' and $resource/Profile/Name eq 'CatalogueOfLife' ");
|
||||
ScopeProvider.instance.set("/gcube/devsec");
|
||||
|
||||
DiscoveryClient<ServiceEndpoint> client = clientFor(ServiceEndpoint.class);
|
||||
|
||||
List<ServiceEndpoint> resources = client.submit(query);
|
||||
|
||||
System.out.println(resources.size());
|
||||
|
||||
if(resources.size() != 0) {
|
||||
try {
|
||||
a.initialize(resources.get(0));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
ExpansionCapabilityImpl b = new ExpansionCapabilityImpl();
|
||||
b.getSynonyms(new ObjectWriter<String>() {
|
||||
|
||||
@Override
|
||||
public boolean write(StreamException error) {
|
||||
// TODO Auto-generated method stub
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean write(String t) {
|
||||
System.out.println(t);
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isAlive() {
|
||||
// System.out.println("isAlive");
|
||||
return true;
|
||||
}
|
||||
}, "rosa");
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,55 @@
|
||||
package org.gcube.data.spd.catalogueoflife;
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
|
||||
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
||||
import org.gcube.common.scope.api.ScopeProvider;
|
||||
import org.gcube.data.spd.catalogueoflife.capabilities.NamesMappingImpl;
|
||||
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
||||
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
||||
|
||||
public class TestMapping {
|
||||
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
|
||||
CatalogueOfLifePlugin a = new CatalogueOfLifePlugin();
|
||||
|
||||
|
||||
SimpleQuery query = queryFor(ServiceEndpoint.class);
|
||||
|
||||
query.addCondition("$resource/Profile/Category/text() eq 'BiodiversityRepository' and $resource/Profile/Name eq 'CatalogueOfLife' ");
|
||||
ScopeProvider.instance.set("/gcube/devsec");
|
||||
|
||||
DiscoveryClient<ServiceEndpoint> client = clientFor(ServiceEndpoint.class);
|
||||
|
||||
List<ServiceEndpoint> resources = client.submit(query);
|
||||
|
||||
System.out.println(resources.size());
|
||||
|
||||
if(resources.size() != 0) {
|
||||
try {
|
||||
a.initialize(resources.get(0));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
NamesMappingImpl b = new NamesMappingImpl();
|
||||
try {
|
||||
Set<String> c = b.commonNameToScientificNamesMapping("Äkta tunga");
|
||||
System.out.println(c);
|
||||
|
||||
// Set<String> d = b.scientificNameToCommonNamesMapping("Carcharhinus albimarginatus");
|
||||
// System.out.println(d);
|
||||
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,20 @@
|
||||
# Set root category priority to WARN and its only appender to A1.
|
||||
log4j.rootCategory=ERROR, A1
|
||||
|
||||
log4j.appender.A1=org.apache.log4j.ConsoleAppender
|
||||
log4j.appender.A2=org.apache.log4j.ConsoleAppender
|
||||
|
||||
|
||||
# A1 uses PatternLayout.
|
||||
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.A1.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p %c{2} [%t,%M:%L] %m%n
|
||||
|
||||
# A2 uses PatternLayout.
|
||||
log4j.appender.A2.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.A2.layout.ConversionPattern=[CoL] %d{HH:mm:ss,SSS} %-5p %c{2} [%t,%M:%L] %m%n
|
||||
|
||||
|
||||
|
||||
# Display any warnings generated by our code
|
||||
log4j.category.org.gcube.data.spd.catalogueoflife=TRACE,A2
|
||||
log4j.additivity.org.gcube.data.spd.catalogueoflife=false
|
||||
Loading…
Reference in New Issue