cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/hibernate/CdmCrudEvent.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.persistence.hibernate;
  11
  12 import java.io.Serializable;
  13
  14 import org.apache.log4j.Logger;
  15 import org.hibernate.event.AbstractEvent;
  16 import org.hibernate.event.EventSource;
  17 import org.hibernate.event.PostDeleteEvent;
  18 import org.hibernate.event.PostInsertEvent;
  19 import org.hibernate.event.PostLoadEvent;
  20 import org.hibernate.event.PostUpdateEvent;
  21 import org.hibernate.persister.entity.EntityPersister;
  22
  23 import eu.etaxonomy.cdm.model.common.CdmBase;
  24
  25 //$Id$
  26 /**
  27  * The CrudEvent unifies all CRUD events into one interface.
  28  * Crud as in Create, Retrieve, Update, Delete. This event will only hold CdmBase objects.
  29  *
  30  *
  31  * @author n.hoffmann
  32  * @created 24.03.2009
  33  * @version 1.0
  34  */
  35 public class CdmCrudEvent extends AbstractEvent{
  36
  37         private static final long serialVersionUID = 9113025682352080372L;
  38
  39         private static final Logger logger = Logger
  40                         .getLogger(CdmCrudEvent.class);
  41
  42         /**
  43          * The event types currently implemented
  44          *
  45          * @author n.hoffmann
  46          * @created 25.03.2009
  47          * @version 1.0
  48          */
  49         public enum EventType {
  50                 INSERT, LOAD, UPDATE, DELETE
  51         }
  52
  53         private CdmBase entity;
  54         private EntityPersister persister;
  55         private Object[] state;
  56         // for update only
  57         private Object[] oldState;
  58         private Serializable id;
  59         private EventType eventType;
  60
  61         /**
  62          * @param source
  63          */
  64         private CdmCrudEvent(
  65                         CdmBase entity,
  66                         Serializable id,
  67                         Object[] state,
  68                         Object[] oldState,
  69                         EntityPersister persister,
  70                         EventSource source,
  71                         EventType eventType
  72         ) {
  73                 super(source);
  74                 this.entity = entity;
  75                 this.id = id;
  76                 this.state = state;
  77                 this.oldState = oldState;
  78                 this.persister = persister;
  79                 this.eventType = eventType;
  80         }
  81
  82         public CdmBase getEntity() {
  83                 return entity;
  84         }
  85         public Serializable getId() {
  86                 return id;
  87         }
  88         public EntityPersister getPersister() {
  89                 return persister;
  90         }
  91         public Object[] getState() {
  92                 return state;
  93         }
  94         public Object[] getOldState() {
  95                 if(oldState == null){
  96                         oldState = state;
  97                 }
  98                 return oldState;
  99         }
 100
 101         public EventType getEventType(){
 102                 return eventType;
 103         }
 104
 105         public boolean isInsert(){
 106                 return eventType == EventType.INSERT;
 107         }
 108
 109         public boolean isLoad(){
 110                 return eventType == EventType.LOAD;
 111         }
 112
 113         public boolean isUpdate(){
 114                 return eventType == EventType.UPDATE;
 115         }
 116
 117         public boolean isDelete(){
 118                 return eventType == EventType.DELETE;
 119         }
 120
 121         /**
 122          * @param event
 123          * @return
 124          */
 125         public static CdmCrudEvent NewInstance(AbstractEvent event) {
 126
 127                 CdmCrudEvent mediationEvent = null;
 128                 try{
 129                         if(event instanceof PostInsertEvent){
 130                                 PostInsertEvent postEvent = (PostInsertEvent) event;
 131                                 mediationEvent = new CdmCrudEvent(
 132                                                                                                                                 (CdmBase)postEvent.getEntity(),
 133                                                                                                                                 postEvent.getId(),
 134                                                                                                                                 postEvent.getState(),
 135                                                                                                                                 null,
 136                                                                                                                                 postEvent.getPersister(),
 137                                                                                                                                 postEvent.getSession(),
 138                                                                                                                                 EventType.INSERT
 139                                                                                                                                 );
 140                         }
 141                         if(event instanceof PostLoadEvent){
 142                                 PostLoadEvent updateEvent = (PostLoadEvent) event;
 143                                 mediationEvent = new CdmCrudEvent(
 144                                                                                                                                 (CdmBase)updateEvent.getEntity(),
 145                                                                                                                                 updateEvent.getId(),
 146                                                                                                                                 null,
 147                                                                                                                                 null,
 148                                                                                                                                 updateEvent.getPersister(),
 149                                                                                                                                 updateEvent.getSession(),
 150                                                                                                                                 EventType.LOAD
 151                                                                                                                                 );
 152                         }
 153                         if(event instanceof PostUpdateEvent){
 154                                 PostUpdateEvent updateEvent = (PostUpdateEvent) event;
 155                                 mediationEvent = new CdmCrudEvent(
 156                                                                                                                                 (CdmBase)updateEvent.getEntity(),
 157                                                                                                                                 updateEvent.getId(),
 158                                                                                                                                 updateEvent.getState(),
 159                                                                                                                                 updateEvent.getOldState(),
 160                                                                                                                                 updateEvent.getPersister(),
 161                                                                                                                                 updateEvent.getSession(),
 162                                                                                                                                 EventType.UPDATE
 163                                                                                                                                 );
 164                         }
 165                         if(event instanceof PostDeleteEvent){
 166                                 PostDeleteEvent deleteEvent = (PostDeleteEvent) event;
 167                                 mediationEvent = new CdmCrudEvent(
 168                                                                                                                                 (CdmBase)deleteEvent.getEntity(),
 169                                                                                                                                 deleteEvent.getId(),
 170                                                                                                                                 deleteEvent.getDeletedState(),
 171                                                                                                                                 null,
 172                                                                                                                                 deleteEvent.getPersister(),
 173                                                                                                                                 deleteEvent.getSession(),
 174                                                                                                                                 EventType.DELETE
 175                                                                                                                                 );
 176                         }
 177                 }catch(ClassCastException e){
 178                         // we are only interested in CdmBase entities, we have the try/catch block in case another entity slips through
 179                         logger.warn("tried to instantiate event for non CdmBase entity");
 180                 }
 181
 182                 return mediationEvent;
 183         }
 184
 185 }