cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/term/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.term;
  11
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.Enumeration;
  15 import java.util.Iterator;
  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.Disjunction;
  28 import org.hibernate.criterion.Order;
  29 import org.hibernate.criterion.Projections;
  30 import org.hibernate.criterion.Restrictions;
  31 import org.hibernate.envers.query.AuditEntity;
  32 import org.hibernate.envers.query.AuditQuery;
  33 import org.springframework.stereotype.Repository;
  34
  35 import eu.etaxonomy.cdm.common.URI;
  36 import eu.etaxonomy.cdm.model.common.AnnotationType;
  37 import eu.etaxonomy.cdm.model.common.CdmBase;
  38 import eu.etaxonomy.cdm.model.common.ExtensionType;
  39 import eu.etaxonomy.cdm.model.common.Language;
  40 import eu.etaxonomy.cdm.model.common.MarkerType;
  41 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
  42 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
  43 import eu.etaxonomy.cdm.model.description.State;
  44 import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
  45 import eu.etaxonomy.cdm.model.description.TextFormat;
  46 import eu.etaxonomy.cdm.model.location.Country;
  47 import eu.etaxonomy.cdm.model.location.NamedArea;
  48 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  49 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  50 import eu.etaxonomy.cdm.model.location.ReferenceSystem;
  51 import eu.etaxonomy.cdm.model.media.Media;
  52 import eu.etaxonomy.cdm.model.media.RightsType;
  53 import eu.etaxonomy.cdm.model.metadata.TermSearchField;
  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.SynonymType;
  62 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  63 import eu.etaxonomy.cdm.model.term.DefinedTerm;
  64 import eu.etaxonomy.cdm.model.term.DefinedTermBase;
  65 import eu.etaxonomy.cdm.model.term.TermType;
  66 import eu.etaxonomy.cdm.model.term.TermVocabulary;
  67 import eu.etaxonomy.cdm.model.view.AuditEvent;
  68 import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;
  69 import eu.etaxonomy.cdm.persistence.dao.term.IDefinedTermDao;
  70 import eu.etaxonomy.cdm.persistence.dto.FeatureDto;
  71 import eu.etaxonomy.cdm.persistence.dto.TermDto;
  72 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  73 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  74
  75 /**
  76  * @author a.kohlbecker
  77  * @since 29.05.2008
  78  */
  79 @Repository
  80 public class DefinedTermDaoImpl
  81         extends IdentifiableDaoBase<DefinedTermBase>
  82         implements IDefinedTermDao{
  83
  84     private static final Logger logger = Logger.getLogger(DefinedTermDaoImpl.class);
  85
  86         public DefinedTermDaoImpl() {
  87                 super(DefinedTermBase.class);
  88                 indexedClasses = new Class[25];
  89                 indexedClasses[0] = Rank.class;
  90                 indexedClasses[1] = AnnotationType.class;
  91                 indexedClasses[2] = ExtensionType.class;
  92                 indexedClasses[3] = Language.class;
  93                 indexedClasses[4] = MarkerType.class;
  94                 indexedClasses[5] = MeasurementUnit.class;
  95                 indexedClasses[6] = DefinedTerm.class;
  96                 indexedClasses[7] = PresenceAbsenceTerm.class;
  97                 indexedClasses[8] = State.class;
  98                 indexedClasses[9] = StatisticalMeasure.class;
  99                 indexedClasses[10] = TextFormat.class;
 100                 indexedClasses[11] = DerivationEventType.class;
 101                 indexedClasses[12] = NamedArea.class;
 102                 indexedClasses[13] = NamedAreaLevel.class;
 103                 indexedClasses[14] = NamedAreaType.class;
 104                 indexedClasses[15] = ReferenceSystem.class;
 105                 indexedClasses[16] = Country.class;
 106                 indexedClasses[17] = RightsType.class;
 107                 indexedClasses[18] = HybridRelationshipType.class;
 108                 indexedClasses[19] = NameRelationshipType.class;
 109                 indexedClasses[20] = NameTypeDesignationStatus.class;
 110                 indexedClasses[21] = NomenclaturalStatusType.class;
 111                 indexedClasses[22] = SpecimenTypeDesignationStatus.class;
 112                 indexedClasses[23] = SynonymType.class;
 113                 indexedClasses[24] = TaxonRelationshipType.class;
 114         }
 115
 116         /**
 117          * Searches by Label
 118          */
 119         @Override
 120     public List<DefinedTermBase> findByTitle(String queryString) {
 121                 return findByTitle(queryString, null);
 122         }
 123
 124         /**
 125          * Searches by Label
 126          */
 127         @Override
 128     public List<DefinedTermBase> findByTitle(String queryString, CdmBase sessionObject) {
 129                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, CdmBase sessionObject)");
 130                 Session session = getSession();
 131                 if ( sessionObject != null ) {//attache the object to the session, TODO needed?
 132                         session.update(sessionObject);
 133                 }
 134                 Query query = session.createQuery("select term from DefinedTermBase term join fetch term.representations representation where representation.label = :label");
 135                 query.setParameter("label", queryString);
 136                 @SuppressWarnings({ "unchecked", "rawtypes" })
 137                 List<DefinedTermBase> result = query.list();
 138                 return result;
 139
 140         }
 141
 142         @Override
 143     public List<DefinedTermBase> findByTitle(String queryString, MatchMode matchMode, int page, int pagesize, List<Criterion> criteria) {
 144                 //FIXME is query parametrised?
 145                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, ITitledDao.MATCH_MODE matchMode, int page, int pagesize, List<Criterion> criteria)");
 146                 Criteria crit = getSession().createCriteria(type);
 147                 crit.add(Restrictions.ilike("titleCache", matchMode.queryStringFrom(queryString)));
 148                 crit.setMaxResults(pagesize);
 149                 int firstItem = (page - 1) * pagesize + 1;
 150                 crit.setFirstResult(firstItem);
 151                 List<DefinedTermBase> results = crit.list();
 152                 return results;
 153         }
 154
 155         @Override
 156     public Country getCountryByIso(String iso3166) {
 157                 // If iso639 = "" query returns non-unique result. We prevent this here:
 158                 if (StringUtils.isBlank(iso3166) || iso3166.length()<2 || iso3166.length()>3) { return null; }
 159                 AuditEvent auditEvent = getAuditEventFromContext();
 160                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 161                     Query query = getSession().createQuery("from Country where iso3166_A2 = :isoCode OR idInVocabulary = :isoCode");
 162                     query.setParameter("isoCode", iso3166);
 163                     return (Country) query.uniqueResult();
 164                 } else {
 165                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Country.class,auditEvent.getRevisionNumber());
 166                         query.add(AuditEntity.property("iso3166_A2").eq(iso3166));
 167                         query.add(AuditEntity.property("idInVocabulary").eq(iso3166));
 168                         return (Country) query.getSingleResult();
 169                 }
 170         }
 171
 172         @Override
 173     public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz ) {
 174                 return getDefinedTermByRepresentationText(text,clazz,null,null);
 175         }
 176
 177         @Override
 178     public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {
 179                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber)");
 180
 181                 Criteria criteria = getCriteria(clazz);
 182
 183                 criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));
 184
 185                 addPageSizeAndNumber(criteria, pageSize, pageNumber);
 186
 187                 @SuppressWarnings("unchecked")
 188         List<T> result = criteria.list();
 189                 return result;
 190         }
 191
 192         @Override
 193     public long countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz) {
 194             checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz)");
 195                 Criteria criteria = getCriteria(clazz);
 196
 197                 criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));
 198
 199                 criteria.setProjection(Projections.rowCount());
 200
 201                 return (Long)criteria.uniqueResult();
 202         }
 203
 204         @Override
 205         public <T extends DefinedTermBase> List<T> getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber) {
 206                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber)");
 207
 208                 Criteria criteria = getCriteria(clazz);
 209
 210                 criteria.createAlias("vocabulary", "voc")
 211                     .add(Restrictions.like("voc.uuid", vocUuid))
 212                         .add(Restrictions.like("idInVocabulary", label, org.hibernate.criterion.MatchMode.EXACT));
 213
 214                 addPageSizeAndNumber(criteria, pageSize, pageNumber);
 215
 216                 @SuppressWarnings("unchecked")
 217         List<T> result = criteria.list();
 218                 return result;
 219         }
 220
 221     @Override
 222         public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationAbbrev(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {
 223                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationAbbrev(String abbrev, Class<T> clazz, Integer pageSize,Integer  pageNumber)");
 224
 225                 Criteria criteria = getCriteria(clazz);
 226
 227                 criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));
 228
 229                 addPageSizeAndNumber(criteria, pageSize, pageNumber);
 230
 231                 @SuppressWarnings("unchecked")
 232                 List<T> result = criteria.list();
 233                 return result;
 234         }
 235
 236         @Override
 237         public long countDefinedTermByRepresentationAbbrev(String text, Class<? extends DefinedTermBase> clazz) {
 238             checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationAbbrev(String abbrev, Class<? extends DefinedTermBase> clazz)");
 239                 Criteria criteria = getCriteria(clazz);
 240
 241                 criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));
 242                 criteria.setProjection(Projections.rowCount());
 243
 244         return (Long)criteria.uniqueResult();
 245         }
 246
 247         @Override
 248     public Language getLanguageByIso(String iso639) {
 249                 if (iso639.length() < 2 || iso639.length() > 3) {
 250                         logger.warn("Invalid length " + iso639.length() + " of ISO code. Length must be 2 or 3.");
 251                         return null;
 252                 }
 253                 boolean isIso639_1 = iso639.length() == 2;
 254
 255                 String queryStr;
 256                 if (isIso639_1){
 257                         queryStr = "from Language where iso639_1 = :isoCode";
 258                 }else{
 259                         queryStr = "from Language where idInVocabulary = :isoCode and vocabulary.uuid = :vocUuid";
 260                 }
 261                 AuditEvent auditEvent = getAuditEventFromContext();
 262                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 263                     Query query = getSession().createQuery(queryStr);
 264                     query.setParameter("isoCode", iso639);
 265                     if (! isIso639_1){
 266                         query.setParameter("vocUuid", Language.uuidLanguageVocabulary);
 267                         }
 268                     return (Language) query.uniqueResult();
 269                 } else {
 270                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Language.class,auditEvent.getRevisionNumber());
 271                         if (isIso639_1){
 272                                 query.add(AuditEntity.property("iso639_1").eq(iso639));
 273                         }else{
 274                                 query.add(AuditEntity.property("iso639_2").eq(iso639));
 275                                 query.add(AuditEntity.property("vocabulary.uuid").eq(Language.uuidLanguageVocabulary));
 276                         }
 277
 278                         return (Language)query.getSingleResult();
 279                 }
 280         }
 281
 282         /**
 283          *  FIXME this will result in a query per language - could you, given that iso codes
 284          *  are unique, use from Language where iso639_1 in (:isoCode) or iso639_2 in (:isoCode)
 285          */
 286         @Override
 287     public List<Language> getLanguagesByIso(List<String> iso639List) {
 288                 List<Language> languages = new ArrayList<Language>(iso639List.size());
 289                 for (String iso639 : iso639List) {
 290                         languages.add(getLanguageByIso(iso639));
 291                 }
 292                 return languages;
 293         }
 294
 295         @Override
 296     public List<Language> getLanguagesByLocale(Enumeration<Locale> locales) {
 297                 List<Language> languages = new ArrayList<Language>();
 298                 while(locales.hasMoreElements()) {
 299                         Locale locale = locales.nextElement();
 300                         languages.add(getLanguageByIso(locale.getLanguage()));
 301                 }
 302                 return languages;
 303         }
 304
 305         @Override
 306     public long count(NamedAreaLevel level, NamedAreaType type) {
 307                 AuditEvent auditEvent = getAuditEventFromContext();
 308                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 309                     Criteria criteria = getCriteria(NamedArea.class);
 310
 311                     if(level != null) {
 312                             criteria.add(Restrictions.eq("level",level));
 313                     }
 314
 315                     if(type != null) {
 316                             criteria.add(Restrictions.eq("type", type));
 317                     }
 318
 319                     criteria.setProjection(Projections.rowCount());
 320
 321                 return (Long)criteria.uniqueResult();
 322                 } else {
 323                         AuditQuery query = makeAuditQuery(NamedArea.class, auditEvent);
 324
 325                         if(level != null) {
 326                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 327                     }
 328
 329                     if(type != null) {
 330                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 331                     }
 332                     query.addProjection(AuditEntity.id().count());
 333                     return (Long)query.getSingleResult();
 334                 }
 335         }
 336
 337         @Override
 338     public long countMedia(DefinedTermBase definedTerm) {
 339                 checkNotInPriorView("DefinedTermDaoImpl.countMedia(DefinedTermBase definedTerm)");
 340                 Query query = getSession().createQuery("select count(media) from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 341             query.setParameter("definedTerm", definedTerm);
 342
 343                 return (Long)query.uniqueResult();
 344         }
 345
 346         @Override
 347     public List<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,  Integer pageNumber) {
 348                 checkNotInPriorView("DefinedTermDaoImpl.getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber)");
 349                 Query query = getSession().createQuery("select media from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 350                 query.setParameter("definedTerm", definedTerm);
 351
 352                 addPageSizeAndNumber(query, pageSize, pageNumber);
 353
 354                 @SuppressWarnings("unchecked")
 355         List<Media> result = query.list();
 356                 return result;
 357         }
 358
 359         @Override
 360     public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber) {
 361                 AuditEvent auditEvent = getAuditEventFromContext();
 362                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 363             Criteria criteria = getCriteria(NamedArea.class);
 364
 365                     if(level != null) {
 366                             criteria.add(Restrictions.eq("level",level));
 367                     }
 368
 369                     if(type != null) {
 370                             criteria.add(Restrictions.eq("type", type));
 371                     }
 372
 373                     addPageSizeAndNumber(criteria, pageSize, pageNumber);
 374
 375                 @SuppressWarnings("unchecked")
 376                 List<NamedArea> result = criteria.list();
 377                 return result;
 378                 } else {
 379             AuditQuery query = makeAuditQuery(NamedArea.class, auditEvent);
 380
 381                         if(level != null) {
 382                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 383                     }
 384
 385                     if(type != null) {
 386                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 387                     }
 388
 389                     @SuppressWarnings("unchecked")
 390             List<NamedArea> result = query.getResultList();
 391                     return result;
 392                 }
 393         }
 394
 395         @Override
 396     public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,
 397                         List<OrderHint> orderHints, List<String> propertyPaths) {
 398
 399             List<NamedArea> result;
 400
 401                 AuditEvent auditEvent = getAuditEventFromContext();
 402                 if (auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 403                         Criteria criteria = getCriteria(NamedArea.class);
 404
 405                         if (level != null) {
 406                                 criteria.add(Restrictions.eq("level", level));
 407                         }
 408                         if (type != null) {
 409                                 criteria.add(Restrictions.eq("type", type));
 410                         }
 411                         addOrder(criteria,orderHints);
 412                         addPageSizeAndNumber(criteria, pageSize, pageNumber);
 413
 414                         result = criteria.list();
 415
 416                 } else {
 417                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,
 418                                 auditEvent.getRevisionNumber());
 419                         if (level != null) {
 420                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 421                         }
 422                         if (type != null) {
 423                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 424                         }
 425                         result = query.getResultList();
 426                 }
 427
 428                 defaultBeanInitializer.initializeAll(result, propertyPaths);
 429
 430                 return result;
 431         }
 432
 433
 434         @Override
 435     public <T extends DefinedTermBase> long countGeneralizationOf(T kindOf) {
 436                 AuditEvent auditEvent = getAuditEventFromContext();
 437                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 438                     Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.kindOf = :kindOf");
 439                     query.setParameter("kindOf", kindOf);
 440                     return (Long)query.uniqueResult();
 441                 } else {
 442             AuditQuery query = makeAuditQuery(DefinedTermBase.class,auditEvent);
 443                         query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 444                     query.addProjection(AuditEntity.id().count());
 445                     return (Long)query.getSingleResult();
 446                 }
 447         }
 448
 449         @Override
 450     public <T extends DefinedTermBase> long countIncludes(Collection<T> partOf) {
 451                 if (partOf == null || partOf.isEmpty()){
 452                         return 0;
 453                 }
 454                 AuditEvent auditEvent = getAuditEventFromContext();
 455                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 456                 Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.partOf in (:partOf)");
 457                 query.setParameterList("partOf", partOf);
 458                     return (Long)query.uniqueResult();
 459                 } else {
 460                         long count = 0;
 461                         for(T t : partOf) {
 462                                 AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);
 463                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 464                             query.addProjection(AuditEntity.id().count());
 465                             count += (Long)query.getSingleResult();
 466                         }
 467                         return count;
 468                 }
 469         }
 470
 471         @Override
 472     public <T extends DefinedTermBase> List<T> getGeneralizationOf(T kindOf, Integer pageSize, Integer pageNumber) {
 473                 AuditEvent auditEvent = getAuditEventFromContext();
 474                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 475                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.kindOf = :kindOf");
 476                     query.setParameter("kindOf", kindOf);
 477
 478                     addPageSizeAndNumber(query, pageSize, pageNumber);
 479
 480                     @SuppressWarnings("unchecked")
 481             List<T> result = query.list();
 482                     return result;
 483                 } else {
 484                          AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);
 485                          query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 486
 487                          addPageSizeAndNumber(query, pageSize, pageNumber);
 488
 489              @SuppressWarnings("unchecked")
 490              List<T> result = query.getResultList();
 491              return result;
 492                 }
 493         }
 494
 495         @Override
 496     public <T extends DefinedTermBase> List<T> getIncludes(Collection<T> partOf,        Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 497                 if (partOf == null || partOf.isEmpty()){
 498                         return new ArrayList<>();
 499                 }
 500                 AuditEvent auditEvent = getAuditEventFromContext();
 501                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 502                 Query query = getSession().createQuery("select term from DefinedTermBase term where term.partOf in (:partOf)");
 503                 query.setParameterList("partOf", partOf);
 504
 505                 addPageSizeAndNumber(query, pageSize, pageNumber);
 506
 507                     @SuppressWarnings("unchecked")
 508             List<T> results = query.list();
 509                     defaultBeanInitializer.initializeAll(results, propertyPaths);
 510                     return results;
 511                 } else {
 512                         List<T> result = new ArrayList<T>();
 513                         for(T t : partOf) {
 514                                 AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);
 515                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 516                                 addPageSizeAndNumber(query, pageSize, pageNumber);
 517
 518                             result.addAll(query.getResultList());
 519                         }
 520                         defaultBeanInitializer.initializeAll(result, propertyPaths);
 521                         return result;
 522                 }
 523         }
 524
 525         @Override
 526     public <T extends DefinedTermBase> long countPartOf(Set<T> definedTerms) {
 527                 checkNotInPriorView("DefinedTermDaoImpl.countPartOf(Set<T> definedTerms)");
 528                 Query query = getSession().createQuery("select count(distinct definedTerm) from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");
 529                 query.setParameterList("definedTerms", definedTerms);
 530                 return (Long)query.uniqueResult();
 531         }
 532
 533         @Override
 534     public <T extends DefinedTermBase> List<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 535                 checkNotInPriorView("DefinedTermDaoImpl.getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber)");
 536                 Query query = getSession().createQuery("select distinct definedTerm from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");
 537                 query.setParameterList("definedTerms", definedTerms);
 538
 539                 addPageSizeAndNumber(query, pageSize, pageNumber);
 540
 541                 @SuppressWarnings("unchecked")
 542         List<T> r = query.list();
 543                 /**
 544                  * For some weird reason, hibernate returns proxies (extending the superclass), not the actual class on this,
 545                  * despite querying the damn database and returning the discriminator along with the rest of the object properties!
 546                  *
 547                  * Probably a bug in hibernate, but we'll manually deproxy for now since the objects are initialized anyway, the
 548                  * performance implications are small (we're swapping one array of references for another, not hitting the db or
 549                  * cache).
 550                  */
 551                 List<T> results = new ArrayList<>();
 552                 if(!definedTerms.isEmpty()) {
 553                     for(T t : r) {
 554                         T deproxied = CdmBase.deproxy(t);
 555                 results.add(deproxied);
 556                     }
 557                     defaultBeanInitializer.initializeAll(results, propertyPaths);
 558                 }
 559                 return results;
 560         }
 561
 562         @Override
 563     public DefinedTermBase findByUri(URI uri) {
 564                 AuditEvent auditEvent = getAuditEventFromContext();
 565                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 566                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.uri = :uri");
 567                     query.setParameter("uri", uri);
 568                     return (DefinedTermBase<?>)query.uniqueResult();
 569                 } else {
 570                         AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);
 571                         query.add(AuditEntity.property("uri").eq(uri));
 572                     return (DefinedTermBase<?>)query.getSingleResult();
 573                 }
 574         }
 575
 576         @Override
 577         public <T extends DefinedTermBase> List<T> listByTermType(TermType termType, Integer limit, Integer start,
 578                 List<OrderHint> orderHints, List<String> propertyPaths) {
 579             Query query = getSession().createQuery("SELECT term FROM DefinedTermBase term WHERE term.termType = :termType");
 580             query.setParameter("termType", termType);
 581
 582             @SuppressWarnings("unchecked")
 583         List<T> result = query.list();
 584
 585             defaultBeanInitializer.initializeAll(result, propertyPaths);
 586         return result;
 587         }
 588
 589         @Override
 590     public <TERM extends DefinedTermBase> List<TERM> listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 591 //              checkNotInPriorView("DefinedTermDaoImpl.listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths)");
 592
 593                 Query query = getSession().createQuery("FROM " + clazz.getSimpleName());
 594
 595             @SuppressWarnings("unchecked")
 596         List<TERM> result = query.list();
 597
 598             defaultBeanInitializer.initializeAll(result, propertyPaths);
 599
 600             return result;
 601         }
 602
 603     @Override
 604     public <S extends DefinedTermBase> List<S> list(Class<S> type, Integer limit, Integer start,
 605             List<OrderHint> orderHints, List<String> propertyPath) {
 606
 607         return deduplicateResult(super.list(type, limit, start, orderHints, propertyPath));
 608     }
 609
 610     /**
 611      * Workaround for https://dev.e-taxonomy.eu/redmine/issues/5871 and #5945
 612      * Terms with multiple representations return identical duplicates
 613      * due to eager representation loading. We expect these duplicates to appear
 614      * in line wo we only compare one term with its predecessor. If it already
 615      * exists we remove it from the result.
 616      * @param orginals
 617      * @return
 618      */
 619     private <S extends DefinedTermBase<?>> List<S> deduplicateResult(List<S> orginals) {
 620         List<S> result = new ArrayList<>();
 621         Iterator<S> it = orginals.iterator();
 622         S last = null;
 623         while (it.hasNext()){
 624             S a = it.next();
 625             if (a != last){
 626                 if (!result.contains(a)){
 627                     result.add(a);
 628                 }
 629             }
 630             last = a;
 631         }
 632         return result;
 633     }
 634
 635     @Override
 636     public <S extends DefinedTermBase> List<S> list(Class<S> clazz, List<TermVocabulary> vocs, Integer limit, String pattern) {
 637         return list(clazz, vocs, 0, limit, pattern, MatchMode.BEGINNING);
 638     }
 639
 640     @Override
 641     public <S extends DefinedTermBase> List<S> list(Class<S> clazz, List<TermVocabulary> vocs, Integer pageNumber, Integer limit, String pattern, MatchMode matchmode){
 642         Session session = getSession();
 643 //        Query query = null;
 644 //        if (pattern != null){
 645 //            if (vocs != null && !vocs.isEmpty()){
 646 //                query = session.createQuery("from NamedArea where titleCache like :pattern and vocabulary in :vocs ORDER BY titleCache");
 647 //                query.setParameterList("vocs", vocs);
 648 //            }else{
 649 //                query = session.createQuery("from NamedArea where titleCache like :pattern ORDER BY titleCache");
 650 //            }
 651 //            pattern = pattern.replace("*", "%");
 652 //            pattern = pattern.replace("?", "_");
 653 //            pattern = pattern + "%";
 654 //            query.setParameter("pattern", pattern);
 655 //
 656 //        } else {
 657 //            query = session.createQuery("FROM NamedArea WHERE vocabulary IN :vocs ORDER BY titleCache");
 658 //            query.setParameterList("vocs", vocs);
 659 //        }
 660 //        if (limit != null && limit > 0){
 661 //           query.setMaxResults(limit);
 662 //        }
 663
 664         if (clazz == null){
 665             clazz = (Class)type;
 666         }
 667         Criteria crit = getSession().createCriteria(clazz, "term");
 668         if (!StringUtils.isBlank(pattern)){
 669             crit.createAlias("term.representations", "reps");
 670             Disjunction or = Restrictions.disjunction();
 671             if (matchmode == MatchMode.EXACT) {
 672                 or.add(Restrictions.eq("titleCache", matchmode.queryStringFrom(pattern)));
 673                 or.add(Restrictions.eq("reps.label", matchmode.queryStringFrom(pattern)));
 674             } else {
 675                 or.add(Restrictions.like("titleCache", matchmode.queryStringFrom(pattern)));
 676                 or.add(Restrictions.like("reps.label", matchmode.queryStringFrom(pattern)));
 677             }
 678             crit.add(or);
 679         }
 680
 681         if (limit != null && limit >= 0) {
 682             crit.setMaxResults(limit);
 683         }
 684
 685         if (vocs != null &&!vocs.isEmpty()){
 686             crit.createAlias("term.vocabulary", "voc");
 687             Disjunction or = Restrictions.disjunction();
 688             for (TermVocabulary<?> voc: vocs){
 689                 Criterion criterion = Restrictions.eq("voc.id", voc.getId());
 690                 or.add(criterion);
 691             }
 692             crit.add(or);
 693         }
 694
 695         crit.addOrder(Order.asc("titleCache"));
 696         if (limit == null){
 697             limit = 1;
 698         }
 699 //        int firstItem = (pageNumber - 1) * limit;
 700
 701         crit.setFirstResult(0);
 702         @SuppressWarnings("unchecked")
 703         List<S> results = deduplicateResult(crit.list());
 704         return results;
 705     }
 706
 707     @Override
 708     public <S extends DefinedTermBase> List<S> listByAbbrev(Class<S> clazz, List<TermVocabulary> vocs, Integer limit, String pattern, TermSearchField type) {
 709         return listByAbbrev(clazz, vocs, 0, limit, pattern, MatchMode.BEGINNING, type);
 710     }
 711
 712     @Override
 713     public <S extends DefinedTermBase> List<S> listByAbbrev(Class<S> clazz, List<TermVocabulary> vocs, Integer pageNumber, Integer limit, String pattern, MatchMode matchmode, TermSearchField abbrevType){
 714
 715         if (clazz == null){
 716             clazz = (Class)type;
 717         }
 718         Criteria crit = getSession().createCriteria(clazz, "type");
 719         if (!StringUtils.isBlank(pattern)){
 720             if (matchmode == MatchMode.EXACT) {
 721                 crit.add(Restrictions.eq(abbrevType.getKey(), matchmode.queryStringFrom(pattern)));
 722             } else {
 723                 crit.add(Restrictions.like(abbrevType.getKey(), matchmode.queryStringFrom(pattern)));
 724             }
 725         }
 726         if (limit != null && limit >= 0) {
 727             crit.setMaxResults(limit);
 728         }
 729
 730         if (vocs != null &&!vocs.isEmpty()){
 731             crit.createAlias("type.vocabulary", "voc");
 732             Disjunction or = Restrictions.disjunction();
 733             for (TermVocabulary<?> voc: vocs){
 734                 Criterion criterion = Restrictions.eq("voc.id", voc.getId());
 735                 or.add(criterion);
 736             }
 737             crit.add(or);
 738         }
 739
 740         crit.addOrder(Order.asc(abbrevType.getKey()));
 741         if (limit == null){
 742             limit = 1;
 743         }
 744 //        int firstItem = (pageNumber - 1) * limit;
 745
 746         crit.setFirstResult(0);
 747         @SuppressWarnings("unchecked")
 748         List<S> results = deduplicateResult(crit.list());
 749         return results;
 750     }
 751
 752     //FIXME AM: this returns only NamedArea counts though not mentioned in method name, fortunately it is currently not in use
 753     @Override
 754     public long count(List<TermVocabulary> vocs, String pattern){
 755         Session session = getSession();
 756         Query query = null;
 757         if (pattern != null){
 758             if (vocs != null && !vocs.isEmpty()){
 759                 query = session.createQuery("SELECT COUNT(*) FROM NamedArea WHERE titleCache LIKE :pattern AND vocabulary IN :vocs");
 760                 query.setParameterList("vocs", vocs);
 761             }else{
 762                 query = session.createQuery("SELECT COUNT(*) FROM NamedArea WHERE titleCache LIKE :pattern ");
 763             }
 764             pattern = pattern.replace("*", "%");
 765             pattern = pattern.replace("?", "_");
 766             pattern = pattern + "%";
 767             query.setParameter("pattern", pattern);
 768
 769         } else {
 770             query = session.createQuery("SELECT COUNT(*) FROM NamedArea WHERE vocabulary IN :vocs");
 771             query.setParameterList("vocs", vocs);
 772         }
 773
 774         Long result = (Long) query.uniqueResult();
 775         return result;
 776     }
 777
 778     @Override
 779     public Collection<TermDto> getIncludesAsDto(
 780             TermDto parentTerm) {
 781         String queryString;
 782         if (parentTerm.getTermType().equals(TermType.NamedArea)){
 783             queryString = TermDto.getTermDtoSelectNamedArea();
 784         }else{
 785             queryString = TermDto.getTermDtoSelect();
 786         }
 787         queryString = queryString
 788                 + "where a.partOf.uuid = :parentUuid";
 789         Query query =  getSession().createQuery(queryString);
 790         query.setParameter("parentUuid", parentTerm.getUuid());
 791
 792         @SuppressWarnings("unchecked")
 793         List<Object[]> result = query.list();
 794
 795         List<TermDto> list = TermDto.termDtoListFrom(result);
 796         return list;
 797     }
 798
 799     @Override
 800     public Collection<TermDto> getKindOfsAsDto(
 801             TermDto parentTerm) {
 802         String queryString;
 803         if (parentTerm.getTermType().equals(TermType.NamedArea)){
 804             queryString = TermDto.getTermDtoSelectNamedArea();
 805         }else{
 806             queryString = TermDto.getTermDtoSelect();
 807         }
 808         queryString = queryString + "where a.kindOf.uuid = :parentUuid";
 809         Query query =  getSession().createQuery(queryString);
 810         query.setParameter("parentUuid", parentTerm.getUuid());
 811
 812         @SuppressWarnings("unchecked")
 813         List<Object[]> result = query.list();
 814
 815         List<TermDto> list = TermDto.termDtoListFrom(result);
 816         return list;
 817     }
 818
 819     @Override
 820     public Collection<TermDto> findByTitleAsDto(String title, TermType termType) {
 821         String queryString = TermDto.getTermDtoSelect()
 822                 + " where a.titleCache like :title "
 823                 + (termType!=null?" and a.termType = :termType ":"");
 824
 825         title = title.replace("*", "%");
 826         Query query =  getSession().createQuery(queryString);
 827         query.setParameter("title", "%"+title+"%");
 828         if(termType!=null){
 829             query.setParameter("termType", termType);
 830         }
 831
 832         @SuppressWarnings("unchecked")
 833         List<Object[]> result = query.list();
 834
 835         List<TermDto> list = TermDto.termDtoListFrom(result);
 836         return list;
 837     }
 838
 839     @Override
 840     public Collection<TermDto> findByTypeAsDto(TermType termType) {
 841         if (termType == null){
 842             return null;
 843         }
 844         String queryString = TermDto.getTermDtoSelect()
 845                 + " where a.termType = :termType ";
 846         Query query =  getSession().createQuery(queryString);
 847
 848         if(termType!=null){
 849             query.setParameter("termType", termType);
 850         }
 851
 852         @SuppressWarnings("unchecked")
 853         List<Object[]> result = query.list();
 854
 855         List<TermDto> list = TermDto.termDtoListFrom(result);
 856         return list;
 857     }
 858
 859     @Override
 860     public Collection<TermDto> findByUriAsDto(URI uri, String termLabel, TermType termType) {
 861         String queryString = TermDto.getTermDtoSelect()
 862                 + " where a.uri like :uri "
 863                 + (termType!=null?" and a.termType = :termType ":"")
 864                 + (termLabel!=null?" and a.titleCache = :termLabel ":"")
 865                 ;
 866         Query query =  getSession().createQuery(queryString);
 867         query.setParameter("uri", uri.toString());
 868         if(termLabel!=null){
 869             query.setParameter("termLabel", "%"+termLabel+"%");
 870         }
 871         if(termType!=null){
 872             query.setParameter("termType", termType);
 873         }
 874
 875         @SuppressWarnings("unchecked")
 876         List<Object[]> result = query.list();
 877
 878         List<TermDto> list = TermDto.termDtoListFrom(result);
 879         return list;
 880     }
 881
 882     @Override
 883     public List<TermDto> getSupportedStatesForFeature(UUID featureUuid){
 884         List<TermDto> list = new ArrayList<>();
 885         String supportedCategoriesQueryString = "SELECT cat.uuid "
 886                 + "from DefinedTermBase t "
 887                 + "join t.supportedCategoricalEnumerations as cat "
 888                 + "where t.uuid = :featureUuid";
 889         Query supportedCategoriesQuery =  getSession().createQuery(supportedCategoriesQueryString);
 890         supportedCategoriesQuery.setParameter("featureUuid", featureUuid);
 891         @SuppressWarnings("unchecked")
 892                 List<UUID> supportedCategories = supportedCategoriesQuery.list();
 893         if(supportedCategories.isEmpty()){
 894             return list;
 895         }
 896
 897         String queryString = TermDto.getTermDtoSelect()
 898                 + "where v.uuid in (:supportedCategories) "
 899                 + "order by a.titleCache";
 900         Query query =  getSession().createQuery(queryString);
 901         query.setParameterList("supportedCategories", supportedCategories);
 902
 903         @SuppressWarnings("unchecked")
 904         List<Object[]> result = query.list();
 905
 906         list = TermDto.termDtoListFrom(result);
 907         return list;
 908     }
 909
 910     @Override
 911     public Collection<TermDto> findByUUIDsAsDto(List<UUID> uuidList) {
 912         List<TermDto> list = new ArrayList<>();
 913         if (uuidList == null || uuidList.isEmpty()){
 914             return null;
 915         }
 916
 917         String queryString = TermDto.getTermDtoSelect()
 918                 + "where a.uuid in :uuidList "
 919                 + "order by a.titleCache";
 920         Query query =  getSession().createQuery(queryString);
 921         query.setParameterList("uuidList", uuidList);
 922
 923         @SuppressWarnings("unchecked")
 924         List<Object[]> result = query.list();
 925
 926         list = TermDto.termDtoListFrom(result);
 927         return list;
 928     }
 929
 930     @Override
 931     public Collection<TermDto> findFeatureByUUIDsAsDto(List<UUID> uuidList) {
 932         List<TermDto> list = new ArrayList<>();
 933         if (uuidList == null || uuidList.isEmpty()){
 934             return null;
 935         }
 936
 937         String queryString = FeatureDto.getTermDtoSelect()
 938                 + "where a.uuid in :uuidList "
 939                 + "order by a.titleCache";
 940         Query query =  getSession().createQuery(queryString);
 941         query.setParameterList("uuidList", uuidList);
 942
 943         @SuppressWarnings("unchecked")
 944         List<Object[]> result = query.list();
 945
 946         list = FeatureDto.termDtoListFrom(result);
 947         return list;
 948     }
 949
 950     @Override
 951     public Collection<TermDto> findFeatureByTitleAsDto(String pattern) {
 952         String queryString = FeatureDto.getTermDtoSelect()
 953                 + " where a.titleCache like :title "
 954                 +  " and a.termType = :termType ";
 955
 956         pattern = pattern.replace("*", "%");
 957         Query query =  getSession().createQuery(queryString);
 958         query.setParameter("title", "%"+pattern+"%");
 959         query.setParameter("termType", TermType.Feature);
 960
 961
 962         @SuppressWarnings("unchecked")
 963         List<Object[]> result = query.list();
 964
 965         List<TermDto> list = FeatureDto.termDtoListFrom(result);
 966         return list;
 967     }
 968
 969 }