D-Net

package eu.dnetlib.openaire.user.queries;

/**

 * Created by sofia on 3/10/2017.

 */

public interface UserVerificationQueries {

    String FETCH_ALL                  = "SELECT * FROM user_verification";

    String FETCH_BY_ID                = "SELECT * FROM user_verification WHERE id = ?";

    String FETCH_BY_USERNAME          = "SELECT * FROM user_verification WHERE username = ?";

    String FETCH_BY_VERIFICATION_CODE = "SELECT * FROM user_verification WHERE verification_code = ?";

    String FETCH_BY_DATE              = "SELECT * FROM user_verification WHERE date = ?";

    String COUNT_ALL = "SELECT COUNT(*) FROM user_verification";

    String INSERT = "INSERT INTO user_verification (" +

            "username, " +

            "verification_code, " +

            "date " +

            ") VALUES (?,?,?)";

    String UPDATE = "UPDATE user_verification SET " +

            "username = ?, " +

            "verification_code = ?, " +

            "date = ? " +

            "WHERE id = ?";

    String DELETE = "DELETE FROM user_verification WHERE username = ?";

}

<?xml version="1.0"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<parent>

		<groupId>eu.dnetlib</groupId>

		<artifactId>dnet45-parent</artifactId>

		<version>1.0.0</version>

	</parent>

	<modelVersion>4.0.0</modelVersion>

	<groupId>eu.dnetlib</groupId>

	<artifactId>uoa-user-management</artifactId>

	<packaging>jar</packaging>

	<version>2.0.3</version>

	<scm>

		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet45/modules/uoa-user-management/tags/uoa-user-management-2.0.3</developerConnection>

	</scm>

	<dependencies>

		<dependency>

			<groupId>junit</groupId>

			<artifactId>junit</artifactId>

			<version>${junit.version}</version>

			<scope>test</scope>

		</dependency>

		<dependency>

			<groupId>org.springframework</groupId>

			<artifactId>spring-beans</artifactId>

			<version>${spring.version}</version>

		</dependency>

		<dependency>

			<groupId>org.springframework</groupId>

			<artifactId>spring-context</artifactId>

			<version>${spring.version}</version>

		</dependency>

		<dependency>

			<groupId>com.sun.jersey.contribs</groupId>

			<artifactId>jersey-spring</artifactId>

			<version>1.8</version>

			<exclusions>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring</artifactId>

				</exclusion>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring-core</artifactId>

				</exclusion>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring-web</artifactId>

				</exclusion>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring-beans</artifactId>

				</exclusion>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring-context</artifactId>

				</exclusion>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring-utils</artifactId>

				</exclusion>

				<exclusion>

					<groupId>org.springframework</groupId>

					<artifactId>spring-aop</artifactId>

				</exclusion>

			</exclusions>

		</dependency>

		<dependency>

			<groupId>com.google.code.gson</groupId>

			<artifactId>gson</artifactId>

			<version>2.6.2</version>

		</dependency>

		<dependency>

			<groupId>javax.servlet</groupId>

			<artifactId>javax.servlet-api</artifactId>

			<version>3.0.1</version>

			<scope>provided</scope>

		</dependency>

		<dependency>

			<groupId>org.postgresql</groupId>

			<artifactId>postgresql</artifactId>

			<version>9.4.1211.jre7</version>

		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->

		<dependency>

			<groupId>org.apache.commons</groupId>

			<artifactId>commons-dbcp2</artifactId>

			<version>2.1.1</version>

		</dependency>

	        <dependency>

        	    <groupId>commons-dbcp</groupId>

        	    <artifactId>commons-dbcp</artifactId>

        	    <version>20030825.184428</version>

	        </dependency>

		<dependency>

			<groupId>com.unboundid</groupId>

			<artifactId>unboundid-ldapsdk</artifactId>

			<version>1.1.3</version>

		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->

		<dependency>

			<groupId>apache</groupId>

			<artifactId>commons-pool</artifactId>

			<version>1.5.3</version>

		</dependency>

		<dependency>

			<groupId>io.jsonwebtoken</groupId>

			<artifactId>jjwt</artifactId>

			<version>0.6.0</version>

		</dependency>

		<dependency>

			<groupId>commons-validator</groupId>

			<artifactId>commons-validator</artifactId>

			<version>1.6</version>

		</dependency>

		<!-- https://mvnrepository.com/artifact/com.sun.mail/javax.mail -->

		<dependency>

			<groupId>com.sun.mail</groupId>

			<artifactId>javax.mail</artifactId>

			<version>1.5.1</version>

		</dependency>

		<!-- https://mvnrepository.com/artifact/org.glassfish/javax.json -->

		<dependency>

			<groupId>org.glassfish</groupId>

			<artifactId>javax.json</artifactId>

			<version>1.0.4</version>

		</dependency>

	</dependencies>

</project>

package eu.dnetlib.openaire.user.actions;

/**

 * Created by sofia on 31/10/2016.

 */

public interface IUserActions {

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

    public boolean activateUser(String activationId) throws Exception;

    public boolean isUserActivated(String email) throws Exception;

    public boolean userExists(String email) throws Exception;

    public boolean usernameExists(String username) throws Exception;

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

    public String prepareResetPassword(String email) throws Exception;

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

    public boolean isAdmin(String email) throws Exception;

    public void editUser(String email, String fname, String lname, String inst)

            throws Exception;

    public String addUser(String username, String email, String password,

                          String firstName, String lastName) throws Exception;

    public String getEmailFromUsername(String username) throws Exception;

    //public UserProfile getUser(String userIdentifier) throws Exception;

}

package eu.dnetlib.openaire.user.utils;

import org.apache.log4j.Logger;

import javax.mail.*;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import java.util.Properties;

/**

 * Created by kiatrop on 9/10/2017.

 */

public class EmailSender {

    private String username;

    private String password;

    private String host;

    private String port;

    private String from;

    private String auth;

    Logger logger = Logger.getLogger(EmailSender.class);

    public void sendEmail(String recipient, String subject, String body) throws MessagingException {

        // Get system properties

        Properties properties = System.getProperties();

        properties.put("mail.transport.protocol", "smtp");

        properties.put("mail.smtp.host", host);

        properties.put("mail.smtp.port", port);

        properties.put("mail.smtp.auth", auth);

        properties.put("mail.smtp.ssl.protocols", "TLSv1.2");

        properties.put("mail.smtp.starttls.enable", "true");

        properties.put("mail.smtp.ssl.trust", "*");

        Session session = javax.mail.Session.getInstance(properties,

                new Authenticator() {

                    protected PasswordAuthentication getPasswordAuthentication() {

                        return new PasswordAuthentication(username, password);

                    }

                });

        // Create a default MimeMessage object.

        MimeMessage message = new MimeMessage(session);

        // Set From: header field of the header.

        message.setFrom(new InternetAddress(from));

        // Set To: header field of the header.

        message.addRecipient(Message.RecipientType.TO, new InternetAddress(recipient));

        // Set Subject: header field

        message.setSubject(subject, "UTF-8");

        // For simple text setText() can be used instead of setContent()

        // Send the actual HTML message, as big as you like

        message.setContent(body, "text/html;charset=UTF-8");

        // Send message

        Transport.send(message);

        logger.debug("Sent message successfully....\n");

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public String getHost() {

        return host;

    }

    public void setHost(String host) {

        this.host = host;

    }

    public String getPort() {

        return port;

    }

    public void setPort(String port) {

        this.port = port;

    }

    public String getFrom() {

        return from;

    }

    public void setFrom(String from) {

        this.from = from;

    }

    public String getAuth() {

        return auth;

    }

    public void setAuth(String auth) {

        this.auth = auth;

    }

}

package eu.dnetlib.openaire.user.utils;

import org.apache.log4j.Logger;

import javax.json.Json;

import javax.json.JsonObject;

import javax.json.JsonReader;

import javax.net.ssl.HttpsURLConnection;

import java.io.BufferedReader;

import java.io.DataOutputStream;

import java.io.InputStreamReader;

import java.io.StringReader;

import java.net.URL;

public class VerifyRecaptcha {

    public static final String url = "https://www.google.com/recaptcha/api/siteverify";

    //private final static String USER_AGENT = "Mozilla/5.0";

    private static Logger logger = Logger.getLogger(VerifyRecaptcha.class);

    public static boolean verify(String gRecaptchaResponse, String secret) {

        logger.debug("Recaptch secret " + secret);

        logger.debug("response " + gRecaptchaResponse);

        if (gRecaptchaResponse == null || "".equals(gRecaptchaResponse)) {

            return false;

        }

        try{

            URL obj = new URL(url);

            HttpsURLConnection con = (HttpsURLConnection) obj.openConnection();

            // add reuqest header

            con.setRequestMethod("POST");

            //con.setRequestProperty("User-Agent", USER_AGENT);

            con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");

            String postParams = "secret=" + secret + "&response="

                    + gRecaptchaResponse;

            // Send post request

            con.setDoOutput(true);

            DataOutputStream wr = new DataOutputStream(con.getOutputStream());

            wr.writeBytes(postParams);

            wr.flush();

            wr.close();

            int responseCode = con.getResponseCode();

            logger.debug("\nSending 'POST' request to URL : " + url);

            logger.debug("Post parameters : " + postParams);

            logger.info("recaptcha response Code : " + responseCode);

            BufferedReader in = new BufferedReader(new InputStreamReader(

                    con.getInputStream()));

            String inputLine;

            StringBuffer response = new StringBuffer();

            while ((inputLine = in.readLine()) != null) {

                response.append(inputLine);

            }

            in.close();

            // print result

            logger.debug(response.toString());

            //parse JSON response and return 'success' value

            JsonReader jsonReader = Json.createReader(new StringReader(response.toString()));

            JsonObject jsonObject = jsonReader.readObject();

            jsonReader.close();

            return jsonObject.getBoolean("success");

        } catch(Exception e){

            logger.error("Error validating recaptcha");

            return false;

        }

    }

}

package eu.dnetlib.openaire.user.dao;

import eu.dnetlib.openaire.user.pojos.migration.User;

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

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.List;

/**

 * Created by sofia on 24/6/2016.

 */

public class SQLUserDAO implements UserDAO {

    @Override

    public User fetchById(String id) {

        return null;

    }

    @Override

    public User fetchByEmail(String mail) {

        return null;

    }

    @Override

    public User fetchByUsername(String username) {

        return null;

    }

    @Override

    public User fetchByName(String name) {

        return null;

    }

    @Override

    public User fetchBySurname(String surname) {

        return null;

    }

    @Override

    public List<User> fetchAll() {

        return null;

    }

    @Override

    public int countAll() {

        return 0;

    }

    @Override

    public void insert(User u) {

    }

    @Override

    public void delete(User u) {

    }

    @Override

    public User update(User u) {

        return null;

    }

    @Override

    public User fromResultSet(ResultSet set) throws SQLException {

        User user = new User(set.getString("username"));

        user.setPassword(set.getString("password"));

        user.setEmail(set.getString("email"));

        user.setName(set.getString("name"));

        user.setSurname(set.getString("surname"));

        return user;

    }

    @Override

    public int executeUpdate(String sql) {

        return 0;

    }

    @Override

    public int executeUpdate(String sql, Statement.Initializer init) {

        return 0;

    }

    @Override

    public User executeQuery(String sql) {

        return null;

    }

    @Override

    public User executeQuery(String sql, Statement.Initializer init) {

        return null;

    }

    @Override

    public long executeCount(String sql) {

        return 0;

    }

    @Override

    public long executeCount(String sql, Statement.Initializer init) {

        return 0;

    }

}

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 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(!InputValidator.isValidUsername(username)) {

            throw new CustomLDAPException("Invalid username!");

        }

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

            throw new CustomLDAPException("Invalid email!");

        }

        if(!InputValidator.isValidPassword(password)) {

            throw new CustomLDAPException("Invalid password!");

        }

        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));

            }

            if(!InputValidator.isValidPassword(password)) {

                throw new CustomLDAPException("Invalid password!");

            }

            //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) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

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

            ldapConnector.getConnection().delete("uid=" + username + "," + ldapConnector.getUsersDN());

        } catch (Exception e) {

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

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public void deleteZombieUser(String username) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

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

            ldapConnector.getConnection().delete("uid=" + username + "," + ldapConnector.getZombiesDN());

        } catch (Exception e) {

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

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public String getUsersEmail(String username) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

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

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

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getUsersDN(), 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("Fail to get user's email exists.", 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(!InputValidator.isValidUsername(username)) {

            throw new CustomLDAPException("Invalid username!");

        }

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

            throw new CustomLDAPException("Invalid email!");

        }

        if(!InputValidator.isValidPassword(password)) {

            throw new CustomLDAPException("Invalid password!");

        }

        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");

            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 String getZombieUsersEmail(String username) throws Exception {

        LDAPConnection connection = ldapConnector.getConnection();

        try {

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

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

            SearchRequest searchRequest = new SearchRequest(ldapConnector.getZombiesDN(), 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("Fail to get zombie user's email exists.", e);

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

    public String getZombieUsersUserName(String email) throws LDAPException {

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

        SearchRequest searchRequest = new SearchRequest(ldapConnector.getZombiesDN(), 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 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(!InputValidator.isValidPassword(password)) {

                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.dao;

import eu.dnetlib.openaire.user.pojos.migration.User;

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

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

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

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.List;

/**

 * Created by sofia on 4/8/2016.

 */

public class LDAPUserDAO implements UserDAO {

    @Autowired

    private LDAPConnector ldapConnector;

    @Override

    public List<User> fetchAll() {

        return null;

    }

    @Override

    public User fetchById(String id) {

        return null;

    }

    @Override

    public User fetchByEmail(String mail) {

        return null;

    }

    @Override

    public User fetchByUsername(String username) {

        return null;

    }

    @Override

    public User fetchByName(String name) {

        return null;

    }

    @Override

    public User fetchBySurname(String surname) {

        return null;

    }

    @Override

    public int countAll() {

        return 0;

    }

    @Override

    public void insert(User u) {

    }

    @Override

    public void delete(User u) {

    }

    @Override

    public User update(User u) {

        return null;

    }

    @Override

    public User fromResultSet(ResultSet set) throws SQLException {

        return null;

    }

    @Override

    public int executeUpdate(String sql) {

        return 0;

    }

    @Override

    public int executeUpdate(String sql, Statement.Initializer init) {

        return 0;

    }

    @Override

    public User executeQuery(String sql) {

        return null;

    }

    @Override

    public User executeQuery(String sql, Statement.Initializer init) {

        return null;

    }

    @Override

    public long executeCount(String sql) {

        return 0;

    }

    @Override

    public long executeCount(String sql, Statement.Initializer init) {

        return 0;

    }

}

package eu.dnetlib.openaire.user.utils;

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

import eu.dnetlib.openaire.user.pojos.UserVerification;

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);

        }

    }

    /**

     * Delete a verification with a specific id

     */

    public void deleteVerificationEntry(String username) {

        try {

            UserVerification userVerification  = new UserVerification(username);

            userVerificationDAO.delete(userVerification);

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

        } catch (SQLException e) {;

            logger.error("Fail to delete 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;

    }

    /**

     * Checks if the verification code has expired

     * !!! Verification code expires in 24hours !!!

     */

    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);

        }

        return true;

    }

    public DataSourceConnector getDataSourceConnector() {

        return dataSourceConnector;

    }

    public void setDataSourceConnector(DataSourceConnector dataSourceConnector) {

        this.dataSourceConnector = dataSourceConnector;

    }

}

package eu.dnetlib.openaire.user.store;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

import javax.sql.DataSource;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

/**

 * Created by sofia on 31/10/2016.

 */

@Component(value = "dataSourceConnector")

public class DataSourceConnector {

    @Value("${openaire.users.db.username}")

    private String username;

    @Value("${openaire.users.db.password}")

    private String password;

    @Value("${openaire.users.db.url}")

    private String dbUrl;

    @Value("${openaire.users.db.driverClassName}")

    private String driver;

    private static boolean driverLoad = false;

    private DataSource datasource;

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

    @PostConstruct

    public void init() {

        logger.info("Initializing data source");

        try {

            Class.forName(driver);

            driverLoad = true;

            BasicDataSource bds = new BasicDataSource();

            bds.setDriverClassName(driver);

            bds.setUrl(dbUrl);

            bds.setUsername(username);

            bds.setPassword(password);

            bds.setMaxIdle(10);

            bds.setMaxActive(100);

            bds.setMaxWait(10000);

            bds.setValidationQuery("select 1");

            bds.setTestOnBorrow(true);

            bds.setTestWhileIdle(true);

            bds.setTimeBetweenEvictionRunsMillis(1200000);

            bds.setMinEvictableIdleTimeMillis(1800000);

            bds.setNumTestsPerEvictionRun(5);

            bds.setDefaultAutoCommit(true);

            this.datasource = bds;

            // Test Connection

            getConnection().close();

            logger.info("Datasource " + datasource);

            logger.info(datasource.getConnection());

        } catch (ClassNotFoundException | SQLException exc) {

            logger.error("Unable to connenct to the DB. ", exc);

            throw new RuntimeException(exc);

        }

    }

    public Connection getConnection() throws SQLException {

        logger.debug("dbUrl " + dbUrl);

        return DriverManager.getConnection(dbUrl, username, password);

        //return DriverManager.getConnection("jdbc:postgresql://localhost:5433/MigrationUser?user=postgres&password=mypassword");

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public String getDbUrl() {

        return dbUrl;

    }

    public void setDbUrl(String dbUrl) {

        this.dbUrl = dbUrl;

    }

    public String getDriver() {

        return driver;

    }

    public void setDriver(String driver) {

        this.driver = driver;

    }

    public DataSource getDatasource() {

        return datasource;

    }

}

package eu.dnetlib.openaire.user.utils;

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

import eu.dnetlib.openaire.user.pojos.RoleVerification;

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.util.ArrayList;

import java.util.List;

@Component(value = "managerVerificationActions")

public class ManagerVerificationActions {

    @Autowired

    private DataSourceConnector dataSourceConnector;

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

    @Autowired

    private RoleVerificationDAO roleVerificationDAO;

    public RoleVerification get(String id) {

        try {

            return roleVerificationDAO.fetchById(id);

        } catch (SQLException e) {

            logger.error("Fail get verification entry.", e);

            return null;

        }

    }

    public RoleVerification addManagerVerification(String id, String email, String type, String entity, String verificationCode, Timestamp date) {

        return addVerification(id, email, type, entity, "manager", verificationCode, date);

    }

    public RoleVerification addMemberVerification(String id, String email, String type, String entity, String verificationCode, Timestamp date) {

        return addVerification(id, email, type, entity, "member", verificationCode, date);

    }

    private RoleVerification addVerification(String id, String email, String type, String entity, String verificationType, String verificationCode, Timestamp date) {

        try {

            RoleVerification roleVerification = new RoleVerification();

            roleVerification.setId(id);

            roleVerification.setEmail(email);

            roleVerification.setVerificationCode(verificationCode);

            roleVerification.setVerificationType(verificationType);

            roleVerification.setType(type);

            roleVerification.setEntity(entity);

            roleVerification.setDate(date);

            if (roleVerificationDAO.insert(roleVerification) > 0) {

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

                return roleVerification;

            } else {

                return null;

            }

        } catch (SQLException e) {

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

            return null;

        }

    }

    public void delete(String id) {

        try {

            roleVerificationDAO.delete(id);

            logger.info("Delete entry with id : " + id);

        } catch (SQLException e) {

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

        }

    }

    public boolean exists(String id) {

        try {

            RoleVerification roleVerification = roleVerificationDAO.fetchById(id);

            return roleVerification != null;

        } catch (SQLException e) {

            return false;