D-Net

package eu.dnetlib.goldoa.service;

import eu.dnetlib.goldoa.domain.*;

import eu.dnetlib.goldoa.service.dao.UserDAO;

import eu.dnetlib.goldoa.service.utils.EmailUtils;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import javax.mail.MessagingException;

import java.math.BigInteger;

import java.nio.charset.Charset;

import java.security.SecureRandom;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import java.util.concurrent.ExecutorService;

//import eu.dnetlib.goldoa.service.utils.EmailUtils;

/**

 * Created by antleb on 3/4/15.

 */

@Service("userManager")

@Transactional

public class UserManagerImpl implements UserManager {

	@Autowired

	private UserDAO userDAO;

	@Autowired

	private EmailUtils emailUtils;

	@Autowired

	ExecutorService executorService;

	private int tokenTTL = 30;

	private Log log = LogFactory.getLog(UserManagerImpl.class);

	public static int generateId(Affiliation affiliation) {

		StringBuilder sb = new StringBuilder();

		if (affiliation.getUsers().get(0) != null)

			sb.append(affiliation.getUsers().get(0).getId());

		if (affiliation.getOrganization() != null)

			sb.append(affiliation.getOrganization().getId());

		return DigestUtils.md5Hex(sb.toString()).hashCode();

	}

	@Override

	public User getById(String personId) throws PersonManagerException {

		return userDAO.getUserById(personId);

	}

	@Override

	public User getByEmail(final String email) throws PersonManagerException {

		return userDAO.getUserByEmail(email);

	}

	@Override

	// register or update

	public User saveUser(final User user) throws PersonManagerException {

		final List<UserRole> previousRoles;

		if (user.getId() == null) {

			user.setId(generateId(user));

			user.setSource("portal");

			previousRoles = new ArrayList<UserRole>();

		} else {

			previousRoles = user.getRoles();

		}

		userDAO.saveUser(user);

		final List<User> moderators = userDAO.getModerators();

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

					List<Role> roles = new ArrayList<>();

					for (UserRole pRole : user.getRoles()) {

						//!previousRoles.contains(pRole) &&

						if ( !pRole.isApproved())

							roles.add(pRole.getPk().getRole());

					}

					if (roles.size() > 0) {

						emailUtils.sendUserRoleRequestedEmail(user, roles);

						for (User moderator : moderators)

							emailUtils.sendModeratorRoleRequestedEmail(moderator, user, roles);

					}

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

		return user;

	}

	@Override

	public void register(final User user) throws PersonManagerException {

		final String token = UUID.randomUUID().toString();

		try {

			User u = userDAO.getUserByEmail(user.getEmail());

			if (u != null)

				throw new PersonManagerException(PersonManagerException.ErrorCause.ALREADY_EXISTS);

		} catch (PersonManagerException e) {

			throw e;

		} catch (RuntimeException e) {

			e.printStackTrace();

			throw e;

		}

		user.setPassword(org.springframework.util.DigestUtils.md5DigestAsHex( user.getPassword().getBytes(Charset.forName("UTF-8"))));

		this.saveUser(user);

		userDAO.saveToken(user.getEmail(), token, tokenTTL);

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

					emailUtils.sendActivationEmail(user, token);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

	public User login(String email, String password) throws PersonManagerException {

		try {

			if (userDAO.verifyLogin(email, password)) {

				System.out.println("verified login");

				User user = getByEmail(email);

				if (user.isActive()) {

					System.out.println("user is active");

					return user;

				}

				else

					throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_ACTIVATED);

			} else {

				throw new PersonManagerException(PersonManagerException.ErrorCause.WRONG_EMAIL_OR_PASSWORD);

			}

		} catch (PersonManagerException e) {

			throw e;

		} catch (Exception e) {

			log.error("Error logging in", e);

		}

		return null;

	}

	@Override

	public User activate(final String email, final String token) throws PersonManagerException {

		if (!userDAO.verifyToken(email, token))

			throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_EXISTS);

		else {

			User user = userDAO.getUserByEmail(email);

			userDAO.activateUser(user.getEmail());

			userDAO.deleteToken(user.getEmail(), token);

		}

		return getByEmail(email);

	}

	@Override

	public void resetPassword(final String email) throws PersonManagerException {

		SecureRandom random = new SecureRandom();

		final String newPassword = new BigInteger(50, random).toString(32);

		if (!userDAO.updatePassword(newPassword, email)) {

			throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_EXISTS);

		}

		final User user = userDAO.getUserByEmail(email);

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

					emailUtils.sendResetPasswordEmail(user, newPassword);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

	public List<Role> getRoles() {

		return userDAO.getRoles();

	}

	@Override

	public List<User> getModerators() {

		return userDAO.getModerators();

	}

	@Override

	public List<User> getAccountingOfficers() {

		return userDAO.getAccountingOfficers();

	}

	@Override

	public void activateUser(String email) {

		userDAO.activateUser(email);

	}

	@Override

	public void activateUsers(List<String> emails) {

		for (String email : emails) {

			userDAO.activateUser(email);

		}

	}

	@Override

	public void deactivateUser(String email) {

		userDAO.deactivateUser(email);

	}

	@Override

	public void deactivateUsers(List<String> emails) {

		for (String email : emails) {

			userDAO.deactivateUser(email);

		}

	}

	@Override

	public void acceptUserRole(final String email, final String roleId) {

		userDAO.acceptUserRole(email, roleId);

		final User user = userDAO.getUserByEmail(email);

		final Role role = userDAO.getRole(roleId);

		final List<User> moderators = getModerators();

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

					emailUtils.sendUserRoleAcceptedEmail(user, role);

					for (User moderator : moderators)

						emailUtils.sendModeratorRoleAcceptedEmail(moderator, user, role);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

	public void rejectRole(final String email, final String roleId) {

		userDAO.rejectUserRole(email, roleId);

		final User user = userDAO.getUserByEmail(email);

		final Role role = getRole(roleId);

		final List<User> moderators = getModerators();

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

					emailUtils.sendUserRoleRejectedEmail(user, role);

					for (User moderator : moderators)

						emailUtils.sendModeratorRoleRejectedEmail(moderator, user, role);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

	public List<User> getUsers() {

		return userDAO.getUsers();

	}

	@Override

	public String generateId(User user) {

		StringBuilder sb = new StringBuilder();

		sb.append(user.getFirstname()).append(user.getLastname()).append(user.getEmail());

		return "portal::" + DigestUtils.md5Hex(sb.toString());

	}

	public int getTokenTTL() {

		return tokenTTL;

	}

	public void setTokenTTL(int tokenTTL) {

		this.tokenTTL = tokenTTL;

	}

	@Override

	public Role getRole(String roleId){

		return userDAO.getRole(roleId);

	}

	@Override

	public List<Role> getUserRoles(String email){

		return userDAO.getUserRoles(email);

	}

}