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.util.ArrayList;
  13 import java.util.Enumeration;
  14 import java.util.List;
  15 import java.util.Locale;
  16 import java.util.Set;
  17
  18 import org.apache.log4j.Logger;
  19 import org.hibernate.Criteria;
  20 import org.hibernate.Query;
  21 import org.hibernate.Session;
  22 import org.hibernate.criterion.Criterion;
  23 import org.hibernate.criterion.Projections;
  24 import org.hibernate.criterion.Restrictions;
  25 import org.hibernate.envers.query.AuditEntity;
  26 import org.hibernate.envers.query.AuditQuery;
  27 import org.springframework.stereotype.Repository;
  28
  29 import eu.etaxonomy.cdm.model.common.CdmBase;
  30 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  31 import eu.etaxonomy.cdm.model.common.Language;
  32 import eu.etaxonomy.cdm.model.description.AbsenceTerm;
  33 import eu.etaxonomy.cdm.model.description.PresenceTerm;
  34 import eu.etaxonomy.cdm.model.location.NamedArea;
  35 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  36 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  37 import eu.etaxonomy.cdm.model.location.WaterbodyOrCountry;
  38 import eu.etaxonomy.cdm.model.media.Media;
  39 import eu.etaxonomy.cdm.model.view.AuditEvent;
  40 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  41 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  42
  43 /**
  44  * @author a.kohlbecker
  45  * @created 29.05.2008
  46  * @version 1.0
  47  */
  48 @Repository
  49 public class DefinedTermDaoImpl extends VersionableDaoBase<DefinedTermBase> implements IDefinedTermDao{
  50         private static final Logger logger = Logger.getLogger(DefinedTermDaoImpl.class);
  51
  52         public DefinedTermDaoImpl() {
  53                 super(DefinedTermBase.class);
  54         }
  55
  56         public List<DefinedTermBase> findByTitle(String queryString) {
  57                 return findByTitle(queryString, null);
  58         }
  59
  60         /* (non-Javadoc)
  61          * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)
  62          */
  63         public List<DefinedTermBase> findByTitle(String queryString, CdmBase sessionObject) {
  64                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, CdmBase sessionObject)");
  65                 Session session = getSession();
  66                 if ( sessionObject != null ) {// FIXME is this needed?
  67                         session.update(sessionObject);
  68                 }
  69                 Query query = session.createQuery("select term from DefinedTermBase term join fetch term.representations representation where representation.label = :label");
  70                 query.setParameter("label", queryString);
  71                 return (List<DefinedTermBase>) query.list();
  72
  73         }
  74
  75         public List<DefinedTermBase> findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz) {
  76                 checkNotInPriorView("DefinedTermDaoImpl.findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz)");
  77                 Session session = getSession();
  78                 Criteria crit = session.createCriteria(clazz);
  79                 crit.add(Restrictions.ilike("persistentTitleCache", queryString));
  80                 List<DefinedTermBase> results = crit.list();
  81                 return results;
  82         }
  83
  84         /* (non-Javadoc)
  85          * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String, eu.etaxonomy.cdm.persistence.dao.common.ITitledDao.MATCH_MODE, int, int, java.util.List)
  86          */
  87         public List<DefinedTermBase> findByTitle(String queryString, MatchMode matchMode, int page, int pagesize, List<Criterion> criteria) {
  88                 //FIXME is query parametrised?
  89                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, ITitledDao.MATCH_MODE matchMode, int page, int pagesize, List<Criterion> criteria)");
  90                 Criteria crit = getSession().createCriteria(type);
  91                 crit.add(Restrictions.ilike("titleCache", matchMode.queryStringFrom(queryString)));
  92                 crit.setMaxResults(pagesize);
  93                 int firstItem = (page - 1) * pagesize + 1;
  94                 crit.setFirstResult(firstItem);
  95                 List<DefinedTermBase> results = crit.list();
  96                 return results;
  97         }
  98
  99
 100         public WaterbodyOrCountry getCountryByIso(String iso639) {
 101                 // If iso639 = "" query returns non-unique result. We prevent this here:
 102                 if (iso639.equals("") ) { return null; }
 103                 AuditEvent auditEvent = getAuditEventFromContext();
 104                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 105                   Query query = getSession().createQuery("from WaterbodyOrCountry where iso3166_A2 = :isoCode");
 106                   query.setParameter("isoCode", iso639);
 107                   return (WaterbodyOrCountry) query.uniqueResult();
 108                 } else {
 109                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(WaterbodyOrCountry.class,auditEvent.getRevisionNumber());
 110                         query.add(AuditEntity.property("iso3166_A2").eq(iso639));
 111                         return (WaterbodyOrCountry) query.getSingleResult();
 112                 }
 113         }
 114
 115         public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz ) {
 116                 Query query = getSession().createQuery("from "+ clazz.getName()+" as wc where wc.representations.text like '"+text+"'");
 117                 return (List<T>) query.list();
 118         }
 119
 120         /* (non-Javadoc)
 121          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#getLangaugeByIso(java.lang.String)
 122          */
 123         public Language getLanguageByIso(String iso639) {
 124                 if (iso639.length() < 2 || iso639.length() > 3) {
 125                         logger.warn("Invalid length " + iso639.length() + " of ISO code. Length must be 2 or 3.");
 126                         return null;
 127                 }
 128                 String isoStandart = "iso639_" + (iso639.length() - 1);
 129                 AuditEvent auditEvent = getAuditEventFromContext();
 130                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 131                     Query query = getSession().createQuery("from Language where " + isoStandart + "= :isoCode");
 132                     query.setParameter("isoCode", iso639);
 133                     return (Language) query.uniqueResult();
 134                 } else {
 135                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Language.class,auditEvent.getRevisionNumber());
 136                         query.add(AuditEntity.property(isoStandart).eq(iso639));
 137                         return (Language)query.getSingleResult();
 138                 }
 139         }
 140
 141         /**
 142          *  FIXME this will result in a query per language - could you, given that iso codes
 143          *  are unique, use from Language where iso639_1 in (:isoCode) or iso639_2 in (:isoCode)
 144          */
 145         public List<Language> getLanguagesByIso(List<String> iso639List) {
 146                 List<Language> languages = new ArrayList<Language>(iso639List.size());
 147                 for (String iso639 : iso639List) {
 148                         languages.add(getLanguageByIso(iso639));
 149                 }
 150                 return languages;
 151         }
 152
 153         public List<Language> getLanguagesByLocale(Enumeration<Locale> locales) {
 154                 List<Language> languages = new ArrayList<Language>();
 155                 while(locales.hasMoreElements()) {
 156                         Locale locale = locales.nextElement();
 157                         languages.add(getLanguageByIso(locale.getLanguage()));
 158                 }
 159                 return languages;
 160         }
 161
 162         public int count(NamedAreaLevel level, NamedAreaType type) {
 163                 AuditEvent auditEvent = getAuditEventFromContext();
 164                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 165                     Criteria criteria = getSession().createCriteria(NamedArea.class);
 166
 167                     if(level != null) {
 168                             criteria.add(Restrictions.eq("level",level));
 169                     }
 170
 171                     if(type != null) {
 172                             criteria.add(Restrictions.eq("type", type));
 173                     }
 174
 175                     criteria.setProjection(Projections.rowCount());
 176
 177                     return (Integer)criteria.uniqueResult();
 178                 } else {
 179                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,auditEvent.getRevisionNumber());
 180
 181                         if(level != null) {
 182                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 183                     }
 184
 185                     if(type != null) {
 186                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 187                     }
 188                     query.addProjection(AuditEntity.id().count("id"));
 189                     return ((Long)query.getSingleResult()).intValue();
 190                 }
 191         }
 192
 193         public int countMedia(DefinedTermBase definedTerm) {
 194                 checkNotInPriorView("DefinedTermDaoImpl.countMedia(DefinedTermBase definedTerm)");
 195                 Query query = getSession().createQuery("select count(media) from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 196             query.setParameter("definedTerm", definedTerm);
 197
 198                 return ((Long)query.uniqueResult()).intValue();
 199         }
 200
 201         public List<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,      Integer pageNumber) {
 202                 checkNotInPriorView("DefinedTermDaoImpl.getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber)");
 203                 Query query = getSession().createQuery("select media from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 204                 query.setParameter("definedTerm", definedTerm);
 205
 206                 if(pageSize != null) {
 207                         query.setMaxResults(pageSize);
 208                     if(pageNumber != null) {
 209                         query.setFirstResult(pageNumber * pageSize);
 210                     }
 211                 }
 212
 213                 return (List<Media>)query.list();
 214         }
 215
 216         public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber) {
 217                 AuditEvent auditEvent = getAuditEventFromContext();
 218                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 219             Criteria criteria = getSession().createCriteria(NamedArea.class);
 220
 221                     if(level != null) {
 222                             criteria.add(Restrictions.eq("level",level));
 223                     }
 224
 225                     if(type != null) {
 226                             criteria.add(Restrictions.eq("type", type));
 227                     }
 228
 229                     if(pageSize != null) {
 230                             criteria.setMaxResults(pageSize);
 231                         if(pageNumber != null) {
 232                             criteria.setFirstResult(pageNumber * pageSize);
 233                         }
 234                     }
 235
 236                     return (List<NamedArea>)criteria.list();
 237                 } else {
 238             AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,auditEvent.getRevisionNumber());
 239
 240                         if(level != null) {
 241                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 242                     }
 243
 244                     if(type != null) {
 245                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 246                     }
 247
 248                     return (List<NamedArea>)query.getResultList();
 249                 }
 250         }
 251
 252         public <T extends DefinedTermBase> int countGeneralizationOf(T kindOf) {
 253                 AuditEvent auditEvent = getAuditEventFromContext();
 254                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 255                     Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.kindOf = :kindOf");
 256                     query.setParameter("kindOf", kindOf);
 257                     return ((Long)query.uniqueResult()).intValue();
 258                 } else {
 259             AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 260                         query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 261                     query.addProjection(AuditEntity.id().count("id"));
 262                     return ((Long)query.getSingleResult()).intValue();
 263                 }
 264         }
 265
 266         public <T extends DefinedTermBase> int countIncludes(Set<T> partOf) {
 267                 AuditEvent auditEvent = getAuditEventFromContext();
 268                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 269                 Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.partOf in (:partOf)");
 270                 query.setParameterList("partOf", partOf);
 271                     return ((Long)query.uniqueResult()).intValue();
 272                 } else {
 273                         Integer count = 0;
 274                         for(T t : partOf) {
 275                                 AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 276                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 277                             query.addProjection(AuditEntity.id().count("id"));
 278                             count += ((Long)query.getSingleResult()).intValue();
 279                         }
 280                         return count;
 281                 }
 282         }
 283
 284         public <T extends DefinedTermBase> List<T> getGeneralizationOf(T kindOf, Integer pageSize, Integer pageNumber) {
 285                 AuditEvent auditEvent = getAuditEventFromContext();
 286                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 287                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.kindOf = :kindOf");
 288                     query.setParameter("kindOf", kindOf);
 289
 290                     if(pageSize != null) {
 291                             query.setMaxResults(pageSize);
 292                         if(pageNumber != null) {
 293                             query.setFirstResult(pageNumber * pageSize);
 294                         }
 295                     }
 296
 297                 return (List<T>)query.list();
 298                 } else {
 299                          AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 300                          query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 301
 302                          if(pageSize != null) {
 303                             query.setMaxResults(pageSize);
 304                              if(pageNumber != null) {
 305                                     query.setFirstResult(pageNumber * pageSize);
 306                              }
 307                          }
 308
 309                          return (List<T>)query.getResultList();
 310                 }
 311         }
 312
 313         public <T extends DefinedTermBase> List<T> getIncludes(Set<T> partOf,   Integer pageSize, Integer pageNumber) {
 314                 AuditEvent auditEvent = getAuditEventFromContext();
 315                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 316                 Query query = getSession().createQuery("select term from DefinedTermBase term where term.partOf in (:partOf)");
 317                 query.setParameterList("partOf", partOf);
 318
 319                     if(pageSize != null) {
 320                             query.setMaxResults(pageSize);
 321                         if(pageNumber != null) {
 322                             query.setFirstResult(pageNumber * pageSize);
 323                         }
 324                     }
 325
 326                     return (List<T>)query.list();
 327                 } else {
 328                         List<T> result = new ArrayList<T>();
 329                         for(T t : partOf) {
 330                                 AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 331                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 332                                 if(pageSize != null) {
 333                                     query.setMaxResults(pageSize);
 334                                 if(pageNumber != null) {
 335                                     query.setFirstResult(pageNumber * pageSize);
 336                                 }
 337                             }
 338
 339                             result.addAll((List<T>)query.getResultList());
 340                         }
 341                         return result;
 342                 }
 343         }
 344
 345         public <T extends DefinedTermBase> int countPartOf(Set<T> definedTerms) {
 346                 checkNotInPriorView("DefinedTermDaoImpl.countPartOf(Set<T> definedTerms)");
 347                 Query query = getSession().createQuery("select count(distinct partOf) from DefinedTermBase definedTerm join definedTerm.partOf partOf where definedTerm in (:definedTerms)");
 348                 query.setParameterList("definedTerms", definedTerms);
 349                 return ((Long)query.uniqueResult()).intValue();
 350         }
 351
 352         public <T extends DefinedTermBase> List<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber) {
 353                 checkNotInPriorView("DefinedTermDaoImpl.getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber)");
 354                 Query query = getSession().createQuery("select distinct partOf from DefinedTermBase definedTerm join definedTerm.partOf partOf where definedTerm in (:definedTerms)");
 355                 query.setParameterList("definedTerms", definedTerms);
 356
 357                 if(pageSize != null) {
 358                         query.setMaxResults(pageSize);
 359                     if(pageNumber != null) {
 360                         query.setFirstResult(pageNumber * pageSize);
 361                     }
 362                 }
 363
 364                 return (List<T>)query.list();
 365         }
 366
 367         public DefinedTermBase findByUri(String uri) {
 368                 AuditEvent auditEvent = getAuditEventFromContext();
 369                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 370                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.uri = :uri");
 371                     query.setParameter("uri", uri);
 372                     return (DefinedTermBase)query.uniqueResult();
 373                 } else {
 374                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 375                         query.add(AuditEntity.property("uri").eq(uri));
 376                     return (DefinedTermBase)query.getSingleResult();
 377                 }
 378         }
 379
 380
 381 //      @Override
 382 //      public List<DefinedTermBase> list(int limit, int start) {
 383 //              Query query = getSession().createQuery("select term from DefinedTermBase term join fetch term.representations representation ");
 384 //              query.setMaxResults(limit);
 385 //              query.setFirstResult(start);
 386 //              return (List<DefinedTermBase>) query.list();
 387 //      }
 388
 389 }