D-Net

package eu.dnetlib.goldoa.service;

import eu.dnetlib.goldoa.domain.Affiliation;

import eu.dnetlib.goldoa.domain.OrganizationManagerException;

import eu.dnetlib.goldoa.domain.Person;

import eu.dnetlib.goldoa.domain.PersonManagerException;

import eu.dnetlib.goldoa.domain.PersonRole;

import eu.dnetlib.goldoa.domain.Project;

import eu.dnetlib.goldoa.domain.Role;

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

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

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

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

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

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

import org.springframework.dao.EmptyResultDataAccessException;

import org.springframework.transaction.annotation.Transactional;

import javax.mail.MessagingException;

import java.math.BigInteger;

import java.security.SecureRandom;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import java.util.concurrent.ExecutorService;

/**

 * Created by antleb on 3/4/15.

 */

@Transactional

public class PersonManagerImpl implements PersonManager {

	@Autowired

	private PersonDAO personDAO;

	@Autowired

	private ProjectDAO projectDAO;

	@Autowired

	private OrganizationDAO organizationDAO;

	@Autowired

	private PublisherManager publisherManager;

	@Autowired

	private OrganizationManager organizationManager;

	@Autowired

	private EmailUtils emailUtils;

	@Autowired

	ExecutorService executorService;

	private int tokenTTL = 30;

	public static int generateId(Affiliation affiliation) {

		StringBuilder sb = new StringBuilder();

		if (affiliation.getPerson() != null)

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

		if (affiliation.getOrganization() != null)

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

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

	}

	@Override

	public Person getById(String personId) throws PersonManagerException {

		try {

			Person person = personDAO.getPersonById(personId);

			loadPersonRelations(person);

			return person;

		} catch (EmptyResultDataAccessException e) {

			throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_EXISTS);

		}

	}

	@Override

	public Person getByEmail(final String email) throws PersonManagerException {

		try {

			Person person = personDAO.getPersonByEmail(email);

			loadPersonRelations(person);

			return person;

		} catch (EmptyResultDataAccessException e) {

			throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_EXISTS);

		}

	}

	@Override

	public Person savePerson(final Person person) throws PersonManagerException {

		final List<PersonRole> previousRoles;

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

			person.setId(generateId(person));

			person.setSource("portal");

			previousRoles = new ArrayList<PersonRole>();

		} else {

			previousRoles = personDAO.getPersonById(person.getId()).getRoles();

		}

		personDAO.savePerson(person);

		deletePersonRelations(person);

		savePersonRelations(person);

		loadPersonRelations(person);

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

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

					for (PersonRole pRole : person.getRoles()) {

						if (!previousRoles.contains(pRole) && !pRole.isApproved())

							roles.add(pRole.getRole());

					}

					if (roles.size() > 0) {

						List<Person> moderators = getModerators();

						emailUtils.sendUserRoleRequestedEmail(person, roles);

						for (Person moderator : moderators)

							emailUtils.sendModeratorRoleRequestedEmail(moderator, person, roles);

					}

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

		return person;

	}

	@Override

	public void register(final Person person) throws PersonManagerException {

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

		try {

			personDAO.getPersonByEmail(person.getEmail());

			throw new PersonManagerException(PersonManagerException.ErrorCause.ALREADY_EXISTS);

		} catch (EmptyResultDataAccessException e) {

		} catch (PersonManagerException e) {

			throw e;

		} catch (RuntimeException e) {

			e.printStackTrace();

			throw e;

		}

		this.savePerson(person);

		personDAO.saveToken(person.getId(), token, tokenTTL);

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				try {

					emailUtils.sendActivationEmail(person, token);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

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

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

			Person person = getByEmail(email);

			if (person.isActive())

				return person;

			else

				throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_ACTIVATED);

		} else {

			throw new PersonManagerException(PersonManagerException.ErrorCause.WRONG_EMAIL_OR_PASSWORD);

		}

	}

	@Override

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

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

			throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_EXISTS);

		else {

			Person person = personDAO.getPersonByEmail(email);

			personDAO.activateUser(person.getId());

			personDAO.deleteToken(person.getId(), 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 (!personDAO.updatePassword(newPassword, email)) {

			throw new PersonManagerException(PersonManagerException.ErrorCause.NOT_EXISTS);

		}

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				Person person = personDAO.getPersonByEmail(email);

				try {

					emailUtils.sendResetPasswordEmail(person, newPassword);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

	public List<Role> getRoles() {

		return personDAO.getRoles();

	}

	@Override

	public List<Person> getModerators() {

		return personDAO.getModerators();

	}

	@Override

	public List<Person> getAccountingOfficers() {

		return personDAO.getAccountingOfficers();

	}

	@Override

	public void activateUser(String userId) {

		personDAO.activateUser(userId);

	}

	@Override

	public void activateUsers(List<String> userIds) {

		for (String userId : userIds) {

			personDAO.activateUser(userId);

		}

	}

	@Override

	public void deactivateUser(String userId) {

		personDAO.deactivateUser(userId);

	}

	@Override

	public void deactivateUsers(List<String> userIds) {

		for (String userId : userIds) {

			personDAO.deactivateUser(userId);

		}

	}

	@Override

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

		personDAO.acceptUserRole(userId, roleId);

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				Person person = personDAO.getPersonById(userId);

				Role role = personDAO.getRole(roleId);

				List<Person> moderators = getModerators();

				try {

					emailUtils.sendUserRoleAcceptedEmail(person, role);

					for (Person moderator : moderators)

						emailUtils.sendModeratorRoleAcceptedEmail(moderator, person, role);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

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

		personDAO.rejectUserRole(userId, roleId);

		executorService.submit(new Runnable() {

			@Override

			public void run() {

				Person person = personDAO.getPersonById(userId);

				Role role = personDAO.getRole(roleId);

				List<Person> moderators = getModerators();

				try {

					emailUtils.sendUserRoleRejectedEmail(person, role);

					for (Person moderator : moderators)

						emailUtils.sendModeratorRoleRejectedEmail(moderator, person, role);

				} catch (MessagingException e) {

					e.printStackTrace();

				}

			}

		});

	}

	@Override

	public List<Person> getUsers() {

		List<Person> persons = personDAO.getUsers();

		for (Person person : persons) {

			loadPersonRelations(person);

		}

		return persons;

	}

	@Override

	public String generateId(Person person) {

		StringBuilder sb = new StringBuilder();

		sb.append(person.getName()).append(person.getLastname()).append(person.getEmail());

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

	}

	private void deletePersonRelations(final Person person) {

		personDAO.deleteAffiliations(person.getId());

		personDAO.deletePersonRoles(person.getId());

		personDAO.removeProjectCoordinators(person.getId());

	}

	private void savePersonRelations(final Person person) {

		List<String> projectIds = new ArrayList<String>();

		if (person.getCoordinatedProjects() != null)

			for (Project project : person.getCoordinatedProjects())

				projectIds.add(project.getId());

		if (person.getPublisher() != null && person.getPublisher().getId() == null)

			publisherManager.savePublisher(person.getPublisher());

		for (Affiliation affiliation : person.getAffiliations()) {

			if (affiliation.getOrganization() != null && affiliation.getOrganization().getId() == null)

				try {

					organizationManager.saveOrganization(affiliation.getOrganization());

				} catch (OrganizationManagerException e) {

					e.printStackTrace();

				}

		}

		personDAO.saveProjectCoordinators(person.getId(), projectIds);

		personDAO.savePersonRoles(person.getId(), person.getRoles());

		personDAO.saveAffiliations(person, person.getAffiliations());

	}

	private void loadPersonRelations(Person person) {

		if (person.getPublisher() != null && person.getPublisher().getId() != null) {

			person.setPublisher(publisherManager.getPublisher(person.getPublisher().getId()));

		} else {

			person.setPublisher(null);

		}

		person.setCoordinatedProjects(projectDAO.getProjectsCoordinatedBy(person.getId()));

		if (person.getAffiliations() != null) {

			for (Affiliation affiliation : person.getAffiliations()) {

				if (affiliation.getOrganization() != null)

					affiliation.setOrganization(organizationDAO.getOrganization(affiliation.getOrganization().getId()));

			}

		}

		if (person.getRoles() != null)

			for (int i = 0; i < person.getRoles().size(); i++) {

				person.getRoles().get(i).setRole(personDAO.getRole(person.getRoles().get(i).getRole().getId()));

			}

	}

	public int getTokenTTL() {

		return tokenTTL;

	}

	public void setTokenTTL(int tokenTTL) {

		this.tokenTTL = tokenTTL;

	}

}