cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/common/DefinedTermDaoImpl.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.dao.hibernate.common;
  11
  12 import java.net.URI;
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.Enumeration;
  16 import java.util.List;
  17 import java.util.Locale;
  18 import java.util.Set;
  19 import java.util.UUID;
  20
  21 import org.apache.commons.lang.StringUtils;
  22 import org.apache.log4j.Logger;
  23 import org.hibernate.Criteria;
  24 import org.hibernate.Query;
  25 import org.hibernate.Session;
  26 import org.hibernate.criterion.Criterion;
  27 import org.hibernate.criterion.Projections;
  28 import org.hibernate.criterion.Restrictions;
  29 import org.hibernate.envers.query.AuditEntity;
  30 import org.hibernate.envers.query.AuditQuery;
  31 import org.springframework.stereotype.Repository;
  32
  33 import eu.etaxonomy.cdm.model.common.AnnotationType;
  34 import eu.etaxonomy.cdm.model.common.CdmBase;
  35 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  36 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  37 import eu.etaxonomy.cdm.model.common.ExtensionType;
  38 import eu.etaxonomy.cdm.model.common.Language;
  39 import eu.etaxonomy.cdm.model.common.MarkerType;
  40 import eu.etaxonomy.cdm.model.common.TermType;
  41 import eu.etaxonomy.cdm.model.description.AbsenceTerm;
  42 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
  43 import eu.etaxonomy.cdm.model.description.PresenceTerm;
  44 import eu.etaxonomy.cdm.model.description.State;
  45 import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
  46 import eu.etaxonomy.cdm.model.description.TextFormat;
  47 import eu.etaxonomy.cdm.model.location.Country;
  48 import eu.etaxonomy.cdm.model.location.NamedArea;
  49 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  50 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  51 import eu.etaxonomy.cdm.model.location.ReferenceSystem;
  52 import eu.etaxonomy.cdm.model.media.Media;
  53 import eu.etaxonomy.cdm.model.media.RightsType;
  54 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  55 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  56 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  57 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  58 import eu.etaxonomy.cdm.model.name.Rank;
  59 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  60 import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
  61 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  62 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  63 import eu.etaxonomy.cdm.model.view.AuditEvent;
  64 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  65 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  66 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  67
  68 /**
  69  * @author a.kohlbecker
  70  * @created 29.05.2008
  71  * @version 1.0
  72  */
  73 @Repository
  74 public class DefinedTermDaoImpl extends IdentifiableDaoBase<DefinedTermBase> implements IDefinedTermDao{
  75         private static final Logger logger = Logger.getLogger(DefinedTermDaoImpl.class);
  76
  77         public DefinedTermDaoImpl() {
  78                 super(DefinedTermBase.class);
  79                 indexedClasses = new Class[26];
  80                 indexedClasses[0] = Rank.class;
  81                 indexedClasses[1] = AnnotationType.class;
  82                 indexedClasses[2] = ExtensionType.class;
  83                 indexedClasses[3] = Language.class;
  84                 indexedClasses[4] = MarkerType.class;
  85                 indexedClasses[5] = AbsenceTerm.class;
  86                 indexedClasses[6] = MeasurementUnit.class;
  87                 indexedClasses[7] = DefinedTerm.class;
  88                 indexedClasses[8] = PresenceTerm.class;
  89                 indexedClasses[9] = State.class;
  90                 indexedClasses[10] = StatisticalMeasure.class;
  91                 indexedClasses[11] = TextFormat.class;
  92                 indexedClasses[12] = DerivationEventType.class;
  93                 indexedClasses[13] = NamedArea.class;
  94                 indexedClasses[14] = NamedAreaLevel.class;
  95                 indexedClasses[15] = NamedAreaType.class;
  96                 indexedClasses[16] = ReferenceSystem.class;
  97                 indexedClasses[17] = Country.class;
  98                 indexedClasses[18] = RightsType.class;
  99                 indexedClasses[19] = HybridRelationshipType.class;
 100                 indexedClasses[20] = NameRelationshipType.class;
 101                 indexedClasses[21] = NameTypeDesignationStatus.class;
 102                 indexedClasses[22] = NomenclaturalStatusType.class;
 103                 indexedClasses[23] = SpecimenTypeDesignationStatus.class;
 104                 indexedClasses[24] = SynonymRelationshipType.class;
 105                 indexedClasses[25] = TaxonRelationshipType.class;
 106         }
 107
 108         /**
 109          * Searches by Label
 110          * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String)
 111          */
 112         @Override
 113     public List<DefinedTermBase> findByTitle(String queryString) {
 114                 return findByTitle(queryString, null);
 115         }
 116
 117
 118         /**
 119          * Searches by Label
 120          * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)
 121          */
 122         @Override
 123     public List<DefinedTermBase> findByTitle(String queryString, CdmBase sessionObject) {
 124                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, CdmBase sessionObject)");
 125                 Session session = getSession();
 126                 if ( sessionObject != null ) {// FIXME is this needed?
 127                         session.update(sessionObject);
 128                 }
 129                 Query query = session.createQuery("select term from DefinedTermBase term join fetch term.representations representation where representation.label = :label");
 130                 query.setParameter("label", queryString);
 131                 return query.list();
 132
 133         }
 134
 135         @Override
 136     public List<DefinedTermBase> findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz) {
 137                 checkNotInPriorView("DefinedTermDaoImpl.findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz)");
 138                 Session session = getSession();
 139                 Criteria crit = session.createCriteria(clazz);
 140                 crit.add(Restrictions.ilike("persistentTitleCache", queryString));
 141                 List<DefinedTermBase> results = crit.list();
 142                 return results;
 143         }
 144
 145         @Override
 146     public List<DefinedTermBase> findByTitle(String queryString, MatchMode matchMode, int page, int pagesize, List<Criterion> criteria) {
 147                 //FIXME is query parametrised?
 148                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, ITitledDao.MATCH_MODE matchMode, int page, int pagesize, List<Criterion> criteria)");
 149                 Criteria crit = getSession().createCriteria(type);
 150                 crit.add(Restrictions.ilike("titleCache", matchMode.queryStringFrom(queryString)));
 151                 crit.setMaxResults(pagesize);
 152                 int firstItem = (page - 1) * pagesize + 1;
 153                 crit.setFirstResult(firstItem);
 154                 List<DefinedTermBase> results = crit.list();
 155                 return results;
 156         }
 157
 158
 159         @Override
 160     public Country getCountryByIso(String iso3166) {
 161                 // If iso639 = "" query returns non-unique result. We prevent this here:
 162                 if (StringUtils.isBlank(iso3166)) { return null; }
 163                 AuditEvent auditEvent = getAuditEventFromContext();
 164                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 165                   Query query = getSession().createQuery("from Country where iso3166_A2 = :isoCode");
 166                   query.setParameter("isoCode", iso3166);
 167                   return (Country) query.uniqueResult();
 168                 } else {
 169                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Country.class,auditEvent.getRevisionNumber());
 170                         query.add(AuditEntity.property("iso3166_A2").eq(iso3166));
 171                         return (Country) query.getSingleResult();
 172                 }
 173         }
 174
 175         @Override
 176     public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz ) {
 177                 return getDefinedTermByRepresentationText(text,clazz,null,null);
 178         }
 179
 180         @Override
 181     public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {
 182                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber)");
 183
 184                 Criteria criteria = null;
 185                 if(clazz == null) {
 186                         criteria = getSession().createCriteria(type);
 187                 } else {
 188                         criteria = getSession().createCriteria(clazz);
 189                 }
 190
 191                 criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));
 192
 193                 if(pageSize != null) {
 194                         criteria.setMaxResults(pageSize);
 195                     if(pageNumber != null) {
 196                         criteria.setFirstResult(pageNumber * pageSize);
 197                     }
 198                 }
 199
 200                 return criteria.list();
 201         }
 202
 203         @Override
 204     public int countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz) {
 205             checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz)");
 206                 Criteria criteria = null;
 207                 if(clazz == null) {
 208                         criteria = getSession().createCriteria(type);
 209                 } else {
 210                         criteria = getSession().createCriteria(clazz);
 211                 }
 212
 213                 criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));
 214
 215                 criteria.setProjection(Projections.rowCount());
 216
 217         return ((Number)criteria.uniqueResult()).intValue();
 218         }
 219
 220         @Override
 221         public <T extends DefinedTermBase> List<T> getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber) {
 222                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber)");
 223
 224                 Criteria criteria = null;
 225                 if(clazz == null) {
 226                         criteria = getSession().createCriteria(type);
 227                 } else {
 228                         criteria = getSession().createCriteria(clazz);
 229                 }
 230
 231                 criteria.createAlias("vocabulary", "voc").add(Restrictions.like("voc.uuid", vocUuid))
 232                         .add(Restrictions.like("idInVocabulary", label, org.hibernate.criterion.MatchMode.EXACT));
 233
 234                 if(pageSize != null) {
 235                         criteria.setMaxResults(pageSize);
 236                     if(pageNumber != null) {
 237                         criteria.setFirstResult(pageNumber * pageSize);
 238                     }
 239                 }
 240
 241                 List<T> result = criteria.list();
 242                 return result;
 243         }
 244
 245         @Override
 246         public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationAbbrev(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {
 247                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationAbbrev(String abbrev, Class<T> clazz, Integer pageSize,Integer  pageNumber)");
 248
 249                 Criteria criteria = null;
 250                 if(clazz == null) {
 251                         criteria = getSession().createCriteria(type);
 252                 } else {
 253                         criteria = getSession().createCriteria(clazz);
 254                 }
 255
 256                 criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));
 257
 258                 if(pageSize != null) {
 259                         criteria.setMaxResults(pageSize);
 260                     if(pageNumber != null) {
 261                         criteria.setFirstResult(pageNumber * pageSize);
 262                     }
 263                 }
 264
 265                 return criteria.list();
 266         }
 267
 268         @Override
 269         public int countDefinedTermByRepresentationAbbrev(String text, Class<? extends DefinedTermBase> clazz) {
 270             checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationAbbrev(String abbrev, Class<? extends DefinedTermBase> clazz)");
 271                 Criteria criteria = null;
 272                 if(clazz == null) {
 273                         criteria = getSession().createCriteria(type);
 274                 } else {
 275                         criteria = getSession().createCriteria(clazz);
 276                 }
 277
 278                 criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));
 279
 280
 281                 criteria.setProjection(Projections.rowCount());
 282
 283         return ((Number)criteria.uniqueResult()).intValue();
 284         }
 285
 286         @Override
 287     public Language getLanguageByIso(String iso639) {
 288                 if (iso639.length() < 2 || iso639.length() > 3) {
 289                         logger.warn("Invalid length " + iso639.length() + " of ISO code. Length must be 2 or 3.");
 290                         return null;
 291                 }
 292                 boolean isIso639_1 = iso639.length() == 2;
 293
 294                 String queryStr;
 295                 if (isIso639_1){
 296                         queryStr = "from Language where iso639_1 = :isoCode";
 297                 }else{
 298                         queryStr = "from Language where idInVocabulary = :isoCode and vocabulary.uuid = :vocUuid";
 299                 }
 300                 AuditEvent auditEvent = getAuditEventFromContext();
 301                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 302                     Query query = getSession().createQuery(queryStr);
 303                     query.setParameter("isoCode", iso639);
 304                     if (! isIso639_1){
 305                         query.setParameter("vocUuid", Language.uuidLanguageVocabulary);
 306                         }
 307                     return (Language) query.uniqueResult();
 308                 } else {
 309                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Language.class,auditEvent.getRevisionNumber());
 310                         if (isIso639_1){
 311                                 query.add(AuditEntity.property("iso639_1").eq(iso639));
 312                         }else{
 313                                 query.add(AuditEntity.property("iso639_2").eq(iso639));
 314                                 query.add(AuditEntity.property("vocabulary.uuid").eq(Language.uuidLanguageVocabulary));
 315                         }
 316
 317                         return (Language)query.getSingleResult();
 318                 }
 319         }
 320
 321         /**
 322          *  FIXME this will result in a query per language - could you, given that iso codes
 323          *  are unique, use from Language where iso639_1 in (:isoCode) or iso639_2 in (:isoCode)
 324          */
 325         @Override
 326     public List<Language> getLanguagesByIso(List<String> iso639List) {
 327                 List<Language> languages = new ArrayList<Language>(iso639List.size());
 328                 for (String iso639 : iso639List) {
 329                         languages.add(getLanguageByIso(iso639));
 330                 }
 331                 return languages;
 332         }
 333
 334         @Override
 335     public List<Language> getLanguagesByLocale(Enumeration<Locale> locales) {
 336                 List<Language> languages = new ArrayList<Language>();
 337                 while(locales.hasMoreElements()) {
 338                         Locale locale = locales.nextElement();
 339                         languages.add(getLanguageByIso(locale.getLanguage()));
 340                 }
 341                 return languages;
 342         }
 343
 344         @Override
 345     public int count(NamedAreaLevel level, NamedAreaType type) {
 346                 AuditEvent auditEvent = getAuditEventFromContext();
 347                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 348                     Criteria criteria = getSession().createCriteria(NamedArea.class);
 349
 350                     if(level != null) {
 351                             criteria.add(Restrictions.eq("level",level));
 352                     }
 353
 354                     if(type != null) {
 355                             criteria.add(Restrictions.eq("type", type));
 356                     }
 357
 358                     criteria.setProjection(Projections.rowCount());
 359
 360                 return ((Number)criteria.uniqueResult()).intValue();
 361                 } else {
 362                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,auditEvent.getRevisionNumber());
 363
 364                         if(level != null) {
 365                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 366                     }
 367
 368                     if(type != null) {
 369                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 370                     }
 371                     query.addProjection(AuditEntity.id().count("id"));
 372                     return ((Long)query.getSingleResult()).intValue();
 373                 }
 374         }
 375
 376         @Override
 377     public int countMedia(DefinedTermBase definedTerm) {
 378                 checkNotInPriorView("DefinedTermDaoImpl.countMedia(DefinedTermBase definedTerm)");
 379                 Query query = getSession().createQuery("select count(media) from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 380             query.setParameter("definedTerm", definedTerm);
 381
 382                 return ((Long)query.uniqueResult()).intValue();
 383         }
 384
 385         @Override
 386     public List<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,  Integer pageNumber) {
 387                 checkNotInPriorView("DefinedTermDaoImpl.getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber)");
 388                 Query query = getSession().createQuery("select media from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 389                 query.setParameter("definedTerm", definedTerm);
 390
 391                 if(pageSize != null) {
 392                         query.setMaxResults(pageSize);
 393                     if(pageNumber != null) {
 394                         query.setFirstResult(pageNumber * pageSize);
 395                     }
 396                 }
 397
 398                 return query.list();
 399         }
 400
 401         /* (non-Javadoc)
 402          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#list(eu.etaxonomy.cdm.model.location.NamedAreaLevel, eu.etaxonomy.cdm.model.location.NamedAreaType, java.lang.Integer, java.lang.Integer)
 403          */
 404         @Override
 405     public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber) {
 406                 AuditEvent auditEvent = getAuditEventFromContext();
 407                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 408             Criteria criteria = getSession().createCriteria(NamedArea.class);
 409
 410                     if(level != null) {
 411                             criteria.add(Restrictions.eq("level",level));
 412                     }
 413
 414                     if(type != null) {
 415                             criteria.add(Restrictions.eq("type", type));
 416                     }
 417
 418                     if(pageSize != null) {
 419                             criteria.setMaxResults(pageSize);
 420                         if(pageNumber != null) {
 421                             criteria.setFirstResult(pageNumber * pageSize);
 422                         }
 423                     }
 424
 425                     return criteria.list();
 426                 } else {
 427             AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,auditEvent.getRevisionNumber());
 428
 429                         if(level != null) {
 430                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 431                     }
 432
 433                     if(type != null) {
 434                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 435                     }
 436
 437                     return query.getResultList();
 438                 }
 439         }
 440
 441         /* (non-Javadoc)
 442          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#list(eu.etaxonomy.cdm.model.location.NamedAreaLevel, eu.etaxonomy.cdm.model.location.NamedAreaType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 443          */
 444         @Override
 445     public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,
 446                         List<OrderHint> orderHints, List<String> propertyPaths) {
 447
 448                 List<NamedArea> result;
 449
 450                 AuditEvent auditEvent = getAuditEventFromContext();
 451                 if (auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 452                         Criteria criteria = getSession().createCriteria(NamedArea.class);
 453
 454                         if (level != null) {
 455                                 criteria.add(Restrictions.eq("level", level));
 456                         }
 457                         if (type != null) {
 458                                 criteria.add(Restrictions.eq("type", type));
 459                         }
 460                         if(orderHints != null){
 461                                 addOrder(criteria,orderHints);
 462                         }
 463                         if (pageSize != null) {
 464                                 criteria.setMaxResults(pageSize);
 465                                 if (pageNumber != null) {
 466                                         criteria.setFirstResult(pageNumber * pageSize);
 467                                 }
 468                         }
 469
 470                         result = criteria.list();
 471                 } else {
 472                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,
 473                                 auditEvent.getRevisionNumber());
 474                         if (level != null) {
 475                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 476                         }
 477                         if (type != null) {
 478                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 479                         }
 480                         result =  query.getResultList();
 481                 }
 482
 483                 defaultBeanInitializer.initializeAll(result, propertyPaths);
 484
 485                 return result;
 486         }
 487
 488
 489         @Override
 490     public <T extends DefinedTermBase> int countGeneralizationOf(T kindOf) {
 491                 AuditEvent auditEvent = getAuditEventFromContext();
 492                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 493                     Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.kindOf = :kindOf");
 494                     query.setParameter("kindOf", kindOf);
 495                     return ((Long)query.uniqueResult()).intValue();
 496                 } else {
 497             AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 498                         query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 499                     query.addProjection(AuditEntity.id().count("id"));
 500                     return ((Long)query.getSingleResult()).intValue();
 501                 }
 502         }
 503
 504         @Override
 505     public <T extends DefinedTermBase> int countIncludes(Collection<T> partOf) {
 506                 if (partOf == null || partOf.isEmpty()){
 507                         return 0;
 508                 }
 509                 AuditEvent auditEvent = getAuditEventFromContext();
 510                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 511                 Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.partOf in (:partOf)");
 512                 query.setParameterList("partOf", partOf);
 513                     return ((Long)query.uniqueResult()).intValue();
 514                 } else {
 515                         Integer count = 0;
 516                         for(T t : partOf) {
 517                                 AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 518                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 519                             query.addProjection(AuditEntity.id().count("id"));
 520                             count += ((Long)query.getSingleResult()).intValue();
 521                         }
 522                         return count;
 523                 }
 524         }
 525
 526         @Override
 527     public <T extends DefinedTermBase> List<T> getGeneralizationOf(T kindOf, Integer pageSize, Integer pageNumber) {
 528                 AuditEvent auditEvent = getAuditEventFromContext();
 529                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 530                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.kindOf = :kindOf");
 531                     query.setParameter("kindOf", kindOf);
 532
 533                     if(pageSize != null) {
 534                             query.setMaxResults(pageSize);
 535                         if(pageNumber != null) {
 536                             query.setFirstResult(pageNumber * pageSize);
 537                         }
 538                     }
 539
 540                 return query.list();
 541                 } else {
 542                          AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 543                          query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 544
 545                          if(pageSize != null) {
 546                             query.setMaxResults(pageSize);
 547                              if(pageNumber != null) {
 548                                     query.setFirstResult(pageNumber * pageSize);
 549                              }
 550                          }
 551
 552                          return query.getResultList();
 553                 }
 554         }
 555
 556         @Override
 557     public <T extends DefinedTermBase> List<T> getIncludes(Collection<T> partOf,        Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 558                 if (partOf == null || partOf.isEmpty()){
 559                         return new ArrayList<T>();
 560                 }
 561                 AuditEvent auditEvent = getAuditEventFromContext();
 562                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 563                 Query query = getSession().createQuery("select term from DefinedTermBase term where term.partOf in (:partOf)");
 564                 query.setParameterList("partOf", partOf);
 565
 566                     if(pageSize != null) {
 567                             query.setMaxResults(pageSize);
 568                         if(pageNumber != null) {
 569                             query.setFirstResult(pageNumber * pageSize);
 570                         }
 571                     }
 572
 573                     List<T> results = query.list();
 574                     defaultBeanInitializer.initializeAll(results, propertyPaths);
 575                     return results;
 576                 } else {
 577                         List<T> result = new ArrayList<T>();
 578                         for(T t : partOf) {
 579                                 AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 580                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 581                                 if(pageSize != null) {
 582                                     query.setMaxResults(pageSize);
 583                                 if(pageNumber != null) {
 584                                     query.setFirstResult(pageNumber * pageSize);
 585                                 }
 586                             }
 587
 588                             result.addAll(query.getResultList());
 589                         }
 590                         defaultBeanInitializer.initializeAll(result, propertyPaths);
 591                         return result;
 592                 }
 593         }
 594
 595         @Override
 596     public <T extends DefinedTermBase> int countPartOf(Set<T> definedTerms) {
 597                 checkNotInPriorView("DefinedTermDaoImpl.countPartOf(Set<T> definedTerms)");
 598                 Query query = getSession().createQuery("select count(distinct definedTerm) from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");
 599                 query.setParameterList("definedTerms", definedTerms);
 600                 return ((Long)query.uniqueResult()).intValue();
 601         }
 602
 603         @Override
 604     public <T extends DefinedTermBase> List<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 605                 checkNotInPriorView("DefinedTermDaoImpl.getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber)");
 606                 Query query = getSession().createQuery("select distinct definedTerm from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");
 607                 query.setParameterList("definedTerms", definedTerms);
 608
 609                 if(pageSize != null) {
 610                         query.setMaxResults(pageSize);
 611                     if(pageNumber != null) {
 612                         query.setFirstResult(pageNumber * pageSize);
 613                     }
 614                 }
 615                 List<T> r = query.list();
 616                 /**
 617                  * For some weird reason, hibernate returns proxies (extending the superclass), not the actual class on this,
 618                  * despite querying the damn database and returning the discriminator along with the rest of the object properties!
 619                  *
 620                  * Probably a bug in hibernate, but we'll manually deproxy for now since the objects are initialized anyway, the
 621                  * performance implications are small (we're swapping one array of references for another, not hitting the db or
 622                  * cache).
 623                  */
 624                 List<T> results = new ArrayList<T>();
 625                 if(!definedTerms.isEmpty()) {
 626                     Class<T> type = (Class<T>)definedTerms.iterator().next().getClass();
 627                     for(T t : r) {
 628                             results.add(CdmBase.deproxy(t, type));
 629                     }
 630                     defaultBeanInitializer.initializeAll(results, propertyPaths);
 631                 }
 632                 return results;
 633         }
 634
 635         @Override
 636     public DefinedTermBase findByUri(URI uri) {
 637                 AuditEvent auditEvent = getAuditEventFromContext();
 638                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 639                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.uri = :uri");
 640                     query.setParameter("uri", uri);
 641                     return (DefinedTermBase)query.uniqueResult();
 642                 } else {
 643                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 644                         query.add(AuditEntity.property("uri").eq(uri));
 645                     return (DefinedTermBase)query.getSingleResult();
 646                 }
 647         }
 648
 649         /* (non-Javadoc)
 650          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#listByTermType(eu.etaxonomy.cdm.model.common.TermType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 651          */
 652         @Override
 653         public List<DefinedTermBase<?>> listByTermType(TermType termType, Integer limit, Integer start,
 654                 List<OrderHint> orderHints, List<String> propertyPaths) {
 655             Query query = getSession().createQuery("select term from DefinedTermBase term where term.termType = :termType");
 656             query.setParameter("termType", termType);
 657
 658             List result = query.list();
 659
 660             defaultBeanInitializer.initializeAll(result, propertyPaths);
 661
 662         return result;
 663         }
 664
 665         @Override
 666     public <TERM extends DefinedTermBase> List<TERM> listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 667 //              checkNotInPriorView("DefinedTermDaoImpl.listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths)");
 668
 669                 Query query = getSession().createQuery("from " + clazz.getSimpleName());
 670             //query.setParameter("DTYPE", );
 671
 672             List<TERM> result = query.list();
 673
 674             defaultBeanInitializer.initializeAll(result, propertyPaths);
 675
 676             return result;
 677         }
 678 }