HibernatePersistenceProvider.java

/*
Name: 
    - HibernatePersistenceProvider 

Description: 
    -  

Requires:
    - 
    
Provides:
    - 

Part of: ProcessPuzzle Framework, Domain and Business Model Ready Architecture. Provides content, workflow and social networking functionality. 
http://www.processpuzzle.com

ProcessPuzzle - Content and Workflow Management Integration Business Platform

Author(s): 
    - Zsolt Zsuffa

Copyright: (C) 2011 This program is free software: you can redistribute it and/or modify it under the terms of the 
GNU General Public License as published by the Free Software Foundation, either version 3 of the License, 
or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package com.processpuzzle.persistence.domain;


import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.configuration.HierarchicalConfiguration;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.QueryException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.exception.DataException;
import org.hibernate.exception.SQLGrammarException;

import com.processpuzzle.application.configuration.domain.PersistenceContext;
import com.processpuzzle.application.configuration.domain.PersistentDataInitializationStrategies;
import com.processpuzzle.commons.persistence.Entity;
import com.processpuzzle.commons.persistence.PersistentObject;
import com.processpuzzle.commons.persistence.RepositoryResultSet;
import com.processpuzzle.commons.persistence.UnitOfWork;
import com.processpuzzle.commons.persistence.query.Query;
import com.processpuzzle.persistence.query.transformer.domain.QueryTransformerFactory;

public class HibernatePersistenceProvider extends DefaultPersistenceProvider implements QLConstants {
   private static final String HIBERNATE_PROPERTY_SELECTOR = "pr:hibernate";
   private static Configuration hibernateConfiguration;
   private static SessionFactory sessionFactory;
   protected static Logger log = LoggerFactory.getLogger( HibernatePersistenceProvider.class );

   // Constructors
   public HibernatePersistenceProvider( String name, HierarchicalConfiguration configuration, List<Class<?>> persistentClasses,
         PersistentDataInitializationStrategies databaseCreationStrategy ) {
      super( name, configuration, persistentClasses, databaseCreationStrategy );
   }

   // Public mutators
   public boolean configure() {
      super.configure();
      hibernateConfiguration = new Configuration();
      addPropertiesToTheHibernateConfiguration();
      handleDatabaseInitializationStrategy();
      addEntityClassesToTheHibernateConfiguration();

      try{
         initDatabase();
      }catch( Exception e ){
         throw new PersistenceProviderInitializationException( this.getClass(), e );
      }

      isConfigured = true;
      return isConfigured();
   }

   @Override
   public Integer add( UnitOfWork work, Class<? extends PersistentObject> entityClass, PersistentObject entity ) {
      Integer id = null;
      HibernateSessionContext sessionContext = (HibernateSessionContext) getSessionContextFor( work );
      Session session = sessionContext.getSession();
      try{
         id = (Integer) session.save( entityClass.getName(), entity );
      }catch( DataException e ){
         throw new PersistenceProviderException( "add", e );
      }catch( HibernateException e ){
         throw new PersistenceProviderException( "add", e );
      }catch( Exception e ){
         // TODO: handle exception
         e.printStackTrace();
      }
      return id;
   }

   @Override
   public void update( UnitOfWork work, Class<? extends PersistentObject> entityClass, PersistentObject entity ) {
      Session hibernateSession = ((HibernateSessionContext) getSessionContextFor( work )).getSession();
      hibernateSession.update( entityClass.getName(), entity );
   }

   @Override
   public void delete( UnitOfWork work, Class<? extends PersistentObject> entityClass, PersistentObject entity ) {
      Session hibernateSession = ((HibernateSessionContext) getSessionContextFor( work )).getSession();
      try{
         hibernateSession.delete( entity );
      }catch( Exception e ){
         log.debug( "Deleting object of entity class: " + entityClass.getName() + "caused an error", e );
         throw new PersistenceProviderException( "delete", e );
      }
   }

   @SuppressWarnings("unchecked")
   @Override
   public <P extends PersistentObject> P findById( UnitOfWork work, Class<P> entityClass, Integer id ) {
      Session hibernateSession = ((HibernateSessionContext) getSessionContextFor( work )).getSession();
      return (P) hibernateSession.get( entityClass, id );
   }

   @SuppressWarnings( "unchecked" )
   @Override
   public <P extends PersistentObject> RepositoryResultSet<P> findAll( UnitOfWork work, Class<P> entityClass ) {
      RepositoryResultSet<P> retValues = null;
      Session hibernateSession = ((HibernateSessionContext) getSessionContextFor( work )).getSession();
      com.processpuzzle.persistence.query.domain.DefaultQuery query = new com.processpuzzle.persistence.query.domain.DefaultQuery( (Class<? extends Entity>) entityClass );
      String queryStatement = QueryTransformerFactory.createHQLQueryTransformer().createStatement( query );

      retValues = new SimpleResultSet<P>( hibernateSession.createQuery( queryStatement ).list() );
      return retValues;
   }

   @Override
   public RepositoryResultSet<? extends PersistentObject> findByQuery( UnitOfWork work, Query query ) {
      RepositoryResultSet<? extends PersistentObject> resultSet = null;
      String queryStatement = null;
      try{
         Session hibernateSession = ((HibernateSessionContext) getSessionContextFor( work )).getSession();
         queryStatement = QueryTransformerFactory.createHQLQueryTransformer().createStatement( query );
         org.hibernate.Query hibernateQuery = hibernateSession.createQuery( queryStatement );
         if( query.getFirstResult() != null )
            hibernateQuery.setFirstResult( query.getFirstResult().intValue() );
         if( query.getMaxResults() != null )
            hibernateQuery.setMaxResults( query.getMaxResults().intValue() );
         List<?> resultList = hibernateQuery.list();
         resultSet = determineResultSet( resultList );
      }catch( QueryException e ){
         log.debug( "Running query: '" + queryStatement + "' raised an exception.", e );
         throw new PersistenceProviderException( "findByQuery", e );
      }catch( SQLGrammarException e ){
         throw new PersistenceProviderException( "findByQuery", e );
      }catch( Exception e ){
         e.printStackTrace();
         throw new Error( "Unhandled exception." );
      }
      return resultSet;
   }

   // Properties
   public String getDriverClass() {
      return configuration.getString( HibernatePersistenceProviderPropertyKey.DRIVER_CLASS.getDefaultKey() );
   }

   public String getConnectionUrl() {
      return configuration.getString( HibernatePersistenceProviderPropertyKey.CONNECTION_URL.getDefaultKey() );
   }

   public String getUserName() {
      return configuration.getString( HibernatePersistenceProviderPropertyKey.USER_NAME.getDefaultKey() );
   }

   public String getPassword() {
      return configuration.getString( HibernatePersistenceProviderPropertyKey.PASSWORD.getDefaultKey() );
   }

   public Configuration getHibernateConfiguration() {
      return hibernateConfiguration;
   }

   SessionFactory getSessionFactory() {
      return sessionFactory;
   }

   // Private helper methods
   @Override
   protected SessionContext startNewSessionContext( UnitOfWork work ) {
      HibernateSessionContext sessionContext = new HibernateSessionContext( sessionFactory );
      return sessionContext;
   }

   @Override
   protected void finishSessionContext( SessionContext context ) {
   // TODO Auto-generated method stub
   }

   @SuppressWarnings( "unchecked" )
   private void addPropertiesToTheHibernateConfiguration() {
      HierarchicalConfiguration hibernateProperties = configuration.configurationAt( HIBERNATE_PROPERTY_SELECTOR );
      for( Iterator<String> iter = hibernateProperties.getKeys(); iter.hasNext(); ){
         String propertyKey = (String) iter.next();
         String propertyValue = hibernateProperties.getString( propertyKey );

         if( propertyKey != "" && propertyValue != "" ){
            propertyKey = propertyKey.toLowerCase();
            propertyKey = propertyKey.replace( PersistenceContext.NAME_SPACE_PREFIX, "" );
            propertyKey = "hibernate." + propertyKey.replace( '/', '.' );
            hibernateConfiguration.setProperty( propertyKey, propertyValue );
         }
      }
   }

   private void addEntityClassesToTheHibernateConfiguration() {
      for( Iterator<Class<?>> iter = persistentClasses.iterator(); iter.hasNext(); ){
         Class<?> persistentClass = (Class<?>) iter.next();
         try{
            log.debug( "Adding: " + persistentClass + " class to Hibernate configuration." );
            hibernateConfiguration.addClass( persistentClass );
         }catch( MappingException e ){
            throw new RepositoryEventHandlerConfigurationException( configuration, e );
         }
      }
   }

   @SuppressWarnings( "unchecked" )
   private RepositoryResultSet<? extends PersistentObject> determineResultSet( List<?> resultList ) {
      RepositoryResultSet<? extends PersistentObject> resultSet = null;
      if( resultList != null && resultList.size() > 0 ){
         Object firstObject = resultList.get( 0 );

         if( firstObject instanceof Long )
            resultSet = new AggregatedResult<PersistentLong>( PersistentLong.class, (List<PersistentLong>) resultList );
         else
            resultSet = new SimpleResultSet<PersistentObject>( (List<PersistentObject>) resultList );
      }else
         resultSet = new SimpleResultSet<PersistentObject>( (List<PersistentObject>) resultList );

      return resultSet;
   }

   private void handleDatabaseInitializationStrategy() {
      if( databaseCreationStrategy == PersistentDataInitializationStrategies.create ){
         hibernateConfiguration.setProperty( "hibernate.hbm2ddl.auto", "create" );
      }else if( databaseCreationStrategy == PersistentDataInitializationStrategies.dropAndCreate ){
         hibernateConfiguration.setProperty( "hibernate.hbm2ddl.auto", "create-drop" );
      }else if( databaseCreationStrategy == PersistentDataInitializationStrategies.update ){
         hibernateConfiguration.setProperty( "hibernate.hbm2ddl.auto", "update" );
      }
   }

   private void initDatabase() {
      try{
         sessionFactory = hibernateConfiguration.buildSessionFactory();
      }catch( Exception e ){
         log.debug( e.getMessage() );
         throw new RepositoryEventHandlerConfigurationException( configuration, e );
      }
   }

   @SuppressWarnings( { "unchecked", "unused" } )
   private void printProperties() {
      for( Iterator iter = hibernateConfiguration.getProperties().entrySet().iterator(); iter.hasNext(); ){
         Map.Entry<String, String> propertyEntry = (Map.Entry) iter.next();
         String key = propertyEntry.getKey();
         String value = propertyEntry.getValue();
         System.out.println( key + " = " + value );
      }
   }

}