Notes

package com.revature.caliber.training.data.implementations;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.revature.caliber.training.beans.Trainer;
import com.revature.caliber.training.data.TrainerDAO;

/**
* Implementation for trainee DAO crud methods
*/
@Repository(value = "TrainerDAOImplementation")
public class TrainerDAOImplementation implements TrainerDAO {

private SessionFactory sessionFactory;
@Autowired
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

/**
* Creates a new trainer
*/
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public void createTrainer(Trainer trainer) {
sessionFactory.getCurrentSession().save(trainer);
}

/**
* Fetches a trainer by their Id
*/
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public Trainer getTrainer(Integer id) {
Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(Trainer.class);
criteria.add(Restrictions.eq("TRAINER_ID", id));
return (Trainer) criteria.uniqueResult();
}

/**
* Fetches a
*/
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public Trainer getTrainer(String name) {
Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(Trainer.class);
criteria.add(Restrictions.eq("NAME", name));
return (Trainer) criteria.uniqueResult();
}

@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public List<Trainer> getAllTrainers() {
Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(Trainer.class);
return criteria.list();
}

@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public void updateTrainer(Trainer trainer) {
sessionFactory.getCurrentSession().saveOrUpdate(trainer);
}

@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public void deleteTrainer(Trainer trainer) {
sessionFactory.getCurrentSession().delete(trainer);
}

@SuppressWarnings("unchecked")
@Transactional(isolation = Isolation.READ_UNCOMMITTED, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class})
public List<Trainer> getTrainersInTier(Integer tierId) {
Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(Trainer.class);
criteria.add(Restrictions.eq("tierId", tierId));
return criteria.list();
}

}
-----------------------------------------------
package com.revature.caliber.training.data.implementations;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.revature.caliber.training.beans.Tier;
import com.revature.caliber.training.beans.Trainee;
import com.revature.caliber.training.data.TierDAO;

/**
* Upon initialization, tier contains VP, QC and Trainer
*/
@Repository(value = "trainingTierDAOImplementation")
public class TierDAOImplementation implements TierDAO {

private SessionFactory sessionFactory;

@Autowired
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

/**
* Returns the tier associated with a specific id
*/
@Override
@Transactional(isolation=Isolation.READ_UNCOMMITTED,
propagation=Propagation.REQUIRED,
rollbackFor=Exception.class)
public Tier getTier(Integer id) {
Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(Tier.class);
criteria.add(Restrictions.eq("tierId", id));
return (Tier)criteria.uniqueResult();
}

/**
* @deprecated This method currently serves no purpose. Might later
*/
public Tier getTier(String name) {
// TODO Auto-generated method stub
return null;
}

/**
* Returns a list of all the Tiers
*/
@Override
@SuppressWarnings("unchecked")
@Transactional(isolation=Isolation.READ_COMMITTED,
propagation=Propagation.REQUIRED,
rollbackFor=Exception.class)
public List<Tier> getAllTiers() {
Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(Tier.class);

return criteria.list();
}

/**
* Updates a tier
*/
@Override
@Transactional(isolation=Isolation.READ_COMMITTED,
propagation=Propagation.REQUIRED,
rollbackFor=Exception.class)
public void updateTier(Tier tier) {
sessionFactory.getCurrentSession().saveOrUpdate(tier);
}

/**
* Creates a new tier to insert into the database
*/
@Override
@Transactional(isolation=Isolation.READ_COMMITTED,
propagation=Propagation.REQUIRED,
rollbackFor = {Exception.class})
public void createTier(Tier tier) {
sessionFactory.getCurrentSession().save(tier);
}

/**
* Removes a tier
*/
@Override
@Transactional(isolation=Isolation.READ_COMMITTED,
propagation=Propagation.REQUIRED,
rollbackFor=Exception.class)
public void deleteTier(Tier tier) {
sessionFactory.getCurrentSession().delete(tier);
}

}