RoleRepositoryImpl.java

package com.tradecloud.repository.impl;

import com.tradecloud.authentication.Role;
import com.tradecloud.authentication.User;
import com.tradecloud.domain.RoleGroup;
import com.tradecloud.domain.infrastructure.persistence.CriteriaBuilder;
import com.tradecloud.domain.search.SearchParams;
import com.tradecloud.repository.RoleRepository;
import com.tradecloud.repository.base.impl.RepositoryBaseImpl;
import org.apache.log4j.Logger;
import org.hibernate.ObjectNotFoundException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.security.core.SpringSecurityMessageSource;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigInteger;
import java.util.Arrays;
import java.util.List;

/**
 * Role Repository (Authority).
 */
@Repository(value = "roleRepository")
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
public class RoleRepositoryImpl extends RepositoryBaseImpl<Role, Object> implements RoleRepository {

    private static Logger log = Logger.getLogger(RoleRepositoryImpl.class);

    public static final String DEF_ROLE_BY_ROLENAME_QUERY = "from Role as r where r.authority = :rolename";

    public static final String FIND_ALL_ROLES_NAME_QUERY = "select distinct description from Role where authority is not null ";

    @Override
    public Role findByName(String rolename) throws ObjectNotFoundException {
        Query query = getCurrentSession().createQuery(DEF_ROLE_BY_ROLENAME_QUERY);
        query.setString("rolename", rolename);
        query.setMaxResults(1);
        List<Role> list = query.list();
        if (list == null || list.isEmpty()) {
            throw new ObjectNotFoundException(SpringSecurityMessageSource.getAccessor().getMessage("JdbcDaoImpl.notFound",
                    new Object[]{rolename}, "Role with name {0} not found"), rolename);
        }
        return list.get(0);
    }

    @Override
    public List<String> findAllRoles() {
        Query query = getCurrentSession().createQuery(FIND_ALL_ROLES_NAME_QUERY);
        List<String> roleList = query.list();
        return roleList;
    }

    @Override
    public Role findByNameAndType(String roleName, boolean fullUser) throws ObjectNotFoundException {
        Query query = getCurrentSession().createQuery(DEF_ROLE_BY_ROLENAME_QUERY);
        query.setString("rolename", roleName);
        query.setMaxResults(1);
        List<Role> list = query.list();
        if (list == null || list.isEmpty()) {
            throw new ObjectNotFoundException(SpringSecurityMessageSource.getAccessor().getMessage("JdbcDaoImpl.notFound",
                    new Object[]{roleName}, "Role with name {0} not found"), roleName);
        }
        return list.get(0);
    }

    @Override
    public List<Role> findAllRolesByType(RoleGroup... excludeRoleGroups) {
        List<Role> roleList = (List<Role>) findByNamedQueryAndNamedParam("findAllByTypeExcludingGroups", "roleGroup",
                Arrays.asList(excludeRoleGroups));
        return roleList;
    }

    @Override
    public List<Role> findAllKPIRoles() {
        List<Role> roleList = (List<Role>) findByNamedQuery("findAllKPI");
        return roleList;
    }

    @Override
    public List<Role> findAllKPIRolesByUser(User user) {

        String query = "select r.* from role r " +
                "join user_role ur on r.authority = ur.authority " +
                "join users u on u.id = ur.user_id " +
                "where r.authority ilike '%kpi%' " +
                "AND u.id =" +user.getId();

        SQLQuery sqlQuery = getSession().createSQLQuery(query);
        return sqlQuery.addEntity(Role.class).list();
    }

    @Override
    public List<Role> findAllMyKPIRolesByUser(User user) {

        String query = "select r.* from role r " +
                "join user_role ur on r.authority = ur.authority " +
                "join users u on u.id = ur.user_id " +
                "where r.authority ilike '%my_kpi%' " +
                "AND u.id =" +user.getId();

        SQLQuery sqlQuery = getSession().createSQLQuery(query);
        return sqlQuery.addEntity(Role.class).list();
    }

    @Override
    public List<String> findAllLiteRolesByUser(User user) {
        SQLQuery sqlQuery = getSession().createSQLQuery("select r.authority from role r " +
                "join user_role ur on r.authority = ur.authority " +
                "join users u on u.id = ur.user_id " +
                "where r.authority ilike '%lite%' " +
                "and roleGroup <> 'SUPERUSER_ALLOCATED_ROLES' " +
                "AND u.id =" +
                user.getId());

        return sqlQuery.list();
    }

    @Override
    public long count(String tableName) {
        return ((BigInteger) getCurrentSession().createSQLQuery("select count(*) from " + tableName +
                        " where roleGroup <> 'SUPERUSER_ALLOCATED_ROLES'")
                .uniqueResult()).longValue();
    }

    @Override
    public long count() {
        return (Long) getCurrentSession()
                .createQuery("select count(*) from " + getPersistentClass().getSimpleName() +
                        " where roleGroup <> 'SUPERUSER_ALLOCATED_ROLES'").uniqueResult();
    }

    @Override
    public List<Role> findAll() {
        return getCurrentSession()
                .createQuery("select * from " + getPersistentClass().getSimpleName() +
                        " where roleGroup <> 'SUPERUSER_ALLOCATED_ROLES'").list();
    }

    @Override
    public List<Role> findAll(SearchParams searchParams) {
        DetachedCriteria criteria = DetachedCriteria.forClass(getPersistentClass());
        CriteriaBuilder.applySearchParams(criteria, searchParams);
        criteria.add(Restrictions.ne("roleGroup", RoleGroup.SUPERUSER_ALLOCATED_ROLES));
        @SuppressWarnings("unchecked")
        List<Role> results = criteria.getExecutableCriteria(getSessionCustom()).list();
        return results;
    }

    @Override
    public long count(Object search) {
        DetachedCriteria criteria = DetachedCriteria.forClass(getPersistentClass());
        criteria.add(Restrictions.ne("roleGroup", RoleGroup.SUPERUSER_ALLOCATED_ROLES));
        // just do a "select count(*)" rather than a full table retrieve!
        criteria.setProjection(Projections.rowCount());
        List<Long> results = criteria.getExecutableCriteria(getSessionCustom()).list();
        // will always have a result of the num of rows
        if (results.isEmpty()) {
            return 0;
        } else {
            return results.get(0);
        }
    }

    @Override
    public List<Role> search(Object search) {
        DetachedCriteria criteria = DetachedCriteria.forClass(getPersistentClass());
        criteria.add(Restrictions.ne("roleGroup", RoleGroup.SUPERUSER_ALLOCATED_ROLES));
        // just do a "select count(*)" rather than a full table retrieve!
        return criteria.getExecutableCriteria(getSessionCustom()).list();
    }

    @Override
    protected <T> List<T> findAll(SearchParams searchParams, DetachedCriteria detachedCriteria) {
        Order resultOrdering = searchParams.isDescending() == true ? Order.desc(searchParams.getOrderBy()) : Order.asc(searchParams.getOrderBy());
        DetachedCriteria criteria = detachedCriteria.addOrder(resultOrdering);
        criteria.add(Restrictions.ne("roleGroup", RoleGroup.SUPERUSER_ALLOCATED_ROLES));

        // Check if we are only searching for active entities
        if (searchParams.isActiveOnly()) {
            criteria.add(Restrictions.eq("active", true));
        }
        @SuppressWarnings("unchecked")
        List<T> results = criteria.getExecutableCriteria(getSessionCustom()).list();

        return results;
    }

    @Override
    public List<Role> getRolesAllocatedBySuperUser() {
        DetachedCriteria criteria = DetachedCriteria.forClass(getPersistentClass());
        criteria.add(Restrictions.eq("roleGroup", RoleGroup.SUPERUSER_ALLOCATED_ROLES));
        return criteria.getExecutableCriteria(getSessionCustom()).list();
    }
}