mEDRA DOI fetcher implementation.

CHANGELOG.md

@@ -11,6 +11,7 @@ Note that this project **does not** adhere to [Semantic Versioning](http://semve
 
 ### Added
 
+- We added a new fetcher to enable users to search mEDRA DOIs [#6602](https://github.com/JabRef/jabref/issues/6602)
 - We added support for importing ris file and load DOI [#6530](https://github.com/JabRef/jabref/issues/6530)
 - We added the Library properties to a context menu on the library tabs [#6485](https://github.com/JabRef/jabref/issues/6485)
 - We added a new field in the preferences in 'BibTeX key generator' for unwanted characters that can be user-specified. [#6295](https://github.com/JabRef/jabref/issues/6295)

src/main/java/org/jabref/logic/importer/WebFetchers.java

@@ -28,6 +28,7 @@
 import org.jabref.logic.importer.fetcher.LibraryOfCongress;
 import org.jabref.logic.importer.fetcher.MathSciNet;
 import org.jabref.logic.importer.fetcher.MedlineFetcher;
+import org.jabref.logic.importer.fetcher.Medra;
 import org.jabref.logic.importer.fetcher.OpenAccessDoi;
 import org.jabref.logic.importer.fetcher.RfcFetcher;
 import org.jabref.logic.importer.fetcher.ScienceDirect;
@@ -121,6 +122,7 @@ public static SortedSet<IdBasedFetcher> getIdBasedFetchers(ImportFormatPreferenc
         set.add(new LibraryOfCongress(importFormatPreferences));
         set.add(new IacrEprintFetcher(importFormatPreferences));
         set.add(new RfcFetcher(importFormatPreferences));
+        set.add(new Medra());
         return set;
     }
 

src/main/java/org/jabref/logic/importer/fetcher/DoiFetcher.java

@@ -25,6 +25,10 @@
 import org.jabref.model.util.DummyFileUpdateMonitor;
 import org.jabref.model.util.OptionalUtil;
 
+import kong.unirest.json.JSONArray;
+import kong.unirest.json.JSONException;
+import kong.unirest.json.JSONObject;
+
 public class DoiFetcher implements IdBasedFetcher, EntryBasedFetcher {
     public static final String NAME = "DOI";
 
@@ -47,18 +51,28 @@ public Optional<HelpFile> getHelpPage() {
     @Override
     public Optional<BibEntry> performSearchById(String identifier) throws FetcherException {
         Optional<DOI> doi = DOI.parse(identifier);
+        String agency = "";
         try {
             if (doi.isPresent()) {
-                URL doiURL = new URL(doi.get().getURIAsASCIIString());
+                Optional<BibEntry> fetchedEntry;
+
+                // mEDRA does not return a parsable bibtex string
+                if (getAgency(doi.get()).isPresent() && "medra".equalsIgnoreCase(getAgency(doi.get()).get())) {
+                    fetchedEntry = new Medra().performSearchById(identifier);
+
+                } else {
+                    URL doiURL = new URL(doi.get().getURIAsASCIIString());
 
-                // BibTeX data
-                URLDownload download = new URLDownload(doiURL);
-                download.addHeader("Accept", MediaTypes.APPLICATION_BIBTEX);
-                String bibtexString = download.asString();
+                    // BibTeX data
+                    URLDownload download = new URLDownload(doiURL);
+                    download.addHeader("Accept", MediaTypes.APPLICATION_BIBTEX);
+                    String bibtexString = download.asString();
+
+                    // BibTeX entry
+                    fetchedEntry = BibtexParser.singleFromString(bibtexString, preferences, new DummyFileUpdateMonitor());
+                    fetchedEntry.ifPresent(this::doPostCleanup);
+                }
 
-                // BibTeX entry
-                Optional<BibEntry> fetchedEntry = BibtexParser.singleFromString(bibtexString, preferences, new DummyFileUpdateMonitor());
-                fetchedEntry.ifPresent(this::doPostCleanup);
                 return fetchedEntry;
             } else {
                 throw new FetcherException(Localization.lang("Invalid DOI: '%0'.", identifier));
@@ -67,6 +81,8 @@ public Optional<BibEntry> performSearchById(String identifier) throws FetcherExc
             throw new FetcherException(Localization.lang("Connection error"), e);
         } catch (ParseException e) {
             throw new FetcherException("Could not parse BibTeX entry", e);
+        } catch (JSONException e) {
+            throw new FetcherException("Could not retrieve Registration Agency", e);
         }
     }
 
@@ -84,4 +100,23 @@ public List<BibEntry> performSearch(BibEntry entry) throws FetcherException {
             return Collections.emptyList();
         }
     }
+
+    /**
+     * Returns registration agency. Null if no agency is found.
+     *
+     * @param doi the doi to be searched
+     * @throws JSONException
+     * @throws IOException
+     */
+    public Optional<String> getAgency(DOI doi) throws JSONException, IOException {
+        Optional<String> agency = Optional.empty();
+        URLDownload download = new URLDownload(DOI.AGENCY_RESOLVER + "/" + doi.getDOI());
+        JSONObject response = new JSONArray(download.asString()).getJSONObject(0);
+
+        if (response != null) {
+            agency = Optional.ofNullable(response.optString("RA"));
+        }
+
+        return agency;
+    }
 }

src/main/java/org/jabref/logic/importer/fetcher/Medra.java

@@ -0,0 +1,182 @@
+package org.jabref.logic.importer.fetcher;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.jabref.logic.importer.FetcherException;
+import org.jabref.logic.importer.IdBasedParserFetcher;
+import org.jabref.logic.importer.ParseException;
+import org.jabref.logic.importer.Parser;
+import org.jabref.logic.importer.SearchBasedParserFetcher;
+import org.jabref.logic.importer.util.JsonReader;
+import org.jabref.logic.importer.util.MediaTypes;
+import org.jabref.logic.net.URLDownload;
+import org.jabref.model.entry.AuthorList;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.types.EntryType;
+import org.jabref.model.entry.types.StandardEntryType;
+import kong.unirest.json.JSONArray;
+import kong.unirest.json.JSONException;
+import kong.unirest.json.JSONObject;
+import org.apache.http.client.utils.URIBuilder;
+
+/**
+ * A class for fetching DOIs from Medra
+ *
+ * @see <a href="https://data.medra.org">mEDRA Content Negotiation API</a> for an overview of the API
+ * <p>
+ * It requires "Accept" request Header attribute to be set to desired content-type.
+ */
+public class Medra implements SearchBasedParserFetcher, IdBasedParserFetcher {
+
+    public static final String API_URL = "https://data.medra.org";
+
+    @Override
+    public String getName() {
+        return "mEDRA";
+    }
+
+    @Override
+    public Parser getParser() {
+        return inputStream -> {
+            JSONObject response = JsonReader.toJsonObject(inputStream);
+
+            List<BibEntry> entries = new ArrayList<>();
+            BibEntry entry = jsonItemToBibEntry(response);
+            entries.add(entry);
+
+            return entries;
+        };
+    }
+
+    private BibEntry jsonItemToBibEntry(JSONObject item) throws ParseException {
+        try {
+            BibEntry entry = new BibEntry();
+            entry.setType(convertType(item.getString("type")));
+            entry.setField(StandardField.TITLE, item.getString("title"));
+            entry.setField(StandardField.AUTHOR, toAuthors(item.optJSONArray("author")));
+            entry.setField(StandardField.YEAR,
+                           Optional.ofNullable(item.optJSONObject("issued"))
+                                   .map(array -> array.optJSONArray("date-parts"))
+                                   .map(array -> array.optJSONArray(0))
+                                   .map(array -> array.optInt(0))
+                                   .map(year -> Integer.toString(year)).orElse(""));
+            entry.setField(StandardField.DOI, item.getString("DOI"));
+            entry.setField(StandardField.PAGES, item.optString("page"));
+            entry.setField(StandardField.ISSN, item.optString("ISSN"));
+            entry.setField(StandardField.JOURNAL, item.optString("container-title"));
+            entry.setField(StandardField.PUBLISHER, item.optString("publisher"));
+            entry.setField(StandardField.URL, item.optString("URL"));
+            entry.setField(StandardField.VOLUME, item.optString("volume"));
+            return entry;
+        } catch (JSONException exception) {
+            throw new ParseException("mEdRA API JSON format has changed", exception);
+        }
+    }
+
+    private EntryType convertType(String type) {
+        switch (type) {
+            case "article-journal":
+                return StandardEntryType.Article;
+            default:
+                return StandardEntryType.Misc;
+        }
+    }
+
+    private String toAuthors(JSONArray authors) {
+        if (authors == null) {
+            return "";
+        }
+
+        // input: list of {"literal":"A."}
+        AuthorList authorsParsed = new AuthorList();
+        String name = "";
+
+        for (int i = 0; i < authors.length(); i++) {
+            JSONObject author = authors.getJSONObject(i);
+            if (author.has("literal")) {
+                name = author.optString("literal", "");
+            } else {
+                name = author.optString("family", "") + " " + author.optString("given", "");
+            }
+
+            authorsParsed.addAuthor(
+                                    name,
+                                    "",
+                                    "",
+                                    "",
+                                    "");
+
+        }
+        return authorsParsed.getAsFirstLastNamesWithAnd();
+    }
+
+    @Override
+    public Optional<BibEntry> performSearchById(String identifier) throws FetcherException {
+
+        try (InputStream stream = getUrlDownload(identifier).asInputStream();
+             PushbackInputStream pushbackInputStream = new PushbackInputStream(stream)) {
+
+            List<BibEntry> fetchedEntries = new ArrayList<>();
+
+            // check if there is anything to read since mEDRA '404 not found' returns nothing
+            int readByte;
+            readByte = pushbackInputStream.read();
+            if (readByte != -1) {
+                pushbackInputStream.unread(readByte);
+                fetchedEntries = getParser().parseEntries(pushbackInputStream);
+            }
+
+            if (fetchedEntries.isEmpty()) {
+                return Optional.empty();
+            }
+
+            BibEntry entry = fetchedEntries.get(0);
+
+            // Post-cleanup
+            doPostCleanup(entry);
+
+            return Optional.of(entry);
+        } catch (URISyntaxException e) {
+            throw new FetcherException("Search URI is malformed", e);
+        } catch (IOException e) {
+            // TODO: Catch HTTP Response 401 errors and report that user has no rights to access resource. It might be that there is an UnknownHostException (eutils.ncbi.nlm.nih.gov cannot be resolved).
+            throw new FetcherException("A network error occurred", e);
+        } catch (ParseException e) {
+            throw new FetcherException("An internal parser error occurred", e);
+        }
+    }
+
+    @Override
+    public void doPostCleanup(BibEntry entry) {
+        IdBasedParserFetcher.super.doPostCleanup(entry);
+    }
+
+    @Override
+    public URL getURLForQuery(String query) throws URISyntaxException, MalformedURLException, FetcherException {
+        URIBuilder uriBuilder = new URIBuilder(API_URL + "/" + query);
+        return uriBuilder.build().toURL();
+    }
+
+    @Override
+    public URLDownload getUrlDownload(String identifier) throws MalformedURLException, FetcherException, URISyntaxException {
+        URLDownload download = new URLDownload(getURLForID(identifier));
+        download.addHeader("Accept", MediaTypes.APPLICATION_JSON);
+        return download;
+    }
+
+    @Override
+    public URL getURLForID(String identifier) throws URISyntaxException, MalformedURLException, FetcherException {
+        URIBuilder uriBuilder = new URIBuilder(API_URL + "/" + identifier);
+        return uriBuilder.build().toURL();
+    }
+
+}

src/main/java/org/jabref/logic/importer/util/MediaTypes.java

@@ -5,4 +5,5 @@
  */
 public class MediaTypes {
     public static final String APPLICATION_BIBTEX = "application/x-bibtex";
+    public static final String APPLICATION_JSON = "application/vnd.citationstyles.csl+json";
 }

src/main/java/org/jabref/model/entry/identifier/DOI.java

@@ -23,6 +23,7 @@ public class DOI implements Identifier {
 
     // DOI/Short DOI resolver
     private static final URI RESOLVER = URI.create("https://doi.org");
+    public static final URI AGENCY_RESOLVER = URI.create("https://doi.org/doiRA");
     // Regex
     // (see http://www.doi.org/doi_handbook/2_Numbering.html)
     private static final String DOI_EXP = ""
@@ -238,7 +239,7 @@ public boolean equals(Object o) {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if ((o == null) || (getClass() != o.getClass())) {
             return false;
         }
         DOI other = (DOI) o;
@@ -249,4 +250,5 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(doi.toLowerCase(Locale.ENGLISH));
     }
+
 }