re-use gbif taxonomic hierarchy inferences; #137

globalbioticinteractions · Dec 19, 2022 · 212dd6e · 212dd6e
1 parent 0d43c3d
commit 212dd6e
Show file tree

Hide file tree

Showing 2 changed files with 83 additions and 0 deletions.
diff --git a/nomer/src/main/java/org/globalbioticinteractions/nomer/match/ParserServiceGBIF.java b/nomer/src/main/java/org/globalbioticinteractions/nomer/match/ParserServiceGBIF.java
@@ -1,5 +1,7 @@
 package org.globalbioticinteractions.nomer.match;
 
+import org.apache.commons.lang3.StringUtils;
+import org.eol.globi.data.CharsetConstant;
 import org.eol.globi.domain.Taxon;
 import org.eol.globi.domain.TaxonImpl;
 import org.eol.globi.domain.Term;
@@ -10,6 +12,9 @@
 import org.gbif.nameparser.api.Rank;
 import org.gbif.nameparser.api.UnparsableNameException;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class ParserServiceGBIF extends ParserServiceAbstract {
 
     private final NameParser parser = new NameParserGBIF();
@@ -21,6 +26,47 @@ public Taxon parse(Term term, String nameString) throws PropertyEnricherExceptio
             Taxon taxonParsed = new TaxonImpl();
             taxonParsed.setName(nameParsed.canonicalNameWithoutAuthorship());
             taxonParsed.setAuthorship(nameParsed.authorshipComplete());
+            if (!nameParsed.getRank().isAmbiguous()) {
+                taxonParsed.setRank(StringUtils.lowerCase(nameParsed.getRank().toString()));
+                List<String> path  = new ArrayList<>();
+                List<String> pathNames  = new ArrayList<>();
+                String genus = nameParsed.getGenus();
+                if (StringUtils.isNotBlank(genus)) {
+                    path.add(genus);
+                    pathNames.add("genus");
+                }
+
+                String infragenericEpithet = nameParsed.getInfragenericEpithet();
+                if (StringUtils.isNotBlank(infragenericEpithet)) {
+                    path.add(infragenericEpithet);
+                    pathNames.add("infragenericEpithet");
+                }
+
+                String specificEpithet = nameParsed.getSpecificEpithet();
+                if (StringUtils.isNotBlank(specificEpithet)) {
+                    path.add(specificEpithet);
+                    pathNames.add("specificEpithet");
+                }
+
+                String infraspecificEpithet = nameParsed.getInfraspecificEpithet();
+                if (StringUtils.isNotBlank(infraspecificEpithet)) {
+                    path.add(infraspecificEpithet);
+                    pathNames.add("infraspecificEpithet");
+                }
+
+                String pathString = StringUtils.join(path, CharsetConstant.SEPARATOR);
+                if (StringUtils.isNotBlank(pathString)) {
+                    taxonParsed.setPath(pathString);
+                }
+
+                String pathNamesString = StringUtils.join(pathNames, CharsetConstant.SEPARATOR);
+                if (StringUtils.isNotBlank(pathNamesString)) {
+                    taxonParsed.setPathNames(pathNamesString);
+                }
+
+            }
+
+
             return taxonParsed;
         } catch (UnparsableNameException e) {
             throw new PropertyEnricherException("failed to parse [" + term.getName() + "]", e);

diff --git a/nomer/src/test/java/org/globalbioticinteractions/nomer/match/ParserServiceGBIFTest.java b/nomer/src/test/java/org/globalbioticinteractions/nomer/match/ParserServiceGBIFTest.java
@@ -1,5 +1,20 @@
 package org.globalbioticinteractions.nomer.match;
 
+import org.eol.globi.domain.NameType;
+import org.eol.globi.domain.Taxon;
+import org.eol.globi.domain.Term;
+import org.eol.globi.domain.TermImpl;
+import org.eol.globi.service.PropertyEnricherException;
+import org.eol.globi.taxon.TermMatchListener;
+import org.hamcrest.core.Is;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+
 public class ParserServiceGBIFTest extends ParserServiceTestAbstract {
 
     @Override
@@ -8,5 +23,27 @@ protected ParserServiceAbstract getParserService() {
     }
 
 
+    @Test
+    public void nameWithSubgenusAndAuthorship() throws PropertyEnricherException {
+
+        AtomicBoolean foundMatch = new AtomicBoolean(false);
+        getParserService().match(Arrays.asList(new TermImpl("someId", "Andrena (Aenandrena) aeneiventris Morawitz, 1872")), new TermMatchListener() {
+            @Override
+            public void foundTaxonForTerm(Long aLong, Term term, NameType nameType, Taxon taxon) {
+                assertThat(nameType, Is.is(NameType.SAME_AS));
+                assertThat(term.getName(), Is.is("Andrena (Aenandrena) aeneiventris Morawitz, 1872"));
+                assertThat(taxon.getName(), Is.is("Andrena aeneiventris"));
+                assertThat(taxon.getAuthorship(), Is.is("Morawitz, 1872"));
+                assertThat(taxon.getRank(), Is.is("species"));
+                assertThat(taxon.getPath(), Is.is("Andrena | Aenandrena | aeneiventris"));
+                assertThat(taxon.getPathNames(), Is.is("genus | infragenericEpithet | specificEpithet"));
+                foundMatch.set(true);
+            }
+        });
+
+        assertTrue(foundMatch.get());
+    }
+
+
 
 }