cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/reference/ReferenceDaoHibernateImpl.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 package eu.etaxonomy.cdm.persistence.dao.hibernate.reference;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import org.apache.log4j.Logger;
  18 import org.hibernate.Hibernate;
  19 import org.hibernate.Query;
  20 import org.hibernate.Session;
  21 import org.hibernate.search.FullTextSession;
  22 import org.hibernate.search.Search;
  23 import org.springframework.beans.factory.annotation.Qualifier;
  24 import org.springframework.stereotype.Repository;
  25
  26 import eu.etaxonomy.cdm.model.reference.IArticle;
  27 import eu.etaxonomy.cdm.model.reference.IBookSection;
  28 import eu.etaxonomy.cdm.model.reference.IInProceedings;
  29 import eu.etaxonomy.cdm.model.reference.IPrintedUnitBase;
  30 import eu.etaxonomy.cdm.model.reference.IReport;
  31 import eu.etaxonomy.cdm.model.reference.IThesis;
  32 import eu.etaxonomy.cdm.model.reference.Reference;
  33 import eu.etaxonomy.cdm.model.reference.ReferenceType;
  34 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  35 import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;
  36 import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;
  37 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  38 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  39 import eu.etaxonomy.cdm.strategy.cache.reference.DefaultReferenceCacheStrategy;
  40
  41 /**
  42  * @author a.mueller
  43  *
  44  */
  45 @Repository
  46 @Qualifier("referenceDaoHibernateImpl")
  47 public class ReferenceDaoHibernateImpl extends IdentifiableDaoBase<Reference> implements IReferenceDao {
  48         private static final Logger logger = Logger.getLogger(ReferenceDaoHibernateImpl.class);
  49
  50         public ReferenceDaoHibernateImpl() {
  51                 super(Reference.class);
  52         }
  53
  54         @Override
  55         public void rebuildIndex() {
  56                 FullTextSession fullTextSession = Search.getFullTextSession(getSession());
  57
  58                 for(Reference reference : list(null,null)) { // re-index all agents
  59                         Hibernate.initialize(reference.getAuthorship());
  60
  61                         if(reference.getType().equals(ReferenceType.Article)) {
  62                                 Hibernate.initialize(((IArticle)reference).getInJournal());
  63                         } else if(reference.getType().equals(ReferenceType.BookSection)) {
  64                                    Hibernate.initialize(((IBookSection)reference).getInBook());
  65                         } else if(reference.getType().equals(ReferenceType.InProceedings)) {
  66                                         Hibernate.initialize(((IInProceedings)reference).getInProceedings());
  67                         }else if(reference.getType().equals(ReferenceType.Thesis)) {
  68                                 Hibernate.initialize(((IThesis)reference).getSchool());
  69                         } else if(reference.getType().equals(ReferenceType.Report)) {
  70                                 Hibernate.initialize(((IReport)reference).getInstitution());
  71                         } else if(reference.getType().isPrintedUnit()) {
  72                                 Hibernate.initialize(((IPrintedUnitBase)reference).getInSeries());
  73                         }
  74                         fullTextSession.index(reference);
  75                 }
  76                 fullTextSession.flushToIndexes();
  77         }
  78
  79         @Override
  80     public List<UuidAndTitleCache<Reference>> getUuidAndTitle(){
  81                 List<UuidAndTitleCache<Reference>> list = new ArrayList<UuidAndTitleCache<Reference>>();
  82                 Session session = getSession();
  83
  84                 Query query = session.createQuery("select uuid, id, titleCache from " + type.getSimpleName());
  85
  86                 @SuppressWarnings("unchecked")
  87         List<Object[]> result = query.list();
  88
  89                 for(Object[] object : result){
  90                         list.add(new UuidAndTitleCache<Reference>(type, (UUID) object[0], (Integer)object[1], (String) object[2]));
  91                 }
  92
  93                 return list;
  94         }
  95
  96         @Override
  97         public List<UuidAndTitleCache<Reference>> getUuidAndTitleCache(Integer limit, String pattern) {
  98                 List<UuidAndTitleCache<Reference>> list = new ArrayList<UuidAndTitleCache<Reference>>();
  99                 Session session = getSession();
 100                  Query query;
 101                 if (pattern != null){
 102                     query = session.createQuery("SELECT " +"r.uuid, r.id, r.titleCache, ab.titleCache FROM " + type.getSimpleName() + " AS r LEFT OUTER JOIN r.authorship AS ab where r.titleCache like :pattern");
 103                 }else{
 104                     query = session.createQuery("SELECT " +"r.uuid, r.id, r.titleCache, ab.titleCache FROM " + type.getSimpleName() + " AS r LEFT OUTER JOIN r.authorship AS ab ");//"select uuid, titleCache from " + type.getSimpleName());
 105                 }
 106
 107                 if (limit != null){
 108                     query.setMaxResults(limit);
 109                 }
 110                 if (pattern != null){
 111                       pattern = pattern.replace("*", "%");
 112                       pattern = pattern.replace("?", "_");
 113                       pattern = pattern + "%";
 114                   query.setParameter("pattern", pattern);
 115             }
 116                 @SuppressWarnings("unchecked")
 117         List<Object[]> result = query.list();
 118
 119                 for(Object[] object : result){
 120                         String referenceTitle = (String) object[2];
 121
 122                         if(referenceTitle != null){
 123                                 String teamTitle = (String) object[3];
 124                                 referenceTitle = DefaultReferenceCacheStrategy.putAuthorToEndOfString(referenceTitle, teamTitle);
 125
 126                                 list.add(new UuidAndTitleCache<Reference>(Reference.class, (UUID) object[0],(Integer)object[1], referenceTitle));
 127                         }else{
 128                                 logger.error("title cache of reference is null. UUID: " + object[0]);
 129                         }
 130                 }
 131
 132                 return list;
 133         }
 134
 135         @Override
 136     public List<Reference> getAllReferencesForPublishing(){
 137                 @SuppressWarnings("unchecked")
 138         List<Reference> references = getSession().createQuery("SELECT r FROM Reference r "+
 139                                 "WHERE r.id IN "+
 140                                         "(SELECT m.markedObj.id FROM Marker m WHERE "+
 141                                                 "m.markerType.id = "+
 142                                                         "(SELECT dtb.id FROM DefinedTermBase dtb, Representation r WHERE r MEMBER OF dtb.representations AND r.text='publish'))").list();
 143                 return references;
 144         }
 145
 146         @Override
 147     public List<Reference> getAllNotNomenclaturalReferencesForPublishing(){
 148
 149                 @SuppressWarnings("unchecked")
 150         List<Reference> references = getSession().createQuery("select t.nomenclaturalReference from TaxonNameBase t").list();
 151                 String queryString = "from Reference b where b not in (:referenceList) and b in (:publish)" ;
 152                 Query referenceQuery = getSession().createQuery(queryString).setParameterList("referenceList", references);
 153                 referenceQuery.setParameterList("publish", getAllReferencesForPublishing());
 154                 @SuppressWarnings("unchecked")
 155         List<Reference> resultRefernces =referenceQuery.list();
 156
 157                 return resultRefernces;
 158         }
 159
 160         // the result list held doubles therefore I put a "distinct" in the query string
 161         @Override
 162     public List<Reference> getAllNomenclaturalReferences() {
 163                 @SuppressWarnings("unchecked")
 164         List<Reference> references = getSession().createQuery(
 165                                 "SELECT DISTINCT t.nomenclaturalReference FROM TaxonNameBase t").list();
 166                 return references;
 167         }
 168
 169
 170     @Override
 171         public List<Reference> getSubordinateReferences(Reference reference) {
 172
 173                 List<Reference> references = new ArrayList();
 174                 List<Reference> subordinateReferences = new ArrayList<Reference>();
 175
 176                 Query query = getSession().createQuery("select r from Reference r where r.inReference = (:reference)");
 177                 query.setParameter("reference", reference);
 178
 179                 @SuppressWarnings("unchecked")
 180             List<Reference> list = query.list();
 181             references.addAll(list);
 182                 for(Reference ref : references){
 183                         subordinateReferences.addAll(getSubordinateReferences(ref));
 184                 }
 185                 references.addAll(subordinateReferences);
 186                 return references;
 187         }
 188
 189     @Override
 190         public List<TaxonBase> listCoveredTaxa(Reference reference, boolean includeSubordinateReferences, List<OrderHint> orderHints, List<String> propertyPaths) {
 191
 192                 /*
 193                  * <li>taxon.name.nomenclaturalreference</li>
 194                  * <li>taxon.descriptions.descriptionElement.sources.citation</li>
 195                  * <li>taxon.descriptions.descriptionSources</li>
 196                  * <li>taxon.name.descriptions.descriptionElement.sources</li>
 197                  * <li>taxon.name.descriptions.descriptionSources</li>
 198                  */
 199
 200                 //TODO implement search in nameDescriptions
 201                 Set<Reference> referenceSet = new HashSet<Reference>();
 202                 referenceSet.add(reference);
 203                 if(includeSubordinateReferences){
 204                         referenceSet.addAll(getSubordinateReferences(reference));
 205                 }
 206
 207
 208                 StringBuilder taxonDescriptionSql = new StringBuilder();
 209                 taxonDescriptionSql.append(
 210                         "select distinct t from Taxon t " +
 211                         // TaxonDescription
 212                         "left join t.descriptions td " +
 213                         "left join td.descriptionSources td_s " +
 214                         "left join td.descriptionElements td_e " +
 215                         "left join td_e.sources td_e_s " +
 216                         // TaxonNameDescription
 217                         "left join t.name n " +
 218                         "left join n.descriptions nd " +
 219                         "left join nd.descriptionSources nd_s " +
 220                         "left join nd.descriptionElements nd_e " +
 221                         "left join nd_e.sources nd_e_s " +
 222
 223                         "where td_e_s.citation in (:referenceBase_1) " +
 224                         "or td_s in (:referenceBase_2) " +
 225                         "or nd_e_s.citation in (:referenceBase_3) " +
 226                         "or nd_s in (:referenceBase_4) or " +
 227                         "n.nomenclaturalReference in (:referenceBase_5) or " +
 228                         "t.sec in (:referenceBase_6)"
 229                         );
 230
 231                 if (orderHints != null && orderHints.size() > 0){
 232                     taxonDescriptionSql.append(" order by ");
 233                     int i = 0;
 234                     for (OrderHint hint : orderHints) {
 235                         if(i > 0) {
 236                             taxonDescriptionSql.append(", ");
 237                         }
 238                         taxonDescriptionSql.append("t.").append(hint.toHql());
 239             }
 240                 }
 241
 242                 // TODO include:
 243                 // name relations
 244                 // taxon relations
 245
 246                 Query query = getSession().createQuery(taxonDescriptionSql.toString());
 247                 query.setParameterList("referenceBase_1", referenceSet);
 248                 query.setParameterList("referenceBase_2", referenceSet);
 249                 query.setParameterList("referenceBase_3", referenceSet);
 250                 query.setParameterList("referenceBase_4", referenceSet);
 251                 query.setParameterList("referenceBase_5", referenceSet);
 252                 query.setParameterList("referenceBase_6", referenceSet);
 253
 254                 @SuppressWarnings("unchecked")
 255         List<TaxonBase> taxonBaseList = query.list();
 256
 257                 defaultBeanInitializer.initializeAll(taxonBaseList, propertyPaths);
 258
 259                 return taxonBaseList;
 260         }
 261 }