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