cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/hibernate/CdmDataChangeEvent.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 CdmDataChangeEvent extends AbstractEvent{
  36         private static final long serialVersionUID = 9113025682352080372L;
  37         private static final Logger logger = Logger.getLogger(CdmDataChangeEvent.class);
  38
  39         /**
  40          * The event types currently implemented
  41          *
  42          * @author n.hoffmann
  43          * @created 25.03.2009
  44          * @version 1.0
  45          */
  46         public enum EventType {
  47                 INSERT, LOAD, UPDATE, DELETE
  48         }
  49
  50         private CdmBase entity;
  51         private EntityPersister persister;
  52         private Object[] state;
  53         // for update only
  54         private Object[] oldState;
  55         private Serializable id;
  56         private EventType eventType;
  57
  58         /**
  59          * @param source
  60          */
  61         private CdmDataChangeEvent(
  62                         CdmBase entity,
  63                         Serializable id,
  64                         Object[] state,
  65                         Object[] oldState,
  66                         EntityPersister persister,
  67                         EventSource source,
  68                         EventType eventType
  69         ) {
  70                 super(source);
  71                 this.entity = entity;
  72                 this.id = id;
  73                 this.state = state;
  74                 this.oldState = oldState;
  75                 this.persister = persister;
  76                 this.eventType = eventType;
  77         }
  78
  79         public CdmBase getEntity() {
  80                 return entity;
  81         }
  82         public Serializable getId() {
  83                 return id;
  84         }
  85         public EntityPersister getPersister() {
  86                 return persister;
  87         }
  88         public Object[] getState() {
  89                 return state;
  90         }
  91         public Object[] getOldState() {
  92                 if(oldState == null){
  93                         oldState = state;
  94                 }
  95                 return oldState;
  96         }
  97
  98         public EventType getEventType(){
  99                 return eventType;
 100         }
 101
 102         public boolean isInsert(){
 103                 return eventType == EventType.INSERT;
 104         }
 105
 106         public boolean isLoad(){
 107                 return eventType == EventType.LOAD;
 108         }
 109
 110         public boolean isUpdate(){
 111                 return eventType == EventType.UPDATE;
 112         }
 113
 114         public boolean isDelete(){
 115                 return eventType == EventType.DELETE;
 116         }
 117
 118         /**
 119          * @param event
 120          * @return
 121          */
 122         public static CdmDataChangeEvent NewInstance(AbstractEvent event) {
 123
 124                 CdmDataChangeEvent mediationEvent = null;
 125                 try{
 126                         if(event instanceof PostInsertEvent){
 127                                 PostInsertEvent postEvent = (PostInsertEvent) event;
 128                                 mediationEvent = new CdmDataChangeEvent(
 129                                                                                                                                 (CdmBase)postEvent.getEntity(),
 130                                                                                                                                 postEvent.getId(),
 131                                                                                                                                 postEvent.getState(),
 132                                                                                                                                 null,
 133                                                                                                                                 postEvent.getPersister(),
 134                                                                                                                                 postEvent.getSession(),
 135                                                                                                                                 EventType.INSERT
 136                                                                                                                                 );
 137                         }
 138                         if(event instanceof PostLoadEvent){
 139                                 PostLoadEvent updateEvent = (PostLoadEvent) event;
 140                                 mediationEvent = new CdmDataChangeEvent(
 141                                                                                                                                 (CdmBase)updateEvent.getEntity(),
 142                                                                                                                                 updateEvent.getId(),
 143                                                                                                                                 null,
 144                                                                                                                                 null,
 145                                                                                                                                 updateEvent.getPersister(),
 146                                                                                                                                 updateEvent.getSession(),
 147                                                                                                                                 EventType.LOAD
 148                                                                                                                                 );
 149                         }
 150                         if(event instanceof PostUpdateEvent){
 151                                 PostUpdateEvent updateEvent = (PostUpdateEvent) event;
 152                                 mediationEvent = new CdmDataChangeEvent(
 153                                                                                                                                 (CdmBase)updateEvent.getEntity(),
 154                                                                                                                                 updateEvent.getId(),
 155                                                                                                                                 updateEvent.getState(),
 156                                                                                                                                 updateEvent.getOldState(),
 157                                                                                                                                 updateEvent.getPersister(),
 158                                                                                                                                 updateEvent.getSession(),
 159                                                                                                                                 EventType.UPDATE
 160                                                                                                                                 );
 161                         }
 162                         if(event instanceof PostDeleteEvent){
 163                                 PostDeleteEvent deleteEvent = (PostDeleteEvent) event;
 164                                 mediationEvent = new CdmDataChangeEvent(
 165                                                                                                                                 (CdmBase)deleteEvent.getEntity(),
 166                                                                                                                                 deleteEvent.getId(),
 167                                                                                                                                 deleteEvent.getDeletedState(),
 168                                                                                                                                 null,
 169                                                                                                                                 deleteEvent.getPersister(),
 170                                                                                                                                 deleteEvent.getSession(),
 171                                                                                                                                 EventType.DELETE
 172                                                                                                                                 );
 173                         }
 174                 }catch(ClassCastException e){
 175                         // we are only interested in CdmBase entities, we have the try/catch block in case another entity slips through
 176                         logger.warn("tried to instantiate event for non CdmBase entity");
 177                 }
 178
 179                 return mediationEvent;
 180         }
 181
 182 }