D-Net

package eu.dnetlib.goldoa.service.dao;

import eu.dnetlib.goldoa.domain.AccountAction;

import eu.dnetlib.goldoa.domain.Role;

import eu.dnetlib.goldoa.domain.User;

import eu.dnetlib.goldoa.domain.UserRole;

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

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.Criteria;

import org.hibernate.criterion.Order;

import org.hibernate.criterion.Restrictions;

import org.hibernate.transform.Transformers;

import org.springframework.stereotype.Repository;

import java.math.BigInteger;

import java.sql.Timestamp;

import java.util.List;

/**

 * Created by antleb on 3/13/15.

 */

@Repository

public class UserDAO extends AbstractDao<String, User> {

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

    /**

     * Returns the person with the given id. Objects of different type are placeholders containing only their id.

     * Objects representing relations are fully initialized, with placeholders for other main entities.

     *

     * @param userId

     * @return

     */

    public User getUserById(String userId) {

        return (User) createEntityCriteria().add(Restrictions.eq("id", userId)).list().get(0);

    }

    /**

     * Returns the person with the given email. Objects of different type are placeholders containing only their id.

     * Objects representing relations are fully initialized, with placeholders for other main entities.

     *

     * @param email

     * @return

     */

    @SuppressWarnings("unchecked")

    public User getUserByEmail(String email) {

        List<User> users = createEntityCriteria().add(Restrictions.eq("email", email)).list();

        if (users.size() == 0)

            return null;

        User u = users.get(0);

        return u;

    }

    @SuppressWarnings("unchecked")

    public List<Role> getUserRoles(String email) {

        Criteria cr = getSession().createCriteria(UserRole.class);

        return cr.add(Restrictions.eq("pk.user",email))

                .setResultTransformer( Transformers.aliasToBean(Role.class)).list();

    }

    public void saveToken(final String email, final String token, final int tokenTTL) {

        AccountAction acc_action = new AccountAction();

        acc_action.setUser(getUserByEmail(email));

        acc_action.setType("activation");

        acc_action.setToken(token);

        acc_action.setDate(new Timestamp(System.currentTimeMillis()));

        acc_action.setExpires(new Timestamp(System.currentTimeMillis() + 1000L * 60L * 60L * 24L * tokenTTL));

        BigInteger id = (BigInteger) getSession().createSQLQuery("select nextval('account_action_seq') as id").list().get(0);

        acc_action.setId(id);

        getSession().persist(acc_action);

    }

    @SuppressWarnings("unchecked")

    public boolean verifyLogin(String email, String password) {

        List<User> users = createEntityCriteria().add(Restrictions.eq("email", email))

        		.add(Restrictions.eq("password", DigestUtils.md5Hex(password))).list();

        if (users.size() != 0)

            return true;

        return false;

    }

    @SuppressWarnings("unchecked")

    public boolean verifyToken(final String email, final String token) {

        Criteria cr = getSession().createCriteria(AccountAction.class);

        List<AccountAction> ac = cr.createAlias("user","u").add(Restrictions.eq("u.email", email))

                .add(Restrictions.eq("token", token)).list();

        if (ac.size() > 0)

            return true;

        return false;

    }

    public void activateUser(final String email) {

        User user = (User) createEntityCriteria().add(Restrictions.eq("email", email)).list().get(0);

        user.setActive(true);

        getSession().update(user);

    }

    public void deleteToken(final String email, final String token) {

        Criteria cr = getSession().createCriteria(AccountAction.class);

        AccountAction ac = (AccountAction) cr.createAlias("user","u").add(Restrictions.eq("u.email", email))

                .add(Restrictions.eq("token", token))

                .add(Restrictions.eq("type", "activation")).list().get(0);

        getSession().delete(ac);

    }

    @SuppressWarnings("unchecked")

    public boolean updatePassword(final String newPassword, final String email) {

        List<User> rs = createEntityCriteria().add(Restrictions.eq("email", email)).list();

        if (rs.get(0) != null) {

            User user = rs.get(0);

            user.setPassword(DigestUtils.md5Hex(newPassword));

            User user_merged = (User) getSession().merge(user);

            return true;

        }

        return false;

    }

    @SuppressWarnings("unchecked")

    public List<Role> getRoles() {

        return (List<Role>)getSession().createCriteria(Role.class).list();

    }

    @SuppressWarnings("unchecked")

    public void saveUser(final User user) {

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

        if (u != null) {

            if(u.getPublisher() != null && u.getPublisher() == user.getPublisher())

                user.setPublisher(u.getPublisher());

            if(user.getPassword() == null)

                user.setPassword(u.getPassword());

            if (user.getPassword() != null && !user.getPassword().equals(u.getPassword()))

                user.setPassword(DigestUtils.md5Hex(user.getPassword()));

            if(u.isActive())

                user.setActive(true);

            User user_merged = (User) getSession().merge(user);

        }else

            persist(user);

    }

    @SuppressWarnings("unchecked")

    public List<User> getUsersByRole(String role_id) {

        return  createEntityCriteria()

                .createAlias("roles" , "r")

                .add(Restrictions.eq("r.pk.role.id",role_id))

                .list();

    }

    public List<User> getModerators() {

        return getUsersByRole("moderator");

    }

    public List<User> getAccountingOfficers() {

        return getUsersByRole("accounting");

    }

    public Role getRole(final String roleId) {

        Criteria cr = getSession().createCriteria(Role.class);

        cr.add(Restrictions.eq("id", roleId));

        return (Role)cr.list().get(0);

    }

    public void deactivateUser(String email) {

        User user = (User) createEntityCriteria().add(Restrictions.eq("email", email)).list().get(0);

        user.setActive(false);

        User user_merged = (User) getSession().merge(user);

    }

    public void acceptUserRole(String email, String roleId) {

        User user = getUserByEmail(email);

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

            if (ur.getPk().getRole().getId().equals(roleId)) {

                ur.setApproved(true);

                getSession().update(user);

            }

        }

    }

    public void rejectUserRole(String email, String roleId) {

        User user = getUserByEmail(email);

        UserRole ur = null;

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

            if (u.getPk().getRole().getId().equals(roleId))

                ur = u;

        }

        user.getRoles().remove(ur);

        getSession().update(user);

        getSession().delete(ur);

    }

    @SuppressWarnings("unchecked")

    public List<User> getUsers() {

        return createEntityCriteria()

                .addOrder(Order.asc("email"))

               // .setCacheable(true)

               // .setCacheRegion("user")

                .list();

    }

}