org.jboss.pressgang.ccms.provider.DBDataProvider Maven / Gradle / Ivy

Go to download
package org.jboss.pressgang.ccms.provider;

import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import javax.persistence.PersistenceException;
import javax.persistence.criteria.CriteriaQuery;
import javax.validation.ValidationException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.hibernate.envers.exception.RevisionDoesNotExistException;
import org.jboss.pressgang.ccms.model.base.AuditedEntity;
import org.jboss.pressgang.ccms.model.exceptions.CustomConstraintViolationException;
import org.jboss.pressgang.ccms.model.utils.EnversUtilities;
import org.jboss.pressgang.ccms.provider.exception.BadRequestException;
import org.jboss.pressgang.ccms.provider.exception.InternalServerErrorException;
import org.jboss.pressgang.ccms.provider.exception.NotFoundException;
import org.jboss.pressgang.ccms.provider.exception.ProviderException;
import org.jboss.pressgang.ccms.provider.listener.ProviderListener;
import org.jboss.pressgang.ccms.wrapper.DBWrapperFactory;

public class DBDataProvider extends DataProvider {
    private final EntityManager entityManager;

    protected DBDataProvider(final EntityManager entityManager, final DBProviderFactory providerFactory,
            final List listeners) {
        super(providerFactory, listeners);
        this.entityManager = entityManager;
    }

    protected EntityManager getEntityManager() {
        return entityManager;
    }

    @Override
    protected DBProviderFactory getProviderFactory() {
        return (DBProviderFactory) super.getProviderFactory();
    }

    protected DBWrapperFactory getWrapperFactory() {
        return getProviderFactory().getWrapperFactory();
    }

    protected  T getEntity(Class clazz, Integer id) {
        try {
            final T entity = getEntityManager().find(clazz, id);
            if (entity == null) {
                throw new NotFoundException("Unable to find " + clazz.getSimpleName()  + " with id " + id);
            } else {
                return entity;
            }
        } catch (Exception e) {
            throw handleException(e);
        }
    }

    protected  T getRevisionEntity(T entity, Integer revision) {
        return getRevisionEntity((Class) entity.getClass(), entity.getId(), revision);
    }

    protected  T getRevisionEntity(Class entityClass, Integer id, Integer revision) {
        try {
            final T entity =  EnversUtilities.getRevision(getEntityManager(), entityClass, id, revision);
            if (entity == null) {
                throw new NotFoundException();
            } else {
                return entity;
            }
        } catch (Exception e) {
            throw handleException(e);
        }
    }

    protected  List getRevisionList(Class entityClass, Integer id) {
        try {
            final Map revisionMapping = EnversUtilities.getRevisionEntities(getEntityManager(), entityClass, id);

            final List revisions = new ArrayList();
            for (final Map.Entry entry : revisionMapping.entrySet()) {
                revisions.add(entry.getValue());
            }

            return revisions;
        } catch (Exception e) {
            throw handleException(e);
        }
    }

    protected  List executeQuery(final CriteriaQuery query) {
        try {
            return getEntityManager().createQuery(query).getResultList();
        } catch (Exception e) {
            throw handleException(e);
        }
    }

    protected RuntimeException handleException(final Exception e) {
        if (e instanceof EntityNotFoundException || e instanceof RevisionDoesNotExistException) {
            return new NotFoundException(e);
        } else if (e instanceof ProviderException) {
            return (ProviderException) e;
        } else if (e instanceof PersistenceException || e instanceof ValidationException || e instanceof
                CustomConstraintViolationException) {
            return new BadRequestException(e);
        } else {
            return new InternalServerErrorException(e);
        }
    }
}