EmployeeDaoBase.java

// license-header java merge-point
//
// Attention: Generated code! Do not modify by hand!
// Generated by DaoBase.vsl in andromda-ejb3-cartridge on 08/08/2014 12:21:06.
//
package org.andromda.demo.ejb3.employee;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Resource;
import javax.ejb.Local;
import javax.ejb.SessionContext;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import org.hibernate.Session;

/**
 * <p>
 * Base EJB3 DAO Class: is able to create, update, remove, load, and find
 * objects of type <code>Employee</code>.
 * </p>
 *
 * @see EmployeeDao
 */
@TransactionAttribute(TransactionAttributeType.REQUIRED)
@Local({EmployeeDao.class})
public abstract class EmployeeDaoBase
    implements EmployeeDao
{
    /** Session Context Injection */
    @Resource
    protected SessionContext context;

    /**
     * Inject persistence context demo-ejb3
     */
    @PersistenceContext(unitName = "demo-ejb3")
    protected EntityManager emanager;

    /**
     * Inject Hibernate Session
     */
    @PersistenceContext(unitName = "demo-ejb3")
    protected Session hibernateSession;

    /**
     * @see EmployeeDao#load
     */
    @Override
    public Object load(final int transform, final Integer id)
        throws EmployeeDaoException
    {
        if (id == null)
        {
            throw new IllegalArgumentException(
                "Employee.load - 'id' can not be null");
        }
        try
        {
            final Employee entity = this.emanager.find(Employee.class, id);
            return transformEntity(transform, entity);
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#load( Integer)
     */
    @Override
    public Employee load( final Integer id)
        throws EmployeeDaoException
    {
        return (Employee)this.load(TRANSFORM_NONE, id);
    }

    /**
     * @see EmployeeDao#loadAll()
     */
    @Override
    @SuppressWarnings({"unchecked"})
    public Collection<Employee> loadAll()
        throws EmployeeDaoException
    {
        return this.loadAll(TRANSFORM_NONE);
    }

    /**
     * @see EmployeeDao#loadAll(int)
     */
    @Override
    public Collection loadAll(final int transform)
        throws EmployeeDaoException
    {
        try
        {
            TypedQuery<Employee> query = this.emanager.createNamedQuery("Employee.findAll", Employee.class);
            List<Employee> results = query.getResultList();
            this.transformEntities(transform, results);
            return results;
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * Create Employee with no VO transformation
     * @see EmployeeDao#create(Employee)
     */
    @Override
    public Employee create(Employee employee)
        throws EmployeeDaoException
    {
        return (Employee)this.create(TRANSFORM_NONE, employee);
    }

    /**
     * Create Employee with VO transformation
     * @see EmployeeDao#create(int, Employee)
     */
    @Override
    public Object create(final int transform, final Employee employee)
        throws EmployeeDaoException
    {
        if (employee == null)
        {
            throw new IllegalArgumentException(
                "Employee.create - 'employee' can not be null");
        }

        try
        {
            this.emanager.persist(employee);
            this.emanager.flush();
            return this.transformEntity(transform, employee);
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * Create a Collection of Employee with no VO transformation
     * @see EmployeeDao#create(Collection)
     */
    @Override
    @SuppressWarnings({"unchecked"})
    public Collection<Employee> create(final Collection<Employee> entities)
        throws EmployeeDaoException
    {
        return create(TRANSFORM_NONE, entities);
    }

    /**
     * Create a Collection of Employee with VO transformation
     * @see EmployeeDao#create(int, Collection)
     */
    @Override
    @SuppressWarnings({"unchecked", "rawtypes"})
    public Collection create(final int transform, final Collection<Employee> entities)
        throws EmployeeDaoException
    {
        if (entities == null)
        {
            throw new IllegalArgumentException(
                "Employee.create - 'entities' can not be null");
        }
        Collection results = new ArrayList();
        try
        {
            for (final Employee entity : entities)
            {
                results.add(create(transform, entity));
            }
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
        return results;
    }

    /**
     * Create Entity Employee using instance attributes with no VO transformation
     * @see EmployeeDao#create(String, EmployeeContractType, EmployeeDeptCode)
     */
    @Override
    public Employee create(
        String name,
        EmployeeContractType contractType,
        EmployeeDeptCode departmentCode)
        throws EmployeeDaoException
    {
        return (Employee)this.create(TRANSFORM_NONE, name, contractType, departmentCode);
    }

    /**
     * Create Entity Employee using instance attributes with VO transformation
     * @see EmployeeDao#create(int, String, EmployeeContractType, EmployeeDeptCode)
     * composite=false identifiers=1
     */
    @Override
    public Object create(
        final int transform,
        String name,
        EmployeeContractType contractType,
        EmployeeDeptCode departmentCode)
        throws EmployeeDaoException
    {
        Employee entity = new Employee();
        entity.setName(name);
        entity.setContractType(contractType);
        entity.setDepartmentCode(departmentCode);
        return this.create(transform, entity);
    }

    /**
     * @see EmployeeDao#update(Employee)
     */
    @Override
    public void update(Employee employee)
        throws EmployeeDaoException
    {
        if (employee == null)
        {
            throw new IllegalArgumentException(
                "Employee.update - 'employee' can not be null");
        }
        try
        {
            this.emanager.merge(employee);
            this.emanager.flush();
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#update(Collection)
     */
    @Override
    public void update(final Collection<Employee> entities)
        throws EmployeeDaoException
    {
        if (entities == null)
        {
            throw new IllegalArgumentException(
                "Employee.update - 'entities' can not be null");
        }
        try
        {
            for (final Employee entity : entities)
            {
                update(entity);
            }
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#remove(Employee)
     */
    @Override
    public void remove(Employee employee)
        throws EmployeeDaoException
    {
        if (employee == null)
        {
            throw new IllegalArgumentException(
                "Employee.remove - 'employee' can not be null");
        }
        try
        {
            this.emanager.remove(employee);
            this.emanager.flush();
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#remove(Integer)
     */
    @Override
    public void remove(Integer id)
        throws EmployeeDaoException
    {
        if (id == null)
        {
            throw new IllegalArgumentException(
                "Employee.remove - 'id' can not be null");
        }
        try
        {
            final Employee entity = this.load(id);
            if (entity != null)
            {
                this.remove(entity);
            }
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#remove(Collection)
     */
    @Override
    public void remove(Collection<Employee> entities)
        throws EmployeeDaoException
    {
        if (entities == null)
        {
            throw new IllegalArgumentException(
                "Employee.remove - 'entities' can not be null");
        }
        try
        {
            for (final Employee entity : entities)
            {
                remove(entity);
            }
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#findByContractType(EmployeeContractType)
     */
    @Override
    public Collection findByContractType(EmployeeContractType contractType)
        throws EmployeeDaoException
    {
        return this.findByContractType(TRANSFORM_NONE, contractType);
    }

    /**
     * @see EmployeeDao#findByContractType(String, EmployeeContractType)
     */
    @Override
    public Collection findByContractType(final String queryString, final EmployeeContractType contractType)
        throws EmployeeDaoException
    {
        return this.findByContractType(TRANSFORM_NONE, queryString, contractType);
    }

    /**
     * @see EmployeeDao#findByContractType(int, EmployeeContractType)
     */
    @Override
    public List findByContractType(final int transform, final EmployeeContractType contractType)
        throws EmployeeDaoException
    {
        try
        {
            TypedQuery<Employee> queryObject = this.emanager.createNamedQuery("Employee.findByContractType", Employee.class);
            queryObject.setParameter("contractType", contractType);
            List results = queryObject.getResultList();
            transformEntities(transform, results);
            return results;
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#findByContractType(int, String, EmployeeContractType)
     */
    @Override
    public List findByContractType(final int transform, final String queryString, final EmployeeContractType contractType)
        throws EmployeeDaoException
    {
        try
        {
            TypedQuery<Employee> queryObject = this.emanager.createQuery(queryString, Employee.class);
            queryObject.setParameter("contractType", contractType);
            List results = queryObject.getResultList();
            transformEntities(transform, results);
            return results;
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#findByDepartmentCode(EmployeeDeptCode)
     */
    @Override
    public Collection findByDepartmentCode(EmployeeDeptCode departmentCode)
        throws EmployeeDaoException
    {
        return this.findByDepartmentCode(TRANSFORM_NONE, departmentCode);
    }

    /**
     * @see EmployeeDao#findByDepartmentCode(String, EmployeeDeptCode)
     */
    @Override
    public Collection findByDepartmentCode(final String queryString, final EmployeeDeptCode departmentCode)
        throws EmployeeDaoException
    {
        return this.findByDepartmentCode(TRANSFORM_NONE, queryString, departmentCode);
    }

    /**
     * @see EmployeeDao#findByDepartmentCode(int, EmployeeDeptCode)
     */
    @Override
    public List findByDepartmentCode(final int transform, final EmployeeDeptCode departmentCode)
        throws EmployeeDaoException
    {
        try
        {
            TypedQuery<Employee> queryObject = this.emanager.createNamedQuery("Employee.findByDepartmentCode", Employee.class);
            queryObject.setParameter("departmentCode", departmentCode);
            List results = queryObject.getResultList();
            transformEntities(transform, results);
            return results;
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * @see EmployeeDao#findByDepartmentCode(int, String, EmployeeDeptCode)
     */
    @Override
    public List findByDepartmentCode(final int transform, final String queryString, final EmployeeDeptCode departmentCode)
        throws EmployeeDaoException
    {
        try
        {
            TypedQuery<Employee> queryObject = this.emanager.createQuery(queryString, Employee.class);
            queryObject.setParameter("departmentCode", departmentCode);
            List results = queryObject.getResultList();
            transformEntities(transform, results);
            return results;
        }
        catch (Exception ex)
        {
            throw new EmployeeDaoException(ex);
        }
    }

    /**
     * Allows transformation of entities into value objects
     * (or something else for that matter), when the <code>transform</code>
     * flag is set to one of the constants defined in <code>EmployeeDao</code>, please note
     * that the {@link #TRANSFORM_NONE} constant denotes no transformation, so the entity itself
     * will be returned.
     *
     * If the integer argument value is unknown {@link #TRANSFORM_NONE} is assumed.
     *
     * @param transform one of the constants declared in {@link EmployeeDao}
     * @param entity an entity that was found
     * @return the transformed entity (i.e. new value object, etc)
     * @see #transformEntities(int,Collection)
     */
    protected Object transformEntity(final int transform, final Employee entity)
    {
        Object target = null;
        if (entity != null)
        {
            switch (transform)
            {
                case TRANSFORM_NONE : // fall-through
                default:
                    target = entity;
            }
        }
        return target;
    }

    /**
     * Transforms a collection of entities using the
     * {@link #transformEntity(int, Employee)}
     * method. This method does not instantiate a new collection.
     * <p/>
     * Transforms into the same collection as the argument, but this time containing the transformed entities
     * This method is to be used internally only.
     *
     * @param transform one of the constants declared in <code>EmployeeDao</code>
     * @param entities the collection of entities to transform
     * @see #transformEntity(int, Employee)
     */
    protected void transformEntities(final int transform, final Collection<Employee> entities)
    {
        switch (transform)
        {
            case TRANSFORM_NONE : // fall-through
                default:
                // do nothing;
        }
    }


    // For unit testing outside of container - persistence context not injected
    /**
     * @return the context
     */
    public SessionContext getContext()
    {
        return this.context;
    }

    /**
     * @param contextIn the context to set
     */
    public void setContext(SessionContext contextIn)
    {
        this.context = contextIn;
    }

    /**
     * @return the emanager
     */
    public EntityManager getEmanager()
    {
        return this.emanager;
    }

    /**
     * @param emanagerIn the emanager to set
     */
    public void setEmanager(EntityManager emanagerIn)
    {
        this.emanager = emanagerIn;
    }

    /**
     * @return the hibernateSession
     */
    public Session getHibernateSession()
    {
        return this.hibernateSession;
    }

    /**
     * @param hibernateSessionIn the hibernateSession to set
     */
    public void setHibernateSession(Session hibernateSessionIn)
    {
        this.hibernateSession = hibernateSessionIn;
    }
}