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 package eu.etaxonomy.cdm.persistence.dao.hibernate.agent;
  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.logging.log4j.LogManager;
  18 import org.apache.logging.log4j.Logger;
  19 import org.hibernate.Criteria;
  20 import org.hibernate.Session;
  21 import org.hibernate.criterion.Criterion;
  22 import org.hibernate.criterion.Restrictions;
  23 import org.hibernate.envers.query.AuditEntity;
  24 import org.hibernate.envers.query.AuditQuery;
  25 import org.hibernate.query.Query;
  26 import org.springframework.stereotype.Repository;
  27
  28 import eu.etaxonomy.cdm.model.agent.Address;
  29 import eu.etaxonomy.cdm.model.agent.AgentBase;
  30 import eu.etaxonomy.cdm.model.agent.Institution;
  31 import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;
  32 import eu.etaxonomy.cdm.model.agent.Person;
  33 import eu.etaxonomy.cdm.model.agent.Team;
  34 import eu.etaxonomy.cdm.model.view.AuditEvent;
  35 import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;
  36 import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;
  37 import eu.etaxonomy.cdm.persistence.dto.TeamOrPersonUuidAndTitleCache;
  38 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  39 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  40 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  41
  42 @Repository
  43 public class AgentDaoImpl extends IdentifiableDaoBase<AgentBase> implements IAgentDao{
  44
  45         @SuppressWarnings("unused")
  46         private static final Logger logger = LogManager.getLogger();
  47
  48         public AgentDaoImpl() {
  49                 super(AgentBase.class);
  50                 indexedClasses = new Class[3];
  51                 indexedClasses[0] = Institution.class;
  52                 indexedClasses[1] = Person.class;
  53                 indexedClasses[2] = Team.class;
  54         }
  55
  56         @Override
  57     public List<Institution> getInstitutionByCode(String code) {
  58                 AuditEvent auditEvent = getAuditEventFromContext();
  59                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
  60                     Criteria crit = getSession().createCriteria(Institution.class);
  61                 crit.add(Restrictions.eq("code", code));
  62                 @SuppressWarnings("unchecked")
  63             List<Institution> result = crit.list();
  64                 return result;
  65                 } else {
  66                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Institution.class,auditEvent.getRevisionNumber());
  67                         query.add(AuditEntity.property("code").eq(code));
  68                         @SuppressWarnings("unchecked")
  69             List<Institution> result = query.getResultList();
  70                         return result;
  71                 }
  72         }
  73
  74         @Override
  75     public long countInstitutionalMemberships(Person person) {
  76                 AuditEvent auditEvent = getAuditEventFromContext();
  77                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
  78                     Query<Long> query = getSession().createQuery("select count(institutionalMembership) from InstitutionalMembership institutionalMembership where institutionalMembership.person = :person", Long.class);
  79                     query.setParameter("person", person);
  80                     return query.uniqueResult();
  81                 } else {
  82                         AuditQuery query = makeAuditQuery(InstitutionalMembership.class, auditEvent);
  83                         query.add(AuditEntity.relatedId("person").eq(person.getId()));
  84                         query.addProjection(AuditEntity.id());
  85                         return (Long)query.getSingleResult();
  86                 }
  87         }
  88
  89         @Override
  90     public long countMembers(Team team) {
  91                 checkNotInPriorView("AgentDaoImpl.countMembers(Team team)");
  92                 Query<Long> query = getSession().createQuery("select count(teamMember) from Team team join team.teamMembers teamMember where team = :team", Long.class);
  93                 query.setParameter("team", team);
  94                 return query.uniqueResult();
  95         }
  96
  97         @Override
  98     public List<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {
  99                 AuditEvent auditEvent = getAuditEventFromContext();
 100                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 101                     Query<InstitutionalMembership> query = getSession().createQuery("select institutionalMembership from InstitutionalMembership institutionalMembership left join fetch institutionalMembership.institute where institutionalMembership.person = :person", InstitutionalMembership.class);
 102                     query.setParameter("person", person);
 103                     addPageSizeAndNumber(query, pageSize, pageNumber);
 104                         return query.list();
 105                 } else {
 106                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(InstitutionalMembership.class,auditEvent.getRevisionNumber());
 107                         query.add(AuditEntity.relatedId("person").eq(person.getId()));
 108                         addPageSizeAndNumber(query, pageSize, pageNumber);
 109                         return query.getResultList();
 110                 }
 111         }
 112
 113         @Override
 114     public List<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {
 115                 checkNotInPriorView("AgentDaoImpl.getMembers(Team team, Integer pageSize,       Integer pageNumber)");
 116                 Query<Person> query = getSession().createQuery("select teamMember from Team team join team.teamMembers teamMember where team = :team order by sortindex", Person.class);
 117                 query.setParameter("team", team);
 118                 //query.addOrder( Order.asc("sortindex") );
 119                 addPageSizeAndNumber(query, pageSize, pageNumber);
 120         List<Person> result = query.list();
 121                 return result;
 122         }
 123
 124         @Override
 125     public long countAddresses(AgentBase agent) {
 126                 checkNotInPriorView("AgentDaoImpl.countAddresses(AgentBase agent)");
 127                 Query<Long> query = getSession().createQuery("select count(address) from AgentBase agent join agent.contact.addresses address where agent = :agent", Long.class);
 128                 query.setParameter("agent", agent);
 129                 return query.uniqueResult();
 130         }
 131
 132         @Override
 133     public List<Address> getAddresses(AgentBase agent, Integer pageSize,Integer pageNumber) {
 134                 checkNotInPriorView("AgentDaoImpl.getAddresses(AgentBase agent, Integer pageSize,Integer pageNumber)");
 135                 Query<Address> query = getSession().createQuery("select address from AgentBase agent join agent.contact.addresses address where agent = :agent", Address.class);
 136                 query.setParameter("agent", agent);
 137                 addPageSizeAndNumber(query, pageSize, pageNumber);
 138         List<Address> result = query.list();
 139         return result;
 140         }
 141
 142         @Override
 143         public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle() {
 144                 List<UuidAndTitleCache<Team>> list = new ArrayList<>();
 145                 Session session = getSession();
 146
 147                 Query<Object[]> query = session.createQuery("select uuid, id, nomenclaturalTitleCache from " + type.getSimpleName() + " where dtype = 'Team'", Object[].class);
 148
 149                 List<Object[]> result = query.list();
 150
 151                 for(Object[] object : result){
 152                         list.add(new UuidAndTitleCache<>(Team.class, (UUID) object[0], (Integer)object[1], (String) object[2]));
 153                 }
 154                 return list;
 155         }
 156
 157         @Override
 158     public <T extends AgentBase> List<TeamOrPersonUuidAndTitleCache<T>> getUuidAndTitleCacheWithCollector(Class<T> clazz, Integer limit, String pattern){
 159             Session session = getSession();
 160
 161         clazz = (clazz == null)? (Class)type : clazz;
 162         String clazzString = " FROM " + clazz.getSimpleName();
 163
 164         Query<Object[]> query = null;
 165
 166         if (pattern != null){
 167             String whereClause = " WHERE collectorTitleCache LIKE :pattern "
 168                      + " OR titleCache LIKE :pattern "
 169                      + " OR nomenclaturalTitleCache like :pattern ";
 170
 171             query = session.createQuery("SELECT DISTINCT uuid, id, nomenclaturalTitleCache, titleCache, collectorTitleCache " + clazzString  + whereClause, Object[].class);
 172             pattern = pattern + "%";
 173             pattern = pattern.replace("*", "%");
 174             pattern = pattern.replace("?", "_");
 175             query.setParameter("pattern", pattern);
 176         } else {
 177             query = session.createQuery("SELECT DISTINCT uuid, id, nomenclaturalTitleCache, titleCache, collectorTitleCache " + clazzString, Object[].class);
 178         }
 179         if (limit != null){
 180             query.setMaxResults(limit);
 181         }
 182
 183         return getTeamOrPersonUuidAndTitleCache(query);
 184         }
 185
 186         @Override
 187     public <T extends AgentBase> List<TeamOrPersonUuidAndTitleCache<T>> getTeamOrPersonUuidAndTitleCache(Class<T> clazz, Integer limit, String pattern){
 188         Session session = getSession();
 189
 190         clazz = (clazz == null)? (Class)type : clazz;
 191         String clazzString = " FROM " + clazz.getSimpleName();
 192
 193         Query<Object[]> query = null;
 194
 195         if (pattern != null){
 196             String whereClause = " WHERE titleCache LIKE :pattern";
 197
 198             query = session.createQuery("SELECT DISTINCT uuid, id, nomenclaturalTitleCache, titleCache, collectorTitleCache " + clazzString  + whereClause, Object[].class);
 199             pattern = pattern + "%";
 200             pattern = pattern.replace("*", "%");
 201             pattern = pattern.replace("?", "_");
 202             query.setParameter("pattern", pattern);
 203         } else {
 204             query = session.createQuery("SELECT DISTINCT uuid, id, nomenclaturalTitleCache, titleCache, collectorTitleCache " + clazzString, Object[].class);
 205         }
 206         if (limit != null){
 207             query.setMaxResults(limit);
 208         }
 209
 210         return getTeamOrPersonUuidAndTitleCache(query);
 211     }
 212
 213         @Override
 214     public <T extends AgentBase> List<TeamOrPersonUuidAndTitleCache<T>> getUuidAndAbbrevTitleCache(Class<T> clazz, Integer limit, String pattern){
 215         Session session = getSession();
 216
 217         clazz = (clazz == null)? (Class)type : clazz;
 218         String clazzString = " FROM " + clazz.getSimpleName();
 219
 220         Query<Object[]> query = null;
 221
 222         if (pattern != null){
 223             String whereClause = " WHERE nomenclaturalTitleCache LIKE :pattern";
 224             if (pattern.startsWith("*")){
 225                 whereClause += " OR titleCache LIKE :pattern";
 226                 whereClause += " OR collectorTitleCache LIKE :pattern";
 227             }
 228
 229             query = session.createQuery("SELECT DISTINCT uuid, id, nomenclaturalTitleCache, titleCache, collectorTitleCache " + clazzString  + whereClause, Object[].class);
 230             pattern = pattern + "%";
 231             pattern = pattern.replace("*", "%");
 232             pattern = pattern.replace("?", "_");
 233             query.setParameter("pattern", pattern);
 234         } else {
 235             query = session.createQuery("SELECT DISTINCT uuid, id, nomenclaturalTitleCache, titleCache, collectorTitleCache " + clazzString, Object[].class);
 236         }
 237         if (limit != null){
 238             query.setMaxResults(limit);
 239         }
 240
 241         return getTeamOrPersonUuidAndTitleCache(query);
 242     }
 243
 244         @Override
 245     public <T extends AgentBase<?>> List<T> findByTitleAndAbbrevTitle(Class<T> clazz, String queryString, MatchMode matchmode, List<Criterion> criterion, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 246         Set<String> params = new HashSet<>();
 247         params.add("titleCache");
 248         params.add("nomenclaturalTitleCache");
 249         params.add("collectorTitleCache");
 250
 251             return findByParam(clazz, params, queryString, matchmode, criterion, pageSize, pageNumber, orderHints, propertyPaths);
 252     }
 253
 254     protected <T extends AgentBase> List<TeamOrPersonUuidAndTitleCache<T>> getTeamOrPersonUuidAndTitleCache(Query<Object[]> query){
 255         List<TeamOrPersonUuidAndTitleCache<T>> list = new ArrayList<>();
 256
 257         List<Object[]> result = query.list();
 258
 259         for(Object[] object : result){
 260           list.add(new TeamOrPersonUuidAndTitleCache((UUID) object[0],(Integer) object[1], (String) object[3], (String) object[2], (String) object[4]));
 261         }
 262         return list;
 263     }
 264 }