cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/agent/AgentDaoImpl.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.agent;
  11
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.UUID;
  15
  16 import org.apache.log4j.Logger;
  17 import org.apache.lucene.analysis.SimpleAnalyzer;
  18 import org.apache.lucene.queryParser.ParseException;
  19 import org.apache.lucene.queryParser.QueryParser;
  20 import org.hibernate.Criteria;
  21 import org.hibernate.Query;
  22 import org.hibernate.Session;
  23 import org.hibernate.criterion.Restrictions;
  24 import org.hibernate.envers.query.AuditEntity;
  25 import org.hibernate.envers.query.AuditQuery;
  26 import org.hibernate.search.FullTextSession;
  27 import org.hibernate.search.Search;
  28 import org.hibernate.search.SearchFactory;
  29 import org.springframework.stereotype.Repository;
  30
  31 import eu.etaxonomy.cdm.model.agent.Address;
  32 import eu.etaxonomy.cdm.model.agent.AgentBase;
  33 import eu.etaxonomy.cdm.model.agent.Institution;
  34 import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;
  35 import eu.etaxonomy.cdm.model.agent.Person;
  36 import eu.etaxonomy.cdm.model.agent.Team;
  37 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  38 import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
  39 import eu.etaxonomy.cdm.model.view.AuditEvent;
  40 import eu.etaxonomy.cdm.persistence.dao.QueryParseException;
  41 import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;
  42 import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;
  43 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  44
  45
  46 @Repository
  47 public class AgentDaoImpl extends IdentifiableDaoBase<AgentBase> implements IAgentDao{
  48
  49         private String defaultField = "titleCache";
  50         private Class<? extends AgentBase> indexedClasses[];
  51
  52
  53         @SuppressWarnings("unused")
  54         private static final Logger logger = Logger.getLogger(AgentDaoImpl.class);
  55
  56         public AgentDaoImpl() {
  57                 super(AgentBase.class);
  58                 indexedClasses = new Class[3];
  59                 indexedClasses[0] = Institution.class;
  60                 indexedClasses[1] = Person.class;
  61                 indexedClasses[2] = Team.class;
  62         }
  63
  64         public List<Institution> getInstitutionByCode(String code) {
  65                 AuditEvent auditEvent = getAuditEventFromContext();
  66                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
  67                     Criteria crit = getSession().createCriteria(Institution.class);
  68                 crit.add(Restrictions.eq("code", code));
  69                 return (List<Institution>)crit.list();
  70                 } else {
  71                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Institution.class,auditEvent.getRevisionNumber());
  72                         query.add(AuditEntity.property("code").eq(code));
  73                         return (List<Institution>)query.getResultList();
  74                 }
  75         }
  76
  77         public int countInstitutionalMemberships(Person person) {
  78                 AuditEvent auditEvent = getAuditEventFromContext();
  79                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
  80                     Query query = getSession().createQuery("select count(institutionalMembership) from InstitutionalMembership institutionalMembership where institutionalMembership.person = :person");
  81                     query.setParameter("person", person);
  82                     return ((Long)query.uniqueResult()).intValue();
  83                 } else {
  84                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(InstitutionalMembership.class,auditEvent.getRevisionNumber());
  85                         query.add(AuditEntity.relatedId("person").eq(person.getId()));
  86                         query.addProjection(AuditEntity.id().count("id"));
  87                         return ((Long)query.getSingleResult()).intValue();
  88                 }
  89         }
  90
  91         public int countMembers(Team team) {
  92                 checkNotInPriorView("AgentDaoImpl.countMembers(Team team)");
  93                 Query query = getSession().createQuery("select count(teamMember) from Team team join team.teamMembers teamMember where team = :team");
  94                 query.setParameter("team", team);
  95                 return ((Long)query.uniqueResult()).intValue();
  96         }
  97
  98         public List<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {
  99                 AuditEvent auditEvent = getAuditEventFromContext();
 100                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 101                     Query query = getSession().createQuery("select institutionalMembership from InstitutionalMembership institutionalMembership left join fetch institutionalMembership.institute where institutionalMembership.person = :person");
 102                     query.setParameter("person", person);
 103                     setPagingParameter(query, pageSize, pageNumber);
 104                         return (List<InstitutionalMembership>)query.list();
 105                 } else {
 106                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(InstitutionalMembership.class,auditEvent.getRevisionNumber());
 107                         query.add(AuditEntity.relatedId("person").eq(person.getId()));
 108                         setPagingParameter(query, pageSize, pageNumber);
 109                         return (List<InstitutionalMembership>)query.getResultList();
 110                 }
 111         }
 112
 113         public List<Person> getMembers(Team team, Integer pageSize,     Integer pageNumber) {
 114                 checkNotInPriorView("AgentDaoImpl.getMembers(Team team, Integer pageSize,       Integer pageNumber)");
 115                 Query query = getSession().createQuery("select teamMember from Team team join team.teamMembers teamMember where team = :team order by sortindex");
 116                 query.setParameter("team", team);
 117                 //query.addOrder( Order.asc("sortindex") );
 118                 setPagingParameter(query, pageSize, pageNumber);
 119                 return (List<Person>)query.list();
 120         }
 121
 122         public Integer countAddresses(AgentBase agent) {
 123                 checkNotInPriorView("AgentDaoImpl.countAddresses(AgentBase agent)");
 124                 Query query = getSession().createQuery("select count(address) from AgentBase agent join agent.contact.addresses address where agent = :agent");
 125                 query.setParameter("agent", agent);
 126                 return ((Long)query.uniqueResult()).intValue();
 127         }
 128
 129         public List<Address> getAddresses(AgentBase agent, Integer pageSize,Integer pageNumber) {
 130                 checkNotInPriorView("AgentDaoImpl.getAddresses(AgentBase agent, Integer pageSize,Integer pageNumber)");
 131                 Query query = getSession().createQuery("select address from AgentBase agent join agent.contact.addresses address where agent = :agent");
 132                 query.setParameter("agent", agent);
 133                 setPagingParameter(query, pageSize, pageNumber);
 134                 return (List<Address>)query.list();
 135         }
 136
 137
 138
 139         public int count(Class<? extends AgentBase> clazz, String queryString) {
 140                 checkNotInPriorView("AgentDaoHibernateImpl.count(String queryString, Boolean accepted)");
 141         QueryParser queryParser = new QueryParser(defaultField, new SimpleAnalyzer());
 142
 143                 try {
 144                         org.apache.lucene.search.Query query = queryParser.parse(queryString);
 145
 146                         FullTextSession fullTextSession = Search.getFullTextSession(this.getSession());
 147                         org.hibernate.search.FullTextQuery fullTextQuery = null;
 148
 149                         if(clazz == null) {
 150                                 fullTextQuery = fullTextSession.createFullTextQuery(query, type);
 151                         } else {
 152                                 fullTextQuery = fullTextSession.createFullTextQuery(query, clazz);
 153                         }
 154
 155                     Integer  result = fullTextQuery.getResultSize();
 156                     return result;
 157
 158                 } catch (ParseException e) {
 159                         throw new QueryParseException(e, queryString);
 160                 }
 161         }
 162
 163         public void purgeIndex() {
 164                 FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 165                 for(Class clazz : indexedClasses) {
 166                     fullTextSession.purgeAll(clazz); // remove all taxon base from indexes
 167                 }
 168                 fullTextSession.flushToIndexes();
 169         }
 170
 171         public void rebuildIndex() {
 172                 FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 173
 174                 for(AgentBase agentBase : list(null,null)) { // re-index all agents
 175                         fullTextSession.index(agentBase);
 176                 }
 177                 fullTextSession.flushToIndexes();
 178         }
 179
 180         public List<AgentBase> search(Class<? extends AgentBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 181                 checkNotInPriorView("AgentDaoHibernateImpl.searchTaxa(String queryString, Boolean accepted,     Integer pageSize, Integer pageNumber)");
 182                 QueryParser queryParser = new QueryParser(defaultField, new SimpleAnalyzer());
 183                 List<AgentBase> results = new ArrayList<AgentBase>();
 184
 185                 try {
 186                         org.apache.lucene.search.Query query = queryParser.parse(queryString);
 187
 188                         FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 189                         org.hibernate.search.FullTextQuery fullTextQuery = null;
 190
 191                         if(clazz == null) {
 192                                 fullTextQuery = fullTextSession.createFullTextQuery(query, type);
 193                         } else {
 194                                 fullTextQuery = fullTextSession.createFullTextQuery(query, clazz);
 195                         }
 196
 197                         addOrder(fullTextQuery,orderHints);
 198
 199                     if(pageSize != null) {
 200                         fullTextQuery.setMaxResults(pageSize);
 201                             if(pageNumber != null) {
 202                                 fullTextQuery.setFirstResult(pageNumber * pageSize);
 203                             } else {
 204                                 fullTextQuery.setFirstResult(0);
 205                             }
 206                         }
 207
 208                     List<AgentBase> result = (List<AgentBase>)fullTextQuery.list();
 209                     defaultBeanInitializer.initializeAll(result, propertyPaths);
 210                     return result;
 211
 212                 } catch (ParseException e) {
 213                         throw new QueryParseException(e, queryString);
 214                 }
 215         }
 216
 217         public String suggestQuery(String string) {
 218                 throw new UnsupportedOperationException("suggestQuery is not supported for AgentBase");
 219         }
 220
 221         public void optimizeIndex() {
 222                 FullTextSession fullTextSession = Search.getFullTextSession(getSession());
 223                 SearchFactory searchFactory = fullTextSession.getSearchFactory();
 224                 for(Class clazz : indexedClasses) {
 225                 searchFactory.optimize(clazz); // optimize the indices ()
 226                 }
 227             fullTextSession.flushToIndexes();
 228         }
 229
 230         /* (non-Javadoc)
 231          * @see eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao#getTeamOrPersonBaseUuidAndNomenclaturalTitle()
 232          */
 233         public List<UuidAndTitleCache<TeamOrPersonBase>> getTeamOrPersonBaseUuidAndNomenclaturalTitle() {
 234                 List<UuidAndTitleCache<TeamOrPersonBase>> list = new ArrayList<UuidAndTitleCache<TeamOrPersonBase>>();
 235                 Session session = getSession();
 236
 237                 Query query = session.createQuery("select uuid, nomenclaturalTitle from " + type.getSimpleName() + " where dtype = 'Person' or dtype = 'Team'");
 238
 239                 List<Object[]> result = query.list();
 240
 241                 for(Object[] object : result){
 242                         list.add(new UuidAndTitleCache<TeamOrPersonBase>(TeamOrPersonBase.class, (UUID) object[0], (String) object[1]));
 243                 }
 244
 245                 return list;
 246         }
 247
 248         /* (non-Javadoc)
 249          * @see eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao#getTeamUuidAndTitleCache()
 250          */
 251         public List<UuidAndTitleCache<Person>> getPersonUuidAndNomenclaturalTitle() {
 252                 List<UuidAndTitleCache<Person>> list = new ArrayList<UuidAndTitleCache<Person>>();
 253                 Session session = getSession();
 254
 255                 Query query = session.createQuery("select uuid, nomenclaturalTitle from " + type.getSimpleName() + " where dtype = 'Person'");
 256
 257                 List<Object[]> result = query.list();
 258
 259                 for(Object[] object : result){
 260                         list.add(new UuidAndTitleCache<Person>(Person.class, (UUID) object[0], (String) object[1]));
 261                 }
 262
 263                 return list;
 264         }
 265 }