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 import java.util.Set;
  14
  15 import org.apache.logging.log4j.LogManager;
  16 import org.apache.logging.log4j.Logger;
  17 import org.hibernate.event.spi.AbstractEvent;
  18 import org.hibernate.event.spi.EventSource;
  19 import org.hibernate.event.spi.PostDeleteEvent;
  20 import org.hibernate.event.spi.PostInsertEvent;
  21 import org.hibernate.event.spi.PostLoadEvent;
  22 import org.hibernate.event.spi.PostUpdateEvent;
  23 import org.hibernate.persister.entity.EntityPersister;
  24
  25 import eu.etaxonomy.cdm.model.common.CdmBase;
  26
  27 /**
  28  * The CrudEvent unifies all CRUD events into one interface.
  29  * Crud as in Create, Retrieve, Update, Delete. This event will only hold CdmBase objects.
  30  *
  31  *
  32  * @author n.hoffmann
  33  * @since 24.03.2009
  34  */
  35 public class CdmDataChangeEvent extends AbstractEvent{
  36     private static final long serialVersionUID = 9113025682352080372L;
  37     private static final Logger logger = LogManager.getLogger();
  38
  39     /**
  40      * The event types currently implemented
  41      *
  42      * @author n.hoffmann
  43      * @since 25.03.2009
  44      * @version 1.0
  45      */
  46     public enum EventType {
  47         INSERT, LOAD, UPDATE, DELETE
  48     }
  49
  50     private final CdmBase entity;
  51     private final EntityPersister persister;
  52     private final Set<CdmBase> affectedObjects;
  53
  54
  55     private final Object[] state;
  56     // for update only
  57     private Object[] oldState;
  58     private final Serializable id;
  59     protected final EventType eventType;
  60
  61
  62     private CdmDataChangeEvent(
  63             CdmBase entity,
  64             Serializable id,
  65             Object[] state,
  66             Object[] oldState,
  67             EntityPersister persister,
  68             EventSource source,
  69             EventType eventType
  70             ) {
  71         super(source);
  72         this.entity = entity;
  73         this.id = id;
  74         this.state = state;
  75         this.oldState = oldState;
  76         this.persister = persister;
  77         this.eventType = eventType;
  78         this.affectedObjects = null;
  79     }
  80     /**
  81      * @param source
  82      */
  83     private CdmDataChangeEvent(
  84             CdmBase entity,
  85             Set<CdmBase> affectedObjects,
  86             EventType eventType
  87             ) {
  88         super(null);
  89         this.entity = entity;
  90         this.persister = null;
  91         this.affectedObjects = affectedObjects;
  92         this.state = null;
  93         this.oldState = null;
  94         this.id = null;
  95         this.eventType = eventType;
  96     }
  97
  98     public CdmBase getEntity() {
  99         return entity;
 100     }
 101     public Serializable getId() {
 102         return id;
 103     }
 104     public EntityPersister getPersister() {
 105         return persister;
 106     }
 107     public Object[] getState() {
 108         return state;
 109     }
 110     public Object[] getOldState() {
 111         if(oldState == null){
 112             oldState = state;
 113         }
 114         return oldState;
 115     }
 116
 117     public Set<CdmBase> getAffectedObjects() {
 118         return affectedObjects;
 119     }
 120
 121     public EventType getEventType(){
 122         return eventType;
 123     }
 124
 125     public boolean isInsert(){
 126         return eventType == EventType.INSERT;
 127     }
 128
 129     public boolean isLoad(){
 130         return eventType == EventType.LOAD;
 131     }
 132
 133     public boolean isUpdate(){
 134         return eventType == EventType.UPDATE;
 135     }
 136
 137     public boolean isDelete(){
 138         return eventType == EventType.DELETE;
 139     }
 140
 141     /**
 142      * @param event
 143      * @return
 144      */
 145     public static CdmDataChangeEvent NewInstance(AbstractEvent event) {
 146
 147         CdmDataChangeEvent mediationEvent = null;
 148         try{
 149             if(event instanceof PostInsertEvent){
 150                 PostInsertEvent postEvent = (PostInsertEvent) event;
 151                 mediationEvent = new CdmDataChangeEvent(
 152                         (CdmBase)postEvent.getEntity(),
 153                         postEvent.getId(),
 154                         postEvent.getState(),
 155                         null,
 156                         postEvent.getPersister(),
 157                         postEvent.getSession(),
 158                         EventType.INSERT
 159                         );
 160             }
 161             if(event instanceof PostLoadEvent){
 162                 PostLoadEvent updateEvent = (PostLoadEvent) event;
 163                 mediationEvent = new CdmDataChangeEvent(
 164                         (CdmBase)updateEvent.getEntity(),
 165                         updateEvent.getId(),
 166                         null,
 167                         null,
 168                         updateEvent.getPersister(),
 169                         updateEvent.getSession(),
 170                         EventType.LOAD
 171                         );
 172             }
 173             if(event instanceof PostUpdateEvent){
 174                 PostUpdateEvent updateEvent = (PostUpdateEvent) event;
 175                 mediationEvent = new CdmDataChangeEvent(
 176                         (CdmBase)updateEvent.getEntity(),
 177                         updateEvent.getId(),
 178                         updateEvent.getState(),
 179                         updateEvent.getOldState(),
 180                         updateEvent.getPersister(),
 181                         updateEvent.getSession(),
 182                         EventType.UPDATE
 183                         );
 184             }
 185             if(event instanceof PostDeleteEvent){
 186                 PostDeleteEvent deleteEvent = (PostDeleteEvent) event;
 187                 mediationEvent = new CdmDataChangeEvent(
 188                         (CdmBase)deleteEvent.getEntity(),
 189                         deleteEvent.getId(),
 190                         deleteEvent.getDeletedState(),
 191                         null,
 192                         deleteEvent.getPersister(),
 193                         deleteEvent.getSession(),
 194                         EventType.DELETE
 195                         );
 196             }
 197         }catch(ClassCastException e){
 198             // we are only interested in CdmBase entities, we have the try/catch block in case another entity slips through
 199             logger.warn("tried to instantiate event for non CdmBase entity");
 200         }
 201
 202         return mediationEvent;
 203     }
 204
 205     public static CdmDataChangeEvent NewInstance(CdmBase entity, Set<CdmBase> affectedObjects, EventType eventType) {
 206
 207         return new CdmDataChangeEvent(entity, affectedObjects, eventType);
 208     }
 209
 210 }