Email domain to org

orcid-core/src/main/java/org/orcid/core/common/manager/EmailDomainManager.java

@@ -0,0 +1,15 @@
+package org.orcid.core.common.manager;
+
+import java.util.List;
+
+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<EmailDomainEntity> findByCategory(EmailDomainEntity.DomainCategory category);
+}

orcid-core/src/main/java/org/orcid/core/common/manager/impl/EmailDomainManagerImpl.java

@@ -0,0 +1,60 @@
+package org.orcid.core.common.manager.impl;
+
+import java.util.List;
+
+import javax.annotation.Resource;
+
+import org.orcid.core.common.manager.EmailDomainManager;
+import org.orcid.persistence.dao.EmailDomainDao;
+import org.orcid.persistence.jpa.entities.EmailDomainEntity;
+import org.orcid.persistence.jpa.entities.EmailDomainEntity.DomainCategory;
+
+import com.google.common.net.InternetDomainName;
+
+public class EmailDomainManagerImpl implements EmailDomainManager {
+
+    @Resource(name = "emailDomainDao")
+    private EmailDomainDao emailDomainDao;
+
+    @Resource(name = "emailDomainDaoReadOnly")
+    private EmailDomainDao emailDomainDaoReadOnly;
+
+    @Override
+    public EmailDomainEntity createEmailDomain(String emailDomain, DomainCategory category) {
+        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");
+        }
+        if (category == null) {
+            throw new IllegalArgumentException("Category must not be empty");
+        }
+        return emailDomainDao.createEmailDomain(emailDomain, category);
+    }
+
+    @Override
+    public boolean updateCategory(long id, DomainCategory category) {
+        if (category == null) {
+            throw new IllegalArgumentException("Category must not be empty");
+        }
+        return emailDomainDao.updateCategory(id, category);
+    }
+
+    @Override
+    public EmailDomainEntity findByEmailDoman(String emailDomain) {
+        if (emailDomain == null || emailDomain.isBlank()) {
+            throw new IllegalArgumentException("Email Domain must not be empty");
+        }
+        return emailDomainDaoReadOnly.findByEmailDoman(emailDomain);
+    }
+
+    @Override
+    public List<EmailDomainEntity> findByCategory(DomainCategory category) {
+        if (category == null) {
+            throw new IllegalArgumentException("Category must not be empty");
+        }
+        return emailDomainDaoReadOnly.findByCategory(category);
+    }
+
+}

orcid-core/src/main/java/org/orcid/core/utils/cache/redis/RedisClient.java

@@ -66,6 +66,10 @@ public RedisClient(String redisHost, int redisPort, String password, int cacheEx
 
     @PostConstruct
     private void init() {
+        if(!enabled) {
+            LOG.debug("Redis is not enabled, so, it will not be initilized");
+            return;
+        }
         try {
             JedisClientConfig config = DefaultJedisClientConfig.builder().connectionTimeoutMillis(this.clientTimeoutInMillis).timeoutMillis(this.clientTimeoutInMillis)
                     .socketTimeoutMillis(this.clientTimeoutInMillis).password(this.redisPassword).ssl(true).build();        

orcid-core/src/main/resources/orcid-core-context.xml

@@ -1214,4 +1214,6 @@
 		<constructor-arg index="3" value="${org.orcid.core.utils.cache.redis.expiration_in_secs:600}" />
 	</bean>
 
+	<bean id="emailDomainManager" class="org.orcid.core.common.manager.impl.EmailDomainManagerImpl"/>
+
 </beans>

orcid-core/src/test/java/org/orcid/core/common/manager/EmailDomainManagerTest.java

@@ -0,0 +1,138 @@
+package org.orcid.core.common.manager;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.orcid.core.common.manager.impl.EmailDomainManagerImpl;
+import org.orcid.persistence.dao.EmailDomainDao;
+import org.orcid.persistence.jpa.entities.EmailDomainEntity;
+import org.orcid.persistence.jpa.entities.EmailDomainEntity.DomainCategory;
+import org.orcid.test.TargetProxyHelper;
+
+public class EmailDomainManagerTest {
+    @Mock
+    private EmailDomainDao emailDomainDaoMock;
+
+    @Mock
+    private EmailDomainDao emailDomainDaoReadOnlyMock;
+
+    EmailDomainManager edm = new EmailDomainManagerImpl();
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+        TargetProxyHelper.injectIntoProxy(edm, "emailDomainDao", emailDomainDaoMock);
+        TargetProxyHelper.injectIntoProxy(edm, "emailDomainDaoReadOnly", emailDomainDaoReadOnlyMock);
+
+        EmailDomainEntity e1 = new EmailDomainEntity("gmail.com", DomainCategory.PERSONAL);
+        EmailDomainEntity e2 = new EmailDomainEntity("yahoo.com", DomainCategory.PERSONAL);
+        EmailDomainEntity e3 = new EmailDomainEntity("orcid.org", DomainCategory.PROFESSIONAL);
+
+        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);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createEmailDomain_NullDomainTest() {
+        edm.createEmailDomain(null, DomainCategory.PROFESSIONAL);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createEmailDomain_EmptyDomainTest() {
+        edm.createEmailDomain("        ", DomainCategory.PROFESSIONAL);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createEmailDomain_InvalidDomainTest() {
+        edm.createEmailDomain("$$$", DomainCategory.PROFESSIONAL);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createEmailDomain_NullCategoryTest() {
+        edm.createEmailDomain("orcid.org", null);
+    }
+
+    @Test
+    public void createEmailDomainTest() {
+        edm.createEmailDomain("orcid.org", DomainCategory.PROFESSIONAL);
+        verify(emailDomainDaoMock, times(1)).createEmailDomain(eq("orcid.org"), eq(DomainCategory.PROFESSIONAL));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void updateCategory_nullCategoryTest() {
+        edm.updateCategory(0, null);
+    }
+
+    @Test
+    public void updateCategoryTest() {
+        edm.updateCategory(0, DomainCategory.PERSONAL);
+        verify(emailDomainDaoMock, times(1)).updateCategory(eq(Long.valueOf(0)), eq(DomainCategory.PERSONAL));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void findByEmailDoman_NullDomainTest() {
+        edm.findByEmailDoman(null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void findByEmailDoman_EmptyDomainTest() {
+        edm.findByEmailDoman("              ");
+    }
+
+    @Test
+    public void findByEmailDoman_NothingFoundTest() {
+        assertNull(edm.findByEmailDoman("other.com"));
+    }
+
+    @Test
+    public void findByEmailDomanTest() {
+        EmailDomainEntity ede = edm.findByEmailDoman("gmail.com");
+        assertNotNull(ede);
+        assertEquals("gmail.com", ede.getEmailDomain());
+        assertEquals(DomainCategory.PERSONAL, ede.getCategory());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void findByCategory_NullCategoryTest() {
+        edm.findByEmailDoman(null);
+    }
+
+    @Test
+    public void findByCategory_NothingFoundTest() {
+        assertTrue(edm.findByCategory(DomainCategory.UNDEFINED).isEmpty());
+    }
+
+    @Test
+    public void findByCategory_OneResultTest() {
+        List<EmailDomainEntity> personal = edm.findByCategory(DomainCategory.PROFESSIONAL);
+        assertNotNull(personal);
+        assertEquals(1, personal.size());
+        assertEquals(DomainCategory.PROFESSIONAL, personal.get(0).getCategory());
+        assertEquals("orcid.org", personal.get(0).getEmailDomain());
+    }
+
+    @Test
+    public void findByCategory_TwoResultsTest() {
+        List<EmailDomainEntity> personal = edm.findByCategory(DomainCategory.PERSONAL);
+        assertNotNull(personal);
+        assertEquals(2, personal.size());
+        assertEquals(DomainCategory.PERSONAL, personal.get(0).getCategory());
+        assertEquals("gmail.com", personal.get(0).getEmailDomain());
+        assertEquals(DomainCategory.PERSONAL, personal.get(1).getCategory());
+        assertEquals("yahoo.com", personal.get(1).getEmailDomain());
+    }
+}

orcid-persistence/src/main/java/org/orcid/persistence/dao/EmailDomainDao.java

@@ -0,0 +1,15 @@
+package org.orcid.persistence.dao;
+
+import java.util.List;
+
+import org.orcid.persistence.jpa.entities.EmailDomainEntity;
+
+public interface EmailDomainDao extends GenericDao<EmailDomainEntity, Long> {
+    EmailDomainEntity createEmailDomain(String emailDomain, EmailDomainEntity.DomainCategory category);
+
+    boolean updateCategory(long id, EmailDomainEntity.DomainCategory category);
+
+    EmailDomainEntity findByEmailDoman(String emailDomain);
+
+    List<EmailDomainEntity> findByCategory(EmailDomainEntity.DomainCategory category);
+}

orcid-persistence/src/main/java/org/orcid/persistence/dao/impl/EmailDomainDaoImpl.java

@@ -0,0 +1,67 @@
+package org.orcid.persistence.dao.impl;
+
+import java.util.List;
+
+import javax.persistence.NoResultException;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+
+import org.orcid.persistence.dao.EmailDomainDao;
+import org.orcid.persistence.jpa.entities.EmailDomainEntity;
+import org.orcid.persistence.jpa.entities.EmailDomainEntity.DomainCategory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.transaction.annotation.Transactional;
+
+public class EmailDomainDaoImpl extends GenericDaoImpl<EmailDomainEntity, Long> implements EmailDomainDao {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EmailDomainDaoImpl.class);
+
+    public EmailDomainDaoImpl() {
+        super(EmailDomainEntity.class);
+    }
+
+    @Override
+    @Transactional
+    public EmailDomainEntity createEmailDomain(String emailDomain, DomainCategory category) {
+        LOG.debug("Creating domain {} with category {}", emailDomain, category);
+        EmailDomainEntity e = new EmailDomainEntity();
+        e.setEmailDomain(emailDomain);
+        e.setCategory(category);
+        entityManager.persist(e);
+        return e;
+    }
+
+    @Override
+    @Transactional
+    public boolean updateCategory(long id, DomainCategory category) {
+        LOG.debug("Updating domain with id {} with category {}", id, category);
+        Query query = entityManager.createNativeQuery("UPDATE email_domain SET category=:category WHERE id = :id");
+        query.setParameter("id", id);        
+        query.setParameter("category", category.toString());
+        return query.executeUpdate() > 0; 
+    }
+
+    @Override
+    public EmailDomainEntity findByEmailDoman(String emailDomain) {
+        TypedQuery<EmailDomainEntity> query = entityManager.createQuery("from EmailDomainEntity where emailDomain = :emailDomain", EmailDomainEntity.class);
+        query.setParameter("emailDomain", emailDomain);
+        try {
+            return query.getSingleResult();
+        } catch(NoResultException nre) {
+            // Ignore this exception
+        } catch(Exception e) {
+            // Propagate any other exception
+            throw e;
+        }
+        return null;
+    }
+
+    @Override
+    public List<EmailDomainEntity> findByCategory(DomainCategory category) {
+        TypedQuery<EmailDomainEntity> query = entityManager.createQuery("from EmailDomainEntity where category = :category", EmailDomainEntity.class);
+        query.setParameter("category", category);
+        List<EmailDomainEntity> results = query.getResultList();
+        return results.isEmpty() ? null : results;
+    }   
+}