diff --git a/orcid-core/src/main/java/org/orcid/core/common/manager/EmailDomainManager.java b/orcid-core/src/main/java/org/orcid/core/common/manager/EmailDomainManager.java index b6c7e310adb..167e25e2d2f 100644 --- a/orcid-core/src/main/java/org/orcid/core/common/manager/EmailDomainManager.java +++ b/orcid-core/src/main/java/org/orcid/core/common/manager/EmailDomainManager.java @@ -2,14 +2,17 @@ import java.util.List; +import org.orcid.core.common.manager.impl.EmailDomainManagerImpl.STATUS; import org.orcid.persistence.jpa.entities.EmailDomainEntity; public interface EmailDomainManager { EmailDomainEntity createEmailDomain(String emailDomain, EmailDomainEntity.DomainCategory category); - + boolean updateCategory(long id, EmailDomainEntity.DomainCategory category); EmailDomainEntity findByEmailDoman(String emailDomain); List findByCategory(EmailDomainEntity.DomainCategory category); + + STATUS createOrUpdateEmailDomain(String emailDomain, String rorId); } diff --git a/orcid-core/src/main/java/org/orcid/core/common/manager/impl/EmailDomainManagerImpl.java b/orcid-core/src/main/java/org/orcid/core/common/manager/impl/EmailDomainManagerImpl.java index b5950fb9f91..dcfe88f952b 100644 --- a/orcid-core/src/main/java/org/orcid/core/common/manager/impl/EmailDomainManagerImpl.java +++ b/orcid-core/src/main/java/org/orcid/core/common/manager/impl/EmailDomainManagerImpl.java @@ -13,20 +13,26 @@ public class EmailDomainManagerImpl implements EmailDomainManager { + public enum STATUS {CREATED, UPDATED}; + @Resource(name = "emailDomainDao") private EmailDomainDao emailDomainDao; @Resource(name = "emailDomainDaoReadOnly") private EmailDomainDao emailDomainDaoReadOnly; - @Override - public EmailDomainEntity createEmailDomain(String emailDomain, DomainCategory category) { + private void validateEmailDomain(String emailDomain) { if (emailDomain == null || emailDomain.isBlank()) { throw new IllegalArgumentException("Email Domain must not be empty"); } if(!InternetDomainName.isValid(emailDomain)) { throw new IllegalArgumentException("Email Domain '" + emailDomain + "' is invalid"); } + } + + @Override + public EmailDomainEntity createEmailDomain(String emailDomain, DomainCategory category) { + validateEmailDomain(emailDomain); if (category == null) { throw new IllegalArgumentException("Category must not be empty"); } @@ -57,4 +63,22 @@ public List findByCategory(DomainCategory category) { return emailDomainDaoReadOnly.findByCategory(category); } + @Override + public STATUS createOrUpdateEmailDomain(String emailDomain, String rorId) { + EmailDomainEntity existingEntity = emailDomainDaoReadOnly.findByEmailDoman(emailDomain); + if(existingEntity != null) { + if(!rorId.equals(existingEntity.getRorId())) { + boolean updated = emailDomainDao.updateRorId(existingEntity.getId(), rorId); + if(updated) + return STATUS.UPDATED; + } + } else { + EmailDomainEntity newEntity = emailDomainDao.createEmailDomain(emailDomain, DomainCategory.PROFESSIONAL, rorId); + if (newEntity != null) { + return STATUS.CREATED; + } + } + return null; + } + } diff --git a/orcid-core/src/main/java/org/orcid/core/solr/OrcidSolrOrgsClient.java b/orcid-core/src/main/java/org/orcid/core/solr/OrcidSolrOrgsClient.java index e30eaf806fb..be4c57fa21a 100644 --- a/orcid-core/src/main/java/org/orcid/core/solr/OrcidSolrOrgsClient.java +++ b/orcid-core/src/main/java/org/orcid/core/solr/OrcidSolrOrgsClient.java @@ -33,7 +33,7 @@ public class OrcidSolrOrgsClient { private static final String SOLR_SELF_SERVICE_ORGS_QUERY = "(org-disambiguated-id-from-source:%s)^50.0 (org-disambiguated-name%s)^50.0 (org-disambiguated-name-string:%s)^25.0"; - + private static final String SOLR_ORG_BY_ROR_ID_QUERY = "org-disambiguated-id-from-source:%s"; public OrgDisambiguatedSolrDocument findById(Long id) { SolrQuery query = new SolrQuery(); @@ -93,4 +93,19 @@ public List getOrgsForSelfService(String searchTer throw new NonTransientDataAccessResourceException(errorMessage, se); } } + + public OrgDisambiguatedSolrDocument getOrgByRorId(String rorId) { + SolrQuery query = new SolrQuery(); + // Escape the : on the email domain to be able to search in solr + query.setQuery(SOLR_ORG_BY_ROR_ID_QUERY.replace("%s", rorId.replace(":", "\\:"))); + query.addOrUpdateSort("score", ORDER.desc); + try { + QueryResponse queryResponse = solrReadOnlyOrgsClient.query(query); + List result = queryResponse.getBeans(OrgDisambiguatedSolrDocument.class); + return (result == null || result.isEmpty()) ? null : result.get(0); + } catch (SolrServerException | IOException se) { + String errorMessage = MessageFormat.format("Error when attempting to search for orgs by ror id, with ror id {0}", new Object[] { rorId }); + throw new NonTransientDataAccessResourceException(errorMessage, se); + } + } } diff --git a/orcid-core/src/test/java/org/orcid/core/common/manager/EmailDomainManagerTest.java b/orcid-core/src/test/java/org/orcid/core/common/manager/EmailDomainManagerTest.java index bc347b9977f..de67c61336a 100644 --- a/orcid-core/src/test/java/org/orcid/core/common/manager/EmailDomainManagerTest.java +++ b/orcid-core/src/test/java/org/orcid/core/common/manager/EmailDomainManagerTest.java @@ -4,7 +4,11 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -16,6 +20,7 @@ import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.orcid.core.common.manager.impl.EmailDomainManagerImpl; +import org.orcid.core.common.manager.impl.EmailDomainManagerImpl.STATUS; import org.orcid.persistence.dao.EmailDomainDao; import org.orcid.persistence.jpa.entities.EmailDomainEntity; import org.orcid.persistence.jpa.entities.EmailDomainEntity.DomainCategory; @@ -38,12 +43,17 @@ public void before() { EmailDomainEntity e1 = new EmailDomainEntity("gmail.com", DomainCategory.PERSONAL); EmailDomainEntity e2 = new EmailDomainEntity("yahoo.com", DomainCategory.PERSONAL); - EmailDomainEntity e3 = new EmailDomainEntity("orcid.org", DomainCategory.PROFESSIONAL); + EmailDomainEntity e3 = new EmailDomainEntity("orcid.org", DomainCategory.PROFESSIONAL, "https://ror.org/04fa4r544"); + e3.setId(1000L); when(emailDomainDaoReadOnlyMock.findByCategory(eq(DomainCategory.PERSONAL))).thenReturn(List.of(e1, e2)); when(emailDomainDaoReadOnlyMock.findByCategory(eq(DomainCategory.PROFESSIONAL))).thenReturn(List.of(e3)); when(emailDomainDaoReadOnlyMock.findByEmailDoman("gmail.com")).thenReturn(e1); + when(emailDomainDaoReadOnlyMock.findByEmailDoman("orcid.org")).thenReturn(e3); + + when(emailDomainDaoMock.createEmailDomain(eq("new.domain"), eq(DomainCategory.PROFESSIONAL), eq("https://ror.org/0"))).thenReturn(new EmailDomainEntity("new.domain", DomainCategory.PROFESSIONAL, "https://ror.org/0")); + when(emailDomainDaoMock.updateRorId(1000L, "https://ror.org/0")).thenReturn(true); } @Test(expected = IllegalArgumentException.class) @@ -135,4 +145,28 @@ public void findByCategory_TwoResultsTest() { assertEquals(DomainCategory.PERSONAL, personal.get(1).getCategory()); assertEquals("yahoo.com", personal.get(1).getEmailDomain()); } + + @Test + public void createOrUpdateEmailDomain_CreateTest() { + STATUS s = edm.createOrUpdateEmailDomain("new.domain", "https://ror.org/0"); + assertEquals(STATUS.CREATED, s); + verify(emailDomainDaoMock, times(1)).createEmailDomain(eq("new.domain"), eq(DomainCategory.PROFESSIONAL), eq("https://ror.org/0")); + verify(emailDomainDaoMock, never()).updateRorId(anyLong(), anyString()); + } + + @Test + public void createOrUpdateEmailDomain_UpdateTest() { + STATUS s = edm.createOrUpdateEmailDomain("orcid.org", "https://ror.org/0"); + assertEquals(STATUS.UPDATED, s); + verify(emailDomainDaoMock, times(1)).updateRorId(eq(1000L), eq("https://ror.org/0")); + verify(emailDomainDaoMock, never()).createEmailDomain(anyString(), any(), anyString()); + } + + @Test + public void createOrUpdateEmailDomain_NoUpdatesTest() { + STATUS s = edm.createOrUpdateEmailDomain("orcid.org", "https://ror.org/04fa4r544"); + assertNull(s); + verify(emailDomainDaoMock, never()).updateRorId(anyLong(), anyString()); + verify(emailDomainDaoMock, never()).createEmailDomain(anyString(), any(), anyString()); + } } diff --git a/orcid-persistence/src/main/java/org/orcid/persistence/dao/EmailDomainDao.java b/orcid-persistence/src/main/java/org/orcid/persistence/dao/EmailDomainDao.java index bb5c5730a53..93ea7a3bc35 100644 --- a/orcid-persistence/src/main/java/org/orcid/persistence/dao/EmailDomainDao.java +++ b/orcid-persistence/src/main/java/org/orcid/persistence/dao/EmailDomainDao.java @@ -6,8 +6,12 @@ public interface EmailDomainDao extends GenericDao { EmailDomainEntity createEmailDomain(String emailDomain, EmailDomainEntity.DomainCategory category); + + EmailDomainEntity createEmailDomain(String emailDomain, EmailDomainEntity.DomainCategory category, String rorId); boolean updateCategory(long id, EmailDomainEntity.DomainCategory category); + + boolean updateRorId(long id, String rorId); EmailDomainEntity findByEmailDoman(String emailDomain); diff --git a/orcid-persistence/src/main/java/org/orcid/persistence/dao/impl/EmailDomainDaoImpl.java b/orcid-persistence/src/main/java/org/orcid/persistence/dao/impl/EmailDomainDaoImpl.java index 5a8416d1e3c..6c75eec184f 100644 --- a/orcid-persistence/src/main/java/org/orcid/persistence/dao/impl/EmailDomainDaoImpl.java +++ b/orcid-persistence/src/main/java/org/orcid/persistence/dao/impl/EmailDomainDaoImpl.java @@ -31,6 +31,18 @@ public EmailDomainEntity createEmailDomain(String emailDomain, DomainCategory ca entityManager.persist(e); return e; } + + @Override + @Transactional + public EmailDomainEntity createEmailDomain(String emailDomain, DomainCategory category, String rorId) { + LOG.debug("Creating domain {} with category {} and ror Id {}", emailDomain, category, rorId); + EmailDomainEntity e = new EmailDomainEntity(); + e.setEmailDomain(emailDomain); + e.setCategory(category); + e.setRorId(rorId); + entityManager.persist(e); + return e; + } @Override @Transactional @@ -42,6 +54,16 @@ public boolean updateCategory(long id, DomainCategory category) { return query.executeUpdate() > 0; } + @Override + @Transactional + public boolean updateRorId(long id, String rorId) { + LOG.debug("Updating domain with id {} with rorId {}", id, rorId); + Query query = entityManager.createNativeQuery("UPDATE email_domain SET ror_id=:rorId WHERE id = :id"); + query.setParameter("id", id); + query.setParameter("rorId", rorId.toString()); + return query.executeUpdate() > 0; + } + @Override public EmailDomainEntity findByEmailDoman(String emailDomain) { TypedQuery query = entityManager.createQuery("from EmailDomainEntity where emailDomain = :emailDomain", EmailDomainEntity.class); diff --git a/orcid-persistence/src/main/java/org/orcid/persistence/jpa/entities/EmailDomainEntity.java b/orcid-persistence/src/main/java/org/orcid/persistence/jpa/entities/EmailDomainEntity.java index 06ea938e449..c676f19cea8 100644 --- a/orcid-persistence/src/main/java/org/orcid/persistence/jpa/entities/EmailDomainEntity.java +++ b/orcid-persistence/src/main/java/org/orcid/persistence/jpa/entities/EmailDomainEntity.java @@ -28,6 +28,7 @@ public static enum DomainCategory {PERSONAL, PROFESSIONAL, UNDEFINED} private Long id; private String emailDomain; private DomainCategory category; + private String rorId; public EmailDomainEntity() { @@ -38,6 +39,12 @@ public EmailDomainEntity(String emailDomain, DomainCategory category) { this.category = category; } + public EmailDomainEntity(String emailDomain, DomainCategory category, String rorId) { + this.emailDomain = emailDomain; + this.category = category; + this.rorId = rorId; + } + @Override @Id @GeneratedValue(strategy = GenerationType.AUTO, generator = "email_domain_seq") @@ -70,9 +77,18 @@ public void setEmailDomain(String emailDomain) { this.emailDomain = emailDomain; } + @Column(name = "ror_id") + public String getRorId() { + return rorId; + } + + public void setRorId(String rorId) { + this.rorId = rorId; + } + @Override public int hashCode() { - return Objects.hash(category, emailDomain, id); + return Objects.hash(category, emailDomain, id, rorId); } @Override @@ -84,6 +100,6 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) return false; EmailDomainEntity other = (EmailDomainEntity) obj; - return category == other.category && Objects.equals(emailDomain, other.emailDomain) && Objects.equals(id, other.id); - } + return category == other.category && Objects.equals(emailDomain, other.emailDomain) && Objects.equals(id, other.id) && Objects.equals(rorId, other.rorId); + } } diff --git a/orcid-persistence/src/main/resources/db/updates/create_email_domain_mapping_tables.xml b/orcid-persistence/src/main/resources/db/updates/create_email_domain_mapping_tables.xml index 02d6c9d413a..bd23c345b21 100644 --- a/orcid-persistence/src/main/resources/db/updates/create_email_domain_mapping_tables.xml +++ b/orcid-persistence/src/main/resources/db/updates/create_email_domain_mapping_tables.xml @@ -20,53 +20,25 @@ - - - - - - - - - - - - - - - - - - - - - + + - - ALTER TABLE email_domain_to_org_id ADD CONSTRAINT email_domain_fk FOREIGN KEY (email_domian_id) REFERENCES email_domain (id); - ALTER TABLE email_domain_to_org_id ADD CONSTRAINT org_disambiguated_id_fk FOREIGN KEY (org_disambiguated_id) REFERENCES org_disambiguated (id); - create index email_domain_to_org_id_domain_index on email_domain_to_org_id(email_domian_id); - create index email_domain_to_org_id_org_index on email_domain_to_org_id(org_disambiguated_id); - + - - - @@ -76,11 +48,11 @@ create index email_domain_domain_index on email_domain(email_domain); + create index email_domain_ror_id_index on email_domain(ror_id); - GRANT SELECT ON email_domain to orcidro; - GRANT SELECT ON email_domain_to_org_id to orcidro; + GRANT SELECT ON email_domain to orcidro; \ No newline at end of file diff --git a/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainLoader.java b/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainLoader.java index 30977c1abfe..f7517c6a436 100644 --- a/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainLoader.java +++ b/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainLoader.java @@ -97,9 +97,11 @@ private void process() { total += 1; } } - LOG.warn("List of invalid domains:"); - for(String invalidDomain : invalidDomains) { - LOG.warn(invalidDomain); + if(!invalidDomains.isEmpty()) { + LOG.warn("List of invalid domains:"); + for(String invalidDomain : invalidDomains) { + LOG.info(invalidDomain); + } } LOG.info("Process done, total: {}, new entities: {}, updated entities: {}", total, newEntities, updatedEntities); } diff --git a/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainToRorLoader.java b/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainToRorLoader.java new file mode 100644 index 00000000000..8037f5d62d0 --- /dev/null +++ b/orcid-scheduler-web/src/main/java/org/orcid/scheduler/loader/cli/EmailDomainToRorLoader.java @@ -0,0 +1,186 @@ +package org.orcid.scheduler.loader.cli; + +import java.io.FileReader; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.orcid.core.common.manager.EmailDomainManager; +import org.orcid.core.common.manager.impl.EmailDomainManagerImpl.STATUS; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.ClassPathXmlApplicationContext; + +import com.fasterxml.jackson.databind.MappingIterator; +import com.fasterxml.jackson.dataformat.csv.CsvMapper; +import com.fasterxml.jackson.dataformat.csv.CsvParser; + +public class EmailDomainToRorLoader { + + private static final Logger LOG = LoggerFactory.getLogger(EmailDomainToRorLoader.class); + + private String filePath; + private EmailDomainManager emailDomainManager; + private List> csvData; + private Set invalidDomains = new HashSet(); + private Map map = new HashMap(); + + private int updatedEntries = 0; + private int createdEntries = 0; + + public EmailDomainToRorLoader(String filePath) { + this.filePath = filePath; + init(filePath); + } + + public void execute() throws IOException { + load(this.filePath); + processCsvData(); + storeDomainToRorMap(); + } + + private void init(String filePath) { + Path path = Paths.get(filePath); + if(!Files.exists(path)) { + LOG.error("File does not exists: '{}'", filePath); + System.exit(1); + } + + @SuppressWarnings("resource") + ApplicationContext context = new ClassPathXmlApplicationContext("orcid-core-context.xml"); + emailDomainManager = (EmailDomainManager) context.getBean("emailDomainManager"); + } + + private void load(String filePath) throws IOException { + LOG.info("Reading file {}", filePath); + FileReader fileReader = new FileReader(filePath); + CsvMapper csvMapper = new CsvMapper(); + csvMapper.enable(CsvParser.Feature.WRAP_AS_ARRAY); + csvMapper.enable(CsvParser.Feature.TRIM_SPACES); + + MappingIterator> it = csvMapper.readerForListOf(String.class).readValues(fileReader); + + if (it != null) { + csvData = new ArrayList>(); + while(it.hasNext()) { + List r = it.next(); + // Hack to avoid adding empty lines if they are present, we need at least 2 columns, the domain and the ror id + if(r.size() > 1) + csvData.add(r); + } + } + fileReader.close(); + } + + private void processCsvData() { + for (List row : csvData) { + String domain = row.get(0); + String rorId = row.get(1); + boolean hasParent = false; + try { + String hasParentField = row.get(2); + hasParent = hasParentField == null ? false : Boolean.valueOf(hasParentField); + } catch(IndexOutOfBoundsException eoob) { + // Leave the hasParent as false + } + + if(!map.containsKey(domain)) { + DomainToRorMap dtrm = new DomainToRorMap(); + dtrm.setDomain(domain); + if(hasParent) { + dtrm.addIdWithParent(rorId); + } else { + dtrm.addIdWithNoParent(rorId); + } + map.put(domain, dtrm); + } else { + DomainToRorMap dtrm = map.get(domain); + if(hasParent) { + dtrm.addIdWithParent(rorId); + } else { + dtrm.addIdWithNoParent(rorId); + } + } + } + } + + private void storeDomainToRorMap() { + for(DomainToRorMap element : map.values()) { + LOG.debug("Processing domain {}", element.getDomain()); + // If the domain has only one entry with no parent, store that one + if(element.getIdsWithNoParent().size() == 1) { + STATUS s = emailDomainManager.createOrUpdateEmailDomain(element.getDomain(), element.getIdsWithNoParent().get(0)); + if(STATUS.CREATED.equals(s)) { + createdEntries++; + } else if (STATUS.UPDATED.equals(s)) { + updatedEntries++; + } + } else if(element.getIdsWithParent().size() == 1) { + // Else, if the domain has only one entry with parent, store that one + STATUS s = emailDomainManager.createOrUpdateEmailDomain(element.getDomain(), element.getIdsWithParent().get(0)); + if(STATUS.CREATED.equals(s)) { + createdEntries++; + } else if (STATUS.UPDATED.equals(s)) { + updatedEntries++; + } + } else { + // Else log a warning because there is no way to provide a suggestion + invalidDomains.add(element.getDomain()); + } + } + + if(!invalidDomains.isEmpty()) { + LOG.warn("The following domains couldn't be mapped ({} In total):", invalidDomains.size()); + for(String invalidDomain : invalidDomains) { + LOG.warn("{}", invalidDomain); + } + } + LOG.info("Created entries: {}, updated entries: {}", createdEntries, updatedEntries); + } + + private class DomainToRorMap { + private String domain; + private List idsWithParent = new ArrayList(); + private List idsWithNoParent = new ArrayList(); + + public void setDomain(String domain) { + this.domain = domain; + } + + public String getDomain() { + return this.domain; + } + + public void addIdWithParent(String rorId) { + LOG.debug("Domain {} adding {} with parent flag", this.domain, rorId); + idsWithParent.add(rorId); + } + + public List getIdsWithParent() { + return this.idsWithParent; + } + + public void addIdWithNoParent(String rorId) { + LOG.debug("Domain {} adding {} with NO parent flag", this.domain, rorId); + idsWithNoParent.add(rorId); + } + + public List getIdsWithNoParent() { + return this.idsWithNoParent; + } + } + + public static void main(String[] args) throws IOException { + String filePath = args[0]; + EmailDomainToRorLoader edl = new EmailDomainToRorLoader(filePath); + edl.execute(); + } +} diff --git a/orcid-web/src/main/java/org/orcid/frontend/web/controllers/EmailDomainController.java b/orcid-web/src/main/java/org/orcid/frontend/web/controllers/EmailDomainController.java index e42dd146931..b4626ba8551 100644 --- a/orcid-web/src/main/java/org/orcid/frontend/web/controllers/EmailDomainController.java +++ b/orcid-web/src/main/java/org/orcid/frontend/web/controllers/EmailDomainController.java @@ -4,8 +4,10 @@ import javax.ws.rs.core.MediaType; import org.orcid.core.common.manager.EmailDomainManager; +import org.orcid.core.solr.OrcidSolrOrgsClient; import org.orcid.core.utils.OrcidStringUtils; import org.orcid.persistence.jpa.entities.EmailDomainEntity; +import org.orcid.utils.solr.entities.OrgDisambiguatedSolrDocument; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @@ -22,12 +24,15 @@ public class EmailDomainController { @Resource private EmailDomainManager emailDomainManager; + @Resource + private OrcidSolrOrgsClient orcidSolrOrgsClient; + @RequestMapping(value = "/find-category", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON) public @ResponseBody ObjectNode findCategory(@RequestParam("domain") String domain) { ObjectMapper mapper = new ObjectMapper(); if(domain == null || domain.isBlank() || domain.length() > 254) { ObjectNode response = mapper.createObjectNode(); - response.put("error", "domain lenght too long or invalid"); + response.put("error", "Domain length too short, empty or invalid"); return response; } domain = OrcidStringUtils.stripHtml(domain); @@ -42,4 +47,32 @@ public class EmailDomainController { return response; } } + + @RequestMapping(value = "/find-org", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON) + public @ResponseBody ObjectNode findOrgInfo(@RequestParam("domain") String domain) { + ObjectMapper mapper = new ObjectMapper(); + ObjectNode response = mapper.createObjectNode(); + if(domain == null || domain.isBlank() || domain.length() > 254) { + response.put("error", "Domain length too short, empty or invalid"); + return response; + } + domain = OrcidStringUtils.stripHtml(domain); + + EmailDomainEntity ede = emailDomainManager.findByEmailDoman(domain); + if(ede != null) { + String rorId = ede.getRorId(); + if(rorId != null && !rorId.isBlank()) { + OrgDisambiguatedSolrDocument orgInfo = orcidSolrOrgsClient.getOrgByRorId(rorId); + if(orgInfo != null) { + // Pick the first result + response.put("Domain", domain); + response.put("ROR", rorId); + response.put("Org Name", orgInfo.getOrgDisambiguatedName()); + response.put("Country", orgInfo.getOrgDisambiguatedCountry()); + response.put("City", orgInfo.getOrgDisambiguatedCity()); + } + } + } + return response; + } } diff --git a/orcid-web/src/main/resources/orcid-frontend-security.xml b/orcid-web/src/main/resources/orcid-frontend-security.xml index d264b73f05e..42e2fd62ab0 100644 --- a/orcid-web/src/main/resources/orcid-frontend-security.xml +++ b/orcid-web/src/main/resources/orcid-frontend-security.xml @@ -421,7 +421,9 @@ + access="IS_AUTHENTICATED_ANONYMOUSLY" /> +