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