EmployeeRepositoryImpl.java

package com.tradecloud.repository.impl;

import com.tradecloud.domain.base.utils.ObjectUtil;
import com.tradecloud.domain.party.Employee;
import com.tradecloud.domain.party.EmployeeRole;
import com.tradecloud.domain.search.SearchParams;
import com.tradecloud.repository.EmployeeRepository;
import com.tradecloud.repository.base.impl.RepositoryBaseImpl;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
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.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Employee Repository.
 * <p>
 * Note the SessionFactory used here is hard coded for the 'tradecloud'
 * database.
 * <p>
 * This is wired directly into the Spring security classes to be used for login.
 * ALso used by our EmployeeService for other user actions.
 */
@Repository(value = "employeeRepository")
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
public class EmployeeRepositoryImpl extends RepositoryBaseImpl<Employee, Object> implements EmployeeRepository {

    private static final long serialVersionUID = 1L;

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

    /**
     * Scan through the employees list and pick out any of the users with a role
     * matching the one we're interested in.
     */
    @Override
    public List<Employee> findAllByRole(String currentRole, SearchParams searchParams) {
        EmployeeRole searchRole = new EmployeeRole(currentRole);
        List<Employee> allEmployees = super.findAll(searchParams);
        // Use a tree set and keep the set organised
        Set<Employee> matchedEmployees = new HashSet<Employee>();

        for (Employee employee : allEmployees) {
            if (employee.getEmployeeRoles().contains(searchRole)) {
                matchedEmployees.add(employee);
            }
        }
        return new ArrayList<Employee>(matchedEmployees);
    }

    @Override
    public List<Employee> findAllByRoleFullName(String roleCode, String fullName) {
        EmployeeRole searchRole = new EmployeeRole(roleCode);
        // todo change below to named-query...
        List<Employee> allEmployees = super.findAll();
        // Use a tree set and keep the set organised
        Set<Employee> matchedEmployees = new HashSet<Employee>();

        for (Employee employee : allEmployees) {
            if (employee.getEmployeeRoles().contains(searchRole) && employee.getFullName().equals(fullName)) {
                matchedEmployees.add(employee);
            }
        }
        return new ArrayList<Employee>(matchedEmployees);
    }

    @Override
    public Employee retrieveEmployeeWithRolesAndExternalReferences(long employeeId) {
        List<Employee> employees = (List<Employee>) findByNamedQueryAndNamedParam("findByIdWithRolesAndReferencesLoaded", "id", employeeId);
        return ObjectUtil.first(employees);
    }

    @Override
    public Employee findByEmail(String email) {
        Criteria searchCriteria = getSessionCustom().createCriteria(Employee.class);
        searchCriteria.add(Restrictions.eq("email", email));
        return (Employee) searchCriteria.uniqueResult();
    }
}