EDIT

  mvn jaxb2:generate

the xml schema file contains ```<annox:annotate>``` elements

```

   <!-- ======================================================================= -->

   <!-- Dependencies needed for Apache Axix WSDL2Java (only during development) -->

   ...

   <!-- ======================================================================= -->

```

```

java -cp  $(mvn3 dependency:build-classpath | grep -v "\[")  org.apache.axis.wsdl.WSDL2Java <url-to-wsdl-file>

```

This project contains all the components required to run the [BioVeL Data Refinement Workflow](https://wiki.biovel.eu/display/doc/Data+Refinement+Workflow)

For more details regarding BioVeL, please visit [www.biovel.eu](www.biovel.eu)

BioVeL is funded by the European Commission 7th Framework Programme (FP7), through the grant agreement number 283359.

Third-Party Dependencies

========================

Libraries

---------

Services

-------

  <groupId>biovel.drf</groupId>

  <artifactId>drf-workflow</artifactId>

  <name>drf-workflow</name>

          <schemaDirectory>src/main/resources/org/bgbm/biovel/drf/tnr</schemaDirectory>

package org.bgbm.biovel.drf.checklist;

import org.bgbm.biovel.drf.client.ServiceProviderInfo;

import org.bgbm.biovel.drf.query.IQueryClient;

public abstract class AggregateChecklistClient<QC extends IQueryClient> extends BaseChecklistClient<QC> {

	public AggregateChecklistClient() {

		super();

	}

	public AggregateChecklistClient(String checklistInfoJson) throws DRFChecklistException {

		super(checklistInfoJson);

	}

	public AggregateChecklistClient(ServiceProviderInfo spiInfo) throws DRFChecklistException {

		super(spiInfo);

	}

}

package org.bgbm.biovel.drf.checklist;

import java.util.EnumSet;

import java.util.Iterator;

import java.util.List;

import org.bgbm.biovel.drf.client.AbstractClient;

import org.bgbm.biovel.drf.client.ServiceProviderInfo;

import org.bgbm.biovel.drf.query.IQueryClient;

import org.bgbm.biovel.drf.tnr.msg.Query;

import org.bgbm.biovel.drf.tnr.msg.TnrMsg;

import org.bgbm.biovel.drf.utils.TnrMsgUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public abstract class BaseChecklistClient<QC extends IQueryClient> extends AbstractClient<QC> {

    protected Logger logger = LoggerFactory.getLogger(BaseChecklistClient.class);

    protected final static String CHECKLIST_KEY = "checklist";

    protected final static String CHECKLIST_URL_KEY = "checklist_url";

    protected final static String COPYRIGHT_URL_KEY = "copyright_url";

    protected final static String CHECKLIST_LIST = "checklist_list";

    public BaseChecklistClient() {

        super();

    }

    public BaseChecklistClient(String checklistInfoJson) throws DRFChecklistException {

        super(checklistInfoJson);

    }

    public BaseChecklistClient(ServiceProviderInfo spInfo) throws DRFChecklistException {

        super(spInfo);

    }

    /**

     * @param tnrMsg

     * @return

     * @throws DRFChecklistException

     */

    protected Query singleQueryFrom(TnrMsg tnrMsg) throws DRFChecklistException {

        List<Query> queryList = tnrMsg.getQuery();

        if(queryList.size() ==  0) {

            throw new DRFChecklistException("query list is empty");

        }

        if(queryList.size() > 1) {

            throw new DRFChecklistException("query list has more than one query");

        }

        Query query = queryList.get(0);

        return query;

    }

    public void queryChecklist(List<TnrMsg> tnrMsgs) throws DRFChecklistException {

        TnrMsg finalTnrMsg = new TnrMsg();

        Iterator<TnrMsg> itrTnrMsg = tnrMsgs.iterator();

        while(itrTnrMsg.hasNext()) {

            Iterator<Query> itrQuery = itrTnrMsg.next().getQuery().iterator();

            while(itrQuery.hasNext()) {

                finalTnrMsg.getQuery().add(itrQuery.next());

            }

        }

        queryChecklist(finalTnrMsg);

    }

    /**

     *

     * @param tnrMsg

     * @throws DRFChecklistException

     */

    public void queryChecklist(TnrMsg tnrMsg) throws DRFChecklistException {

        TnrMsgUtils.assertSearchModeSet(tnrMsg, true);

        SearchMode mode = TnrMsgUtils.getSearchMode(tnrMsg);

        preExcuteQuery(tnrMsg);

        if(!getSearchModes().contains(mode)){

            throw new DRFChecklistException("Unsupported SearchMode");

        }

        if (getSearchModes().contains(mode)){

            switch(mode){

            case scientificNameExact:

                 resolveScientificNamesExact(tnrMsg);

                 break;

            case scientificNameLike:

                resolveScientificNamesLike(tnrMsg);

                break;

            case vernacularNameExact:

                resolveVernacularNamesExact(tnrMsg);

                break;

            case vernacularNameLike:

                resolveVernacularNamesLike(tnrMsg);

                break;

            case findByIdentifier:

                if(checkSupportedIdentifieres(tnrMsg)){

                    findByIdentifier(tnrMsg);

                } else {

                    logger.info("The queries contain unsupported identifier strings");

                    throw new UnsupportedIdentifierException("Queries contain unsupported identifier strings");

                }

                break;

            default:

                throw new DRFChecklistException("Unimplemented SearchMode");

            }

        } else {

            logger.info("Search mode " + mode + " not supported by this ChecklistClient implementation");

        }

        postExcuteQuery(tnrMsg);

    }

    /**

     * @param tnrMsg

     */

    private void postExcuteQuery(TnrMsg tnrMsg) {

     // empty stub, to be implemented by subclasses if necessary

    }

    /**

     * @param tnrMsg

     */

    private void preExcuteQuery(TnrMsg tnrMsg) {

        // empty stub, to be implemented by subclasses if necessary

    }

    /**

     * Checks all the queries of the <code>tnrMsg</code> of they

     * contain a query string which is supported as identifier by the

     * implementing checklist client.

     * <p>

     * Fails if only one of the query string is not supported!

     *

     * @param tnrMsg

     * @return

     */

    private boolean checkSupportedIdentifieres(TnrMsg tnrMsg) {

        for (Query q : tnrMsg.getQuery()){

            if(! isSupportedIdentifier(q.getRequest().getQueryString())){

                return false;

            }

        }

        return true;

    }

    /**

     * Searches for scientific names which exactly match the given query string.

     *

     * @param tnrMsg

     * @throws DRFChecklistException

     */

    public abstract void resolveScientificNamesExact(TnrMsg tnrMsg) throws DRFChecklistException;

    /**

     * Searches for scientific names which start with the given query string.

     *

     * @param tnrMsg

     * @throws DRFChecklistException

     */

    public abstract void resolveScientificNamesLike(TnrMsg tnrMsg) throws DRFChecklistException;

    /**

     * Searches for taxa with an vernacular name that exactly match the given query string.

     *

     * @param tnrMsg

     * @throws DRFChecklistException

     */

    public abstract void resolveVernacularNamesExact(TnrMsg tnrMsg) throws DRFChecklistException;

    /**

     * Searches for taxa with an vernacular name that contains the given query string.

     *

     * @param tnrMsg

     * @throws DRFChecklistException

     */

    public abstract void resolveVernacularNamesLike(TnrMsg tnrMsg) throws DRFChecklistException;

    /**

     * Searches taxa having a specific identifier

     *

     * @param tnrMsg

     * @throws DRFChecklistException

     */

    public abstract void  findByIdentifier(TnrMsg tnrMsg) throws DRFChecklistException;

    public abstract EnumSet<SearchMode> getSearchModes();

    public abstract boolean isSupportedIdentifier(String value);

}

package org.bgbm.biovel.drf.checklist;

import java.net.URI;

import java.util.ArrayList;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.http.HttpHost;

import org.apache.http.ParseException;

import org.bgbm.biovel.drf.client.ServiceProviderInfo;

import org.bgbm.biovel.drf.query.RestClient;

import org.bgbm.biovel.drf.tnr.msg.Classification;

import org.bgbm.biovel.drf.tnr.msg.NameType;

import org.bgbm.biovel.drf.tnr.msg.Query;

import org.bgbm.biovel.drf.tnr.msg.Response;

import org.bgbm.biovel.drf.tnr.msg.Source;

import org.bgbm.biovel.drf.tnr.msg.Synonym;

import org.bgbm.biovel.drf.tnr.msg.Taxon;

import org.bgbm.biovel.drf.tnr.msg.TaxonName;

import org.bgbm.biovel.drf.tnr.msg.TnrMsg;

import org.bgbm.biovel.drf.utils.IdentifierUtils;

import org.bgbm.biovel.drf.utils.TnrMsgUtils;

import org.gbif.nameparser.NameParser;

import org.json.simple.JSONArray;

import org.json.simple.JSONAware;

import org.json.simple.JSONObject;

import org.json.simple.parser.JSONParser;

public class BgbmEditClient extends AggregateChecklistClient<RestClient> {

    /**

     *

     */

    public static final String ID = "bgbm-cdm-server";

    public static final String LABEL = "Name catalogues served by the BGBM CDM Server";

    public static final String DOC_URL = "http://wp5.e-taxonomy.eu/cdmlib/rest-api-name-catalogue.html";

    public static final String COPYRIGHT_URL = "http://wp5.e-taxonomy.eu/cdmlib/license.html";

    private static final String SERVER_PATH_PREFIX = "/";

    private static final HttpHost HTTP_HOST = new HttpHost("api.cybertaxonomy.org", 80); // new HttpHost("test.e-taxonomy.eu", 80);

    private final Map<String,Query> taxonIdQueryMap = new HashMap<String,Query>();

    private final Map<String,String> taxonIdMatchStringMap = new HashMap<String, String>();

    public static final EnumSet<SearchMode> SEARCH_MODES = EnumSet.of(

            SearchMode.scientificNameExact,

            SearchMode.scientificNameLike,

            SearchMode.findByIdentifier

            );

    public BgbmEditClient() {

        super();

    }

    public BgbmEditClient(String checklistInfoJson) throws DRFChecklistException {

        super(checklistInfoJson);

    }

    @Override

    public void initQueryClient() {

        queryClient = new RestClient(HTTP_HOST);

    }

    @Override

    public ServiceProviderInfo buildServiceProviderInfo() {

        ServiceProviderInfo checklistInfo = new ServiceProviderInfo(ID,LABEL,DOC_URL,COPYRIGHT_URL, getSearchModes());

        checklistInfo.addSubChecklist(new ServiceProviderInfo("col",

                "Catalogue Of Life (EDIT - name catalogue end point)",

                "http://wp5.e-taxonomy.eu/cdmlib/rest-api-name-catalogue.html",

                "http://www.catalogueoflife.org/col/info/copyright", ServiceProviderInfo.DEFAULT_SEARCH_MODE));

        return checklistInfo;

    }

    /**

     * Adds the acceptedTaxonUuids found in the <code>responseBody</code> to the

     * private field <code>taxonIdQueryMap</code>

     * and populates the <code>taxonIdMatchStringMap</code>

     *

     * @param queryList

     * @param responseBodyJson

     * @throws DRFChecklistException

     */

    private void buildTaxonIdMapsFromCatalogueServiceResponse(List<Query> queryList , String responseBody) throws DRFChecklistException {

        JSONArray responseBodyJson = parseResponseBody(responseBody, JSONArray.class);

        if(responseBodyJson.size() != queryList.size()){

            throw new DRFChecklistException("Query and Response lists have different lengths");

        }

        Iterator<JSONObject> itrNameMsgs = responseBodyJson.iterator();

        for (Query query : queryList) {

            JSONArray responseArray = (JSONArray) itrNameMsgs.next().get("response");

            if(responseArray != null) {

                Iterator<JSONObject> resIterator = responseArray.iterator();

                while (resIterator.hasNext()) {

                    JSONObject res = resIterator.next();

                    JSONArray accTaxonUuidArray = (JSONArray) res.get("acceptedTaxonUuids");

                    String matchingName = res.get("title").toString();

                    Iterator<String> atIterator = accTaxonUuidArray.iterator();

                    while (atIterator.hasNext()) {

                        String acceptedTaxonId = atIterator.next();

                        boolean isAcceptedTaxonMatch = res.get("taxonConceptUuids").toString().contains(acceptedTaxonId);

                        if(!taxonIdQueryMap.containsKey(acceptedTaxonId) || isAcceptedTaxonMatch){

                            // matches for accepted taxa should be preferred here

                            // matches for synomymy or other types should never overwrite

                            // accepted taxon matches

                            taxonIdQueryMap.put(acceptedTaxonId, query);

                            taxonIdMatchStringMap.put(acceptedTaxonId, matchingName);

                        }

                        //System.out.println("Found accepted taxon id : " + accTaxonId);

                    }

                }

            }

        }

    }

    /**

     * Adds the acceptedTaxonUuids found in the <code>responseBody</code> to the

     * private field <code>taxonIdQueryMap</code>

     * and populates the <code>taxonIdMatchStringMap</code>

     *

     * @param queryList

     * @param responseBodyJson

     * @throws DRFChecklistException

     */

    private void addTaxaToTaxonIdMapFromIdentifierServiceResponse(List<Query> queryList , String responseBody) throws DRFChecklistException {

        /*

         * {"class":"DefaultPagerImpl","count":8,"currentIndex":0,"firstRecord":1,"indices":[0],"lastRecord":8,"nextIndex":0,"pageSize":30,"pagesAvailable":1,"prevIndex":0,

            "records":[

                  {

                  "cdmEntity":{

                      "cdmUuid":"0cf5a6fe-b1df-4f4f-85a8-31fef4be2a68",

                      "class":"CdmEntity",

                      "titleCache":"Abies alba Mill. sec. SCHMEIL-FITSCHEN, Flora von Deutschland und angrenzenden Ländern, 89. Aufl"},

                  "class":"FindByIdentifierDTO",

                   "identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"3d256539-d7f7-4dd1-ad7f-cd6e4c141f24","class":"CdmEntity","titleCache":"Abies alba Mill. sec. OBERDORFER, Pflanzensoziologische Exkursionsflora, ed. 7"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"61c2bc4f-a23d-4160-8f14-625b4484fc2f","class":"CdmEntity","titleCache":"Abies alba Mill. sec. HEGI, Illustrierte Flora von Mitteleuropa, Aufl. 2 u. 3"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"7a63f215-0a41-4b7e-9394-bda4521d6ad1","class":"CdmEntity","titleCache":"Abies alba Mill. sec. GREUTER et. al., Med-Checklist bisher Bde. 1, 3 und 4"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"872088a4-95f4-472c-ae79-a29028bb3fbf","class":"CdmEntity","titleCache":"Abies alba Mill. sec. Wisskirchen & Haeupler, 1998"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"90ee17be-d455-4564-949d-9c53e27a6a6f","class":"CdmEntity","titleCache":"Abies alba Mill. sec. TUTIN et al., Flora Europaea"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"b0d35335-63e6-41ab-bdb0-d01851134e9c","class":"CdmEntity","titleCache":"Abies alba Mill. sec. EHRENDORFER, Liste der Gefäßpflanzen Mitteleuropas, 2. Aufl"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}},{"cdmEntity":{"cdmUuid":"b7a352aa-1f73-41f3-a4e3-b24fc1c2cd5f","class":"CdmEntity","titleCache":"Abies alba Mill. sec. ROTHMALER, 1990"},"class":"FindByIdentifierDTO","identifier":{"class":"AlternativeIdentifier","identifier":"1","typeLabel":"Florein Identifier","typeUuid":"8b67291e-96e0-4556-8d6a-c94e8750b301"}}],"suggestion":""}

        */

        if(queryList.size() > 1){

            throw new DRFChecklistException("Only single Querys are supported");

        }

        Query query = queryList.get(0);

        JSONObject jsonPager = parseResponseBody(responseBody, JSONObject.class);

        JSONArray jsonRecords = (JSONArray) jsonPager.get("records");

        Iterator<JSONObject> resIterator = jsonRecords.iterator();

        while (resIterator.hasNext()) {

            JSONObject record = resIterator.next();

            JSONObject cdmEntity = (JSONObject) record.get("cdmEntity");

            String uuid = cdmEntity.get("cdmUuid").toString();

            taxonIdQueryMap.put(uuid, query);

        }

    }

    private void addTaxonToTaxonIdMap(List<Query> queryList , String responseBody) throws DRFChecklistException {

        if(queryList.size() > 1){

            throw new DRFChecklistException("Only single Querys are supported");

        }

        Query query = queryList.get(0);

        JSONObject cdmEntity = parseResponseBody(responseBody, JSONObject.class);

        String uuid = cdmEntity.get("uuid").toString();

        taxonIdQueryMap.put(uuid, query);

    }

    /**

     * @param responseBody

     * @return

     * @throws DRFChecklistException

     */

    private <T extends JSONAware> T parseResponseBody(String responseBody, Class<T> jsonType) throws DRFChecklistException {

        // TODO use Jackson instead? it is much faster!

        JSONParser parser = new JSONParser();

        Object obj;

        try {

            obj = parser.parse(responseBody);

        } catch (ParseException e) {

            logger.error("parseResponseBody() - ", e);

            throw new DRFChecklistException(e);

        } catch (org.json.simple.parser.ParseException e) {

            logger.error("parseResponseBody() - ", e);

            throw new DRFChecklistException(e);

        }

        if(jsonType.isAssignableFrom(obj.getClass())){

            return jsonType.cast(obj);

        } else {

            throw new DRFChecklistException("parseResponseBody() - deserialized responseBody is not of type " + jsonType ) ;

        }

    }

    private Taxon generateAccName(JSONObject taxon) {

        Taxon accTaxon = new Taxon();

        TaxonName taxonName = new TaxonName();

        String resName = (String) taxon.get("name");

        taxonName.setFullName(resName);

        NameParser ecatParser = new NameParser();

        String nameCanonical = ecatParser.parseToCanonical(resName);

        taxonName.setCanonicalName(nameCanonical);

        taxonName.setRank((String) taxon.get("rank"));

        String lsid = (String) taxon.get("lsid");

        JSONObject scrutinyjs = (JSONObject)taxon.get("taxonomicScrutiny");

        String accordingTo = (String) scrutinyjs.get("accordingTo");

        String modified = (String) scrutinyjs.get("modified");

        accTaxon.setTaxonName(taxonName);

        accTaxon.setTaxonomicStatus((String)taxon.get("taxonStatus"));

        accTaxon.setAccordingTo(accordingTo);

        accTaxon.setIdentifier(lsid);

        JSONObject sourcejs = (JSONObject)taxon.get("source");

        String sourceUrl = (String) sourcejs.get("url");

        String sourceDatasetID =  (String) sourcejs.get("datasetID");

        String sourceDatasetName = (String) sourcejs.get("datasetName");

        String sourceName = "";

        Source source = new Source();

        source.setIdentifier(sourceDatasetID);

        source.setDatasetName(sourceDatasetName);

        source.setName(sourceName);

        source.setUrl(sourceUrl);

        accTaxon.getSources().add(source);

        JSONObject classification =(JSONObject)taxon.get("classification");

        if(classification != null) {

            Classification c = new Classification();

            c.setKingdom((String) classification.get("Kingdom"));

            c.setPhylum((String) classification.get("Phylum"));

            c.setClazz((String) classification.get("Class"));

            c.setOrder((String) classification.get("Order"));

            c.setFamily((String) classification.get("Family"));

            c.setGenus((String) classification.get("Genus"));

            accTaxon.setClassification(c);

        }

        return accTaxon;

    }

    private void generateSynonyms(JSONArray relatedTaxa, Response tnrResponse) {

        Iterator<JSONObject> itrSynonyms = relatedTaxa.iterator();

        while(itrSynonyms.hasNext()) {

            JSONObject synonymjs = itrSynonyms.next();

            String status = (String) synonymjs.get("taxonStatus");

            if(status != null && status.equals("synonym")) {

                Synonym synonym = new Synonym();

                TaxonName taxonName = new TaxonName();

                String resName = (String) synonymjs.get("name");

                taxonName.setFullName(resName);

                NameParser ecatParser = new NameParser();

                String nameCanonical = ecatParser.parseToCanonical(resName);

                taxonName.setCanonicalName(nameCanonical);

                synonym.setTaxonomicStatus((String)synonymjs.get("taxonStatus"));

                taxonName.setRank((String) synonymjs.get("rank"));

                synonym.setTaxonName(taxonName);

                JSONObject scrutinyjs = (JSONObject)synonymjs.get("taxonomicScrutiny"); // TODO this will change in future releases of the service

                synonym.setAccordingTo((String) scrutinyjs.get("accordingTo"));

                JSONObject sourcejs = (JSONObject)synonymjs.get("source");

                String sourceUrl = (String) sourcejs.get("url");

                String sourceDatasetID =  (String) sourcejs.get("datasetID");

                String sourceDatasetName = (String) sourcejs.get("datasetName");

                String sourceName = "";

                Source source = new Source();

                source.setIdentifier(sourceDatasetID);

                source.setDatasetName(sourceDatasetName);

                source.setName(sourceName);

                source.setUrl(sourceUrl);

                synonym.getSources().add(source);

                tnrResponse.getSynonym().add(synonym);

            }

        }

    }

    @Override

    public void resolveScientificNamesExact(TnrMsg tnrMsg) throws DRFChecklistException {

        List<Query> queryList = tnrMsg.getQuery();

        // selecting one request as representative, only

        // the search mode and addSynonmy flag are important

        // for the further usage of the request object

        Query.Request request = queryList.get(0).getRequest();

        for (ServiceProviderInfo checklistInfo : getServiceProviderInfo().getSubChecklists()) {

            URI namesUri = queryClient.buildUriFromQueryList(queryList,

                    SERVER_PATH_PREFIX + checklistInfo.getId() + "/name_catalogue.json",

                    "query",

                    "*", null);

            String searchResponseBody = queryClient.get(namesUri);

            buildTaxonIdMapsFromCatalogueServiceResponse(queryList, searchResponseBody);

            List<String> taxonIdList = new ArrayList<String>(taxonIdQueryMap.keySet());

            if(taxonIdList.size() > 0) {

                URI taxonUri = queryClient.buildUriFromQueryStringList(taxonIdList,

                        SERVER_PATH_PREFIX + checklistInfo.getId() + "/name_catalogue/taxon.json",

                        "taxonUuid",

                        null);

                String taxonResponseBody = queryClient.get(taxonUri);

                updateQueriesWithResponse(taxonResponseBody, checklistInfo, request);

            }

        }

    }

    @Override

    public void resolveScientificNamesLike(TnrMsg tnrMsg) throws DRFChecklistException {

        // delegate to resolveScientificNamesExact, since the like search mode is handled in buildUriFromQueryList

        resolveScientificNamesExact(tnrMsg);

    }

    @Override

    public void resolveVernacularNamesExact(TnrMsg tnrMsg) throws DRFChecklistException {

        // TODO Auto-generated method stub

    }

    @Override

    public void resolveVernacularNamesLike(TnrMsg tnrMsg) throws DRFChecklistException {

        // TODO Auto-generated method stub

    }

    @Override

    public void findByIdentifier(TnrMsg tnrMsg) throws DRFChecklistException {

        List<Query> queryList = tnrMsg.getQuery();

        if(queryList.size() > 1){

            throw new DRFChecklistException("Only single Querys are supported");

        }

        Query.Request request = queryList.get(0).getRequest();

        Map<String, String> findByIdentifierParameters = new HashMap<String,String>();

        findByIdentifierParameters.put("includeEntity", "1");

        String identifier = request.getQueryString();

        for (ServiceProviderInfo checklistInfo : getServiceProviderInfo().getSubChecklists()) {

            // taxon/findByIdentifier.json?identifier=1&includeEntity=1

            if(IdentifierUtils.checkLSID(identifier)){

                URI namesUri = queryClient.buildUriFromQueryList(queryList,

                        SERVER_PATH_PREFIX + checklistInfo.getId() + "/authority/metadata.do",

                        "lsid",

                        null,

                        null );

                String responseBody = queryClient.get(namesUri);

                addTaxonToTaxonIdMap(queryList, responseBody);

            } else {

                URI namesUri = queryClient.buildUriFromQueryList(queryList,

                        SERVER_PATH_PREFIX + checklistInfo.getId() + "/taxon/findByIdentifier.json",

                        "identifier",

                        null, // like search for identifiers not supported by this client

                        findByIdentifierParameters );

                String responseBody = queryClient.get(namesUri);

                addTaxaToTaxonIdMapFromIdentifierServiceResponse(queryList, responseBody);

            }

            List<String> taxonIdList = new ArrayList<String>(taxonIdQueryMap.keySet());

            if(taxonIdList.size() > 0) {

                URI taxonUri = queryClient.buildUriFromQueryStringList(taxonIdList,

                        SERVER_PATH_PREFIX + checklistInfo.getId() + "/name_catalogue/taxon.json",

                        "taxonUuid",

                        null);

                String taxonResponseBody = queryClient.get(taxonUri);

                updateQueriesWithResponse(taxonResponseBody, checklistInfo, request);

            }

        }

    }

    private void updateQueriesWithResponse(String responseBody, ServiceProviderInfo ci, Query.Request request) throws DRFChecklistException {

        if(responseBody == null || responseBody.isEmpty()){

            return;

        }

        JSONArray responseBodyJson = parseResponseBody(responseBody, JSONArray.class);

        Iterator<JSONObject> itrTaxonMsgs = responseBodyJson.iterator();

        int i = -1;

        while(itrTaxonMsgs.hasNext()) {

            i++;

            JSONObject taxonInfo = itrTaxonMsgs.next();

            JSONObject taxonResponse = (JSONObject) taxonInfo.get("response");

            JSONObject taxon = (JSONObject) taxonResponse.get("taxon");

            JSONArray relatedTaxa = (JSONArray) taxonResponse.get("relatedTaxa");

            JSONObject taxonRequest = (JSONObject) taxonInfo.get("request");

            String taxonUuid = (String) taxonRequest.get("taxonUuid");

            if(taxon != null) {

                Response tnrResponse = TnrMsgUtils.tnrResponseFor(ci);

                String matchingName = taxonIdMatchStringMap.get(taxonUuid);

                if(matchingName != null){

                    tnrResponse.setMatchingNameString(matchingName);

                    tnrResponse.setMatchingNameType(matchingName.equals(taxon.get("name").toString()) ? NameType.TAXON : NameType.SYNONYM);

                }

                Taxon accName = generateAccName(taxon);

                tnrResponse.setTaxon(accName);

                if(request.isAddSynonymy()){

                    generateSynonyms(relatedTaxa, tnrResponse);

                }

                Query query = taxonIdQueryMap.get(taxonUuid);

                if(query != null) {

                    query.getResponse().add(tnrResponse);

                }

            }

        }

    }

    @Override

    public EnumSet<SearchMode> getSearchModes() {

        return SEARCH_MODES ;

    }

    @Override

    public boolean isSupportedIdentifier(String value) {

        // return IdentifierUtils.checkLSID(value) || IdentifierUtils.checkUUID(value);

        return value != null;

    }

}

package org.bgbm.biovel.drf.checklist;

public class DRFChecklistException extends Exception {

    public DRFChecklistException(Throwable cause) {

        super(cause);

    }

    public DRFChecklistException(String message) {

        super(message);

    }

    public DRFChecklistException(String message, Throwable cause) {

       super(message , cause);

    }

}

package org.bgbm.biovel.drf.checklist;

import java.io.PrintStream;

import java.net.URI;

import java.util.ArrayList;

import java.util.EnumSet;

import java.util.Iterator;

import java.util.List;

import org.apache.lucene.queryParser.QueryParser;

import org.bgbm.biovel.drf.client.ServiceProviderInfo;

import org.bgbm.biovel.drf.query.TinkerPopClient;

import org.bgbm.biovel.drf.store.Neo4jStore;

import org.bgbm.biovel.drf.store.Store;

import org.bgbm.biovel.drf.tnr.msg.Classification;

import org.bgbm.biovel.drf.tnr.msg.NameType;

import org.bgbm.biovel.drf.tnr.msg.Query;

import org.bgbm.biovel.drf.tnr.msg.Query.Request;

import org.bgbm.biovel.drf.tnr.msg.Response;

import org.bgbm.biovel.drf.tnr.msg.Source;

import org.bgbm.biovel.drf.tnr.msg.Synonym;

import org.bgbm.biovel.drf.tnr.msg.Taxon;

import org.bgbm.biovel.drf.tnr.msg.TaxonBase;

import org.bgbm.biovel.drf.tnr.msg.TaxonName;

import org.bgbm.biovel.drf.tnr.msg.TnrMsg;

import org.bgbm.biovel.drf.utils.IdentifierUtils;

import org.bgbm.biovel.drf.utils.Profiler;

import org.bgbm.biovel.drf.utils.TnrMsgUtils;

import org.neo4j.graphdb.Relationship;

import com.tinkerpop.blueprints.Graph;

import com.tinkerpop.blueprints.Vertex;

import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Vertex;

import com.tinkerpop.blueprints.oupls.sail.GraphSail;

import com.tinkerpop.gremlin.java.GremlinPipeline;

import com.tinkerpop.pipes.util.FastNoSuchElementException;

import com.tinkerpop.pipes.util.structures.Table;

public class EEA_BDC_Client extends AggregateChecklistClient<TinkerPopClient> {

    /**

     *

     */

    public static final String ID = "eea_bdc";

    public static final String LABEL = "European Environment Agency (EEA) Biodiversity data centre (BDC)";

    public static final String DOC_URL = "http://semantic.eea.europa.eu/documentation";

    public static final String COPYRIGHT_URL = "http://www.eea.europa.eu/legal/eea-data-policy";

    private static final String SPECIES_RDF_FILE_URL = "http://localhost/download/species.rdf.gz"; // http://eunis.eea.europa.eu/rdf/species.rdf.gz

    private static final String TAXONOMY_RDF_FILE_URL = "http://localhost/download/taxonomy.rdf.gz"; // http://eunis.eea.europa.eu/rdf/taxonomy.rdf.gz

    private static final String LEGALREFS_RDF_FILE_URL = "http://localhost/download/legalrefs.rdf.gz"; // http://eunis.eea.europa.eu/rdf/legalrefs.rdf.gz

    private static final String REFERENCES_RDF_FILE_URL = "http://localhost/download/references.rdf.gz"; // http://eunis.eea.europa.eu/rdf/references.rdf.gz

    private static final boolean REFRESH_TDB = false;

    public static final EnumSet<SearchMode> SEARCH_MODES = EnumSet.of(

            SearchMode.scientificNameExact,

            SearchMode.scientificNameLike,

            SearchMode.vernacularNameExact,

            SearchMode.vernacularNameLike,

            SearchMode.findByIdentifier);

    public static enum RdfSchema {

        /*

         *     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

    xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#"

    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"

    xmlns:dcterms="http://purl.org/dc/terms/"

    xmlns:dc="http://purl.org/dc/elements/1.1/"

    xmlns:dwc="http://rs.tdwg.org/dwc/terms/"

    xmlns:owl="http://www.w3.org/2002/07/owl#"

    xmlns="http://eunis.eea.europa.eu/rdf/species-schema.rdf#"

    xmlns:sioc="http://rdfs.org/sioc/ns#"

    xmlns:skos="http://www.w3.org/2004/02/skos/core#"

    xmlns:bibo="http://purl.org/ontology/bibo/"

    xmlns:cc="http://creativecommons.org/ns#"

    xmlns:foaf="http://xmlns.com/foaf/0.1/"

         */

        EUNIS_SPECIES("es","http://eunis.eea.europa.eu/rdf/species-schema.rdf#"),

        EUNIS_TAXONOMY("et", "http://eunis.eea.europa.eu/rdf/taxonomies-schema.rdf#"),

        DWC("dwc", "http://rs.tdwg.org/dwc/terms/"),

        RDF("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"),

        RDFS("rdfs", "http://www.w3.org/2000/01/rdf-schema#"),

        SKOS_CORE("scos_core", "http://www.w3.org/2004/02/skos/core#"),

        DC("dc", "http://purl.org/dc/terms/source"),

        DCTERMS("dcterms", "http://purl.org/dc/terms/");

        private String schemaUri;

        private String abbreviation;

        RdfSchema(String abbreviation, String schemaUri) {

            this.abbreviation = abbreviation;

            this.schemaUri = schemaUri;

        }

        public String schemaUri() {

            return schemaUri;

        }

        public String abbreviation() {

            return abbreviation;

        }

        public String property(String name) {

            return schemaUri + name;

        }

    }

    public enum SubCheckListId {

        eunis, natura_2000;

    }

    private enum RankLevel{

        Kingdom, Phylum, Clazz, Order, Family, Genus;

    }

    public EEA_BDC_Client() {

        super();

    }

    public EEA_BDC_Client(String checklistInfoJson) throws DRFChecklistException {

        super(checklistInfoJson);

    }

    @Override

    public void initQueryClient() {

            Neo4jStore neo4jStore;

            try {

                neo4jStore = new Neo4jStore();

            } catch (Exception e1) {

                throw new RuntimeException("Creation of Neo4jStore failed",  e1);

            }

            if(REFRESH_TDB) {

                updateStore(neo4jStore);

            }

            queryClient = new TinkerPopClient(neo4jStore);

    }

    /**

     * @param neo4jStore

     */

    private void updateStore(Store neo4jStore) {

        try {

            neo4jStore.loadIntoStore(

//                    SPECIES_RDF_FILE_URL,

                    TAXONOMY_RDF_FILE_URL

//                    LEGALREFS_RDF_FILE_URL,

//                    REFERENCES_RDF_FILE_URL

                    );

        } catch (Exception e) {

            throw new RuntimeException("Loading "

                    + SPECIES_RDF_FILE_URL + ", "

                    + TAXONOMY_RDF_FILE_URL + ", "

                    + LEGALREFS_RDF_FILE_URL + ", "

                    + REFERENCES_RDF_FILE_URL +

                    " into Neo4jStore failed",  e);

        }

    }

    @Override

    public ServiceProviderInfo buildServiceProviderInfo() {

        ServiceProviderInfo checklistInfo = new ServiceProviderInfo(ID, LABEL, DOC_URL, COPYRIGHT_URL, getSearchModes());

        checklistInfo.addSubChecklist(new ServiceProviderInfo(SubCheckListId.eunis.name(), "EUNIS",

                "http://www.eea.europa.eu/themes/biodiversity/eunis/eunis-db#tab-metadata",

                "http://www.eea.europa.eu/legal/copyright", SEARCH_MODES));

        return checklistInfo;

    }

    /**

     * @param queryString

     * @throws DRFChecklistException

     */

    private void addPrexfixes(StringBuilder queryString) throws DRFChecklistException {

        for(RdfSchema schema : RdfSchema.values()) {

            queryString.append(String.format("PREFIX %s: <%s>\n", schema.abbreviation(), schema.schemaUri()));

        }

    }

    /**

     * @param checklistInfo

     * @return

     * @throws DRFChecklistException

     */

    private StringBuilder prepareQueryString() throws DRFChecklistException {

        StringBuilder queryString = new StringBuilder();

        addPrexfixes(queryString);

        return queryString;

    }

    private Taxon createTaxon(Vertex v) {

        Taxon taxon = new Taxon();

        TaxonName taxonName = createTaxonName(v);

        // Taxon

        taxon.setTaxonName(taxonName);

        taxon.setIdentifier(v.getId().toString());

        taxon.setAccordingTo(queryClient.relatedVertexValue(v, RdfSchema.DWC, "nameAccordingToID"));

        URI typeUri = queryClient.vertexURI(v, RdfSchema.RDF, "type");

        taxon.setTaxonomicStatus(typeUri.getFragment());

        createSources(v, taxon);

        // classification

        Classification c = null;

        Vertex parentV= null;

        try {

            parentV = queryClient.relatedVertex(v, RdfSchema.EUNIS_SPECIES, "taxonomy");

        } catch (Exception e) {

            logger.error("No taxonomy information for " + v.toString());

        }

        while (parentV != null) {

            logger.debug("parent taxon: " + parentV.toString());

            String level = queryClient.relatedVertexValue(parentV, RdfSchema.EUNIS_TAXONOMY, "level");

            String parentTaxonName = queryClient.relatedVertexValue(parentV, RdfSchema.EUNIS_TAXONOMY, "name");

            RankLevel rankLevel = null;

            try {

                rankLevel = RankLevel.valueOf(level);

            } catch (Exception e) {

                // IGNORE

            }

            if(rankLevel != null) {

                if(c == null) {

                 c = new Classification();

                }

                switch(rankLevel) {

                case Clazz:

                    c.setClazz(parentTaxonName);

                    break;

                case Family:

                    c.setFamily(parentTaxonName);

                    break;

                case Genus:

                    c.setGenus(parentTaxonName);

                    break;

                case Kingdom:

                    c.setKingdom(parentTaxonName);

                    break;

                case Order:

                    c.setOrder(parentTaxonName);

                    break;

                case Phylum:

                    c.setPhylum(parentTaxonName);

                    break;

                default:

                    break;

                }

            }

            Vertex lastParentV = parentV;

            parentV = queryClient.relatedVertex(parentV, RdfSchema.EUNIS_TAXONOMY, "parent");

            if(lastParentV.equals(parentV)) {

                // avoid endless looping when data is not correct

                break;

            }

        }

        if(c != null) {

            taxon.setClassification(c);

        }

        return taxon;

    }

    /**

     * @param model

     * @param taxonR

     * @param taxonBase

     */

    private void createSources(Vertex v, TaxonBase taxonBase) {

        // Sources are source references, re there others like data bases?

        GremlinPipeline<Graph, Vertex> taxonPipe = new GremlinPipeline<Graph, Vertex>(v);

        try {

            List<Vertex> titleVs = taxonPipe

                    .outE(RdfSchema.EUNIS_SPECIES.property("hasLegalReference")).inV()

                    .outE(RdfSchema.DCTERMS.property("source")).inV().dedup()

                    .outE(RdfSchema.DCTERMS.property("title")).inV()

                    .toList();

            for(Vertex tv : titleVs) {

                Source source = new Source();

                logger.error(tv.toString());

                source.setName(tv.getProperty(GraphSail.VALUE).toString());

                taxonBase.getSources().add(source);

            }

        } catch (FastNoSuchElementException e) {

            logger.debug("No sources found");

        }

    }

    /**

     * @param taxonR

     * @return

     */

    private TaxonName createTaxonName(Vertex v) {

        TaxonName taxonName = new TaxonName();

        // TaxonName

        taxonName.setFullName(queryClient.relatedVertexValue(v, RdfSchema.RDFS, "label"));

        taxonName.setCanonicalName(queryClient.relatedVertexValue(v, RdfSchema.EUNIS_SPECIES, "binomialName"));

        taxonName.setRank(queryClient.relatedVertexValue(v, RdfSchema.EUNIS_SPECIES, "taxonomicRank"));

        return taxonName;

    }

    private void createSynonyms(Vertex taxonV, Response tnrResponse) {

        GremlinPipeline<Graph, Vertex> taxonPipe = new GremlinPipeline<Graph, Vertex>(taxonV);

        try {

            List<Vertex> synonymVs = taxonPipe

                    .inE(RdfSchema.EUNIS_SPECIES.property("eunisPrimaryName")).outV().dedup()

                    .toList();

            for(Vertex synonymV : synonymVs) {

                String typeUri = queryClient.relatedVertexValue(synonymV, RdfSchema.RDF, "type");

                String status = null;

                try {

                    status = URI.create(typeUri).getFragment();

                } catch (Exception e) {

                }

                if (status != null && status.equals("SpeciesSynonym")) {

                    Synonym synonym = new Synonym();

                    TaxonName taxonName = createTaxonName(synonymV);

                    synonym.setTaxonomicStatus(status);

                    synonym.setTaxonName(taxonName);

                    synonym.setAccordingTo(queryClient.relatedVertexValue(synonymV, RdfSchema.DWC, "nameAccordingToID"));

                    createSources(synonymV, synonym);

                    tnrResponse.getSynonym().add(synonym);

                }

            }

        } catch (FastNoSuchElementException e) {

            logger.debug("No sources found");

        }

    }

    @Override

    public void resolveScientificNamesExact(TnrMsg tnrMsg) throws DRFChecklistException {

        for (ServiceProviderInfo checklistInfo : getServiceProviderInfo().getSubChecklists()) {

            // FIXME query specific subchecklist

            // selecting one request as representative, only

            // the search mode and addSynonmy flag are important

            // for the further usage of the request object

            Query query = singleQueryFrom(tnrMsg);

            String queryString = query.getRequest().getQueryString();

            logger.debug("original queryString: "+ queryString);

            queryString = QueryParser.escape(queryString);

            queryString = queryString.replace(" ", "\\ ");

            if(query.getRequest().getSearchMode().equals(SearchMode.scientificNameLike.name())) {

                queryString += "*";

            }

            logger.debug("prepared queryString: "+ queryString);

            GremlinPipeline<Graph, Vertex> pipe = null;

            Profiler profiler = Profiler.newCpuProfiler(false);

            logger.debug("Neo4jINDEX");

            ArrayList<Vertex> hitVs = queryClient.vertexIndexQuery("value:" + queryString);

            pipe = new GremlinPipeline<Graph, Vertex>(hitVs);

            List<Vertex> vertices = new ArrayList<Vertex>();

            pipe.in(RdfSchema.EUNIS_SPECIES.property("binomialName")).fill(vertices);

            updateQueriesWithResponse(vertices, null, null, checklistInfo, query);

            profiler.end(System.err);

        }

    }

    @Override

    public void resolveScientificNamesLike(TnrMsg tnrMsg) throws DRFChecklistException {

        // delegate to resolveScientificNamesExact,

        resolveScientificNamesExact(tnrMsg);

    }

    @Override

    public void resolveVernacularNamesExact(TnrMsg tnrMsg) throws DRFChecklistException {

        List<Query> queryList = tnrMsg.getQuery();

        for (ServiceProviderInfo checklistInfo : getServiceProviderInfo().getSubChecklists()) {

            // FIXME query specific subchecklist

            // selecting one request as representative, only

            // the search mode and addSynonmy flag are important

            // for the further usage of the request object

            Query query = singleQueryFrom(tnrMsg);

            String queryString = query.getRequest().getQueryString();

            logger.debug("original queryString: "+ queryString);

            queryString = QueryParser.escape(queryString);

            queryString = queryString.replace(" ", "\\ ");

            if(query.getRequest().getSearchMode().equals(SearchMode.vernacularNameLike.name())) {

                queryString = "*" + queryString + "*";

            }

            logger.debug("prepared queryString: "+ queryString);

            GremlinPipeline<Graph, Vertex> pipe = null;

            Profiler profiler = Profiler.newCpuProfiler(false);

            // by using the Neo4j index directly it is possible to

            // take full advantage of the underlying Lucene search engine

            ArrayList<Vertex> hitVs = queryClient.vertexIndexQuery("value:" + queryString);

//            List<String> matchingNames = new ArrayList<String>(hitVs.size());

//            for(Vertex v : hitVs) {

//                String matchValue = v.getProperty(GraphSail.VALUE).toString();

//                matchingNames.add(matchValue);

//                logger.debug("matchingName  " + matchValue);

//            }

            List<Vertex> vertices = new ArrayList<Vertex>();

            pipe = new GremlinPipeline<Graph, Vertex>(hitVs);

            Table table = new Table();

            pipe.as("match").in(RdfSchema.DWC.property("vernacularName")).as("taxon").table(table).iterate();

            updateQueriesWithResponse(

                    table.getColumn("taxon"), table.getColumn("match"),

                    NameType.VERNACULAR_NAME, checklistInfo, query);

            profiler.end(System.err);

        }

    }

    @Override

    public void resolveVernacularNamesLike(TnrMsg tnrMsg) throws DRFChecklistException {

        resolveVernacularNamesExact(tnrMsg);

    }

    @Override

    public void findByIdentifier(TnrMsg tnrMsg) throws DRFChecklistException {

        for (ServiceProviderInfo checklistInfo : getServiceProviderInfo().getSubChecklists()) {

            // FIXME query specific subchecklist

            Query query = singleQueryFrom(tnrMsg);

            String queryString = query.getRequest().getQueryString();

            // by using the Neo4j index directly it is possible to

            // take full advantage of the underlying Lucene search engine

            queryString = QueryParser.escape(queryString);

            ArrayList<Vertex> hitVs = queryClient.vertexIndexQuery("value:" + queryString);

            if(hitVs.size() > 0) {

                Response response = tnrResponseFromResource(hitVs.get(0), query.getRequest(), null, null);

                query.getResponse().add(response);

            } else if(hitVs.size() > 1) {

                throw new DRFChecklistException("More than one node with the id '" + queryString + "' found");

            }

        }

    }

    private void updateQueriesWithResponse(List<Vertex> taxonNodes, List<Vertex> matchNodes, NameType matchType, ServiceProviderInfo ci, Query query){

        if (taxonNodes == null) {

            return;

        }

        logger.debug("matching taxon nodes:");

        int i = -1;

        for (Vertex v : taxonNodes) {

            i++;

            logger.debug("  " + v.toString());

            printPropertyKeys(v, System.err);

            if(v.getProperty("kind").equals("url")) {

                logger.error("vertex of type 'url' expected, but was " + v.getProperty("type").equals("url"));

                continue;

            }

            Vertex matchNode = null;

            if(matchNodes != null) {

                matchNode = matchNodes.get(i);

            }

            Response tnrResponse = tnrResponseFromResource(v, query.getRequest(), matchNode, matchType);

            if(tnrResponse != null) {

                query.getResponse().add(tnrResponse);

            }

        }

    }

    /**

     * @param model

     * @param taxonR

     * @param request

     * @param matchType

     * @param matchNode

     * @return

     */

    private Response tnrResponseFromResource(Vertex taxonV, Request request, Vertex matchNode, NameType matchType) {

        Response tnrResponse = TnrMsgUtils.tnrResponseFor(getServiceProviderInfo());

        GremlinPipeline<Graph, Vertex> pipe = new GremlinPipeline<Graph, Vertex>(taxonV);

        String validName = queryClient.relatedVertexValue(taxonV, RdfSchema.EUNIS_SPECIES, "validName");

        boolean isAccepted = validName != null && validName.equals("true");

        logger.debug("processing " + (isAccepted ? "accepted taxon" : "synonym or other")  + " " + taxonV.getId());

        //

        if(matchNode != null) {

            String matchingName = matchNode.getProperty(GraphSail.VALUE).toString();

            tnrResponse.setMatchingNameString(matchingName);

            tnrResponse.setMatchingNameType(matchType);

        }

        // case when accepted name

        if(isAccepted) {

            Taxon taxon = createTaxon(taxonV);

            tnrResponse.setTaxon(taxon);

            if(matchNode == null) {

                tnrResponse.setMatchingNameType(NameType.TAXON);

                String matchingName = taxon.getTaxonName().getCanonicalName();

                tnrResponse.setMatchingNameString(matchingName);

            }

        }

        else {

            // case when synonym

            Vertex synonymV = taxonV;

            taxonV = null;

            try {

                taxonV = queryClient.relatedVertex(synonymV, RdfSchema.EUNIS_SPECIES, "eunisPrimaryName");

            } catch(Exception e) {

                logger.error("No accepted taxon found for " + synonymV.toString() + " (" + synonymV.getProperty(GraphSail.VALUE) + ")");

            }

            if(taxonV != null) {

                Taxon taxon = createTaxon(taxonV);

                tnrResponse.setTaxon(taxon);

            } else {

            }

            if(matchNode == null) {

                tnrResponse.setMatchingNameType(NameType.SYNONYM);

                String matchingName = queryClient.relatedVertexValue(synonymV, RdfSchema.EUNIS_SPECIES, "binomialName");

                tnrResponse.setMatchingNameString(matchingName);

            }

        }

        if(request.isAddSynonymy()) {

            createSynonyms(taxonV, tnrResponse);

        }

        logger.debug("processing " + (isAccepted ? "accepted taxon" : "synonym or other")  + " " + taxonV.getId() + " DONE");

        return tnrResponse;

    }

    /**

     * @param vertex

     */

    private void printEdges(Neo4j2Vertex vertex) {

        Iterable<Relationship> rels = vertex.getRawVertex().getRelationships();

        Iterator<Relationship> iterator = rels.iterator();

        if(iterator.hasNext()) {

            Relationship rel = iterator.next();

            System.err.println(rel.toString() + ": " + rel.getStartNode().toString() + "-[" +  rel.getType() + "]-" + rel.getEndNode().toString());

        }

    }

    private void printPropertyKeys(Vertex v, PrintStream ps) {

        StringBuilder out = new StringBuilder();

        out.append(v.toString());

        for(String key : v.getPropertyKeys()) {

            out.append(key).append(": ").append(v.getProperty(key)).append(" ");

        }

        ps.println(out.toString());

    }

    @Override

    public EnumSet<SearchMode> getSearchModes() {

        return SEARCH_MODES;

    }

    @Override

    public boolean isSupportedIdentifier(String value) {

        return IdentifierUtils.checkURI(value);

    }

}

package org.bgbm.biovel.drf.checklist;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import org.apache.http.HttpHost;

import org.apache.http.client.utils.URIBuilder;

import org.bgbm.biovel.drf.client.ServiceProviderInfo;

import org.bgbm.biovel.drf.query.RestClient;

import org.bgbm.biovel.drf.tnr.msg.Classification;

import org.bgbm.biovel.drf.tnr.msg.Query;

import org.bgbm.biovel.drf.tnr.msg.Response;

import org.bgbm.biovel.drf.tnr.msg.Source;

import org.bgbm.biovel.drf.tnr.msg.Synonym;

import org.bgbm.biovel.drf.tnr.msg.Taxon;

import org.bgbm.biovel.drf.tnr.msg.TaxonName;

import org.bgbm.biovel.drf.tnr.msg.TnrMsg;

import org.bgbm.biovel.drf.utils.JSONUtils;

import org.bgbm.biovel.drf.utils.TnrMsgUtils;

import org.json.simple.JSONArray;

import org.json.simple.JSONObject;

public class GBIFBackboneClient extends AggregateChecklistClient<RestClient> {

    /**

     *

     */

    private static final HttpHost HTTP_HOST = new HttpHost("api.gbif.org",80);

    public static final String ID = "gbif";

    public static final String LABEL = "GBIF Checklist Bank";

    public static final String URL = "http://uat.gbif.org/developer/species";

    public static final String DATA_AGR_URL = "http://data.gbif.org/tutorial/datauseagreement";

    private static final String MAX_PAGING_LIMIT = "1000";

    private static final String VERSION = "v1";

    public static final ServiceProviderInfo CINFO = new ServiceProviderInfo(ID,LABEL,ServiceProviderInfo.DEFAULT_SEARCH_MODE,URL,DATA_AGR_URL, VERSION);

    public static final EnumSet<SearchMode> SEARCH_MODES = EnumSet.of(SearchMode.scientificNameExact);