D-Net

{

  "type_source": "SVN", 

  "goal": "package -U -T 4C source:jar", 

  "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-user-management/trunk",

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

  "mail": "antleb@di.uoa.gr, kiatrop@di.uoa.gr, sbaltzi@di.uoa.gr",

  "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet4-snapshots", 

  "name": "uoa-user-management"

}

package eu.dnetlib.openaire.user;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

/**

 * Unit test for simple App.

 */

public class AppTest 

    extends TestCase

{

    /**

     * Create the test case

     *

     * @param testName name of the test case

     */

    public AppTest( String testName )

    {

        super( testName );

    }

    /**

     * @return the suite of tests being tested

     */

    public static Test suite()

    {

        return new TestSuite( AppTest.class );

    }

    /**

     * Rigourous Test :-)

     */

    public void testApp()

    {

        assertTrue( true );

    }

}

package eu.dnetlib.openaire.user.ldap;

import com.unboundid.ldap.sdk.*;

import eu.dnetlib.openaire.user.LDAPUser;

import org.junit.Before;

import org.junit.Test;

/**

 * Created by kiatrop on 27/9/2017.

 */

public class LDAPEnhancer {

    LDAPConnection ldapConnector;

    String ldapUsersDN;

    @Before

    public void init() throws LDAPException {

        ldapConnector = new LDAPConnection("esperos.di.uoa.gr", 389, "cn=admin,dc=openaire,dc=eu", "serenata");

        ldapUsersDN = "ou=users,dc=openaire,dc=eu";

    }

    @Test

    public void enhance() throws LDAPSearchException {

        Filter filter = Filter.createEqualityFilter("ou", "users");

        SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUBORDINATE_SUBTREE, filter);

        SearchResult searchResult = ldapConnector.search(searchRequest);

        for (SearchResultEntry entry : searchResult.getSearchEntries()) {

            System.out.println(entry.getAttribute("dn"));

        }

    }

    @Test

    public void getUserTest() throws LDAPSearchException {

            String usersDN =  "ou=users,dc=openaire,dc=eu";

                Filter filter = Filter.createEqualityFilter("cn","kiatrop");

                SearchRequest searchRequest =

                        new SearchRequest(usersDN, SearchScope.SUB, filter, "mail", "displayName", "cn");

                SearchResult searchResult = ldapConnector.search(searchRequest);

                LDAPUser user = new LDAPUser();

                for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                    System.out.println(entry.getAttributeValue("cn"));

                    System.out.println(entry.getAttributeValue("mail"));

                    System.out.println(entry.getAttributeValue("displayName"));

                }

        }

}

package eu.dnetlib.openaire.user;

/**

 * Created by sofia on 29/11/2016.

 */

public class LDAPUser {

    private String cn;

    private String displayName;

    private String email;

    public LDAPUser(){

    }

    public LDAPUser(String cn, String displayName, String email)

    {

        this.cn = cn;

        this.displayName = displayName;

        this.email = email;

    }

    public String getCn() {

        return cn;

    }

    public void setCn(String cn) {

        this.cn = cn;

    }

    public String getDisplayName() {

        return displayName;

    }

    public void setDisplayName(String displayName) {

        this.displayName = displayName;

    }

    public String getEmail() {

        return email;

    }

    public void setEmail(String email) {

        this.email = email;

    }

}

package eu.dnetlib.openaire.user.ldap;

import com.unboundid.ldap.sdk.*;

import org.apache.log4j.Logger;

import java.util.UUID;

/**

 * Created by sofia on 31/10/2016.

 */

public class UserActionsLDAP {

    transient Logger logger = Logger.getLogger(UserActionsLDAP.class);

    private int ldapPort = 0;

    private String ldapAddress;

    private String ldapUsername;

    private String ldapPassword;

    private String ldapUsersDN;

    public boolean activateUser(String activationId) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("activating user with activationId " + activationId);

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("employeeNumber", activationId);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            String dn = null;

            if ( searchResult.getSearchEntries().size() > 0	) {

                for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                    dn = "uid=" + entry.getAttributeValue("uid") + "," + ldapUsersDN;

                }

                Modification mod1 = new Modification(ModificationType.REPLACE, "JoomlaBlockUser", "0");

                Modification mod2 = new Modification(ModificationType.REPLACE, "employeeNumber");

                connection.modify(dn, mod1, mod2);

                return true;

            } else {

                return false;

            }

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public String addUser(String email, String password) throws Exception {

        throw new UnsupportedOperationException();

    }

    public String addUser(String username, String email, String password, String firstName, String lastName) throws Exception {

        logger.debug("adding user " + username + " " + email + " to ldap");

        Attribute cn = new Attribute("cn", username);

        Attribute displayName = new Attribute("displayName", firstName + " " + lastName);

        Attribute mail = new Attribute("mail", email);

        Attribute givenName = new Attribute("givenName", firstName);

        Attribute joomlaBlockUser = new Attribute("JoomlaBlockUser", "1");

        Attribute joomlaGroup = new Attribute("JoomlaGroup", "Registered");

        Attribute objectClass = new Attribute("objectClass", "top", "inetOrgPerson", "JoomlaUser");

        Attribute userPassword = new Attribute("userPassword", Joomla15PasswordHash.create(password));

        Attribute sn = new Attribute("sn", lastName);

        Attribute uid = new Attribute("uid", username);

        // Attribute joomlaUserParams = new Attribute("JoomlaUserParams", "");

        String activationId = UUID.randomUUID().toString();

        Attribute x500UniqueIdentifier = new Attribute("employeeNumber", activationId);

        LDAPConnection connection = null;

        try {

            DN dn = new DN("uid=" + username + "," + ldapUsersDN);

            System.out.println("cn: " + cn + " displayName: " + displayName + " mail: " + mail + " givenName: " + givenName + " joomlaBlockUser: " + joomlaBlockUser + " joomlaGroup: " + joomlaGroup + " objectClass: " + objectClass + " userPassword: " + userPassword + " sn: " + sn + " uid: " + uid + " x500UniqueIdentifier: " + x500UniqueIdentifier);

            Entry entry = new Entry(dn.toNormalizedString(), cn, displayName, mail, givenName, joomlaBlockUser, joomlaGroup, objectClass, userPassword, sn, uid/*

																																								 * ,

																																								 * joomlaUserParams

																																								 */, x500UniqueIdentifier);

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            connection.add(entry);

            return activationId;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean correctCreds(String email, String password) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("checking if user " + email + " entered a correct password when logging in");

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "userPassword");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                if (Joomla15PasswordHash.check(password, entry.getAttributeValue("userPassword")))

                    return true;

            }

            return false;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public void editUser(String email, String fname, String lname, String inst) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("editing user " + email);

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            String dn = null;

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                dn = "uid=" + entry.getAttributeValue("uid") + "," + ldapUsersDN;

            }

            Modification mod1 = new Modification(ModificationType.REPLACE, "displayName", fname + " " + lname);

            Modification mod2 = new Modification(ModificationType.REPLACE, "givenName", fname);

            Modification mod3 = new Modification(ModificationType.REPLACE, "sn", lname);

            Modification mod4 = new Modification(ModificationType.REPLACE, "o", inst);

            connection.modify(dn, mod1, mod2, mod3, mod4);

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    /*

    @Override

    public eu.dnetlib.openaire.user.user.UserProfile getUser(String userIdentifier) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("getting user " + userIdentifier + " from ldap");

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", userIdentifier);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "mail", "givenName", "sn", "o", "uid");

            SearchResult searchResult = connection.search(searchRequest);

            UserProfileIS profile = new UserProfileIS();

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                profile.setEmail(entry.getAttributeValue("mail"));

                profile.setFname(entry.getAttributeValue("givenName"));

                profile.setLname(entry.getAttributeValue("sn"));

                profile.setInstitution(entry.getAttributeValue("o"));

                profile.setUsername(entry.getAttributeValue("uid"));

            }

            return profile;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }*/

    public boolean isAdmin(String email) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("checking if user " + email + " is an administrator");

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "JoomlaGroup");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                for (String role : entry.getAttributeValues("JoomlaGroup"))

                    if (role.equals("validatorAdmin"))

                        return true;

            }

            logger.debug(email + " is not administrator");

            return false;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean isUserActivated(String email) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("checking if user " + email + " is activated");

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "JoomlaBlockUser");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                int val = entry.getAttributeValueAsInteger("JoomlaBlockUser");

                if (val == 0)

                    return true;

                else

                    return false;

            }

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

        return false;

    }

    public String prepareResetPassword(String email) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("preparing reset password for user " + email);

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            String dn = null;

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                dn = "uid=" + entry.getAttributeValue("uid") + "," + ldapUsersDN;

            }

            String uuid = UUID.randomUUID().toString();

            Modification mod = new Modification(ModificationType.REPLACE, "employeeNumber", uuid);

            connection.modify(dn, mod);

            return uuid;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public void resetPassword(String uuid, String password) throws Exception {

        LDAPConnection connection = null;

        try {

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("employeeNumber", uuid);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            String dn = null;

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                dn = "uid=" + entry.getAttributeValue("uid") + "," + ldapUsersDN;

            }

            Modification mod1 = new Modification(ModificationType.REPLACE, "userPassword", Joomla15PasswordHash.create(password));

            Modification mod2 = new Modification(ModificationType.REPLACE, "employeeNumber");

            connection.modify(dn, mod1, mod2);

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean userExists(String email) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("checking if user " + email + " exists in ldap");

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "mail");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty())

                return true;

            return false;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean usernameExists(String username) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("checking if user " + username + " exists in ldap");

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("uid", username);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty()) {

                return true;

            }

            return false;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public String getEmailFromUsername(String username) throws Exception {

        LDAPConnection connection = null;

        try {

            logger.debug("getting email for user " + username);

            connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

            Filter filter = Filter.createEqualityFilter("uid", username);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "mail");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                return entry.getAttributeValue("mail");

            }

            return null;

        } catch (Exception e) {

            logger.error("", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public String getUsername(String email) throws LDAPException {

        LDAPConnection ldapConnection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

        Filter filter = Filter.createEqualityFilter("mail", email);

        SearchRequest searchRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, filter, "uid");

        SearchResult searchResult = ldapConnection.search(searchRequest);

        if (searchResult.getSearchEntries() != null) {

            if (searchResult.getSearchEntries().size() > 1) {

                logger.warn("An email is used for two different usernames! We only keep the first one");

            }

            if (searchResult.getSearchEntries().get(0) != null) {

                return searchResult.getSearchEntries().get(0).getAttributeValue("uid");

            }

        }

        return null;

    }

    public void setLdapPort(int ldapPort) {

        this.ldapPort = ldapPort;

    }

    public void setLdapAddress(String ldapAddress) {

        this.ldapAddress = ldapAddress;

    }

    public void setLdapUsername(String ldapUsername) {

        this.ldapUsername = ldapUsername;

    }

    public void setLdapPassword(String ldapPassword) {

        this.ldapPassword = ldapPassword;

    }

    public void setLdapUsersDN(String ldapUsersDN) {

        this.ldapUsersDN = ldapUsersDN;

    }

    public static void main(String[] args) {

        UserActionsLDAP ldap =  new UserActionsLDAP();

        String ldapAddress = "esperos.di.uoa.gr";

        String ldapUsername = "cn=admin,dc=openaire,dc=eu";

        String ldapPassword = "serenata";

        String ldapUsersDN = "ou=users,dc=openaire,dc=eu";

        int ldapPort = 389;

        ldap.setLdapAddress(ldapAddress);

        ldap.setLdapUsername(ldapUsername);

        ldap.setLdapPassword(ldapPassword);

        ldap.setLdapUsersDN(ldapUsersDN);

        ldap.setLdapPort(ldapPort);

        // CHECK: usernameExists(uid)

        // TERMINAL: ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu dn

//        try {

//            if (ldap.usernameExists("ngasparis"))

//                System.out.println("username exists");

//            else

//                System.out.println("username doesn't exist");

//

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: userExists(mail)

        // TERMINAL: ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu mail

//        try {

//            if (ldap.userExists("n.gasparis@di.uoa.gr"))

//                System.out.println("user exists");

//            else

//                System.out.println("user doesn't exist");

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: isUserActivated(mail)

        // TODO not sure!

        // TERMINAL: ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu mail

//        try {

//            if (ldap.isUserActivated("n.gasparis@di.uoa.gr"))

//                System.out.println("user is activated");

//            else

//                System.out.println("user isn't activated");

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: getUser(mail)

        // TERMINAL(mail): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu mail

        // TERMINAL(firstname): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu givenName

        // TERMINAL(lastname): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu sn

        // TERMINAL(institution): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu o

        // TERMINAL(username): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu uid

//        try {

//            gr.uoa.di.validator.api.user.UserProfileIS userProfile = (gr.uoa.di.validator.api.user.UserProfileIS) ldap.getUser("n.gasparis@di.uoa.gr");

//            System.out.println("User with Firstname: "        + userProfile.getFname() +

//                                  "\n          Lastname: "    + userProfile.getLname() +

//                                  "\n          Username: "    + userProfile.getUsername() +

//                                  "\n          Email: "       + userProfile.getEmail() +

//                                  "\n          Institution: " + userProfile.getInstitution());

//

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: getEmailFromUsername(username)

        // ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu mail

//        try {

//            if (ldap.usernameExists("user is adminngasparis")) {

//                String email = ldap.getEmailFromUsername("ngasparis");

//                System.out.println("username exists with email: " + email);

//            }

//            else

//                System.out.println("username doesn't exist");

//

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: isAdmin(mail)

        // TODO not sure

//        try {

//            if (ldap.isAdmin("n.gasparis@di.uoa.gr"))

//                System.out.println("user is admin");

//            else

//                System.out.println("user isn't admin");

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: addUser(username, email, password, firstname, lastname)

        // TERMINAL (check only): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu dn

//

//        try {

//            String activationId = ldap.addUser("sbaltzi", "sbaltzi@di.uoa.gr", "12345678", "sofia", "baltzi");

//            System.out.println("Added user with activation id:" + activationId);

//            gr.uoa.di.validator.api.user.UserProfileIS userProfile = (gr.uoa.di.validator.api.user.UserProfileIS) ldap.getUser("sbaltzi@di.uoa.gr");

//            System.out.println("User with Firstname: "        + userProfile.getFname() +

//                                  "\n          Lastname: "    + userProfile.getLname() +

//                                  "\n          Username: "    + userProfile.getUsername() +

//                                  "\n          Email: "       + userProfile.getEmail() +

//                                  "\n          Institution: " + userProfile.getInstitution());

//

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: correctCreds(mail, password)

//        try {

//            if (ldap.correctCreds("sbaltzi@di.uoa.gr", "12345678"))

//                System.out.println("correct credentials");

//            else

//                System.out.println("wrong credentials");

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: editUser()

        // TERMINAL(mail): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu mail

        // TERMINAL(firstname): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu givenName

        // TERMINAL(lastname): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu sn

        // TERMINAL(institution): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu o

        // TERMINAL(username): ldapsearch -x -LLL -h esperos.di.uoa.gr -b dc=openaire,dc=eu uid

//        try {

//            ldap.editUser("sbaltzi@di.uoa.gr", "sofie", "baltzi", "di");

//            gr.uoa.di.validator.api.user.UserProfileIS userProfile = (gr.uoa.di.validator.api.user.UserProfileIS) ldap.getUser("sbaltzi@di.uoa.gr");

//            System.out.println("User with Firstname: "        + userProfile.getFname() +

//                                  "\n          Lastname: "    + userProfile.getLname() +

//                                  "\n          Username: "    + userProfile.getUsername() +

//                                  "\n          Email: "       + userProfile.getEmail() +

//                                  "\n          Institution: " + userProfile.getInstitution());

//

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        // CHECK: prepareResetPassword(mail)

        // CHECK: resetPassword(mail, newpassword)

//        try {

//            String uuid = ldap.prepareResetPassword("sbaltzi@di.uoa.gr");

//            System.out.println("uuid is " + uuid);

//            ldap.resetPassword(uuid, "12345678");

//            if (ldap.correctCreds("sbaltzi@di.uoa.gr", "12345678"))

//                System.out.println("correct credentials");

//            else

//                System.out.println("wrong credentials");

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

    }

}

package eu.dnetlib.openaire.user.ldap;

import com.unboundid.ldap.sdk.*;

import eu.dnetlib.openaire.user.LDAPUser;

import eu.dnetlib.openaire.user.MigrationUser;

import eu.dnetlib.openaire.user.Role;

import eu.dnetlib.openaire.user.dao.RoleDAO;

import eu.dnetlib.openaire.user.dao.SQLMigrationUserDAO;

import eu.dnetlib.openaire.user.store.LDAPConnector;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import java.sql.SQLException;

/**

 * Created by sofia on 7/11/2016.

 */

public class MUserActionsLDAP {

    @Autowired

    private LDAPConnector ldapConnector;

    private static final Logger logger = Logger.getLogger(MUserActionsLDAP.class);

    public  boolean authenticate(String cn, String password) throws LDAPException {

        LDAPConnection connection = ldapConnector.getConnection();

        String usersDN = ldapConnector.getUsersDN();

        try {

            logger.debug("checking if user " + cn + " entered a correct password when logging in");

            Filter filter = Filter.createEqualityFilter("cn", cn);

            SearchRequest searchRequest = new SearchRequest(usersDN, SearchScope.SUB, filter, "userPassword");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                if (Joomla15PasswordHash.check(password, entry.getAttributeValue("userPassword")))

                    return true;

            }

            return false;

        }

        finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean usernameExists(String username) throws LDAPException

    {

        logger.debug("checking if username " + username + " exists");

        LDAPConnection connection = ldapConnector.getConnection();

        String usersDN = ldapConnector.getUsersDN();

        try {

            logger.debug("checking if username " + username + " exists");

            Filter filter = Filter.createEqualityFilter("cn", username);

            SearchRequest searchRequest = new SearchRequest(usersDN, SearchScope.SUB, filter, "cn");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty()) {

                logger.debug("User exists.");

                return true;

            }

            logger.debug("User does not exist.");

            return false;

        }

        finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean authenticateUser(String email, String password) throws LDAPException {

        LDAPConnection connection = ldapConnector.getConnection();

        String usersDN = ldapConnector.getUsersDN();

        try {

            logger.debug("checking if user " + email + " entered a correct password when logging in");

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(usersDN, SearchScope.SUB, filter, "userPassword");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                if (Joomla15PasswordHash.check(password, entry.getAttributeValue("userPassword")))

                    logger.debug("User exists.");

                    return true;

            }

            logger.debug("User does not exist.");

            return false;

        }

        finally {

            if (connection != null)

                connection.close();

        }

    }

    public String getRole(String email, String password) throws LDAPException, SQLException {

        boolean authenticated = authenticateUser(email, password);

        if (authenticated)

        {

            SQLMigrationUserDAO muDAO = new SQLMigrationUserDAO();

            MigrationUser mUser = new MigrationUser();

            mUser = muDAO.fetchByEmail(email);

            RoleDAO roleDAO = new RoleDAO();

            Role role = roleDAO.fetchById(mUser.getRoleId());

            return role.getRole();

        }

        return null;

    }

    public LDAPUser getUser(String username) throws LDAPException {

        LDAPConnection connection = ldapConnector.getConnection();

        String usersDN = ldapConnector.getUsersDN();

        try {

            logger.debug("getting user " + username + " from ldap");

            Filter filter = Filter.createEqualityFilter("cn",username);

            SearchRequest searchRequest =

                    new SearchRequest(usersDN, SearchScope.SUB, filter, "mail", "displayName", "cn");

            SearchResult searchResult = connection.search(searchRequest);

            LDAPUser user = new LDAPUser();

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                user.setCn(entry.getAttributeValue("cn"));

                user.setEmail(entry.getAttributeValue("mail"));

                user.setDisplayName(entry.getAttributeValue("displayName"));

            }

            logger.debug("Cn = " + user.getCn() + " mail = " + user.getEmail() + " displayName = " + user.getDisplayName());

            return user;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

}

package eu.dnetlib.openaire.user.ldap;

import com.unboundid.util.Base64;

import java.security.GeneralSecurityException;

import java.security.MessageDigest;

import java.util.Random;

/**

 * Created by sofia on 31/10/2016.

 */

public class Joomla15PasswordHash {

    public static boolean check(String passwd,String dbEntry) {

        String hashed = "{MD5}"+ Base64.encode(pack(Joomla15PasswordHash.md5(passwd)));

        if(dbEntry.equals(hashed))

            return true;

        else

            return false;

    }

    static Random _rnd;

    public static String create(String passwd) {

        return "{MD5}"+Base64.encode(pack(Joomla15PasswordHash.md5(passwd)));

    }

    /** Takes the MD5 hash of a sequence of ASCII or LATIN1 characters,

     *  and returns it as a 32-character lowercase hex string.

     *

     *  Equivalent to MySQL's MD5() function

     *  and to perl's Digest::MD5::md5_hex(),

     *  and to PHP's md5().

     *

     *  Does no error-checking of the input,  but only uses the low 8 bits

     *  from each input character.

     */

    public static String md5(String data) {

        byte[] bdata = new byte[data.length()]; int i; byte[] hash;

        for (i=0;i<data.length();i++) bdata[i]=(byte)(data.charAt(i)&0xff );

        try {

            MessageDigest md5er = MessageDigest.getInstance("MD5");

            hash = md5er.digest(bdata);

        } catch (GeneralSecurityException e) { throw new RuntimeException(e); }

        StringBuffer r = new StringBuffer(32);

        for (i=0;i<hash.length;i++) {

            String x = Integer.toHexString(hash[i]&0xff);

            if (x.length()<2) r.append("0");

            r.append(x);

        }

        return r.toString();

    }

    public static byte[] pack(String md5) {

        byte[] bytes = new byte[16];

        int j = 0;

        for(int i=0; i < 31; i+=2) {

            bytes[j] = (byte) Integer.parseInt(md5.charAt(i)+""+md5.charAt(i+1),16);

            j++;

        }

        return bytes;

    }

}

package eu.dnetlib.openaire.user.utils;

import com.unboundid.ldap.sdk.*;

import com.unboundid.ldap.sdk.extensions.PasswordModifyExtendedRequest;

import com.unboundid.ldap.sdk.extensions.PasswordModifyExtendedResult;

import eu.dnetlib.openaire.user.store.LDAPConnector;

import org.apache.commons.validator.routines.EmailValidator;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;

import java.util.List;

/**

 * Created by kiatrop on 29/9/2017.

 */

public class LDAPActions {

    private LDAPConnector ldapConnector;

    private Logger logger = Logger.getLogger(LDAPConnector.class);

    public String getUsername(String email) throws LDAPException {

        Filter filter = Filter.createEqualityFilter("mail", email);

        SearchRequest searchRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, filter, "uid");

        SearchResult searchResult = ldapConnector.getConnection().search(searchRequest);

        if (searchResult.getSearchEntries() != null) {

            if (searchResult.getSearchEntries().size() > 1) {

                logger.warn("An email is used for two different usernames! We only keep the first one.");

            }

            if (searchResult.getSearchEntries().size() == 0) {

                return null;

            }

            if (searchResult.getSearchEntries().get(0) != null) {

                return searchResult.getSearchEntries().get(0).getAttributeValue("uid");

            }

        }

        return null;

    }

    public Entry createUser(String username, String email, String firstName, String lastName, String institution, String password) throws Exception {

        if(!username.matches("^[a-zA-Z0-9][a-zA-Z0-9_-]{4,150}")){

            throw new CustomLDAPException("Invalid username!");

        }

        if(!EmailValidator.getInstance().isValid(email)){

            throw new CustomLDAPException("Invalid email!");

        }

        Filter uidFilter = Filter.createEqualityFilter("uid", username);

        SearchRequest uidRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, uidFilter, "cn", "mail", "uid", "objectClass");

        Filter mailFilter = Filter.createEqualityFilter("mail", email);

        SearchRequest mailRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, mailFilter, "cn", "mail", "uid", "objectClass");

        SearchResult searchResult = ldapConnector.getConnection().search(uidRequest);

        if(!searchResult.getSearchEntries().isEmpty()){

            throw new CustomLDAPException("Username " + username + " already exists!");

        }

        searchResult = ldapConnector.getConnection().search(mailRequest);

        if(!searchResult.getSearchEntries().isEmpty()){

            throw new CustomLDAPException("Email " + email + " already exists!");

        }

        Entry entry = new Entry("dn: uid=" + username + ",ou=users,dc=openaire,dc=eu",

                "objectClass: inetOrgPerson",

                "objectClass: eduPerson",

                "cn: "  + username,

                "uid: " + username,

                "displayName: " + firstName + " " + lastName,

                "mail: " + email,

                "givenName: " + firstName,

                "sn: " + lastName,

                "eduPersonPrincipalName: " + username + "@openaire.eu");

        if(institution != null && !institution.isEmpty()) {

            entry.addAttribute("o", institution);

        }

        ldapConnector.getConnection().add(entry);

        PasswordModifyExtendedRequest passwordModifyExtendedRequest = new PasswordModifyExtendedRequest(entry.getDN(), (String) null, password);

        PasswordModifyExtendedResult passwordModifyResult = (PasswordModifyExtendedResult) ldapConnector.getConnection().processExtendedOperation(passwordModifyExtendedRequest);

        logger.info("User: " + username + " was created successfully!");

        return entry;

    }

    public void updateUser(String username, String email, String firstName, String lastName, String password) throws Exception {

        SearchRequest searchRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, Filter.createEqualityFilter("uid", username), "mail", "givenName", "sn", "displayName");

        SearchResult searchResult = ldapConnector.getConnection().search(searchRequest);

        List<Modification> mods = new ArrayList<>();

        if (!searchResult.getSearchEntries().isEmpty()) {

            Entry entry = searchResult.getSearchEntries().get(0);

            if(!entry.getAttributeValue("mail").equals(email)){

                if(!EmailValidator.getInstance().isValid(email)){

                    throw new CustomLDAPException("Invalid email!");

                }

                Filter uidFilter = Filter.createEqualityFilter("uid", username);

                Filter mailFilter = Filter.createEqualityFilter("mail", email);

                SearchRequest mailRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, Filter.createANDFilter(mailFilter, Filter.createNOTFilter(uidFilter)), "mail", "givenName", "sn", "displayName");

                SearchResult mailResult = ldapConnector.getConnection().search(mailRequest);

                if(!mailResult.getSearchEntries().isEmpty()){

                    throw new CustomLDAPException("Email " + email + " already in use!");

                }

                mods.add(new Modification(ModificationType.REPLACE, "mail", email));

            }

            if(entry.getAttributeValue("givenName") == null){

                mods.add(new Modification(ModificationType.ADD, "givenName", firstName));

            } else if(!entry.getAttributeValue("givenName").equals(firstName)){

                mods.add(new Modification(ModificationType.REPLACE, "givenName", firstName));

            }

            if(entry.getAttributeValue("sn") == null){

                mods.add(new Modification(ModificationType.ADD, "sn", lastName));

            } else if(!entry.getAttributeValue("sn").equals(lastName)){

                mods.add(new Modification(ModificationType.REPLACE, "sn", lastName));

            }

            if(entry.getAttributeValue("displayName") == null) {

                mods.add(new Modification(ModificationType.ADD, "displayName", firstName + " " + lastName));

            } else if (!entry.getAttributeValue("displayName").equals(firstName + " " + lastName)) {

                mods.add(new Modification(ModificationType.REPLACE, "displayName", firstName + " " + lastName));

            }

            //mods.add(new Modification(ModificationType.REPLACE, "userPassword",password));

            if(!mods.isEmpty()) {

                ldapConnector.getConnection().modify(entry.getDN(), mods);

            }

            PasswordModifyExtendedRequest passwordModifyExtendedRequest = new PasswordModifyExtendedRequest(entry.getDN(), (String) null, password);

            PasswordModifyExtendedResult passwordModifyResult = (PasswordModifyExtendedResult) ldapConnector.getConnection().processExtendedOperation(passwordModifyExtendedRequest);

        } else {

            throw new CustomLDAPException("Username " + username + " not found!");

        }

    }

//    public void resetPassword(String username, String email, String password) throws Exception {

//        SearchRequest searchRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, Filter.createEqualityFilter("uid", username), "mail");

//        SearchResult searchResult = ldapConnector.getConnection().search(searchRequest);

//        List<Modification> mods = new ArrayList<>();

//

//        if (!searchResult.getSearchEntries().isEmpty()) {

//            Entry entry = searchResult.getSearchEntries().get(0);

//            if(!entry.getAttributeValue("mail").equals(email)){

//                if(!EmailValidator.getInstance().isValid(email)){

//                    throw new CustomLDAPException("Invalid email!");

//                }

//                Filter uidFilter = Filter.createEqualityFilter("uid", username);

//                Filter mailFilter = Filter.createEqualityFilter("mail", email);

//                SearchRequest mailRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, Filter.createANDFilter(mailFilter, Filter.createNOTFilter(uidFilter)), "mail", "givenName", "sn", "displayName");

//                SearchResult mailResult = ldapConnector.getConnection().search(mailRequest);

//                if(!mailResult.getSearchEntries().isEmpty()){

//                    throw new CustomLDAPException("Email " + email + " already in use!");

//                }

//                mods.add(new Modification(ModificationType.REPLACE, "mail", email));

//            }

//            //mods.add(new Modification(ModificationType.REPLACE, "userPassword",password));

//            if(!mods.isEmpty()) {

//                ldapConnector.getConnection().modify(entry.getDN(), mods);

//            }

//              if(!password.matches("(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{6,}")){

//                   throw new CustomLDAPException("Invalid password!");

//              }

//            PasswordModifyExtendedRequest passwordModifyExtendedRequest = new PasswordModifyExtendedRequest(entry.getDN(), (String) null, password);

//            PasswordModifyExtendedResult passwordModifyResult = (PasswordModifyExtendedResult) ldapConnector.getConnection().processExtendedOperation(passwordModifyExtendedRequest);

//        } else {

//            throw new CustomLDAPException("Username " + username + " not found!");

//        }

//    }

//    public void deleteUser(String username/*, String email */) throws Exception {

//        LDAPConnection connection = ldapConnector.getConnection();

//        List<Modification> mods = new ArrayList<>();

//

//        try {

//

//            //mods.add(new Modification(ModificationType.DELETE, "mail", email));

//            mods.add(new Modification(ModificationType.DELETE, "uid", username));

//            logger.info("User: " + username + "was deleted!");

//            if(!mods.isEmpty()) {

//                ldapConnector.getConnection().modify(ldapConnector.getUsersDN(), mods);

//            }

//

//        } catch (Exception e) {

//            logger.error("Fail to delete user.", e);

//            throw e;

//        } finally {

//            if (connection != null)

//                connection.close();

//        }

//    }

    public Entry createZombieUser(String username, String email, String firstName, String lastName, String institution, String password) throws Exception {

        if(!username.matches("^[a-zA-Z0-9][a-zA-Z0-9_-]{4,150}")){

            throw new CustomLDAPException("Invalid username!");

        }

        if(!EmailValidator.getInstance().isValid(email)){

            throw new CustomLDAPException("Invalid email!");

        }

        Filter uidFilter = Filter.createEqualityFilter("uid", username);

        SearchRequest uidRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, uidFilter, "cn", "mail", "uid", "objectClass");

        Filter mailFilter = Filter.createEqualityFilter("mail", email);

        SearchRequest mailRequest = new SearchRequest("dc=openaire,dc=eu", SearchScope.SUB, mailFilter, "cn", "mail", "uid", "objectClass");

        SearchResult searchResult = ldapConnector.getConnection().search(uidRequest);

        if(!searchResult.getSearchEntries().isEmpty()){

            logger.info("S" + searchResult.getSearchEntries());

            throw new CustomLDAPException("Username " + username + " already exists!");

        }

        searchResult = ldapConnector.getConnection().search(mailRequest);

        if(!searchResult.getSearchEntries().isEmpty()){

            throw new CustomLDAPException("Email " + email + " already exists!");

        }

        Entry entry = new Entry("dn: uid=" + username + ",ou=zombies,dc=openaire,dc=eu",

                "objectClass: inetOrgPerson",

                "objectClass: eduPerson",

                "cn: "  + username,

                "uid: " + username,

                "displayName: " + firstName + " " + lastName,

                "mail: " + email,

                "givenName: " + firstName,

                "sn: " + lastName,

                "eduPersonPrincipalName: " + username + "@openaire.eu");

        if(institution != null && !institution.isEmpty()) {

            entry.addAttribute("o", institution);

        }

        ldapConnector.getConnection().add(entry);

        PasswordModifyExtendedRequest passwordModifyExtendedRequest = new PasswordModifyExtendedRequest(entry.getDN(), (String) null, password);

        PasswordModifyExtendedResult passwordModifyResult = (PasswordModifyExtendedResult) ldapConnector.getConnection().processExtendedOperation(passwordModifyExtendedRequest);

        logger.info("User: " + username + " was created successfully!");

        return entry;

    }

    public void moveUser(String username) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

            logger.info("Moving user:" +username);

            ModifyDNRequest modifyDNRequest =

                    new ModifyDNRequest("uid=" + username + ",ou=zombies,dc=openaire,dc=eu", "uid=" + username, true, "ou=users,dc=openaire,dc=eu");

//            ModifyDNRequest modifyDNRequest =

//                    new ModifyDNRequest("uid=" + username + ",ou=zombies,dc=openaire,dc=eu","uid=" + username + ",ou=users,dc=openaire,dc=eu", true);

//

            LDAPResult result = connection.modifyDN(modifyDNRequest);

        }

        catch (Exception e){

            logger.error("Fail to move user.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean isZombieUsersEmail(String email) throws Exception{

        LDAPConnection connection = ldapConnector.getConnection();

        try {

            logger.debug("checking if zombie user " + email + " exists in ldap");

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getZombiesDN(), SearchScope.SUB, filter, "mail");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty()) {

                logger.info("Zombie user with email: " + email + " exists!");

                return true;

            } else {

                return false;

            }

        } catch (Exception e) {

            logger.error("Fail to check if zombie user email exists.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean isZombieUsersUsername(String username) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

            logger.debug("checking if zombie user " + username + " exists in ldap");

            Filter filter = Filter.createEqualityFilter("uid", username);

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getZombiesDN(), SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty()) {

                logger.info("Zombie user with username: " + username + " exists!");

                return true;

            } else {

                return false;

            }

        } catch (Exception e) {

            logger.error("Fail to check if zombie username exists.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean emailExists(String email) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

            logger.debug("checking if user " + email + " exists in ldap");

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getUsersDN(), SearchScope.SUB, filter, "mail");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty()) {

                logger.info("User with email: " + email + " exists!");

                return true;

            } else {

                return false;

            }

        } catch (Exception e) {

            logger.error("Fail to check if user email exists.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public boolean usernameExists(String username) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

            logger.debug("checking if user " + username + " exists in ldap");

            Filter filter = Filter.createEqualityFilter("uid", username);

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getUsersDN(), SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            if (!searchResult.getSearchEntries().isEmpty()) {

                logger.info("User with username: " + username + " exists!");

                return true;

            } else {

                return false;

            }

        } catch (Exception e) {

            logger.error("Fail to check if username exists.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public void resetPassword(String username, String password) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

            Filter filter = Filter.createEqualityFilter("uid", username);

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getUsersDN(), SearchScope.SUB, filter, "uid");

            SearchResult searchResult = connection.search(searchRequest);

            String dn = null;

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                dn = "uid=" + entry.getAttributeValue("uid") + "," + ldapConnector.getUsersDN();

                //logger.info("dn " + dn);

            }

            if(!password.matches("(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{6,}")){

                throw new CustomLDAPException("Invalid password!");

            }

            //Modification mod1 = new Modification(ModificationType.REPLACE, "userPassword", password);

            PasswordModifyExtendedRequest passwordModifyExtendedRequest = new PasswordModifyExtendedRequest(dn, (String) null, password);

            PasswordModifyExtendedResult passwordModifyResult = (PasswordModifyExtendedResult) ldapConnector.getConnection().processExtendedOperation(passwordModifyExtendedRequest);

            //connection.modify(dn, mod1);

        } catch (Exception e) {

            logger.error("Fail to reset password.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public LDAPConnector getLdapConnector() {

        return ldapConnector;

    }

    public void setLdapConnector(LDAPConnector ldapConnector) {

        this.ldapConnector = ldapConnector;

    }

}

package eu.dnetlib.openaire.user.utils;

import eu.dnetlib.openaire.user.UserVerification;

import eu.dnetlib.openaire.user.dao.UserVerificationDAO;

import eu.dnetlib.openaire.user.store.DataSourceConnector;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.time.LocalDateTime;

import java.time.temporal.ChronoUnit;

/**

 * Created by kiatrop on 2/10/2017.

 */

@Component(value = "verificationActions")

public class VerificationActions {

    @Autowired

    private DataSourceConnector dataSourceConnector;

    private Logger logger = Logger.getLogger(VerificationActions.class);

    @Autowired

    private UserVerificationDAO userVerificationDAO;

    /**

     * Adds new row in the verification table

     */

    public void addVerificationEntry(String username, String verificationCode, Timestamp date) {

        try {

            UserVerification userVerification  = new UserVerification(username);

            logger.info("verificationCode: " + verificationCode);

            userVerification.setVerificationCode(verificationCode);

            userVerification.setDate(date);

            userVerificationDAO.insert(userVerification);

            logger.info("Insert user: " + username);

        } catch (SQLException e) {;

            logger.error("Fail to insert user.", e);

        }

    }

    /**

     * Updates the row of verification table with the new date for the given username

     */

    public void updateVerificationEntry(String username, String verificationCode, Timestamp date) {

        try {

            // Get userId to update user

            UserVerification userVerificationOld = userVerificationDAO.fetchByUsername(username);

            UserVerification userVerification  = new UserVerification(username);

            userVerification.setVerificationCode(verificationCode);

            userVerification.setDate(date);

            userVerification.setId(userVerificationOld.getId());

            userVerificationDAO.update(userVerification);

            //logger.info("Update user: " + username + " with verification code " + verificationCode);

        } catch (SQLException e) {

            logger.error("Fail to update user.", e);

        }

    }

    /**

     * Checks if the verification row exists for the given username

     */

    public boolean verificationEntryExists(String username) {

        try {

            UserVerification userVerification = userVerificationDAO.fetchByUsername(username);

            if (userVerification == null) {

                logger.info("There is no user with username: " + username);

                return false;

            }

            else {

                logger.info("User: " + username + " was found!");

                return true;

            }

        } catch (SQLException e) {

            logger.error("Fail to search user.", e);

        }

        return true;

    }

    /**

     * Checks if the verification row exists for the given username

     */

    public boolean verificationCodeIsCorrect(String username, String verificationCode) {

            try {

                UserVerification userVerification = userVerificationDAO.fetchByUsername(username);

                if (userVerification == null) {

                    logger.info("There is no user with username: " + username);

                    return false;

                }

                else {

                    logger.info("User: " + username + " was found!");

                    if (verificationCode.equals(userVerification.getVerificationCode())) {

                        logger.info("Verification Code is correct!");

                        //logger.info("... and verification code: " + verificationCode + " is correct!");

                        return true;

                    }

                }

            } catch (SQLException e) {

                logger.error("Fail to search user.", e);

            }

            return false;

    }

    public boolean verificationCodeHasExpired(String username){

        try {

            UserVerification userVerification = userVerificationDAO.fetchByUsername(username);

            LocalDateTime date = userVerification.getDate().toLocalDateTime();

            long nHours = ChronoUnit.HOURS.between(date, LocalDateTime.now());

            if (nHours > (long)24)

                return true;

            else

                return false;

        } catch (SQLException e) {

            logger.error("Fail to search user.", e);

        }