diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/AuthorAssoc.java b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/AuthorAssoc.java new file mode 100644 index 000000000..807567fba --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/AuthorAssoc.java @@ -0,0 +1,47 @@ +package eu.dnetlib.doiboost; + +import eu.dnetlib.dhp.schema.oaf.Author; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +public class AuthorAssoc implements Serializable { + private Double score ; + private List to_be_enriched; + private Author with_enricheing_content; + + public Double getScore() { + return score; + } + + public void setScore(Double score) { + this.score = score; + } + + public List getTo_be_enriched() { + return to_be_enriched; + } + + public void setTo_be_enriched(List to_be_enriched) { + this.to_be_enriched = to_be_enriched; + } + + public Author getWith_enricheing_content() { + return with_enricheing_content; + } + + public void setWith_enricheing_content(Author with_enricheing_content) { + this.with_enricheing_content = with_enricheing_content; + } + + public static AuthorAssoc newInstance(Author a){ + AuthorAssoc ret = new AuthorAssoc(); + ret.score = 0.0; + ret.to_be_enriched = new ArrayList<>(); + ret.with_enricheing_content = a; + + return ret; + + } +} diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/DoiBoostAuthorMerger.java b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/DoiBoostAuthorMerger.java new file mode 100644 index 000000000..b5bb25ec1 --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/DoiBoostAuthorMerger.java @@ -0,0 +1,236 @@ + +package eu.dnetlib.doiboost; + +import java.text.Normalizer; +import java.util.*; +import java.util.stream.Collectors; + +import eu.dnetlib.dhp.schema.oaf.Result; +import eu.dnetlib.dhp.utils.DHPUtils; + +import com.wcohen.ss.JaroWinkler; + +import eu.dnetlib.dhp.schema.oaf.Author; +import eu.dnetlib.dhp.schema.oaf.StructuredProperty; + +import scala.Tuple2; + +/** + * This is a version of the AuthorMerger specific for DoiBoost. + * Here we suppose a match must exist for the authors. We compare via JaroWrinkler similarity measure each author in the list + * that should be enriched with each author in the enriching list. For each enriching author we select the best match that is + * the author with the highest similarity score. + * The association is done from the enriching author to the enriched because in this way only one match per enriching author can be found + * One enriching author can have the same maximum similarity score with more than one + * + * + * + * + * The idea is to enrich the most similar authors having at least one + * word of the name in + * common + * Quello che faccio e’ abbastanza semplice: ho una struttura dati che mantine l’informazione di associazione fra il record che puo’ possibilmente arricchire e quello che deve essere arricchito. + * 6:22 + * Questa struttura ha la lista di autori che possono essere arricchiti, l’autore che arricchisce e lo score di similarita fra l’autore che arricchisce e gli autori arricchiti. E’ il valore di una mappa che per chiave la il fullname dell’autore che arricchisce + * 6:23 + * per ogni autore che puo’ essere arricchito verifico se la entri nella mappa di quello che arricchisce e’ associata ad un autore con score di similarita’ piu’ basso. Se cosi’ e’ modifico l’associazione nella mappa per l’autore che arricchisce, sostituendo l’autore arricchito a cui era associato prima con quello nuovo che ha score piu’ alto. Se lo score e’ lo stesso, aggiungo il nuovo autore da arricchire alla lista degli autori associata all’autore che arricchisce + * 6:25 + * Alla fine caso facile: ogni entry e’ associata ad un unico autore da arricchire => verifico che almeno una delle parole che sono nei due nomi sia in comune fra i due insiemi Se e’ cosi’, aggiungo i pid mancanti all’autore da arricchire dell’autore che arricchisce + * 6:26 + * caso brutto: ci sono piu’ autori da arricchire con la stessa similarita: arricchisco quello che ha il maggior numero di parole del fullname uguali a quelle dell’autore che arricchisce. In caso di parita’ non si arricchisce + * 6:28 + * ricordiamoci che si parte dal presupposto che un match debba esistere visto che abbiamo lo stesso doi + * 6:29 + * di conseguenza l’autore che ha lo score di similarita’ piu’ alto fra quelli presenti ed anche una parola in comune del nome dovrebbe essere sufficiente per poterlo arricchire. + * 6:30 + * I casi di omonimia che potrebbero portare problemi con i rank degli autori non si mappano + */ + +public class DoiBoostAuthorMerger { + + + public static List merge(List> authors, Boolean crossref) { + + Iterator> it = authors.iterator(); + List author = it.next(); + + while (it.hasNext()){ + List autList = it.next(); + Tuple2, Boolean> tmp = mergeAuthor(author, autList, crossref); + author = tmp._1(); + crossref = tmp._2(); + } + + return author; + + } + + public static Tuple2, Boolean> mergeAuthor(final List baseAuthor, final List otherAuthor, + final Boolean crossref) { + + if(baseAuthor == null || baseAuthor.size() == 0) + return new Tuple2<>(otherAuthor, false); + if(otherAuthor == null || otherAuthor.size() == 0) + return new Tuple2<>(baseAuthor, crossref); + + if(crossref) { + enrichPidFromList(baseAuthor, otherAuthor); + return new Tuple2<>(baseAuthor, true); + } + else + if (baseAuthor.size() > otherAuthor.size()){ + enrichPidFromList(baseAuthor, otherAuthor); + return new Tuple2<>(baseAuthor, false); + }else{ + enrichPidFromList(otherAuthor, baseAuthor); + return new Tuple2<>(otherAuthor, false); + } + + } + + + private static void enrichPidFromList(List base, List enrich) { + + //search authors having identifiers in the enrich list + final List authorsWithPids = enrich + .stream() + .filter(a -> a.getPid() != null && a.getPid().size() > 0) + .collect(Collectors.toList()); + + Map assocMap = authorsWithPids + .stream() + .map( + a -> new Tuple2<>(DHPUtils.md5(a.getFullname()), AuthorAssoc.newInstance(a))) + .collect(Collectors.toMap(Tuple2::_1, Tuple2::_2, (x1, x2) -> x1)); + + + //for each author in the base list, we search the best enriched match + base.stream() + .map(a -> new Tuple2<>(a, authorsWithPids.stream() + .map(e -> new Tuple2<>(e, sim(a, e))).collect(Collectors.toList()))) + .forEach(t2 -> { + + for (Tuple2 t : t2._2()) { + String mapEntry = DHPUtils.md5(t._1().getFullname()); + AuthorAssoc aa = assocMap.get(mapEntry); + if(aa.getScore() < t._2() && aa.getScore() < 0.9){ + aa.setScore(t._2()); + aa.setTo_be_enriched(new ArrayList<>()); + aa.getTo_be_enriched().add(t2._1()); + }else if(t._2() > 0.9){ + aa.getTo_be_enriched().add(t2._1()); + } + } + + }); + + assocMap.keySet().forEach(k -> enrichAuthor(assocMap.get(k))); + + + } + + private static long getCommonWords(List fullEnrich, List fullEnriching){ + return fullEnrich.stream().filter( w -> fullEnriching.contains(w)).count(); + } + + + private static void enrichAuthor(Author enrich, Author enriching){ + //verify if some of the words in the fullname are contained in the other + //get normalized fullname + + long commonWords = getCommonWords(normalize(enrich.getFullname()), + normalize(enriching.getFullname())); + if(commonWords > 0 ){ + if(enrich.getPid() == null){ + enrich.setPid(new ArrayList<>()); + } + Set aPids = enrich.getPid().stream().map(p -> pidToComparableString(p)).collect(Collectors.toSet()); + enriching.getPid().forEach(p -> { + if (!aPids.contains(pidToComparableString(p))){ + enrich.getPid().add(p); + } + }); + if (enrich.getAffiliation() == null){ + if (enriching.getAffiliation() != null){ + enrich.setAffiliation(enriching.getAffiliation()); + } + } + } + + + } + + //Verify the number of words in common. The one that has more, wins. If the number of words in common are the same we + //enrich no author + private static void enrichAuthor(AuthorAssoc authorAssoc) { + if (authorAssoc.getTo_be_enriched().size() == 1){ + enrichAuthor(authorAssoc.getTo_be_enriched().get(0), authorAssoc.getWith_enricheing_content()); + }else{ + long common = 0; + List selected = new ArrayList<>() ; + for(Author a : authorAssoc.getTo_be_enriched()){ + long current_common = getCommonWords(normalize(a.getFullname()), + normalize(authorAssoc.getWith_enricheing_content().getFullname())); + if (current_common > common){ + common = current_common; + selected = new ArrayList<>(); + selected.add(a); + }else if(current_common == common){ + selected.add(a); + } + } + if (selected.size() == 1){ + enrichAuthor(selected.get(0), authorAssoc.getWith_enricheing_content()); + } + } + + } + + + public static String pidToComparableString(StructuredProperty pid) { + return (pid.getQualifier() != null + ? pid.getQualifier().getClassid() != null ? pid.getQualifier().getClassid().toLowerCase() : "" + : "") + + (pid.getValue() != null ? pid.getValue().toLowerCase() : ""); + } + + + + + private static Double sim(Author a, Author b) { + return new JaroWinkler() + .score(normalizeString(a.getFullname()), normalizeString(b.getFullname())); + + } + + private static String normalizeString(String fullname) { + return String.join(" ", normalize(fullname)); + } + + + private static List normalize(final String s) { + String[] normalized = nfd(s) + .replaceAll("[^\\p{ASCII}]", "") + .toLowerCase() + // do not compact the regexes in a single expression, would cause StackOverflowError + // in case + // of large input strings + .replaceAll("(\\W)+", " ") + .replaceAll("(\\p{InCombiningDiacriticalMarks})+", " ") + .replaceAll("(\\p{Punct})+", " ") + .replaceAll("(\\d)+", " ") + .replaceAll("(\\n)+", " ") + .trim() + .split(" "); + + Arrays.sort(normalized); + + return Arrays.asList(normalized); + + + } + + private static String nfd(final String s) { + return Normalizer.normalize(s, Normalizer.Form.NFD); + } +} diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkGenerateDoiBoost.scala b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkGenerateDoiBoost.scala index b77de13b9..8bab0b7e1 100644 --- a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkGenerateDoiBoost.scala +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkGenerateDoiBoost.scala @@ -3,7 +3,7 @@ package eu.dnetlib.doiboost import eu.dnetlib.dhp.application.ArgumentApplicationParser import eu.dnetlib.dhp.oa.merge.AuthorMerger import eu.dnetlib.dhp.schema.common.ModelConstants -import eu.dnetlib.dhp.schema.oaf.{Organization, Publication, Relation, Dataset => OafDataset} +import eu.dnetlib.dhp.schema.oaf.{Author, Organization, Publication, Relation, Dataset => OafDataset} import eu.dnetlib.doiboost.mag.ConversionUtil import org.apache.commons.io.IOUtils import org.apache.spark.SparkConf @@ -25,6 +25,7 @@ object SparkGenerateDoiBoost { val conf: SparkConf = new SparkConf() val parser = new ArgumentApplicationParser(IOUtils.toString(getClass.getResourceAsStream("/eu/dnetlib/dhp/doiboost/generate_doiboost_params.json"))) parser.parseArgument(args) + var crossref : Boolean = true val spark: SparkSession = SparkSession .builder() @@ -52,8 +53,8 @@ object SparkGenerateDoiBoost { if (a != null && a._2 != null) { b.mergeFrom(a._2) b.setId(a._1) - val authors =AuthorMerger.mergeAuthor(b.getAuthor, a._2.getAuthor) - b.setAuthor(authors) + val authors =DoiBoostAuthorMerger.mergeAuthor(b.getAuthor, a._2.getAuthor, true) + b.setAuthor(authors._1) return b } } @@ -68,8 +69,8 @@ object SparkGenerateDoiBoost { else { if (b2 != null ) { b1.mergeFrom(b2) - val authors =AuthorMerger.mergeAuthor(b1.getAuthor, b2.getAuthor) - b1.setAuthor(authors) + val authors = DoiBoostAuthorMerger.mergeAuthor(b1.getAuthor, b2.getAuthor, true) + b1.setAuthor(authors._1) if (b2.getId!= null && b2.getId.nonEmpty) b1.setId(b2.getId) return b1 @@ -104,7 +105,10 @@ object SparkGenerateDoiBoost { val otherPub = item._2._2 if (otherPub != null) { crossrefPub.mergeFrom(otherPub) - crossrefPub.setAuthor(AuthorMerger.mergeAuthor(crossrefPub.getAuthor, otherPub.getAuthor)) + val mergeRes : (java.util.List[Author], java.lang.Boolean) = DoiBoostAuthorMerger.mergeAuthor(crossrefPub.getAuthor, otherPub.getAuthor, crossref) + crossrefPub.setAuthor(mergeRes._1) + crossref = mergeRes._2 + } } crossrefPub diff --git a/dhp-workflows/dhp-doiboost/src/test/java/eu/dnetlib/dhp/doiboost/DoiBoostAuthorMergerTest.java b/dhp-workflows/dhp-doiboost/src/test/java/eu/dnetlib/dhp/doiboost/DoiBoostAuthorMergerTest.java new file mode 100644 index 000000000..5e7aa81d6 --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/test/java/eu/dnetlib/dhp/doiboost/DoiBoostAuthorMergerTest.java @@ -0,0 +1,406 @@ + +package eu.dnetlib.dhp.doiboost; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +import org.apache.neethi.Assertion; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; + +import eu.dnetlib.dhp.schema.common.ModelConstants; +import eu.dnetlib.dhp.schema.oaf.Author; +import eu.dnetlib.dhp.schema.oaf.Publication; +import eu.dnetlib.dhp.schema.oaf.StructuredProperty; +import eu.dnetlib.doiboost.DoiBoostAuthorMerger; +import eu.dnetlib.pace.util.MapDocumentUtil; +import scala.Tuple2; + +public class DoiBoostAuthorMergerTest { + + private String publicationsBasePath; + + private List> authors; + + + @BeforeEach + public void setUp() throws Exception { + + publicationsBasePath = Paths + .get(DoiBoostAuthorMergerTest.class.getResource("/eu/dnetlib/dhp/doiboost").toURI()) + .toFile() + .getAbsolutePath(); + + } + + @Test + public void mergeTestOrcid() { + + authors = readSample(publicationsBasePath + "/matching_authors_first.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + for (List authors1 : authors) { + System.out.println("List " + (authors.indexOf(authors1) + 1)); + for (Author author : authors1) { + System.out.println(authorToString(author)); + } + } + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + + Assertions.assertEquals(10, merge.size()); + + Assertions.assertEquals(3, merge.stream().filter(a -> a.getPid() != null).count()); + + merge + .stream() + .filter(a -> a.getPid() != null) + .forEach( + a -> Assertions + .assertTrue( + a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID)))); + merge.stream().filter(a -> a.getPid() != null).forEach(a -> { + try { + System.out.println(new ObjectMapper().writeValueAsString(a)); + } catch (JsonProcessingException e) { + e.printStackTrace(); + } + }); + + } + + public List> readSample(String path, Class clazz) { + List> res = new ArrayList<>(); + BufferedReader reader; + try { + reader = new BufferedReader(new FileReader(path)); + String line = reader.readLine(); + while (line != null) { + res + .add( + new Tuple2<>( + MapDocumentUtil.getJPathString("$.id", line), + new ObjectMapper().readValue(line, clazz))); + // read next line + line = reader.readLine(); + } + reader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + + return res; + } + + public String authorToString(Author a) { + + String print = "Fullname = "; + print += a.getFullname() + " pid = ["; + if (a.getPid() != null) + for (StructuredProperty sp : a.getPid()) { + print += sp.toComparableString() + " "; + } + print += "]"; + return print; + } + + @Test + public void mergeTestMAG() { + + authors = readSample(publicationsBasePath + "/matching_authors_second", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + for (List authors1 : authors) { + System.out.println("List " + (authors.indexOf(authors1) + 1)); + for (Author author : authors1) { + System.out.println(authorToString(author)); + } + } + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + + Assertions.assertEquals(10, merge.size()); + + Assertions.assertEquals(10, merge.stream().filter(a -> a.getPid() != null).count()); + + merge + .stream() + .filter(a -> a.getPid() != null) + .forEach( + a -> Assertions + .assertTrue( + a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals("URL")))); + merge.stream().filter(a -> a.getPid() != null).forEach(a -> { + try { + System.out.println(new ObjectMapper().writeValueAsString(a)); + } catch (JsonProcessingException e) { + e.printStackTrace(); + } + }); + + } + + + @Test + public void mergeTestCrossrefEmpty1() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/empty_crossref_authors_first.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + + Assertions.assertEquals(3, merge.size()); + + Assertions.assertEquals(3, merge.stream().filter(a -> a.getPid() != null).count()); + + merge + .stream() + .filter(a -> a.getPid() != null) + .forEach( + a -> Assertions + .assertTrue( + a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID)))); + merge.stream().filter(a -> a.getPid() != null).forEach(a -> { + try { + System.out.println(new ObjectMapper().writeValueAsString(a)); + } catch (JsonProcessingException e) { + e.printStackTrace(); + } + }); + + System.out.println(new ObjectMapper().writeValueAsString(merge)); + + } + + + @Test + public void mergeTestCrossrefEmpty2() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/empty_crossref_authors_second.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + + List merge = DoiBoostAuthorMerger.merge(authors, false); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + + Assertions.assertEquals(10, merge.size()); + + Assertions.assertEquals(10, merge.stream().filter(a -> a.getPid() != null).count()); + + merge + .stream() + .filter(a -> a.getPid() != null) + .forEach( + a -> Assertions + .assertTrue( + a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals("URL")))); + merge.stream().filter(a -> a.getPid() != null).forEach(a -> { + try { + System.out.println(new ObjectMapper().writeValueAsString(a)); + } catch (JsonProcessingException e) { + e.printStackTrace(); + } + }); + + Assertions.assertTrue(3 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID))).count()); + + } + + @Test + public void mergeTestCrossrefEmpty3() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/empty_crossref_author_third.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + + Assertions.assertEquals(10, merge.size()); + + Assertions.assertEquals(10, merge.stream().filter(a -> a.getPid() != null).count()); + + merge + .stream() + .filter(a -> a.getPid() != null) + .forEach( + a -> Assertions + .assertTrue( + a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals("URL")))); + + Assertions.assertTrue(3 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID))).count()); + + + } + + + @Test + public void mergeTestCrossrefEmpty4() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/empty_crossref_author_fourth.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + + Assertions.assertEquals(3, merge.size()); + + Assertions.assertEquals(3, merge.stream().filter(a -> a.getPid() != null).count()); + + + Assertions.assertTrue(3 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID))).count()); + + + } + + @Test + public void shouldMergeTest1() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/should_appear_author1.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + Assertions.assertTrue(6 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID))).count()); + + Assertions.assertTrue(34 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID_PENDING))).count()); + + merge.stream().filter(a -> a.getRank() == 26) + .forEach(a -> + Assertions.assertTrue(a.getPid() + .stream() + .anyMatch(pid -> pid.getValue().equals("0000-0002-2445-5275") + && pid.getQualifier().getClassid().equals(ModelConstants.ORCID) + ) + ) + ); + + + } + + @Test + public void shouldMergeTest2() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/should_appear_author2.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + + + Assertions.assertTrue(5 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID))).count()); + + Assertions.assertTrue(34 == merge.stream().filter(a -> a.getPid() !=null) + .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID_PENDING))).count()); + + merge.stream().filter(a -> a.getFullname().equals("da luz geraldo eduardo")) + .forEach(a -> + Assertions.assertTrue(a.getPid() + .stream() + .anyMatch(pid -> pid.getValue().equals("http://orcid.org/0000-0003-2434-0387") + && pid.getQualifier().getClassid().equals(ModelConstants.ORCID_PENDING) + ) + ) + ); + + + } + + @Test + public void shouldNotMergeTest1() throws JsonProcessingException { + + authors = readSample(publicationsBasePath + "/should_appear_author3.json", Publication.class) + .stream() + .map(p -> p._2().getAuthor()) + .collect(Collectors.toList()); + + + List merge = DoiBoostAuthorMerger.merge(authors, true); + + System.out.println("Merge "); + for (Author author : merge) { + System.out.println(authorToString(author)); + } + +// Assertions.assertTrue(5 == merge.stream().filter(a -> a.getPid() !=null) +// .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID))).count()); +// +// Assertions.assertTrue(34 == merge.stream().filter(a -> a.getPid() !=null) +// .filter(a -> a.getPid().stream().anyMatch(p -> p.getQualifier().getClassid().equals(ModelConstants.ORCID_PENDING))).count()); +// +// merge.stream().filter(a -> a.getFullname().equals("da luz geraldo eduardo")) +// .forEach(a -> +// Assertions.assertTrue(a.getPid() +// .stream() +// .anyMatch(pid -> pid.getValue().equals("http://orcid.org/0000-0003-2434-0387") +// && pid.getQualifier().getClassid().equals(ModelConstants.ORCID_PENDING) +// ) +// ) +// ); + + + } +}