cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/occurrence/OccurrenceDaoHibernateImpl.java

   1 /**
   2 * Copyright (C) 2008 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 */
   6
   7 package eu.etaxonomy.cdm.persistence.dao.hibernate.occurrence;
   8
   9 import java.util.ArrayList;
  10 import java.util.List;
  11 import java.util.Set;
  12
  13 import org.apache.log4j.Logger;
  14 import org.apache.lucene.analysis.SimpleAnalyzer;
  15 import org.apache.lucene.queryParser.ParseException;
  16 import org.apache.lucene.queryParser.QueryParser;
  17 import org.hibernate.Hibernate;
  18 import org.hibernate.Query;
  19 import org.hibernate.envers.query.AuditEntity;
  20 import org.hibernate.envers.query.AuditQuery;
  21 import org.hibernate.search.FullTextSession;
  22 import org.hibernate.search.Search;
  23 import org.hibernate.search.SearchFactory;
  24 import org.springframework.stereotype.Repository;
  25
  26 import eu.etaxonomy.cdm.model.media.Media;
  27 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  28 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  29 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  30 import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;
  31 import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
  32 import eu.etaxonomy.cdm.model.occurrence.FieldObservation;
  33 import eu.etaxonomy.cdm.model.occurrence.LivingBeing;
  34 import eu.etaxonomy.cdm.model.occurrence.Observation;
  35 import eu.etaxonomy.cdm.model.occurrence.Specimen;
  36 import eu.etaxonomy.cdm.model.occurrence.Fossil;
  37 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  38 import eu.etaxonomy.cdm.model.taxon.Synonym;
  39 import eu.etaxonomy.cdm.model.taxon.Taxon;
  40 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  41 import eu.etaxonomy.cdm.model.view.AuditEvent;
  42 import eu.etaxonomy.cdm.persistence.dao.QueryParseException;
  43 import eu.etaxonomy.cdm.persistence.dao.common.ISearchableDao;
  44 import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;
  45 import eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl;
  46 import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;
  47 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  48
  49 /**
  50  * @author a.babadshanjan
  51  * @created 01.09.2008
  52  */
  53 @Repository
  54 public class OccurrenceDaoHibernateImpl extends IdentifiableDaoBase<SpecimenOrObservationBase> implements IOccurrenceDao {
  55
  56         @SuppressWarnings("unused")
  57         private static final Logger logger = Logger.getLogger(TaxonDaoHibernateImpl.class);
  58
  59         private static final String defaultField = "titleCache";
  60         private Class<? extends SpecimenOrObservationBase> indexedClasses[];
  61
  62         public OccurrenceDaoHibernateImpl() {
  63                 super(SpecimenOrObservationBase.class);
  64                 indexedClasses = new Class[7];
  65                 indexedClasses[0] = FieldObservation.class;
  66                 indexedClasses[1] = DerivedUnit.class;
  67                 indexedClasses[2] = LivingBeing.class;
  68                 indexedClasses[3] = Observation.class;
  69                 indexedClasses[4] = Specimen.class;
  70                 indexedClasses[5] = DnaSample.class;
  71                 indexedClasses[6] = Fossil.class;
  72         }
  73
  74         public int countDerivationEvents(SpecimenOrObservationBase occurence) {
  75                 checkNotInPriorView("OccurrenceDaoHibernateImpl.countDerivationEvents(SpecimenOrObservationBase occurence)");
  76                 Query query = getSession().createQuery("select count(distinct derivationEvent) from DerivationEvent derivationEvent join derivationEvent.originals occurence where occurence = :occurence");
  77                 query.setParameter("occurence", occurence);
  78
  79                 return ((Long)query.uniqueResult()).intValue();
  80         }
  81
  82         public int countDeterminations(SpecimenOrObservationBase occurence) {
  83                 AuditEvent auditEvent = getAuditEventFromContext();
  84                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
  85                     Query query = getSession().createQuery("select count(determination) from DeterminationEvent determination where determination.identifiedUnit = :occurence");
  86                     query.setParameter("occurence", occurence);
  87                     return ((Long)query.uniqueResult()).intValue();
  88                 } else {
  89                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DeterminationEvent.class,auditEvent.getRevisionNumber());
  90                         query.add(AuditEntity.relatedId("identifiedUnit").eq(occurence.getId()));
  91                         query.addProjection(AuditEntity.id().count("id"));
  92
  93                         return ((Long)query.getSingleResult()).intValue();
  94                 }
  95         }
  96
  97         public int countMedia(SpecimenOrObservationBase occurence) {
  98                 checkNotInPriorView("OccurrenceDaoHibernateImpl.countMedia(SpecimenOrObservationBase occurence)");
  99                 Query query = getSession().createQuery("select count(media) from SpecimenOrObservationBase occurence join occurence.media media where occurence = :occurence");
 100                 query.setParameter("occurence", occurence);
 101
 102                 return ((Long)query.uniqueResult()).intValue();
 103         }
 104
 105         public List<DerivationEvent> getDerivationEvents(SpecimenOrObservationBase occurence, Integer pageSize,Integer pageNumber, List<String> propertyPaths) {
 106                 checkNotInPriorView("OccurrenceDaoHibernateImpl.getDerivationEvents(SpecimenOrObservationBase occurence, Integer pageSize,Integer pageNumber)");
 107                 Query query = getSession().createQuery("select distinct derivationEvent from DerivationEvent derivationEvent join derivationEvent.originals occurence where occurence = :occurence");
 108                 query.setParameter("occurence", occurence);
 109
 110                 if(pageSize != null) {
 111                     query.setMaxResults(pageSize);
 112                     if(pageNumber != null) {
 113                         query.setFirstResult(pageNumber * pageSize);
 114                     } else {
 115                         query.setFirstResult(0);
 116                     }
 117                 }
 118
 119                 List<DerivationEvent> result = (List<DerivationEvent>)query.list();
 120                 defaultBeanInitializer.initializeAll(result, propertyPaths);
 121                 return result;
 122         }
 123
 124         public List<DeterminationEvent> getDeterminations(SpecimenOrObservationBase occurence, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 125                 AuditEvent auditEvent = getAuditEventFromContext();
 126                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 127                         Query query = getSession().createQuery("select determination from DeterminationEvent determination where determination.identifiedUnit = :occurence");
 128                         query.setParameter("occurence", occurence);
 129
 130                         if(pageSize != null) {
 131                                 query.setMaxResults(pageSize);
 132                                 if(pageNumber != null) {
 133                                         query.setFirstResult(pageNumber * pageSize);
 134                                 } else {
 135                                         query.setFirstResult(0);
 136                                 }
 137                         }
 138                         List<DeterminationEvent> result = (List<DeterminationEvent>)query.list();
 139             defaultBeanInitializer.initializeAll(result, propertyPaths);
 140                         return result;
 141                 } else {
 142                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DeterminationEvent.class,auditEvent.getRevisionNumber());
 143                         query.add(AuditEntity.relatedId("identifiedUnit").eq(occurence.getId()));
 144                         if(pageSize != null) {
 145                                 query.setMaxResults(pageSize);
 146                                 if(pageNumber != null) {
 147                                         query.setFirstResult(pageNumber * pageSize);
 148                                 } else {
 149                                         query.setFirstResult(0);
 150                                 }
 151                         }
 152                         List<DeterminationEvent> result = (List<DeterminationEvent>)query.getResultList();
 153             defaultBeanInitializer.initializeAll(result, propertyPaths);
 154                         return result;
 155                 }
 156         }
 157
 158         public List<Media> getMedia(SpecimenOrObservationBase occurence, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 159                 checkNotInPriorView("OccurrenceDaoHibernateImpl.getMedia(SpecimenOrObservationBase occurence, Integer pageSize, Integer pageNumber, List<String> propertyPaths)");
 160                 Query query = getSession().createQuery("select media from SpecimenOrObservationBase occurence join occurence.media media where occurence = :occurence");
 161                 query.setParameter("occurence", occurence);
 162
 163                 if(pageSize != null) {
 164                     query.setMaxResults(pageSize);
 165                     if(pageNumber != null) {
 166                         query.setFirstResult(pageNumber * pageSize);
 167                     } else {
 168                         query.setFirstResult(0);
 169                     }
 170                 }
 171
 172                 List<Media> results = (List<Media>)query.list();
 173                 defaultBeanInitializer.initializeAll(results, propertyPaths);
 174                 return results;
 175         }
 176
 177         public int count(Class clazz, String queryString) {
 178                 checkNotInPriorView("OccurrenceDaoHibernateImpl.count(String queryString, Boolean accepted)");
 179         QueryParser queryParser = new QueryParser(defaultField, new SimpleAnalyzer());
 180
 181                 try {
 182                         org.apache.lucene.search.Query query = queryParser.parse(queryString);
 183
 184                         FullTextSession fullTextSession = Search.getFullTextSession(this.getSession());
 185                         org.hibernate.search.FullTextQuery fullTextQuery = null;
 186
 187                         if(clazz == null) {
 188                                 fullTextQuery = fullTextSession.createFullTextQuery(query, type);
 189                         } else {
 190                                 fullTextQuery = fullTextSession.createFullTextQuery(query, clazz);
 191                         }
 192
 193                     Integer  result = fullTextQuery.getResultSize();
 194                     return result;
 195
 196                 } catch (ParseException e) {
 197                         throw new QueryParseException(e, queryString);
 198                 }
 199         }
 200
 201         public void optimizeIndex() {
 202                 FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 203                 SearchFactory searchFactory = fullTextSession.getSearchFactory();
 204                 for(Class clazz : indexedClasses) {
 205                 searchFactory.optimize(clazz); // optimize the indices ()
 206                 }
 207             fullTextSession.flushToIndexes();
 208         }
 209
 210         public void purgeIndex() {
 211                 FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 212                 for(Class clazz : indexedClasses) {
 213                     fullTextSession.purgeAll(clazz); // remove all taxon base from indexes
 214                 }
 215                 fullTextSession.flushToIndexes();
 216         }
 217
 218         public void rebuildIndex() {
 219         FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 220
 221                 for(SpecimenOrObservationBase occurrence : list(null,null)) { // re-index all taxon base
 222
 223                         for(DeterminationEvent determination : (Set<DeterminationEvent>)occurrence.getDeterminations()) {
 224                             Hibernate.initialize(determination.getActor());
 225                             Hibernate.initialize(determination.getTaxon());
 226                         }
 227                         Hibernate.initialize(occurrence.getDefinition());
 228                         if(occurrence instanceof DerivedUnitBase) {
 229                                 DerivedUnitBase derivedUnit = (DerivedUnitBase) occurrence;
 230                                 Hibernate.initialize(derivedUnit.getCollection());
 231                                 if(derivedUnit.getCollection() != null) {
 232                                         Hibernate.initialize(derivedUnit.getCollection().getSuperCollection());
 233                                         Hibernate.initialize(derivedUnit.getCollection().getInstitute());
 234                                 }
 235                                 Hibernate.initialize(derivedUnit.getStoredUnder());
 236                                 SpecimenOrObservationBase original = derivedUnit.getOriginalUnit();
 237                                 if(original != null && original.isInstanceOf(FieldObservation.class)) {
 238                                         FieldObservation fieldObservation = original.deproxy(original, FieldObservation.class);
 239                                         Hibernate.initialize(fieldObservation.getGatheringEvent());
 240                                         if(fieldObservation.getGatheringEvent() != null) {
 241                                                 Hibernate.initialize(fieldObservation.getGatheringEvent().getActor());
 242                                         }
 243                                 }
 244                         }
 245                         fullTextSession.index(occurrence);
 246                 }
 247                 fullTextSession.flushToIndexes();
 248         }
 249
 250         public List<SpecimenOrObservationBase> search(Class<? extends SpecimenOrObservationBase> clazz, String queryString,Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 251                 checkNotInPriorView("OccurrenceDaoHibernateImpl.searchTaxa(String queryString, Boolean accepted,        Integer pageSize, Integer pageNumber)");
 252                 QueryParser queryParser = new QueryParser(defaultField, new SimpleAnalyzer());
 253                 List<SpecimenOrObservationBase> results = new ArrayList<SpecimenOrObservationBase>();
 254
 255                 try {
 256                         org.apache.lucene.search.Query query = queryParser.parse(queryString);
 257
 258                         FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 259                         org.hibernate.search.FullTextQuery fullTextQuery = null;
 260
 261                         if(clazz == null) {
 262                                 fullTextQuery = fullTextSession.createFullTextQuery(query, SpecimenOrObservationBase.class);
 263                         } else {
 264                                 fullTextQuery = fullTextSession.createFullTextQuery(query, clazz);
 265                         }
 266
 267                         addOrder(fullTextQuery,orderHints);
 268
 269                     if(pageSize != null) {
 270                         fullTextQuery.setMaxResults(pageSize);
 271                             if(pageNumber != null) {
 272                                 fullTextQuery.setFirstResult(pageNumber * pageSize);
 273                             } else {
 274                                 fullTextQuery.setFirstResult(0);
 275                             }
 276                         }
 277
 278                     List<SpecimenOrObservationBase> result = (List<SpecimenOrObservationBase>)fullTextQuery.list();
 279                     defaultBeanInitializer.initializeAll(result, propertyPaths);
 280                     return result;
 281
 282                 } catch (ParseException e) {
 283                         throw new QueryParseException(e, queryString);
 284                 }
 285         }
 286
 287         public String suggestQuery(String string) {
 288                 throw new UnsupportedOperationException("suggestQuery is not supported for SpecimenOrObservationBase");
 289         }
 290 }